jasonzemos

> messaging apps are all the same, making them easy targets for standardization and interoperability.

This is patently false. Look no further than the other comments in this thread. Nobody can agree on what they want out of the messaging experience. Some want a rich experience like telegram and others want a minimal one like IRC. Should this protocol's features maintain parity with the proprietary and centralized services? Better develop them rapidly to keep up. Should they stagnate to maintain interoperability across an ecosystem? Good luck being competitive. We haven't even gotten to the features themselves and I promise you there will be irreconcilable differences. Does the protocol maintain message history or is it ephemeral? What is the privacy model? Can we delete messages on other servers due to GDPR? When you spend time at the business end of the messaging space, these dichotomies flow endlessly, without consensus, and they cover the entire horizon of the space.

If you think you know the answers to these questions, you don't, because you're solving the wrong problem. If you want to decentralize messaging you have to solve the problem of how to agree to disagree while maintaining interoperability for a shared experience. Let me just make that last point clear: you cannot design a messaging protocol where one party sees emojis and the other doesn't. That doesn't work because you can't lose social information.

Matrix has failed to solve this problem. We need a new approach. What will emerge to finally conquer this space?

That's because they stole it. When you stand on the shoulders of giants it's not difficult to take the next step. In cases where the Soviets outpaced the west, most notably in the space race, they did so for lack of prudence. The US could only tolerate at most one accident (Apollo 1) else the entire endeavor would have been jeopardized. Rigorous testing, empirical investigation, and redundancy all imposed costs on the US. The Soviets instead just devalued human life and kept all their failures secret, lowering their cost to gain agility for progress.

In the end the Soviets produced a very small amount of organic peer-reviewed cutting edge research in contrast to the west. Worse, the politics impressed on its academics lead to Lysenkoism.

Is Mozilla an example for the next major adopter of Matrix or are they not? If they are, and everyone else signs up for modular.im as well: at what point does this ship of Theseus called Federation only exist inside a bottle?

This is really good news. I have only one question for Mozilla: why choose a solution whose hallmark is decentralization and the libre model- only to become a customer of a centralized host (modular.im). Why can't Mozilla actually federate? That's a step backward from your IRCd in my opinion.

I hope Mozilla gets onboard with everyone else running their own Synapse, hacks on it, and pay their dues with patches, rather than with their cash.

Is this statement a joke? Who makes a statement from a company by saying they are making a statement by the management? What's the point? To look official? Next, this "statement" says nothing. Of course that's the point, but at least be creative. You should be, because I can imagine how challenging it is to defend something universally indefensible.

How dumb do you have to be to make this guy an officer. He could've been the chef in the basement washing just as much money.

Associations with Mark Karpeles are like wearing blackface: it's never okay. Never. It doesn't matter what the reason is.

Who am I to submit a proposal to fix fundamental problems in your company? That's called consulting. You just raised an 8 million dollar Series A you are soliciting me to work for you for free, in the leaf comments of a Hacker News thread? Are you for real?

I volunteered at least three solid examples of fundamental indecisions that have unambiguously cost your investors alone millions of dollars over several funding rounds; lest I mention also cost every poor soul that has volunteered their free time in the name of FOSS -- an ethically ambiguous embrace by you at best; every one of them is locked into the cost of your missteps.

I have clearly linked these indecisions to real-world outcomes. It's all history by now. The foundations of state resolution weren't in place when you built Communities/Groups so you didn't use the matrix chatroom; you built an entirely new inferior HTTP protocol without any state or replication whatsoever over several months. Now that you finally prioritized fixing that underlying problem with rooms there's a need to replace and spec an actual Groups system. In the meantime nobody can develop Matrix Groups into their software, not my server, not clients like Ditto, etc, because you tell everyone not to. You're going to overhaul the whole thing. You're doing them a favor by saving them that wasted effort. But Synapse and Riot use Groups and Matrix promotes it on matrix.org; still there's been no serious visible progress toward groups-as-rooms.

This is why Matrix is indeed a de facto centralized system. Let's not even get into issues in this system where every server trusts matrix.org for cryptographic keys. Matrix is really centralized around you.

In the end nobody is working with you. I have the only third-party implementation of this stack. Nobody is working with me either, but that's called the transitive property.

You have some time to think about this. I would say until the next recession hits. Then this is over. The way you do things won't survive that.

I selected some examples because I don't want to be lost in abstraction, but please, I am asking kindly that you not focus on my examples (unless it's pressing) because the issue here is systemic. I'm not giving these examples for you to just retreat back with your head down and address them. The locus is more fundamental: the etiology for why these errors even exist and why there continue to be new ones all the time; all at great cost, perhaps even existential cost. You should be concerned with that bigger picture, surely.

Scores of other issues could have been cited, but I included the representation example having confidence you'd probably tout those exact experiments and respond with that blog post. Your conclusion at the time was that CBOR and JSON had negligible differences. The company then proceeded to de-prioritize any serious work in that direction while simultaneously ramping up efforts for end-to-end encryption by default. This was a flawed conclusion and it has demonstrably added to your tower of debt. Even my "hi" example is already passé because now that too is another giant base64 string adding to this jumble. You can't bolt Ferrari body panels on a Honda and call it a Ferrari.

I can spend all day citing issues just as poignant, and you might even be kind enough to elevate them against the ~10,000 other [github] issues they're contending with. I can spend all day unpacking the string of missteps leading to all of your engineering disasters. It's not going to have any returns- not for either of us. It doesn't root the problems.

If I could impress upon you some serious advice, it would be to value people less transactionally. Don't estimate a person's worth by how they fill a few open gaps in your grand master plan and then dispense with them as if they won't be filling in any more. Avoid that by valuing people by how they think, and then don't try to think like them yourself. Delegate to them instead.

I'll just pick one. Matrix is resource-heavy, even in the best of times. There is a confluence of smaller contributing factors, and several effects on both its usability and developer/platform friendliness. Consider this anecdote of the overhead of sending the message "hi" as a baseline: in Matrix, this takes about 1KiB on average after all is said and done in JSON (and varies, unfavorably). So to over-simplify, that's 1K to the disk, 1K to each server in the chatroom, for which there could be several hundred, and 1K read on query from clients and other servers -- all for a 2 byte payload.

Before I'm accused of being unfair because there's always going to be a ridiculous ratio for something like a "hi" message, consider some alternatives for both the format and payloads of the fundamental protocol primitives. Most of the messages contain cryptographic metadata which has a succinct binary representation, but JSON requires base64; when represented naturally with CBOR the overhead can be reduced ~40%, and without encoding/decoding either. Consider that virtually all of the overhead in "hi" is either cryptographic hashes or signatures or integers (depth/ts) which would benefit from compact formats.

Does representation actually matter though? Why can't I just store Matrix in my format and federate with your format? I guess this is an example of where theory and reality collide. One cannot write a server which handles messages as abstractly as possible (leveraging these JSON/CBOR extensible formats) while at the same time knowing which fields have a more efficient binary representation and transforming that. In reality that just looks like a CBOR message with a bunch of base64 plaintext strings. It doesn't achieve that 40%.

All of this is important because of Matrix's (superior) design over its event abstraction. When the whole protocol is hinged on fundamental primitives (a good thing) attention to detail and focus must be given to those primitives. The more optimized they are, the more everything built with them is also optimized. When the foundation is efficient, developers can do more with matrix and enrich the user experience. For another example, matrix has been reluctant to give developers the power to store shared-program (i.e bot) state efficiently in a chat room. This is because there's no mechanism to delete state_keys, or even discard overwritten state itself. That's an important cornerstone that's missing while the rest of the tower is being piled on.

It might be possible to confuse any of these issues as trivialities, and their solutions as bike-shedding. I contest their importance is evident in how they emerge to shape the character of the entire system. Consider: does matrix require the entire DAG to be acquired like a bitcoin block-chain? Then I better be careful and conservative about messages. Does matrix allow gaps in the DAG and have a smaller chain for auth? Then I can be liberal about messages and delete stuff later. When I go to build an application which communicates over Matrix those qualities emerge as fundamental limitations or liberations of what users can experience.

Others have better responses to the rest of these points; many of them are still significant issues though a lot has progressed over the last couple years. I can preempt one though by saying alternatives to Synapse like https://github.com/matrix-construct/construct are probably something more aligned with your interests. (disclosure: I started the project with kaniini).

After more than two years in and around this space I'm still comfortable with stating that I'd take Matrix with all^wmost its flaws over ActivityPub. All of these protocols kind of suck. I see Matrix as having the lowest hamming distance between where it is and where it should be.

I'd rather see interest in Matrix than ActivityPub.

> You research the chemistry ...

I would say that is literally the most public information in the universe.

> Over the years, their numbers have included construction workers, insurance agents, pharmacists — even an underwear distributor.

This is ironic for a conservative state because it's indistinguishable to me from Soviet communism. I can't help but think about this scene from Chernobyl (https://www.youtube.com/watch?v=idb_qsAAe1c) which illustrates the true tragedy of this broken system. Emma Goldman wrote in "My Disillusionment in Russia" (1923):

> Bourgeois dictatorship is replaced by the "dictatorship of the proletariat" — or by that of its "advance guard," the Communist Party. Lenin takes the seat of the Romanovs, the Imperial Cabinet is rechristened Soviet of People's Commissars, Trotsky is appointed Minister of War, and a labourer becomes the Military Governor General of Moscow. That is, in essence, the Bolshevik conception of revolution, as translated into actual practice.

I'm referring to a single 1cm^2 paper tab; of course the contents can vary due to the unregulated effects of prohibition. This is just not enough to induce strong visual hallucinations and Hunter S. Thompson type experiences. There has also been a recent interest in micro-dosing (https://www.nytimes.com/2017/01/07/style/microdosing-lsd-aye...) though this seems extremely difficult to procure in ways that I'd trust, I keep my eyes open.

> It was akin to 12 hour, mentally-clear cannabis high.

This is the best way to describe reasonable (small) doses of LSD. It's like the purest sativa possible; as if somebody removed all of the earthiness and stoniness and then amplified the psychoactive.

What is he really supposed to represent? Skipping all the hard work, middle-fingering the system, and getting rich quick? That's worth at most 15 minutes of fame, and a long long time ago. Mr. Buterin isn't in jail simply because no government has the slightest fucking idea how to parse this massive exabyte jumble of cryptocoin hodgepodge over the last decade.

Meanwhile, thousands of poor souls have been lost in the basements of universities doing real honest-to-god useful work which may never be understood and used by industry, or even see the light of day; they lack this disingenuous excessive hyper-promotion and the means to compete for media attention with our favorite cult heroes like Vitalik.

> Either Vitalik is extremely smart or he just doesn't know what he's talking about. Overall, his opinions are just confusing and distracting like the whole Ethereum ecosystem.

Vitalik started out years ago with writings consisting entirely of self-citing the Ethereum echo-chamber. Judging by the citations here he's starting to understand the value in the works of the established institutions, tenured university professors, and career cryptographers -- people whom it's obvious in his circles are either loathed as some irrelevant elites or simply, wholly unknown.

Now that Vitalik has spent the last few years actually surveying the last decades of theoretical achievements in the literature, maybe it's time to build a secure distributed world-computer. Oh wait.

Would you be alright if a VPN profiled and sold your browsing habits, engaging in very traditional, even benign business model similar to what everyone else is (e.g. credit cards, etc) doing -- but with the knack of keeping your real identity strictly anonymous and detached from these activities?

In other words, would you be alright if the VPN built a profile of your VPN identity? The corollary, I think, asks if you're interested in a VPN to separate your activities, or to thoroughly diffuse them for actual information loss.

So my running conclusion is that Rust's founding decisions were made with a sort of "go big or go home" logic given this premise. To conclude that breaking even one part of C/C++ is grounds to throw up one's hands and drain the baby with the bathwater makes sense through this prism. At that point one might as well pour through the literature and academic languages to pick out all the goodies and gimmicks that haven't been mainstreamed before too.

The problem here is that Rust is not graceful replacement for C/C++. I'm being sold on Rust from a systems perspective and the system is already written in C. It's a simple and incomplete language begging for extension but it's done a good job of abstractly representing commodity computing hardware to a programmer for 50 years. Rust doesn't even make an attempt to gracefully regrade C/C++ into Safe-C++ and I can't come to any other conclusion that this is for nothing more than a lack of creativity.

There is an ignorance to the real costs of reinventing the wheel when one doesn't replace the original wheel too. That's why I am starting to truly convince myself Rust is actually harmful. If Rust gracefully took C in another direction (like C++ did), I could add Rust compilation units to my projects and share C interfaces which basically give me access to the entire existing universe so long as I use something like `extern "Rust" {` or visa-versa. If Rust broke ~10% of C++ I could put forth ~10% effort to port my projects to it and integrate it entirely. At a certain point down that vector, Rust can be the messianic "C++ done right" without looking back.

> This means that effectively all C++ code would fail to compile under this implementation.

You're implying that all C++ code uses pointers and that's patently false. It's even false for C code. Pointers was the first thing C++ boxed with references. Box it more. Forks of C++ even exist, like GNU++ extensions. There's a whole spectrum of possibilities between that and where you are right now and I don't see why everyone needs to cross this chasm and embrace Rust at this cost.

Breaking one part of the language doesn't break everything for everyone. That's definitely a fallacy if it couches the justification I'm chasing here.

> Are you suggesting that the only language that should get to use KVM is C

What I'm asking is why Rust can't read the C header. I know that sounds like a ridiculous question, but I'm asking it honestly and seriously.

> Implementations are irrelevant

And that's why Rust started from scratch. I totally understand the problem and the justification to address it. Yet nobody has ever been able to justify why it's necessary to dispense with the entirety of C and C++ to achieve memory safety. The power of frameworks like LLVM give you freedom to implement whatever semantics you want. Rust wouldn't have gotten off the ground if it weren't for that kind of power. I feel this power has been abused. For example, you could create a fork of C++ that merely compile-errors when you use a pointer and not a reference unless you enclose it in some `unsafe` block that you invented -- anything you want like that is possible. One can simply start with C++ augmented so that everything is const by default; that is the ideal progress to me.

There's still no justification for Rust to be completely hausdorff to the last 50 years of established C systems and start over. If Rust doesn't really offer anything substantive for this amount of divergence I feel it will always be relegated to wrappers and a niche community.

That just makes Rust a simulacrum.

> Explicit compile-time tracking and enforcement of the scope of object validity, preventing (or at least making more unlikely) a class of bugs including use-after-free, uninitialized reads, buffer overflows, dangling pointers.

Why does an entirely new syntax have to be invented from the ground up to solve this problem? Does C-like syntax not adequately inform a compiler that wants to implement something like Rust's borrowing? It appears to work for `std::unique_ptr` and `std::move` semantics. It doesn't appear that Rust's syntax conveys any order of magnitude more information. Minor augmentations to C/C++, taking it some other direction which fixes whatever shortcomings for next-generation static analysis tools can be the focus of effort. I don't see why Rust first has to invent the universe.

Here's an example of overhead effort required by Rust: https://github.com/rust-vmm/kvm-bindings. This has already been implemented in C and distributed with most operating systems. Why wrap it? Now when KVM gets new features Rust has to also update its wrapper interface too. Isn't that just a propagation delay?

Then perhaps correct me on what problems Rust is specifically trying to solve? As far as I can tell Rust stands on the shoulders of the LLVM backend- there are existing frontends, like C and C++ but Rust started from scratch.

My question is for what purpose? The problems we face today syntactically relate to intuitively expressing global superword-level parallelism to fully leverage AVX-512. No language is currently sufficient in this regard. Was Rust's syntax designed to maximally inform the autovectorizer in the backend to do this? That would be a worthy goal for this kind of investment. Otherwise it's wheel reinvention to me, and I feel Rust is being pushed really, really hard.

What I don't understand about all of these languages born out of some inspiration to "do C++ right" which includes the inception of Java, Go, and now this: is the complete disregard for established systems and failure to stand on their shoulders. C++ stood on the shoulders of C and one doesn't need to cite the decades of success as proof; some syntax has proven itself as quite optimal.

From what I understand compiler frontends can be augmented to solve all of the problems Rust is trying to solve. Instead Rust is reinventing the entire wheel which is already sharing an axle with Go and Java's entirely reinvented wheels -- not just with syntax, but entire ecosystems from the ground up.

I'd like to start seeing a little more reuse of both ideas and effort instead of this present state.

This comment literally illustrates the pathology described by its parent. Not all organizations are cults run by cliche fascists who crush subordinates who make that kind of criticism.

Why does that justify conforming the user to the software? Software, especially web software, has this magical quality of doing different things for different people even at the same time.

> Her statements have been coherent, extensive and detailed; however, my overall assessment is that the evidential situation has been weakened to such an extent that that there is no longer any reason to continue the investigation.

I used to think Sweden was "woke" and progressive but I was mistaken. A statement like this by law enforcement in California would be unacceptable.

"It is better to have 100 functions operate on one data structure than to have 10 functions operate on 10 data structures." This quote is from Alan Perlis' Epigrams on Programming (1982).

When I click the reference footnote on that page leading to iad.gov I get an invalid certificate authority error, heh.

https://www.iad.gov/iad/library/ia-guidance/ia-solutions-for...)

It seems as if universities live in the dystopia that the software industry avoided when it stopped counting lines of code.