web3.js

ds built, or smart contracts deployed to these nodes (that the frontend interacts with)

ect wallet button, and it will allow for you to connect your wallet to the website. This will authenticate you into their website, there's some additional steps on Opensea IIRC if you want to construct a full profile, but the base authentication only requires this. And like I mentioned, you can authenticate in this manner without owning a single dollar worth of crypto. For the projects that allow for you to interface with chains / wallets, I've used these: For ethereum: https://github.com/ChainSafe/web3.js For solana: https://github.com/solana-labs/solana-web3.js Essentially what it comes down to is a user has a wallet, that is typically a web wallet via extension, but you can of course use hardware wallets if you'd like, however those do require you to own one, so if you just want to play around with the ecosystem, these extensions are the easiest to use. These above projects are javascript APIs that allow for interacting with wallets and onchain programs. Note that both of these are frontend solutions. There are backend solutions for both chains. EDIT - also there is this provided from solana labs as an adapter for many different wallet types: https://github.com/solana-labs/wallet-adapter

ite you visit gets an ID that I'll keep across all my devices, through which you can find out exactly how much money I have, in what cryptocurrencies. And they can use that to track my purchases. Forever. I raised this with the developers and they said "oh yeah we know about that and we'll fix it later". (Edit: sounds like this security problem was eventually fixed months or years later.) What on earth? People want to build the future of the web on this junk pile? Holy cow this is a house of cards. [1] https://github.com/ChainSafe/web3.js/issues/1178

& hydration. So the server sent the JSON it used to render to the client to dehydrate the page, and that JSON happened to include the raw database rows (with SSNs). The system is magic enough so you don't have to understand how that process works; but not magic enough to protect you from the consequences. Junior devs use the magic anyway and get stuck, or make mistakes like this. Senior devs feel like we have to learn everything and get overwhelmed. Other examples of this: - Recently I wanted to use some rust code (compiled to wasm via wasm-pack) in a svelte project with snowpack or rollup. I know how to include wasm in a webpage, but the bundlers needed special plugins to handle this. And the plugins for wasm are halfbaked, poorly maintained and janky. - I worked with a team a few years ago who was using some graphql wrapper around contentful. (Before contentful had an official graphql endpoint). The wrapper was very good, but we needed to run some queries that weren't supported by the wrapper. This was close to impossible. Nobody on the team was strong enough to read the graphql code to figure out how to solve our problem. I did it eventually - via some custom endpoints. But I shouldn't have. After I left the team had no idea how to maintain or modify the code I wrote, and they were entirely stuck. - The "web obesity crisis" comes from projects pulling giant amounts of javascript into their webpages. Our tooling makes this easy (npm install) and safe (incompatible versions of the same package are included separately). So its easy to end up with libraries like web3, which include about a dozen different versions of bn.js resulting in 2.3mb of uncompressed JS which takes nearly a second to parse on a modern computer. - [1] https://github.com/ChainSafe/web3.js/issues/1178 I don't know what the answer here is, but I know when I was writing qbasic as a kid it wasn't like this. Maybe we need to stop going "up the stack", and instead go sideways - throwing things out as we add more. I worry this whole problem will get much worse before it gets any better.

dive into - the tooling is more mature than other dev-centric blockchains. However, keep in mind that ethereum as a base can be a tricky place to launch your app because of high transactional fees, and you would likely want to integrate a layer 2 like Arbitrum or support alternative coins in a final application. I'll link some pages to a few technologies I used when building some ethereum dapps https://www.trufflesuite.com/truffle https://www.trufflesuite.com/ganache for wallet integration, either of these work https://github.com/ChainSafe/web3.js https://github.com/ethers-io/ethers.js I highly recommend checking out The Graph too - it allows for you to leverage graphQL on your smart contract data by creating a dedicated subgraph. With some careful integration, you can replace a dedicated backend that would normally be required for various APIs with this. It's a very exciting project imo. https://thegraph.com/en/ And of course, the solidity documentation is very helpful. Coming from a scripting heavy background, solidity was very easy for me to pick up and write a simple escrow service. https://docs.soliditylang.org/en/v0.8.9/ I'd also recommend checking out other chains once you become more comfortable with the system. I'm currently working on Solana and it's a bit more difficult to work with due to the tooling not being as mature, but it is a very interesting chain to work with and I hope that it can scale better than Ethereum has.

delight and horrify in equal measure: https://github.com/ChainSafe/web3.js/issues/1178

ion means accepting that I work at the speed notion does, and that feels antithetical to the feeling of productivity I have in snappier, lighter tools like Bear and iA writer. But Notion and XCode aren't really the problem. The problem is cultural. It seems to be the worst in the web ecosystem, though its not confined there. My favorite example of all is this issue in web3.js[1]. I can't help but play Benny Hill music in my head while I scroll through this 3 year old, apparently unsolvable issue thread. When the new M1 macs came out lots of people were complaining that there's no 32 gig variant. Holy cow that is so many bytes. The Atari 2600 had 128 bytes of ram. The NES ran super mario bros in 2kb. Its completely ridiculous to me that our software can even fill 16gb doing everyday computing. Is there a ceiling? Will there ever be a ceiling, or should we expect a document editor in 2030 to sit on 256gb of ram, just because thats how much ram modern javascript frameworks use by then? [1] https://github.com/ethereum/web3.js/issues/1178#issuecomment...