1. 4

    And nowadays, all arguments that say that indexes should be 0-based are actually arguments that offsets are 0-based, indexes are offsets, therefore indexes should be 0-based. That’s a circular argument.

    This is not a circular argument.

    The rest seems mostly straw-mans, without argument for 1-based indexing.

    1. 6

      This sounds a bit like it’s going to take the course of USB3.0, which turned from an improved USB into an abomination that tried to do everything. While that certainly not only has downsides, I’m not sure if it’s a good development.

      1. 2

        Yeah reading “5G ready” on an antenna will hardly say which part of the standard will be supported. Will you be able to connect to short-range frequencies (30 - 300GHz) as well? Unlicensed spectrum (5-6 GHz)? It is certain that when buying a phone for example this kind of info will be usually missing, just like USB-C does not give exactly what is supported by the port.

        On the other end, industry features (sidelinking, V2X etc) will change a lot of things, not only for corporations but also citizens and society. Good or bad remains to be seen.

      1. 1

        Nice! I love the controls, very usable. I will probably use it actually.

        I had written something a little similar, shimpr, POSIX shell presentation tool. For some things about managing input and term geometry it seems to reduce to similar solution, but you have avoided extended tput for example. I was not aware of its limitations actually.

        And good to know that SIGWINCH is supposed to become POSIX.

        1. 4

          TL;DR Programming looks very much like talking from Neuro Imaging

          1. 4

            Thank you, I find this article to be more interesting.

            To see what happens in the brain during this process, the team used a functional magnetic resonance tomograph. The image data clearly showed that the test subjects’ left brain areas were activated, which are mainly associated with speech comprehension. “To our surprise, we could not observe any activity in the direction of mathematical or logical thinking,” said the researcher summarising the results. “Our research suggests that speech understanding plays a central role in programming. The renowned Dutch computer scientist Edsger W. Dijkstra already expressed this assumption in the 1980s,” Apel adds.

            It’s the second time I hear about this idea. Anecdotal evidence around me seems to support it. I know very competent programmers that had mental blocks about mathematics. All competent programmers I know however are talented at writing and expressing themselves.

            In my opinion literacy and linguistic talent is a better predictor about the quality of the programming output of a person. I think because understanding algorithms and data structures is an important part, but even more important is communicating with your peer, and writing good quality code is all about communicating intent to other people in your team.

            1. 1

              Indeed, I agree about program comprehension; However, I wonder if the same can be said about writing a new program. That is, if you are asked to implement a new algorithm from scratch, would it still light up the speech processing parts of the brain. Going the reverse; if one is trying to understand a mathematical paper, would the logical parts of the brain still light up?

              1. 1

                In my opinion literacy and linguistic talent is a better predictor about the quality of the programming output of a person. I think because understanding algorithms and data structures is an important part, but even more important is communicating with your peer, and writing good quality code is all about communicating intent to other people in your team.

                Ultimately, programming is a form of communication, and art. Knuth argues that here. You need to be able to understand your own thoughts well enough to put them down in a medium, which is fundamentally a form of art. It’s a dialogue between yourself, it’s a dialogue with the platonic idea-space, and it’s a dialogue with the computer, it’s systems, and other people who read it. There’s room for process, but that does not deny that fundamentally it has an artistic component that we as a field, constantly ignore, that we stifle. The more we regard programming as a mechanical endeavour, or as a scientific endeavour, the more we deny and devalue our own independence, skill, proficiency, and the work itself. Attempts to ‘codify’ programming will fail, without that acknowledgement.

            1. 1

              The initial and recurrent issue of VLIW is having a smart enough compiler.

              I have worked on another project using VLIW. On paper it is very interesting, you can get into theoretical very high FLOPS with rather low power, and the arch itself seems pretty simple. You can take older open arch and adapt them (the project I worked was also adapted from SPARC, like this one).

              But you need to have a lot of firepower on the software side, and have a real strategy to get a good compiler. I have yet to see it succeed.

              All those VLIW projects could maybe mutualize their efforts, have a common optimization pass specialized for VLIW in OSS compilers.

                1. 16

                  Unfortunately, the comparison is written in such a clearly biased way that it probably makes fossil sound worse than it is (I mean you wouldn’t need to resort to weasel words and name-calling if fossil was valid alternative whose benefits spoke for themselves .. right?). Why would anyone write like that if their aim is to actually promote fossil?

                  1. 5

                    The table at the top is distractingly polemic, but the actual body of the essay is reasonable and considers both social and technical factors.

                    My guess is that author is expecting the audience to nod along with the table before clicking through to the prose; it seems unlikely to be effective for anyone who doesn’t already believe the claims made in the table.

                    1. 4

                      This is what’s turned me off from even considering using it.

                    2. 12

                      “Sprawling, incoherent, and inefficient”

                      Not sure using a biased comparison from the tool author is useful. Even then, the least they could do is use factual language.

                      This is always something that gripes me reading the recurring fossil evangelism: git criticism is interesting and having a different view should give perspective, but the fossil author always use this kind of language that makes it useless. Git adapts to many kind of teams and workflow. The only thing I take from his comparison is that he never learnt to use it and does not want to.

                      Now this is also a very valid criticism of git: it is not just a turn-key solution, it needs polish and another system needs to put forth a specific work organization with it. That’s a choice for the project team to make. Fossil wants to impose its own method, which of course gives a more architected, polished, finish, but makes it impossible to use in many teams and projects.

                      1. 2

                        Maybe they don’t care about widely promoting fossil and just created that page so people stop asking about a comparison?

                      2. 5

                        One of the main reasons for me for not using Fossil is point 2.7 on that list: “What you should have done vs. What you actually did”. Fossil doesn’t really support history rewrites, so no “rebase” which I use nearly daily.

                        1. 2

                          This is also a problem with Git. Like you, I use rebase daily to rewrite history, when that was never really my objective; I just want to present a palatable change log before my changes are merged. Whatever happens before that shouldn’t require something as dangerous as a rebase (and force push).

                          1. 4

                            I don’t think it makes any sense to describe rebases as ‘dangerous’, nor to say that you want to present a palatable change log without rewriting history unless you’re saying you want the VCS to help you write nicer history in the first place?

                            1. 2

                              I think whether rebase is dangerous depends on the interface you are using Git with. The best UI for Git is, in my opinion, Magit. And when doing a commit you can choose from a variety of options, one of them being “Instant Fixup”.

                              I often use this when I discover that I missed to check-in a new file with a commit or something like that. It basically adds a commit, does an interactive rebase, reorders the commits so that the fixup-commit is next to the one being fixed and executes the rebase pipeline.

                              There are other similar options for committing and Magit makes this straight-forward. So much, indeed, that I have to look up how to do it manually when using the Git CLI.

                              1. 2

                                Rebase is not dangerous. You have the reflog to get back to any past state if needed, you can rewrite as much as you need without losing anything.

                                Now, I see only two ways of presenting a palatable change log: either you are able to write it perfectly the first time, or you are able to correct it. I don’t see how any VCS would allow you to do the first one. If you use a machine to try to present it properly (like it seems fossil strives to do), you will undoubtedly hit limitations, forcing the dev to compose with those limitations to write something readable and meaningful to the rest of the team. I very much prefer direct control into what I want to communicate.

                                1. 4

                                  I prefer to work offline. Prior to Git I used SVK as frontend for SVN since it allowed offline use. However, once Git was released I quickly jumped ship because of its benefits, i.e. real offline copy of all data, better functionality (for me).

                                  In your linked document it states “Never use rebase on public branches” and goes on to list how to use rebase locally. So, yes, using rebase on public branches and force-pushing them is obviously only a last resort when things went wrong (e.g. inadvertently added secrets).

                                  Since I work offline, often piling up many commits before pushing them to a repo on the web, I use rebase in cases when unpushed commits need further changes. In my other comment I mentioned as example forgotten files. It doesn’t really make sense to add another commit “Oops, forgotten to add file…” when I just as easily can fixup the wrong commit.

                                  So the main reason for using rebase for me is correcting unpushed commits which I can often do because I prefer to work offline, pushing the latest commits only when necessary.

                                  1. 2

                                    In addition to what @gettalong said, keep in mind the original use-case of git is to make submitting patches on mailing lists easier. When creating a patch series, it’s very common to receive feedback and need to make changes. The only way to do that is to rebase.

                              1. 4

                                We need to stop writing drivers in such ad-hoc and low-level ways. This is the second large effort to reverse-engineer Mali, after Lima, and the primary artifacts produced by these projects are piles of C. Long-term maintainability can only come from higher-level descriptions of hardware capabilities.

                                I’m a little frustrated at the tone of the article. I was required to write this sort of drivel when I was applying for grants, but by and large, the story of how I wrote a GPU driver is simple: I was angry because there wasn’t a production-quality driver, so I integrated many chunks of code and documentation from existing hard-working-but-exhausted hackers to make an iterative improvement. The ingredients here must have been quite similar. The deliberate sidelining of the Lima effort, in particular, seems rather rude; Panfrost doesn’t mark the first time that people have been upset with this ARM vendor refusing to release datasheets, and I think that most folks in the GPU-driver-authorship world are well aware of how the continual downplaying of Lima is part of the downward spiral that led to their project imploding.

                                I don’t think I ever hid that r300, r500, and indeed radeonhd, from the same author as Lima, were all big influences on my work, and that honest acknowledgement of past work is the only way to avoid losing contributors in the future.

                                1. 16

                                  I’m a little frustrated at the tone of the article. I was required to write this sort of drivel

                                  Is it not possible that the tone is a true, unforced reflection of the author’s enthusiasm? That’s how I read it. Maybe that’s just naive of me.

                                  1. 9

                                    Long-term maintainability can only come from higher-level descriptions of hardware capabilities.

                                    Is there any source you can provide indicating that this would actually work? From my understanding, creating meaningful abstractions over hardware is an extodinarily tough problem to solve. For example device trees work as a general purpose description of hardware, but still need a lot of kernel-space driver fluff to get anything talking correctly. What kind of higher level description do you think would work in this space?

                                    FYI: I have zero experience in graphics driver land so I don’t actually know anything about this domain. ¯\_(ツ)_/¯

                                    1. 1

                                      I read it not as “assembling a driver from common code components and interfaces in c”, but as “write a high-level description of the hardware and api, from which implementations in C or Rust or whatever can be generated”.

                                      But maybe we’re both reading it wrong :)

                                    2. 4

                                      Isn’t the primary artefact produced a set of instruction able to use a GPU? I would think it comes first, before the piles of C.

                                      Long-term maintainability can only come from higher-level descriptions of hardware capabilities.

                                      This seems like an extraordinary claim. “Can only come from” is a very strong statement.

                                      1. 4

                                        GPU drivers are not required to have a single shape. Indeed, they usually have whatever shape is big and complex enough to fit their demanded API. The high-level understanding of GPUs is what allowed the entire Linux GPU driver tree to be refactored around a unified memory manager, and what allowed the VGA arbiter to be implemented. High-level descriptions, in particular datasheets, are already extremely valuable pieces of information which are essential for understanding what a driver is doing. At the same time, the modern GPU driver contains shader compilers, and those compilers are oriented around declarative APIs which deal with hardware features using high-level descriptions of capabilities.

                                        Let me show you some C. This module does PCI ID analysis and looks up capabilities in a table, but it’s done imperatively. This module does very basic Gallium-to-r300 translation for state constants, but rather than a table or a relation, it is disgustingly open-coded. (I am allowed to insult my own code from a decade ago.) I won’t lie, Panfrost has tables, but this is, to me, only the slightest of signs of progress.

                                        1. 3

                                          Ah, I see what you mean.

                                          Higher-level description means genericity, this can lead to bloated code trying to deal with the future, impairing the present. Trying to keep the proper balance of high-enough description and low-enough efficient description is a challenge.

                                          Helping the maintenance effort by lending hands to refactor with a fresh mindset is my naive view of how to fight this, but I know this is falling prey to the rewrite fallacy.

                                    1. 3

                                      I have used Snowden’s argument (referred to in this comment: https://lobste.rs/s/6yrndd/how_do_you_talk_i_have_nothing_hide_people#c_0la4ee ), however this is sometimes ineffective when the person is not politically interested in “solidarity” or resistance against the oppression.

                                      For the more individualistic people, I’ve switched to using “saying that you do not care about privacy because you have nothing to hide, is like saying you don’t care about advertising because you have nothing to buy”. One of the core issue with privacy, that affects everyone is that privacy-invading services are built to coerce and manipulate opinion on a large scale. To some, this is acceptable when dealing about mundane stuff (what you will buy for your week groceries), but I’ve yet to encounter someone who thought it was okay when going into the political / social realm. Recent examples were pretty clear that the end-game here is not just advertising, but also vote manipulation and political destabilization of democracies.

                                      When I’m saying that is like “saying that you do not care about advertising because you have nothing to buy”, it’s not that it is the same as ads (for better or worse), because many are not at all opposed to seeing ads. It’s more about the few people saying that they are not themselves impacted by advertising. It affects everyone, even those that are aware of its effect. This is overt manipulation. The issue with privacy is that it gives amunition to people that are trying to do exactly the same as advertising, but with other subjects, and even if you believe that it won’t affect you, everyone can fall prey to disinformation.

                                      1. 4

                                        Haha, I did exactly this, minus the coloring for a presentation to a client. I only had an SSH access to my machine and was demoing CLI tools, so was too lazy to change context (and was able to have the slides stay into a corner of the screen with the tool taking the other side).

                                        Without much formatting, the script itself is very short, it was fun. Not sure the client was impressed however! But the presentation went well (at least the product was exceeding expectations).

                                        I’m not sure there are many reasons to do it in bash instead of POSIX shell however? Only thing lacking might be local variables in functions, but many shell still implement them.

                                        1. 3

                                          Local variables (or more specifically the ‘local’ keyword) can be mimicked in POSIX shell by wrapping the code in ( ) with the expense of a sub-shell.

                                          Example:

                                          (
                                              var=hello
                                              printf '%s\n' "$var"
                                          )
                                          
                                          # '$var' will be unset.
                                          printf '%s\n' "$var"
                                          

                                          I also sometimes do this with functions themselves.

                                          func() (
                                              var=hello
                                              # code here.
                                          )
                                          

                                          (Notice how ‘()’ is used in place of ‘{}’ for the function body).

                                          1. 2

                                            Interesting! I’m planning to use this in a talk I’m giving this weekend. Let’s see how that goes. :D

                                            I’m not sure there are many reasons to do it in bash instead of POSIX shell however?

                                            I use bash interactively and am fairly comfortable with its features; mapfile etc. are pretty nifty. Shouldn’t be too hard to port it to POSIX sh though—I just might.

                                          1. 4

                                            As someone who is working in the telecom industry, I can assert, mobile network operators have become less composed of technical experts creating and doing their own things and more about managing and juggling multiple vendor solutions. It has become rare to encounter mobile operators that know what they are doing without relying on consultants hired for specific projects and delegating everything to the cheapest third party that fulfills the RFP written by that consultant. Even more absurd, sometimes the consultants have no idea what they are talking about and MNOs are buying things they have no clue about and will never use just for the hype of ticking a box on a sheet.
                                            Let’s add that the field is hard to get into, the documentation is fierce to dive in. That leads to many security vulnerabilities, which are in a lot of cases not really vulnerability but features and configurations that haven’t been set properly because no one had any idea what they were doing.

                                            1. 1

                                              How much did the complexity of the standards contribute to this disaster? Why is the world still hooked on this mobile crap instead of having good public Wi-Fi coverage everywhere?

                                              1. 8

                                                The Wi-Fi standard is not well-suited for medium-distance communication. The frequencies only work on short-distance. The mobile crap is like this because it is complex to build a good network with some distance between the nodes. Using Wi-Fi instead would not make it magically better, you’d have complex addendum to the Wi-Fi to make it minimally viable.

                                                Funnily, the frequencies for 5G will also favor short-distances, meaning only high-density cities will have proper coverage.

                                                1. 1

                                                  The standards are amendments over amendments over amendments, all stacking one over the other and referencing one another. You literally have to jump between 10-20 documents all the time. So I think that yes, the standards being convoluted has pushed mobile operator away from implementing them and letting third party handle the complexity. As for Wi-Fi, you’d need a brand new infrastructure to cover everything, which costs money, time, and legal approval in many countries. Mobile has the premise of being seamless. Let’s also not forget the players here, sim card manufacturers are manufacturing credit and debit cards, passports, and sometime even cash money for countries. They are very big. Same for core network equipment manufacturers. There’s a whole ecosystem of actors that benefit from this.

                                                  1. 1

                                                    In many many countries that’s just not possible, while upgrading the existing infrastructure is easier to do and is almost invisible to the end-user.

                                                1. 3

                                                  In the “Handling Collisions” section, he writes

                                                  It is possible that hash_b will return 0, reducing the second term to 0. This will cause the hash table to try to insert the item into the same bucket over and over. We can mitigate this by adding 1 to the result of the second hash, making sure it’s never 0.

                                                  How does adding 1 to a hash ensure that it’s not 0?

                                                  1. 1

                                                    It’s possible for hash_b(x) = 0, so that (hash_a(x) + i) * hash_b(x) is always 0, no matter how many times you increase i to get another bucket.

                                                    1. 2

                                                      It’s possible hash_b(x) = -1

                                                      1. 2

                                                        Looking at the ht_hash implementation, it doesn’t look like it will ever return negative values.

                                                        1. 2

                                                          So the hash function can return [0, INT_MAX], meaning that (INT_MAX + 1) is possible. If hash_a() can also return 0, we thus have 0 + (undefined behavior probably being -1) % num_buckets.

                                                          -1 % num_buckets still returns -1. Not a good idea for an index.

                                                          The guide is interesting, pretty simple. But those issues are fundamental in C and should be tackled right now. It does not add too much complexity to limit the number of buckets, only use unsigned values (avoid undefined behavior), and check for edge-cases.

                                                          The hash function itself can easily overflow a long integer, meaning that the precaution of up-casting to long, modulo then restrict to int is useless and incorrect. Still undefined behavior.

                                                          There are other well-defined stream hash-functions, easy to write in a few lines that can be used instead.

                                                          1. 5

                                                            The hash function returns [0, m] where m is the number of buckets (at least in ht_get_hash). That means, unless the hash table has INT_MAX buckets, hash_b + 1 won’t overflow.

                                                            The overflow potential that is there is that hash += (long)pow(a, len_s - (i+1)) * s[i]; could overflow the long hash; it probably won’t because long is probably 64 bits, but on some systems (maybe especially the kind of system where you would want a home grown hash table implementation), long could be 32 or 16 bits. I agree that using unsigned there would be better.

                                                            Also, while it doesn’t really matter to this discussion, 32-bit INT_MAX + 1 overflows from 01111111111111111111111111111111 to 10000000000000000000000000000000, which represents -2147483648 in two’s complement, not -1. -1 would be all bits set to 1. (Of course, this is UB and the compiler could just make the program terminate or launch nethack or whatever instead)

                                                  1. 2

                                                    I used to sort of like strl*

                                                    But I now prefer to let my code die noisily and as soon as possible when I do such stupid…

                                                    I then know I’m doing stupid.

                                                    I then fix my code.

                                                    My code is then no longer stupid.

                                                    1. 3

                                                      What are you trying to say? Do you prefer to use strncpy instead of strlcpy because strncpy is somehow noisier? What?

                                                      1. 2

                                                        I’m saying both are a Bad Idea.

                                                        If you hit the case in strl* where you need to truncate the result so you can null terminate AND/OR the case in strn* where you don’t null terminate…..

                                                        You have a bug.

                                                        So wrap ’em both (or replace them) and check for that case and die noisily as soon as possible and then fix your code.

                                                        Or use a memory safe language such as D.

                                                        1. 1

                                                          String truncation is not necessarily a bug. You might have outside requirements. The correct thing to do is to check it properly, which needs to be done in all languages.

                                                          strlcpy is cumbersome for truncation check. At least it leaves the memory in a better shape. strscpy is better to quickly check that you properly copied your string

                                                          1. 2

                                                            If we were all perfect… we wouldn’t even be talking about strn*

                                                            We’re talking about it because the strn* api’s are a very very common source of defects. They are at the 2.5 to 3 out 10 on the Rusty Scale of API Goodness http://sweng.the-davies.net/Home/rustys-api-design-manifesto

                                                            So you’re right. “String truncation is not necessarily a bug”, it just is around about 99 out of a 100 uses.

                                                            My proposal bumps it up to 5/10 on the scale.

                                                    1. 2

                                                      This is not the job of strlcpy to initialize memory.

                                                      memset or = {0};, don’t rely on quirks from badly designed functions. strncpy() will always write len bytes, but that’s going beyond the scope of a copy function.

                                                      1. 1
                                                        #define strscpy(dst, src, len)  \
                                                            do {                        \
                                                                memset(dst, 0, len);    \
                                                                strlcpy(dst, src, len); \
                                                            while (0);
                                                        

                                                        How’s this? I bet there’s still a one-off bug somewhere.

                                                        1. 3

                                                          not that it matters, but memset(3) will return dst, so you could (maybe not should) also do

                                                          #define strscpy(dst, src, len) \
                                                          	strlcpy(memset(dst, 0, len), src, len)
                                                          
                                                          1. 2

                                                            Still has the problem of evaluating len twice.

                                                            For clarity’s sake, a better approach here would be to implement strscpy as a (potentially inline) function rather than a macro. The types of all the arguments are known and there’s no preprocessor trickery going on.

                                                          2. 2

                                                            Probably just a typo, but drop the semicolon after while (0). Having it defeats the purpose of wrapping your code in a do {} while loop in the first place.

                                                            1. 1

                                                              You’re right that it’s a typo, but it doesn’t break anything, as far as I see. It would just equality valid to add or to omit a semicolon in the real code.

                                                              1. 10

                                                                The whole point of using do { ... } while (0) is to handle the case where adding a semicolon in the real code is not valid. Consider the calling code

                                                                if (a)
                                                                    macro();
                                                                else
                                                                    foo();
                                                                

                                                                If you define your macro as #define macro() do { ... } while (0) then this works fine. But if you define it as do { ... } while (0); then this expands to

                                                                if (a)
                                                                    do { ... } while (0);;  /* note two semicolons here */
                                                                else
                                                                    foo();
                                                                

                                                                That extra semicolon counts as an extra empty statement between the body of the if and the else. You can’t have two statements in the body of an if (without wrapping things with curly braces) so the compiler will refuse to compile this. Probably complaining that the else has no preceding if. This is the same reason why plain curly braces don’t work properly in a macro.

                                                            2. 2

                                                              How do you detect truncation?

                                                              strlcpy will also attempt to evaluate strlen(src), meaning that if src is malformed, you will read memory that should not be read, and you will waste time evaluating it in every case.

                                                              ssize_t strscpy(char *dst, const char *src, size_t len)
                                                              {
                                                              	size_t nleft = len;
                                                              	size_t res = 0;
                                                              
                                                              	/* Copy as many bytes as will fit. */
                                                              	while (nleft != 0) {
                                                              		dst[res] = src[res];
                                                              		if (src[res] == '\0')
                                                              			return res;
                                                              		res++;
                                                              		nleft--;
                                                              	}
                                                              
                                                              	/* Not enough room in dst, set NUL and return error. */
                                                              	if (res != 0)
                                                              		dst[res - 1] = '\0';
                                                              	return -E2BIG;
                                                              }
                                                              
                                                              1. 1
                                                                char *dir, pname[PATH_MAX];
                                                                if (strlcpy(pname, dir, sizeof(pname)) >= sizeof(pname))
                                                                    goto toolong;
                                                                
                                                            1. 3

                                                              Syn, Syn/Ack, Ack TCP segments will be 64 bytes, which is also the smallest Ethernet frame a driver will send (the nicer ones padding the payload with zeroes if a packet was shorter). This is a good lower-bound to use for stress-testing, as the connection-per-second will be influenced by the capability of a system to process such short packets.

                                                              Then, it is also good to know there is a PPS budget on EC2 instances. What I find curious is that kernel-bypass solutions are able to go way over this limit, and Amazon published an ENA driver in DPDK for higher-loads. With the budget seen here, such kernel-bypass solution seems useless.

                                                              1. 1

                                                                I updated with 0 bytes payload (54 byte packets) results.

                                                                Yes, trying DPDK would be interesting. At packet rates reported in our blog kernel handling seems to be perfectly sufficient.

                                                              1. -5

                                                                We need an actual replacement for C and the Rust team is bickering about monads.

                                                                Rust seems like a playtoy for CT students. A toy won’t be used by people for serious projects in the long run.

                                                                Adding a single new way to express types means that everyone needs to learn this new feature. Even if some sane project forbid its use, others won’t and all practictioners will need to be familiar with the entirety of the language to be able to efficiently and safely use the language.

                                                                When will we have C with a borrow-checker? A new PL language is certainly nice and a good stroke to the ego of a few, but it won’t solve current pressing issues.

                                                                1. 8

                                                                  “A toy won’t be used by people for serious projects in the long run.”

                                                                  It’s used in serious projects by businesses right now. Example. There’s also two OS’s, one for desktops and one for microcontrollers. It’s already more than a toy. I think there’s a lot of people that like C’s style who won’t adopt something as different as Rust, though. Zig is promising as something they might like.

                                                                  “When will we have C with a borrow-checker? “

                                                                  I’ve argued for that myself. The best of the safer C’s that might be given Rust’s borrow-checker in version 2 were Clay and Cyclone. Whatever is built needs to stay close to C’s actual style to get more people interested in it. C was not designed for verification, though. So, this means all the difficulties of analyzing its safety go up as one gets close to its current design and implementations. Maybe someone will figure out a simpler, safer, and still C-enough design. If not, people won’t move unless they have to.

                                                                  Hence, why I favor regulations that force memory safety into apps. Then, they’ll use Rust, D, design a better C… anything that outweighs the fines or legal damages from their avoidable vulnerabilities.

                                                                  1. 0

                                                                    Is there a language that expresses lifetimes as types that can be shared by objects?

                                                                    There would be the two default lifetimes ‘static’ and ‘’ (on the stack). Then one would have to describe the equivalent of the Send and Sync trait for any other lifetimes, which would describe how the memory will be allocated, how it will be read, written and then freed.

                                                                    This means that you’d have lifetimes describing exactly how a memory block will work, and a borrow-checker would be able to verify that objects used in an interface would respect the expected lifetime.

                                                                    The Rust notation is clunky and limiting. Lifetimes seems like an afterthought, something that had to be slapped on the type system to make the borrow-checker happy. But it should be central and explicit.

                                                                    I’m not asking for a C-like syntax. I’m asking for C-like simplicity and clarity. Structs and memory maps should not be inheritable, no generics. Lifetimes could however be scoped (when an object embeds another).

                                                                    Then there should be the sane practices like const by default, NULL sumtype, utf-8 string slices (and accompanying library) (Rust is doing that perfectly).

                                                                    1. 2

                                                                      “The Rust notation is clunky and limiting. Lifetimes seems like an afterthought, something that had to be slapped on the type system to make the borrow-checker happy. But it should be central and explicit.”

                                                                      I can’t answer you on that. I do like putting things in perspective. Your wording makes it seem like there’s a ton of languages doing borrow checkers with Rust having a shitty one. There’s only two that I know of with Rust having made it (Clay didn’t). All the other languages either don’t have safety or have runtime cost.

                                                                      Also, the property is none of these temporal errors on all inputs. That’s similar to formal verification. Before Rust, the way you do that for a systems program (esp C) was separation logic. Microsoft’s tool, VCC, was better than most. Their proof specialists were cranking out two lines of code a day on average. Rust has people learning data-orientied design, their language constructs, and certain amount of time to make it click to get same result. That’s a major improvement.

                                                                      Whatever you’re advocating needs to do what selaration logic does for imperative, low-level code with at least the usability and ergonomics of Rust. There’s your goal post. Post it when you find or design it. :)

                                                                  2. 5

                                                                    We need an actual replacement for C and the Rust team is bickering about monads.

                                                                    I don’t think it’s the Rust team, nor bickering; more like the musing of a fan of Haskell who sees Rust as his ticket to using FP in production. If that stays at the stage of musing or if it becomes the foundational idea for a new programming language (i.e., not Rust), then all the success to the author.

                                                                    I came to Rust a few years ago from OCaml. At first, I tried to use Rust in an OCaml style, and I was thoroughly put in my place by the compiler. The functional style goes against the grain in Rust—many methods work by mutation (e.g., concatenating two vectors) rather than by returning new values as in functional languages; many of the cool techniques of FP (e.g., persistent data structures) are either impossible or way too inconvenient for Rust. I’ve also struggled trying to use some methods (e.g., HashSet::union()) in a functional style; the union method returns an iterator rather than an actual object and taking the union of three objects efficiently turned out to be quite difficult; I ended up using mutation and it was easy and simple:

                                                                    let mut a = ...;
                                                                    let b = ...;
                                                                    let c = ...;
                                                                    for elem in b { a.insert(elem); }
                                                                    for elem in c { a.insert(elem); }
                                                                    

                                                                    After being thwarted enough times, I began using Rust like Rust wants to be used—like a procedural language. There’s no point in trying to force the language into a style that it’s not suited for: the language gets more complex (and Rust certainly doesn’t need anymore of that) and the costs in the future will be high for little (I think) benefit.

                                                                    Edit: Here’s the code for doing the union of three sets in functional and procedural styles: https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&gist=c1f3b54ef83a4e017b6865db2be6ffac

                                                                  1. 1

                                                                    This seems to have two thesese. One, that resources are used more to do the same amount of work, is almost true. We could make do with much fewer resources, if our stacks got much simpler. Look at how heavy things like ZFS are in terms of complexity for what they do. Some of this can be cleaned up.

                                                                    The second is that we are doomed because of it. Our doom follows historical trends in decreasing rates of childbirth, not in trivial things like how many clock cycles a clock simulation takes every second.

                                                                    Also I don’t take kindly his dismissal of libertarians. He seems to be misguided.

                                                                    Also: human time is a resource too. It can be exhausted like any other.

                                                                    1. 3

                                                                      One, that resources are used more to do the same amount of work

                                                                      This is not his thesis. He picks up Borgmann’s device paradigm, which leads to an alienating approach of resource consumption. This is not that too much is consumed for the current work, but that the base reflex of “encapsulating” complexity leads to a kind of impedance mismatch with your environment, a loss of focus on what matters in our lives.

                                                                      Seeing this as only an issue of “too much resource for too little results” is completely myopic. The issue is not that it is inefficient, though it is, but that it leads to an ever-increasing resource consumption, without regard to things and principles that matters (“focal things and practices” from Borgmann).

                                                                      His view of libertarians having completely lost touch from this is right, and his quips at them building their ethics on this flaw is well stated. Libertarianism is the death of any society, a completely delusional dismissal of basic economic concepts like “market failure”.

                                                                      1. 1

                                                                        Resource consumption without regard ignores other resources not listed. Or: all resource consumption is to lower other resource consumption, ideally not in equal measure.

                                                                    1. 15

                                                                      This fellow seems to be defending the use of systemd; it gets the job done, he argues. But even he won’t defend the attitude of its creator. When anyone says “systemd” the first thing that comes to mind for most people is outrageous arguments, name-calling, and vitriol on both sides.

                                                                      I’m somewhat hopeful that if we’ve learned anything in the time since systemd gained wide adoption, it’s that we can’t continue to ignore bad behavior from project leads. Ignoring social factors because you think the technology is solid is not a good strategy. Even Linus has realized this now.

                                                                      1. 0

                                                                        We only should care about social attitudes when a project has no more technical issues to resolve. Until then, the technology should come first, always.

                                                                        1. 9

                                                                          Not only will there always be technical issues to resolve (meaning we will never get around to the social issues), but software artifacts are an embodiment of social attitudes the same way any other work of engineering is (which means that our technical choices still be influenced by social ones).

                                                                          SystemD is centralized and monolithic because its governance is centralized around a single BDFL. It follows a design that is as consistent as its creator’s vision is. It replaces several daemons, which are inconsistent and don’t talk to each other very well because they were created by people with different visions who didn’t talk to each other very much.

                                                                          In other words, a compiler project with five teams will produce a five pass compiler. News at 11.

                                                                          1. 6

                                                                            “which means that our technical choices still be influenced by social ones”

                                                                            One of favorite examples: assignment being := vs = (or just not = vs =). The original ones used = for equality with a different symbol for assignment. One guy tweaking a language for an important project had a personal preference to use = for assignment. When it took off, we’ve been having = vs == errors ever since. Many designs followed the = pattern just assuming it made engineering sense or would be familiar. Just a social choice with long-term effects.

                                                                            1. 2

                                                                              Exactly. We will always have technical issues to resolve, and never get to social issues. We work with technology. Social issues are not relevant in technical forums. To use an extreme example, I will watch movies starring Kevin Spacey despite his personal checkered past, since I watch movies to be entertained, not for some meta purpose.

                                                                              Technical choices grow from our social understanding, but those choices can not be judged by that social understanding any more than software written by a black man, white man, Muslim, Jew, or Christian can be judged on the merits of the author’s beliefs or culture.

                                                                              SystemD provides a case study in how organizational groups effect the software produced, surprising nobody and shedding no light on the technical merits or problems with the monolithic approach. Argue why SystemD should be done differently or the same way, don’t stop your examination with the team that built it.

                                                                              1. 2

                                                                                surprising nobody and shedding no light on the technical merits or problems with the monolithic approach.

                                                                                But shedding light on the technical merit of a monolithic organization. Because there is a technical output, it is relevant to technical forums.

                                                                                If a reader here see this and starts to ponder how they want to structure their next project community, because it will have an impact on the kind of technical architecture that will naturally grow out of it, then the discussion was a productive one on a technical forum.

                                                                            2. 4

                                                                              I wish we could do this. Unfortunately, technology is there for humans to use, to try to serve human goals, so completely decoupling the two is not feasible.

                                                                              On a more practical level, if I’m reporting an obvious mistake in a piece of vital infrastructure that I’m being paid to deal with, and offer to put my time into fixing it if someone who knows what they’re doing can give me a big of guidance, I really don’t want to get told “working as intended” and have to spend hours arguing otherwise.

                                                                              1. 1

                                                                                Would you have any qualms about using reiserfs?

                                                                                1. 3

                                                                                  It’s practically unmaintained as I understand it, so yes, I’d have qualms about trusting it with my data.

                                                                                  1. 2

                                                                                    Though it didn’t say it explicitly, it seems pretty obvious to me that the question wasn’t about trusting it with your data, it was about the author being convicted of first-degree murder of his wife. Even if the filesystem were maintained, would that not give you pause before using it?

                                                                                    1. 4

                                                                                      I understood the point. No, even though the author has definitely killed his wife, the software is not necessarily bad.

                                                                            1. 19

                                                                              Urbit’s innovations have stood in the dark shadow of moldbug’s neofeudalist writings. Every time Urbit comes up in conversations among crypto people here in Berlin, someone in the group says “but have you looked at what Curtis wants the world to look like?” and then the subject changes.

                                                                              I think it’s good for the project that people can say “yeah but he’s gone now, what do you think about the ___ mechanism?” since there are some interesting ideas to examine in there. They built everything from scratch. A VM, a language, a filesystem, etc etc etc…

                                                                              But still, this is kind of like if Terry had stepped away from TempleOS.

                                                                              1. 7

                                                                                The whole concept as I understand it seems pretty interesting, but come on - the entire ecosystem of Urbit is still absurd. Hoon, the weird new pronunciation scheme you have to learn, the obtuse naming schemes…

                                                                                1. 3

                                                                                  I found the weird names annoying as well, but Curtis does come up with a valid reason for this, in that everything gets rewritten and refactored multiple times, so “…it lets the hard problem of naming get solved later, and hence better.” As the system gets more mature, and actually usable, it would be nice if they came up with some meaningful names for the bigger components (e.g. rename Ford to Build System). He also admits his biggest mistake was assigning 1 to false and 0 to true. I’m sure this was a result of his habitual contrariness.

                                                                                  1. 4

                                                                                    I’m sure this was a result of his habitual contrariness.

                                                                                    Or perhaps cognitive contamination from /bin/sh.

                                                                                2. 10

                                                                                  Every time Urbit comes up in conversations among crypto people here in Berlin, someone in the group says “but have you looked at what Curtis wants the world to look like?” and then the subject changes.

                                                                                  And I find this quite baffling. It’s deeply disappointing that people whom I respect default to this gossip-driven analysis instead, that a project as ambitious and worthy as Urbit gets buried in “foogate” style rumors.

                                                                                  Urbit is fascinating. It is the only project I know of designed to address distributed problems (viz. community moderation, censorship, identity, ownership) from an incentive-based approach instead of the typical GNU-style “sheer will and religion” approach.

                                                                                  1. 35

                                                                                    Since Curtis apparently wants the world to be in a certain manner and more or less spun up his own world in Urbit, maybe it’s prudent to consider what Curtis’ opinions on things are before adopting the project that likely embodies them?

                                                                                    I’m not sure myself, but in a project like this, it may be hard to meaningfully separate creator and creation - even after the creator left (as the fundamental architecture is still shaped in his image).

                                                                                    1. 6

                                                                                      I think the new primer https://urbit.org/primer/ makes a good case that there is nothing actually feudal about Urbit in practical terms. Once you own a planet, the personal level of Urbit entity, you are free to have its traffic routed by any star, the network routing level, that will accept you. This could be a problem it Facebook or some government buys up every star in the system, which is unlikely for the foreseeable future.

                                                                                      1. 6

                                                                                        Once you own a planet

                                                                                        Of which there will be - by design (“Any reputation system needs scarcity of identity.”) - fewer than there are people on this planet right now (4 billion in total). Given how these systems work, it will be interesting to reclaim “lost” ones, reducing supply even further over time.

                                                                                        Will everybody else be a sharecropper? Or will they have to spin up their own network?

                                                                                        Now these identities can be subpartitioned (“moons”, again 2^32, and they’re bound to their “planet”), but if global network size doesn’t matter, why setup such limits in the first place? This isn’t the 1970’s anymore (as they correctly state in their marketing material).

                                                                                        This could be a problem it Facebook or some government buys up every star in the system

                                                                                        They merely need to control the galaxies: “The galaxies form a senate which updates the logic of the Ethereum land registry by majority vote”. The platform doesn’t seem to design elections for this “senate” into the platform.

                                                                                        “Tlon remains the guardian of the urbit.org galaxies. We have always wanted the address space to be widely distributed.” - address space, yes. But Tlon owns the right to repartition the entire platform as they “bought back” galaxies. Even if you “own” a planet, that’s only one of Tlon’s decisions away from not being yours anymore.

                                                                                        Since control over your data is bound to a planet, which is contingent of (at some point) a galaxy “sponsoring” you, and they can make up all the rules, it looks like just the same kind of sharecropping to me as any of the big vendor-lock platforms that make up the modern internet. Just with more obscure ownership.

                                                                                        1. 5

                                                                                          and they can make up all the rules

                                                                                          This is just dishonest. The “rules” are voted on by a senate, the same way the rules of the internet are voted on by the IEEE currently.

                                                                                          Tlon owns the right to repartition the entire platform as they “bought back” galaxies. Even if you “own” a planet, that’s only one of Tlon’s decisions away from not being yours anymore.

                                                                                          False. Owning Urbit addresses is like owning a bitcoin wallet. Tlon can’t take it away from you any more than Satoshi can.

                                                                                          (edit:)

                                                                                          if global network size doesn’t matter, why setup such limits in the first place?

                                                                                          Global network size does matter, as you quoted, “Any reputation system needs scarcity of identity.” It seems to me like you are giving Urbit a bad-faith reading. If you try a good-faith reading, try the “principle of charity”, you might find that you agree with Urbit more than you realize.

                                                                                          1. 5

                                                                                            The “rules” are voted on by a senate

                                                                                            Who or what makes up the senate? I quoted the part of their marketing material already and to me it looks like absolute rule by whoever controls a majority of galaxy nodes, so 129 hosts. The rules they vote on make up the “land registry”, from which, apparently, everything else is derived.

                                                                                            “Any reputation system needs scarcity of identity”

                                                                                            Yes, I quoted that.

                                                                                            But how is a reputation system relevant to what you can or cannot do to your append-only data log? I prefer scuttlebutts solution to approximately the same problem: you keep your log, I keep my log, and if I decide to trust you, I also look at your log (and parse the bits you decide to share with me by giving me the keys).

                                                                                            No need for reputation except the reputation that already exists in the real world, that makes me decide whether to trust you.

                                                                                            [edit to add: the Urbit folks claim elsewhere that galaxies and stars are entirely meaningless, but since they’ve been made part of the fabric that makes up the platform, by having them spawn each other and planets, they can’t be that meaningless. Otherwise, why add them in the first place?]

                                                                                            1. 3

                                                                                              Who or what makes up the senate?

                                                                                              Galaxy owners. See the bottom of https://urbit.org/primer for the distribution. I don’t think anyone really knows exactly how this will work yet, the owners are pretty well distributed with nobody owning 51% of the address space.

                                                                                              But how is a reputation system relevant to what you can or cannot do to your append-only data log?

                                                                                              It’s not. A reputation system is relevant to how valuable my Urbit is. If I start spamming people with my planet, then the star that is my supervisor can stop sending me packets. I could move to another star, but if my reputation gets bad enough, nobody will want to send/receive my packets, and my Urbit will become worthless, I wouldn’t even be able to resell it. This is not the case with e.g. email addresses, which spammers can create ad infinitum. That is the only reason for the scarcity of addresses.

                                                                                              Re: the append log, only I can write to that, no different than scuttlebutt.

                                                                                              Also, nobody claimed galaxies and stars are meaningless; they are network infrastructure responsible for routing packets. They are arbitrary in that a planet doesn’t really care which star it’s getting packets from, just like you don’t care which AWS data center is serving you a website.

                                                                                    2. 18

                                                                                      Paraphrasing a comment I made about Jordan Peterson’s work - learning Urbit and the weird way it is structured is a significant time investment. A simple heuristic to determine whether something is worth your time is to check what the creator of this thing is like.

                                                                                      In the case of JP, my impression is unfortunately only 3rd hand.

                                                                                      In the case of Jarvin, or rather his alter ego Mencius Moldbug, I have read some primary material, such as the following blog post:

                                                                                      https://www.unqualified-reservations.org/2013/01/how-bitcoin-dies/

                                                                                      Imagine that the BTC/USD market is perfectly liquid with no exchange overhead. Imagine also that there are two types of BTC users: Jews, who speculate (holding BTC long-term with the expectation that it will appreciate against USD); and Aryans, who only trade (and sweep all BTC balances into USD at the end of every day). These are simplifications, of course—but edifying ones.

                                                                                      Jarvin was (in my imperfect recollection) criticized for the use of these terms, and (again, iirc) replied that he was only being “provocative”. Fair enough, I’m sure Jarvin (and people of his ilk) have plenty of experience in discussing whether what they’re writing is only provocative or if they’re genuinely anti-Semitic (Jarvin identifies as a Jew, I believe). It’s a depressingly common occurrence online.

                                                                                      But from a step outside, looking at something to invest time and effort in, and seeing that a project is closely identified with a person I would never want to be associated with, it’s quite easy to choose not to delve too much further.

                                                                                      I also happen to believe that he (along with many cryptocurrency enthusiasts) are fundamentally mistaken about how economics work, and I discount Urbit for that reason too.

                                                                                      1. 1

                                                                                        In the case of Peterson, his work is philosophical, so that heuristic makes a large amount of sense. Although when dealing with someone so, uh, misrepresented by various groups, I’d think it would be more sensible to actually look at the (readily, freely available) source material.

                                                                                        I agree that it is a significant time investment to fully understand, but I think you can get a good approximation of his basic mindset by watching one of his non-combative interviews, or one or two of his (non-biblical) lectures .

                                                                                        1. 1

                                                                                          Thanks for the suggestions!

                                                                                          I was a bit unclear when I wrote:

                                                                                          In the case of JP, my impression is unfortunately only 3rd hand.

                                                                                          I meant it in the narrow sense that I cannot offer any first-hand critique of his work. I’m really hesitant to parrot statements like “Person X holds Y views” unless I’ve verified this personally.

                                                                                          (I’d love to post a link to my comment but it’s really hard to find on the site, I’ll try to update if I can find it)

                                                                                          However, there’s a limit of how much time I’m prepared to spend just to be able to defend or criticize someone. In JP’s case, my desire to engage with his work is minimal since his most well-known public stance is vociferously anti-trans.

                                                                                          1. 1

                                                                                            In JP’s case, my desire to engage with his work is minimal since his most well-known public stance is vociferously anti-trans.

                                                                                            This is a good example of why it is worth going to the source. Peterson is not anti-trans, which he has stated many times and demonstrated by having respectful, productive interviews with at least one trans person that I can think of (Theryn Meyer).

                                                                                            The popular narrative conflates his objection to compelled speech in general with his objection to trans people (who were the subject of a particular piece of compelled speech legislation).

                                                                                            1. 2

                                                                                              I was prodded by your comment to read up a bit more about the entire Canadian controversy that I referred to.

                                                                                              You’re correct, based on the reporting I’ve read JP can’t be denoted as anti-trans. Thanks for encouraging me to learn more about this issue.

                                                                                              1. 3

                                                                                                Thanks for being open to revisiting your views; that’s a remarkably rare virtue.

                                                                                        2. 0

                                                                                          if they’re genuinely anti-Semitic (Jarvin identifies as a Jew, I believe) … are fundamentally mistaken about how economics work, and I discount Urbit for that reason too.

                                                                                          What? You seem confused. Urbit is a technological structure, not a political one or economic one.

                                                                                          1. 18

                                                                                            Urbit is a technological structure, not a political one or economic one.

                                                                                            The entire premise of Urbit is the ownership of “scarce resources” (analogous to physical land) where one can seek rent. That’s both economic and political.

                                                                                            1. 4

                                                                                              Ok, but that’s no different from DNS.

                                                                                              Also:

                                                                                              Urbit’s distribution and sponsorship hierarchy of galaxies, stars and planets is not designed as a political structure, or even a social structure. The actual social layer is in userspace – one layer up.

                                                                                              Socially and politically, Urbit is a flat network of planets. Galaxies and stars are plumbing. No one cares which star is your sponsor, any more than your Facebook friends care who your ISP is, or you care what data center Facebook is in.

                                                                                              1. 6

                                                                                                Ok, but that’s no different from DNS.

                                                                                                DNS is absolutely a politic, economic and technical structure.

                                                                                                1. 3

                                                                                                  You’re misunderstanding structures and the downstream implications that these structures cause. DNS is a techincal structure that has implications which are technical, political, and economic.

                                                                                                  The US Congress is a political structure which has implications that are political and economic (and sometimes technical, in the case of, say, regulating Facebook data privacy or whatever).

                                                                                                  1. 7

                                                                                                    DNS isn’t just a technical structure. The distinction between structures and implications (which I don’t think is useful in this context anyway) does to economics, but DNS does make political/social choices - for example, the number of root servers, control being hierarchical rather than distributed, and so on. All of these are both technical and political choices that the project makes, and that’s after generously excluding the organisations, committees, and documents that make DNS work.

                                                                                                    Urbit’s choice to have “scarce resources” is an intentionally different political choice from the one DNS made, which never intended to hit the resource limits we currently have with IPv4 - which is why we now have IPv6, and an address space where addresses becoming scarce is almost entirely implausible for the foreseeable future. Urbit’s choice was made with full knowledge of how scarcity effects these systems, making it absolutely clear that the design decision is political, not technical.

                                                                                            2. 7

                                                                                              Is there an example of a technology that doesn’t have political or economic implications? Considering the potential scope and impact of Urbit beyond its technological contributions seems especially important since it seems to me that it’s trying to alter the current conventional paradigm for internet services.

                                                                                              1. 3

                                                                                                Is there an example of a technology that doesn’t have political or economic implications?

                                                                                                No. And I didn’t say it doesn’t have political/economic implications, in fact it definitely does. But in my opinion, the Urbit political implications are better than what we currently have. Consider:

                                                                                                Socially and politically, Urbit is a flat network of planets. Galaxies and stars are plumbing. No one cares which star is your sponsor, any more than your Facebook friends care who your ISP is, or you care what data center Facebook is in. … Because sponsorship has an escape mechanism, it is not a feudal bond (like your relationship to Facebook).

                                                                                                Urbit is a decentralized network of social networks. No one can regulate it. Urbit is made to blossom into an endless garden of human cultures, each of which must regulate itself, none of which can bother the others. The soil in which these flowers grow must be level and neutral.

                                                                                          2. 7

                                                                                            I agree. It’s a kind of politics that makes people weak centered on our basic instincts of us vs them. The better route is to separate the two, ignore whatever bullshit he writes on his blog, focus on his technology, identify what good/bad can come out of it, and (if good) then either adopt or clone plus compete with it. The adopt or clone decision is where you consider the person. Even then, it’s not their political ramblings so much as what they do in a development and business context day to day. A person with strange beliefs who acts civil and hard working around others in a business is fine with me.

                                                                                            Edit to add: Work in diverse company with piles of people each with different beliefs, some diametrically opposed. We somehow still function and mostly get along with each other. Different mindset with effort put in is all it takes. Makes job more interesting, too.

                                                                                            1. 4

                                                                                              Except Urbit is deeply rooted, in its design, by Jarvin’s beliefs about politics and economics. A technology can’t stand in isolation from its context when its a deeply social technology like Urbit.

                                                                                              1. 5

                                                                                                That’s a statement of faith, not proof. Assuming no patent risk, I can literally take his tech, distill out ideas useful to me, and use it for those things. I could’ve done that without ever knowing what his political beliefs are. I can do it while knowing what his political beliefs are. I can even do it to support things he opposes. Therefore, they provably don’t matter if I’m not partnering with him.

                                                                                                They matter to you or others like you who feel a need to combine a person’s political beliefs or statements with everything they do. You’re limiting yourself voluntarily for ideological reasons. I intentionally avoided limiting myself that way since it reduces what I can get done with no value in return. My opponents who control the world in damaging ways also don’t limit themselves like you: they’ll work with or fund people whose beliefs or personalities they can’t stand if it achieves common goals. Got them where they are. Defeating them to stop real damage (vs crap people write on Internet) will take all kinds of people working together despite differing beliefs.

                                                                                                1. 6

                                                                                                  Oh don’t get me wrong, I’m all for appropriate parts of technology for uses outside their design. My statement wasn’t about restricting yourself. What I mean is that (and this is especially true in software) the design of a technology is better understood when looking at the “whys” and not just the “hows”. For example, why does Urbit limit its address space? It’s not a technological limitation. In fact, there are lots of parts of the system built around the idea of artificial resource scarcity. Without understanding this system “top”, which covers many lines of code in various components, how are you going to properly take what you need if say, you don’t want that silly limitation?

                                                                                                  A person with strange beliefs who acts civil and hard working around others in a business is fine with me.

                                                                                                  I find that a person with “strange beliefs” (to put it nicely) is also a strange person to work with. Most work is communist in nature ( in the Graeber definition of “from each according to their ability, to each according to their need”). When you ask for a code review, your colleague typically doesn’t say “I will do it but what will you do for me?”. If you need a wrench, the guy next to you doesn’t go “Only if you give me $1”. If the friction is low enough, or need great enough, people will typically do it. Any strange beliefs that stray away from this kind of work ethic typically make all work far less efficient, and even unworkable.

                                                                                                  1. 2

                                                                                                    In fact, there are lots of parts of the system built around the idea of artificial resource scarcity.

                                                                                                    Ok, now I agree with you there. What you’re talking about, though, is design goals. I’m all for understanding them since I need to understand the rationale behind the decisions. I think I avoided Urbit when I saw cryptocurrencies or something mentioned. The rationales might have a political component. I can still ignore that if I choose. Sometimes, I learn from it like with privacy techs whose features might be inspired by sneaky behavior of companies or governments. One can still separate design requirements from political motivations in most cases just by filtering and/or generalizing.

                                                                                                    “is also a strange person to work with. “

                                                                                                    Now, now, that’s jumping to conclusions. A person should be judged on what they actually do rather than hypothesizing. I only read a little on this guy with some people saying he’s really nice at conferences with informative talks. Some people said there were problems but those posts weren’t as specific. If he’s actually disrupting people, then he’s not a good guy to have around. If he’s not and is helpful, then he is potentially a good guy to have around. That’s how I do it with coworkers. It works with some being weird on occasion but they usually just avoid uncomfortable subjects if they know it bothers someone. Unless they’re assholes which is a different thing entirely. ;)

                                                                                                    “When you ask for”

                                                                                                    Since I know little about him, I’d say whoever you’re describing is a person that demands something in return for his work. Presumably, the employees aren’t working for free. They’re doing that, too. I’m also aware of, experienced a lot of, people trying to be users getting others to do their work for them or get something from nothing. They’re not give and take people so much as take, take, take. One strategy for dealing with that is to be a no, extra, free work by default person who is selective about their generosity. I just read an awesome article about such a transition recently.

                                                                                                    Now, that said, a person that acts like that can also be a drain on a business or not right for its culture. Not even political culture so much as performance standards. If they’re paid to do an app, the best team will always be supporting each other to get it out the door in whatever state the business needs. I’d not hire such a person that made everything a trade if they were already getting paid for an outcome that required that minor thing to achieve. I’d rather them be helpful by default covering for each others’ weaknesses and helping them improve on them. I’m sure you’re of the same mind on that, too. :)

                                                                                                    1. 7

                                                                                                      “is also a strange person to work with. “

                                                                                                      Now, now, that’s jumping to conclusions.

                                                                                                      Re-reading what I wrote I was definitely a little obtuse. Let me elaborate, I find people with his kind of ideas usually hard to work with. But that’s just my experience. I didn’t mean strange ideas in general, but “strange ideas” as in, his ideas. Reading previous articles, it seems his co-workers basically seemed to have done what you would do, basically tiptoe around those issues to maintain a polite atmosphere. Which is fine and probably the most appropriate thing to do in that situation.

                                                                                                      However, I think we can agree that we should not entertain asinine ideas. If he was a flat earther and designed his software to have a 2D address space because the plane is the way to go, we would certainly find that a strange design choice that introduces complexity. But for some reason when someone thinks some races are a better fit for slavery and that democracy is bad and incorporates those ideas into his design by having an ownership model based on those ideas, we seem to say “I can work with that guy, he is fine, he likes cats as I do”. To me, that’s just a form of support and validation. Maybe you are able to compartmentalize these things, but what if the person can’t and finds your support validation of the other stuff. I’m going to call in Godwin’s Law here and say, yes, Hitler also loved his mother and painted some nice stuff, but would I work with him on chemistry projects?

                                                                                                      1. 3

                                                                                                        “But for some reason when someone thinks some races are a better fit for slavery and that democracy is bad “

                                                                                                        Those are actually specific examples where I’d consider not working with someone. Especially if the project was about individual empowerment and decentralization. I’ve still worked with people who had a white supremacist background. We’d occasionally have to call them out on their behavior if a discussion between them and black folks involved race. They’d make an advance which we sane, white people would block. They almost always walk off. Then, it’s done. They and the black folks usually get along day-to-day with one we just fired being missed a lot. Might shock you with the stuff you read on tech forums about what blacks, Jews, etc believe and need for inclusive environments, eh?

                                                                                                        “To me, that’s just a form of support and validation. Maybe you are able to compartmentalize these things, but what if the person can’t and finds your support validation of the other stuff.”

                                                                                                        Which brings me to this. Down here in the South, we know there’s lots of racists on each side. As we might say it, we know everyone has a bit of bullshit or crazy shit in their head. With a Christian majority, we’re also taught that people are inherently sinful with us needing to admonish it, be forgiving, and be patient in helping them get better. So, what of these people who think other races are inferior and individual decisions are worthless? How to get them further away from these beliefs?

                                                                                                        There’s only one thing that works that I can tell from observing where the South was and is today. That’s getting different people in one place forced to be around each other, tolerating each other, for long periods of time. For us, it starts in public schools where racist whites and blacks along with people in the middle are stuck together. Then in the workplaces. The process over time lowered that racist bullshit down to tolerable levels where the KKK-style people are fairly uncommon or rare depending on the area. They mostly hide from us. Even they often like black people where they are compartmentalizing what they learned to like vs what they were taught to hate.

                                                                                                        What you’re advocating is essentially enlightened people pushing out those who still need to learn stuff away from those who will teach them. Then, they cluster into groups of racists who continue reading garbage, hating on people, plotting, and planning. Many such shunned groups ended up voting for Trump last election since he was only one pretending to care about them. There was no way to reach them since the radical-leftist liberals succeeded in censoring them off as many forums as possible. They similarly created their own recruiting locals and drowning out opposition. Division and siloing at an all-time high on the net like it used to be in meat space in the South. (slow clap for radical liberals)

                                                                                                        We’re not showing support for these idiots: we’re showing them that people are better than they think. We’ll call them out where needed. If they disrupt too much and ignore warnings, we’ll eject them from that position so they know we mean business. They’ll have another chance to do better. Contrast that to radical-liberal doctrine behind CoC’s where statements on any medium or place will get people blocked from all places with similar CoC. See paragraph above for where that shit leads. My reaction is more patient and measured with a chance for people to learn over time. And it always takes time.

                                                                                                        1. 3

                                                                                                          That’s getting different people in one place forced to be around each other, tolerating each other, for long periods of time.

                                                                                                          I think this is absolutely right. I’m not advocating for people to splinter of and shun each other. What I’m advocating is people should not ignore bad ideas and make sure the other party knows. I’m not a moral relativist. And you are right about Trump folks feeling left out. You are also right that the liberals basically ignored them.

                                                                                                          However, You are wrong that radical-leftists are liberals because they are not liberals. Radical leftists despise liberals just as much as the right does. But you won’t find that kind of discussion on Fox News or NY Times.

                                                                                                          1. 2

                                                                                                            I forgot about the definition dispute. My bad. Yeah, OK, your position seems a lot more reasonable. I like that. :)

                                                                                                          2. 1

                                                                                                            I’m a lot less patient and tolerant than I used to be: particularly of stupid stuff directed at someone else.

                                                                                                          3. 2

                                                                                                            If he was a flat earther and designed his software to have a 2D address space because the plane is the way to go, we would certainly find that a strange design choice that introduces complexity.

                                                                                                            I don’t know about you, but I would judge the idea as strange if I would not see the benefits of it, not because its author has different political views. If 2d addresses would solve many issues than it might be a good idea regardless of who came up with it.

                                                                                                        2. 1

                                                                                                          The reason for network address scarcity is to make spamming cost-ineffective.

                                                                                                          Compare that with the state of email spam, where email addresses are basically free.

                                                                                                          1. 2

                                                                                                            Alternatively, they could do something like bank-level verification checking government ID’s and requiring a deposit to create an account. Then, maybe fining whoever is spamming. Then, it should go down. Worst case with low or now fines, whoever is compromised will find out about that changing their credentials or reinstalling their system.

                                                                                                            Jumping from “there’s spam cuz addresses are free” to “need network address scarcity” is the kind of unnecessary, risky solution that crowd is fond of. Better to just fix the problems in existing systems or design new ones with methods proven in existing ones. They have an irrational aversion to doing that for some reason.

                                                                                                            1. 2

                                                                                                              Relying on government ids is a centralized solution. Urbit is decentralized, thus needs a decentralized reputation system.

                                                                                                              1. 2

                                                                                                                It could be bootstrapped that way. The different organizations become part of the reputation system. Hell, it might even become a new service from banks and credit unions. They already often act as notaries.

                                                                                                                1. 2

                                                                                                                  Yeah, I’d rather not have banks regulating my computer usage…

                                                                                                                  1. 2

                                                                                                                    Are you using burst transmission or a mesh network not connected to the Internet (doubtful)? Otherwise, you already use a centralized service via one of the big ISP’s that ID’d you and took payment with centralized currency. They also regulate your computer usage far as the network goes. Although they got issues, they’re still less volatile than most of these decentralized systems. The most popular ones, esp Bittorrent, operate over the centralized ones, too, for their benefits. That’s despite decentralized options being available for a long time. They’re too slow and unreliable.

                                                                                                                    It always interests me that you rely on centralized services on one hand with justifications but tell me in other areas there can be no justification for relying on centralized service. Make up your mind. Meanwhile, the inconsistency suggests to me that we can leverage centralized services as a component in these decentralization schemes.

                                                                                                                    1. 4

                                                                                                                      Decentralized computing infrastructure is something valuable we should work toward. We’re not there yet, but Urbit is a step in the right direction. Ofc sometimes its better to centralize some things, but in computing I’d rather have decentralized infra.

                                                                                                            2. 0

                                                                                                              Spamming is not the main motivation. The main motivation is to provide a source of funding to the company by selling the space. Oh, and the designer was a neo-feudalist which probably inspired the whole enterprise.

                                                                                                              1. 3

                                                                                                                The main motivation is to provide a source of funding to the company by selling the space.

                                                                                                                I’ll add that I’m skeptical of all companies that look like pyramid schemes or at least just funnels of money to the creators in exchange for tech that’s highly risky. Throw in any cryptocurrencies to that list since they’re usually structured in an elitist way for founders. If it’s a money system, I want it done fairly by non-profits or public-benefit companies whose incentives will protect the currency, exchange, and so on. Preferably one that’s already profitable from another revenue stream where they don’t have to worry about trying to monetize the financial project. It can just breakeven with a slight surplus or donations to cover expansion.

                                                                                                                1. 3

                                                                                                                  You are right on the money here.

                                                                                                                  1. 3

                                                                                                                    Great pun haha.

                                                                                                    2. 8

                                                                                                      Lol no one owes moldbug respect

                                                                                                    3. 5

                                                                                                      Whatever his political stance he’s still as excellent a writer as he was one the old Usenet. One of the more memorable flames on talk.bizarre was from his hand.

                                                                                                      1. 12

                                                                                                        I found him self-aggrandizing and subject to an inescapable superiority complex. When he writes philosophy he is unnecessarily verbose, so everything said seems tainted by trivial matters such as the author ego and it leaves me wondering whether the actual ideas expressed are self-sufficient or tainted by this ego: trying to project, to present himself: keeping at the marketing speak level and building an idea of himself, instead of leaving his ideas laid bare.

                                                                                                        It’s not precise, and he just reads like an insufferable prick. I found Urbit rather interesting though, but I can only rejoice that the project is now without this guy.

                                                                                                        1. 2

                                                                                                          I tried reading the linked post and couldn’t make heads or tails of it. Maybe because it’s written “in-universe” so to speak and therefore addresses those people familiar with the specialized terminology of the Urbit system.