ABKA101

Doesn’t $ICP fix this issue @dominic_w?

Wtf is happening with near:native?😮 What’s the reason behind this surge? 🫣🤔 $Near is now ranked 32 on @CoinMarketCap and internet-computer:native is at 48. I hope internet-computer:native will surpass near:native soon.😁📈

TEHRAN'S 'LIFELINE': @gen_jackkeane warns that a new deal leaves Iran bruised but intact, convincing the regime that they forced the U.S. to back down. "But my problem with the deal here is that we leave Iran bruised but intact, and they'll walk away from here, citing and convincing themselves that they got the United States to back down." "And as a result of that, we extend a lifeline to the regime, for sure, for them to do what? To recover. And in the deal, the unfrozen assets are about 100 billion. It's likely we're going to take some part of that and give that to them up front and also reduce some of the sanctions." "And certainly we're going to monitor their behavior. But nonetheless, it is a lifeline to the regime that extends them for years to come."

@MassieforKY @tedcruz AIPAC brags about how much control they have.

What is the Internet Computer The Internet Computer Protocol (ICP) is a protocol for decentralizing execution environments inside a common trust boundary. In short, in a network consisting of nodes and edges between the nodes, TCP/IP can decentralize the edges and ICP can decentralize the nodes. By decentralizing both, we can create a trust boundary around the whole network. The result is that where before we could only draw trust boundaries around groups of nodes with the same owner, we can now draw a trust boundary around independent nodes and independent edges. This gives us a protocol path toward turning the Internet into a single decentralized execution environment. One huge, decentralized cloud: an Internet Computer. @dfinity and @dominic_w have gotten some ridicule for the name “Internet Computer”. It’s too weird, too grandiose, and not as cool as Ethereum’s “World Computer”. But I think that by understanding exactly what ICP is, Internet Computer becomes the correct and appropriate term. To understand the revolution ICP brings about in better detail, we have to take a few steps back, not just to web2 but all the way to web1. Here I will not talk about web1/web2/web3 in terms of read/write/own. It’s a somewhat silly classification: you could write and own stuff on web1, in fact you usually did so in more decentralized ways than on web2. I see web1 as the era of people using TCP/IP to hook up their own computers into a global network (the Internet), then evolving via web hotels into the huge, centralized computation providers of web2, where the networked computers of web1 are clustered into bigger execution environments called “clouds”. Web3 will be about clustering clouds (and independent computers) into an Internet scale execution environment, and ICP is a protocol for doing just that. First came TCP/IP and decentralized communication We’ll start by considering just one computer, Alice’s computer. Alice owns her computer, she controls what programs run on it, and thus she can trust it. Then we add a second computer that also belongs to Alice, as well as a network cable between them. She owns both computers and the cable, so she can trust the whole network. Now enters Bob, who also owns a computer. Alice doesn’t trust Bob, and Bob doesn’t trust Alice. Yet they want to be able to send some data to each other, so they want to hook a cable between Bob’s computer and one of Alice’s. But who should operate the cable? Bob doesn’t trust Alice to operate the cable, and vice versa. TCP/IP is a decentralized communication protocol that solves this issue by enabling routing across independently operated networks. Both Alice and Bob can operate cables, data is free to pick any cable and, very simplified, as long as at least one cable is up it will arrive (as long as there is a viable route, the network can route around failures). Bob and Alice can even outsource cable operations to Caesar, without either of them having to trust him. Thanks to TCP/IP, Alice and Bob can communicate without trusting each other. However, since they don’t trust each other, they still can’t form a common execution environment for a program that runs partly on Alice’s computer, partly on Bob’s. In Alice’s home network, where she owns both computers and the cable between them, she is free to distribute a program between both her computers, constrained only by the laws of physics, not by the problems of trust. Alice has a “trust boundary” around her home network. She can see her little two-computer cluster as a common execution environment for programs, that can distribute as they see fit inside the trust boundary, and she can add computers to her home network to increase its capacity for running larger distributed programs. One day Alice’s home network grows so large that she can’t fit all her computers at home anymore. She decides to put a few in the summer house. But running a cable between her two houses seems far-fetched. Could she just use Caesar (or one of Caesar’s many competitors on the growing TCP/IP Internet) to run the cable? She very well could. Thanks to TCP/IP she doesn’t have to trust/own the cables, she only needs to own the computers to be able to continue trusting the whole network of her computers as an execution environment. Seen as a network diagram, she doesn’t have to own the edges, only the nodes. This is web 1.0 where communication between computers is decentralized and trustless thanks to TCP/IP. You can write a program and distribute it over your own computers. Thanks to TCP/IP you don’t have to operate the cables in your network to make this work. Thanks to TCP/IP you can also share messages with computers you don’t trust, and then you can decide how to react to their dubious claims. But TCP/IP doesn’t by itself let you create an execution environment you can trust using computers you don’t trust. Cables yes, computers no. The edges are solved, the nodes are not. And this continued to be the case. The evolution into what we now call web 2.0 was essentially one of delegating trust to big corporations. What happened was that Alice eventually started wondering if she really had to run all the computers herself to be able to trust them. Technically, yes, but what about in practice? She pretty much trusted her brother Joe, after all, maybe Joe could run a few servers for her? The next step after trusting Joe (once his house is also full) is to extend some trust to some company that you decide cares enough about its reputation and continued revenue streams to not betray their customers. Alice runs her most important stuff on her own computers that she can trust, but also some less important things on computers she trusts less, operated by other people. She can still trust the communication layer between all these computers, thanks to TCP/IP (and some improvements on top like SSL/HTTPS). What happened next was that the companies that first hosted space for Alice to put her extra computers, and then hosted the computers themselves for Alice and others to rent, started to exploit that they could leverage their own trust boundary on their own network. Once a company didn’t just own a big warehouse where people could put their computers but owned a warehouse full of computers that people could rent, they could draw a trust boundary around the whole warehouse and call it a “cloud”. If they owned two warehouses full of boxes, they could draw a trust boundary around both warehouses and that would be their cloud, and so on. The important part was that when one company owned all the computers, they could trust them enough to cluster them into one massive execution environment. This created an enormous incentive to centralize computer ownership, and we saw the rise of behemoths such as AWS, Azure and Google Cloud. And it made sense, because it was no real difference to the trust assumption for Alice to deploy to the cloud compared to deploying to a computer that she rented from the same company (and only somewhat better than owning the computer but renting space for it in the same company’s warehouse). The core problem, however, remained unchanged: that you couldn’t create an execution environment that spans two clouds unless they have the same owner. You can certainly distribute your application over two clouds, but without a protocol to group the two clouds into the same trust boundary you can’t treat the two clouds as one unified execution environment. However, today’s mega-clouds certainly seem big enough to house any program in either cloud, so perhaps that’s not an issue? Monoculture and anti-fragility But there is a big issue that remains with all this centralization, which is fragility. Centralization eventually becomes top-heavy, and we’re already seeing how the system is starting to crack at the seams. We see it when AWS goes down and brings half the Internet with it. We see it when AWS and Azure go down at the same time and take practically the whole Internet with them. It’s the mono-culture risk that comes from lack of independent providers. If we still had a million web hotels instead of just a few, big cloud providers, we would have basically the same fundamental delegation of security to other companies, no real difference there, but we would have much better resilience from a multitude of independent providers. We would, however, not have our huge “cloud” execution environments where we can run distributed programs too large to fit single computers. It seems we have decided that the cloud advantage is worth it, trending towards centralization, but as the disadvantages are becoming real people start looking for alternatives. But what would a solution even look like? To answer that, we have to go back to the very beginning and start looking for an answer to the question: How can I create a protocol that lets me trust execution on computers that I don’t own – just like TCP/IP lets me trust communication through cables I don’t own? ICP answers that fundamental question. ICP decentralizes execution in the nodes in the same way that TCP/IP decentralizes the communication in the edges between the nodes. It does so, as is the standard in crypto and blockchain tech, by using combinations of cryptography and game theory. The implication becomes that Alice can distribute a program over her machine and Bob’s machine. If Bob uses the Internet Computer Protocol to join his computer to the ICP network, Alice can run code on it without having to trust Bob – she only needs to trust the protocol, just like with TCP/IP. The trick is that Alice will run her code on Bob’s machine as well as simultaneously running copies of the same code on 12 other machines, each owned by an independent operator (Cecilia, David, Eric, etc). The protocol uses replicated execution, consensus, cryptography, and economic incentives so that dishonest operators cannot unilaterally change the outcome. The result is that Alice can expect her code to execute in the way it was written. It really can’t be overstated how important this is. It’s the Yin to TCP/IP’s Yang. It completes the picture of turning the whole network – the whole Internet – into one trusted execution environment, without sacrificing resilience due to fragility from centralization monoculture. To understand its significance, let’s consider how it impacts the whole chain from the bottom up. For web1 it solves the issue of trust delegation when you don’t have the chance to put your own server online, and you have to trust someone else to run it for you. Now you can delegate execution without delegating trust. Before ICP, you never really could. You had to trust that web hotel “node” with your program in a way you didn’t have to trust any single Internet “edge” to send your messages in an honest fashion thanks to TCP/IP, and that you now don’t have to trust any single “node operator” to run your program in an honest fashion thanks to ICP. An ICP “subnet” is a small cluster (typically 13 computers) of redundant, independent replicas running your program. When you deploy to a subnet, you don’t decide to trust that the people running the computers in the subnet are honest – they may very well be anonymous – instead you trust that the protocol stops them from being dishonest. Decentralization is very often about redundancy and ensuring “enough” honest operators remain online. Thus with TCP/IP and ICP, you can draw a network map of nodes and edges, and draw a trust boundary around the whole thing, despite all the nodes and all the edges in the network having different owners, and create a common execution environment that just grows with the number of nodes added, at Internet scale. This is new, it was only possible with the edges (the lines between the nodes) in the network before. It is quite revolutionary, and it doesn’t stop at solving web1, because the protocol is abstract enough that the nodes in the ICP network map don’t have to be computers (or subnets) – they can also be whole clouds, and even other blockchains. For Web 1.0 ICP solves the question of “how can I trust my web hotel”. For Web 2.0, ICP solves the question of “how can I build a large, unified execution environment (cloud) from independent providers”. For Web 3.0 ICP solves the question of “how can I create an even larger, totally unified execution environment, the size of the Internet, consisting of both computers and whole clouds, as well as blockchains, working together inside one, enormous trust boundary?” ICP solves all three of these questions in essentially the same way – ICP’s solution to the first web1 question is powerful enough to solve the web2 question and the web3 question in the same go. Dfinity is currently introducing “Cloud Engines” as a way to bring cloud infrastructure such as AWS, Azure, and Google Cloud into the ICP trust model, forming a common execution environment with the existing subnets. The technology that lets ICP incorporate other blockchains as nodes inside its trust boundary is called “Chain Fusion”. It may be with Cloud Engines, when it becomes clear how ICP can organize both whole clouds as well as individual computers into one Internet-scale trust boundary and execution environment, that it will really click for people. For some it started by clicking as “wait a minute – that’s like a web hotel we can trust (or, rather, don’t have to trust)!”. For others it clicked as “hey, that’s like a whole cloud you don’t have to trust – a decentralized cloud! – move over, Amazon and Microsoft!” But with Cloud Engines, I think we’re ready to see the whole picture: ICP is capable of organizing all the clouds and all the computers on the Internet into one common execution environment by creating one common trust boundary. It turns the whole Internet into one, huge computer – the Internet Computer - which it wasn’t before. Before it was a network of computers and clouds, all with their own trust boundaries, but you could not distribute a program over the totality. With ICP, you can. Amazon and Microsoft, welcome inside the new, Internet-scale trust boundary called the Internet Computer. The vision is massive, but the protocol scales, and the network grows from the ground up. The Internet Computer is one growing trust boundary, and the more of the Internet that joins it, the more of the Internet that starts behaving as one massive, decentralized computer. It can scale to eat the entire old Internet and keep growing. You might say that this is what Ethereum was already building, a World Computer. Yes, Ethereum creates a trust boundary around the smart contracts on its blockchain, making it fair to call it a World Computer. But ICP’s claim is different. Ethereum is not designed for Internet Scale in the same infrastructure sense as TCP/IP and ICP. Ethereum popularized the World Computer idea, but ICP targets Internet-scale execution, storage, web-serving, and cross-system integration. Other blockchains create their own trust boundaries. ICP is designed to let its trust boundary expand outward, potentially encompassing independent computers, clouds, and other blockchains. It all becomes part of the one trust boundary of the Internet Computer. In conclusion, it is my opinion that the Internet Computer Protocol is a profound contribution to decentralized systems theory, perhaps only matched by TCP/IP itself. You still need good algorithms to distribute your program, of course, but we already had those. We have many ways to distribute a program inside a trust boundary. What we didn’t have was a way to let the trust boundary grow without centralized ownership of nodes. That is what ICP brings. It’s so big that most people can’t see it.

Please join me Thursday at 8:30 am ET for @Pagayaltd’s 1Q26 earnings call. CFO Evangelos Perros, President Sanjiv Das, and I will be discussing our results. $PGY

🚨 $ICP PUSHING IT'S LIMITS AGAIN! Internet Computer just hit 3,995 tx/s sustained across a full 24-hour period, marking a new 90-day high. If $ICP is going to power AI and cloud infrastructure, this level of throughput is necessary! (@chainspect_app)