Hongchao's Notes

Visualize ALPHred VM Execution

Sat, 07 Sep 2024 00:00:00 +0000

ALPHred is a stack-based virtual machine designed for Alephium, used to execute smart contracts on the Alephium blockchain. The need for a specialized VM arises from Alephium’s unique stateful UTXO (sUTXO) model, which supports the Ethereum style account model for handling contracts state, as well as the Bitcoin style immutable UTXO model for secure assets management.

ALPHred also introduced many innovative features to enhance the security and efficiency of smart contracts execution. One example is Asset Permission System, which explicitly stipulates the flow of assets at the VM level, giving confidence to developers and users that all asset transfers within the smart contract happen as intended. Together with the UTXOs model, it offers a simpler and more secure user experience by eliminating the token approval risks in systems such as EVM.

In this article, let’s dive into ALPHred’s internals with the help of Alephium Decoder.

General Architecture

The ALPHred VM utilizes a stack-based architecture, with a decicated frame stack managing function calls. A new frame is pushed onto the stack when a function is invoked, and removed once the function returns. Each frame contains local variables, an operation stack (opStack) and a series of instructions. It also has access to the immutable and mutable fields of the contract, asset balances, block and transaction information, etc. During execution, ALPHred VM processes a sequence of instructions for the function on top of the frame stack, relying on its opStack to store intermediate values and operants. These instructions cover a wide range of operations, such as loading and storing local variables and contract fields, approving and transferring assets, initiating local or external function calls, etc. ALPHred VM finishes execution when the last frame is successfully popped out of the stack.

This design enables efficient smart contract execution while maintaining clear separation between different function contexts and contract states.

The following image visualizes the general architecture of ALPHred VM when replaying a transaction on Alephium Decoder. On the left hand side, we can see the next VM instructions to be executed for the top frame. On the right hand side, we can see the active frames in the frame stack. TxScript frame is always at the bottom of the stack since it is the entry point of a Alephium transaction that interacts with the smart contracts. For other frames, it displays the address of the contract where the function belongs to and its method index. It also shows the local variables, asset balances and contract fields that are accessible to the frame if they exist.

As we replay the instructions step by step, we can observe the changes for the frame stack and the contract state, as well as the gas consumption for each instruction.

Key VM Instructions

The ALPHred VM utilizes a set of carefully designed instructions to efficiently manage its operations. Let’s explore some of the key instructions that form the backbone of its functionality.

Load and Store Variables

ALPHred VM provides instructions to load and store variables from the frame’s local variables as well as the contract’s state (fields).

LoadLocal: Loads a local variable onto the opStack.
StoreLocal: Stores the top value from the opStack into a local variable.
LoadImmField: Loads an immutable field from the contract onto the opStack.
LoadMutField: Loads a mutable field from the contract onto the operation stack.
StoreMutField: Stores the top value from the operation stack into a mutable field of the contract.

These instructions allow the VM to efficiently access and modify both local variables within a function’s scope and the contract’s state. The distinction between immutable and mutable fields is crucial:

Immutable fields (LoadImmField) are set when the contract is deployed and cannot be changed afterwards. They are used for constant values that should remain the same throughout the contract’s lifetime.
Mutable fields (LoadMutField, StoreMutField) represent the changeable state of the contract. These can be modified during contract execution, allowing for dynamic state management.

This separation provides a clear distinction between constant and variable contract properties, enhancing both security and efficiency. Immutable fields can be optimized by the VM, while mutable fields allow for flexible state updates as required by the contract’s logic.

As shown in the image above, the top LoadMutField instructions will load the first mutable fields onto the opStack. We can also see the LoadLocal, StoreLocal and LoadImmField instructions as well.

Function Calls

ALPHred VM provides two key instructions for function calls: callExternal and callLocal. These instructions allow for efficient execution of both inter-contract and intra-contract function calls.

callExternal: This instruction is used to call functions in other contracts. It enables cross-contract interactions, which are essential for building complex decentralized applications. When executing a callExternal instruction, the VM creates a new frame for the called function and pushes it onto the frame stack. This new frame includes its own set of local variables and opStack, ensuring proper isolation of execution contexts between different contracts.
callLocal: This instruction is used to call functions within the same contract. When a callLocal instruction is executed, a new frame is created for the called function and pushed onto the frame stack, but it retains access to the same contract state (immutable and mutable fields) as the calling function.

In the image above, we can see an example of a callExternal instruction. The VM is about to call a function from another contract: the top of opStack is the contract id, the method index is 7 as encoded in the callExternal instruction. U256 2 and U256 0 represents the number of return values and arguments for this function, which are used by ALPHred VM to perform basic compatibility checks. When the called function returns, the VM will pop out the new frame, push its 2 return values onto the opStack of the current frame and continue execution.

Asset Management

ALPHred VM provides instructions to approve and transfer assets.

approveToken: Approve a certain amount of token to an address.
approveALPH: Approve a certain amount of ALPH to an address.
transferToken: Transfer certain amount of token to an address’s transaction output.
transferALPH: Transfer certain amount of ALPH to an address’s transaction output.

In the image above, we can see an example of ApproveToken instruction. The VM is about to approve U256 1 amount of token fed6cb5a26e2bcbf0be83f0bf472b45d91a4f68c4e995a12255f4591e75c1000 to address 12aH6to1JQxDFsvJ89jtFCnKEcub5ew8x2EABGEDMTYyK (see opStack). After that the available and approved asset balance for this address will be updated.

When calling a function, it can only use the assets approved for it. As we can imagine, if we have a tree of method calls, the approved fund will cascade from the root of the tree all the way to the leaves. This is how ALPHred VM supports the Asset Permission System, which makes the flow of funds across method calls explicit and enforces constraints on each method, specifying which tokens can be spent and in what amounts.

Contract Creation

ALPHred VM provides a set of instructions for creating contracts and subcontracts (more on its benefits here). These instructions are also how tokens are issued on Alephium.

Create Contract
- Base instruction: createContract
- Token variants: createContractWithToken, createContractAndTransferToken
- Copy creation versions: copyCreateContract, copyCreateContractWithToken, copyCreateContractAndTransferToken
Create Subcontract
- Base instruction: createSubContract
- Token variants: createSubContractWithToken, createSubContractAndTransferToken
- Copy creation versions: copyCreateSubContract, copyCreateSubContractWithToken, copyCreateSubContractAndTransferToken

Each base instruction has variants for issuing token (WithToken) and transferring those tokens to a recipient (AndTransferToken). The copy versions allow for creating new contracts based on the code of an existing contract.

In the image above, ALPHred VM is about to create a new subcontract using the copyCreateSubContract instruction. On the opStack it has its parent contract id, the subcontract path, as well as the the template contract id where it can copy code from. After execution, it will push the new subcontract’s id onto the opStack. You can read more about copyCreateSubContract instruction here.

Other Instructions

ALPHred VM includes a variety of other instructions that are essential for smart contract execution and blockchain operations. Here are some of the common instructions, it is not meant to be an exhaustive list.

Control Flow
- Jump: Unconditional jump to a specified instruction.
- IfTrue: Conditional jump if the top of the stack is true.
- IfFalse: Conditional jump if the top of the stack is false.
Stack Operations
- Pop: Remove the top element from the stack.
- Dup: Duplicate the top element of the stack.
- Swap: Swap the top two elements of the stack.
Arithmetic and Logic
- I256Add/U256Add: Add two numbers.
- I256Sub/U256Sub: Subtract two numbers.
- I256Mul/U256Mul: Multiply two numbers.
- I256Div/U256Div: Divide two numbers.
- I256Mod/U256Mod: Compute the modulus of two numbers.
- BoolNot: Logical NOT operation.
- BoolAnd: Bitwise AND operation.
- BoolOr: Bitwise OR operation.
- U256Xor: Bitwise XOR operation.
Cryptographic Operations
- Blake2b: Compute the Blake2b hash of the input.
- Keccak256: Compute the Keccak256 hash of the input.
- Sha256: Compute the Sha256 hash of the input.
- VerifySecP256K1: Verify a secp256k1 signature.
- VerifyED25519: Verify an ED25519 signature.
- EthEcRecover: Recover an address from an ECDSA signature
Blockchain Interaction
- TxId: Get the current transaction ID.
- BlockTimeStamp: Get the timestamp of the current block.
- BlockTarget: Get the target of the current block.
Contract Interaction
- DestroySelf: Destroy the current contract and transfer its balance.

These instructions, along with the instructions highlighted earlier, form the comprehensive instruction set of the ALPHred VM. They enable developers to create complex, secure, and efficient smart contracts on the Alephium blockchain.

Conclusion

The ALPHred VM is a key component of the Alephium blockchain, offering a robust and secure environment for smart contract execution. Its comprehensive instruction set enables sophisticated operations, efficient asset management, and flexible contract creation. These features, combined with built-in security measures and blockchain-specific operations, make ALPHred VM a solid foundation for developers building on Alephium.

An Imperfect Perfection

Sat, 24 Aug 2024 00:00:00 +0000

In a world that often chases perfection – whether in our work, our relationships, or the objects we possess – there lies a certain beauty in imperfection. This paradoxical notion is something I’ve come to appreciate deeply through my relationship with a particular timepiece: the Mark 1 version of the Explorer 1 (Reference 214270). While some may see its flaws as detracting from its value, I have found that these imperfections are precisely what make this watch not just special, but a true embodiment of “imperfect perfection.”

A Classic with Quirks

Explorer 1 is renowned as one of the quintessential tool watches, designed with adventurers in mind. With its minimalist design and rugged build, epitomizes the spirit of exploration and resilience.

However, the Explorer 1 214270 Mark 1 is not without its controversies. Two features, in particular, have sparked debate among watch aficionados: the short hands and the unlumed 3, 6, and 9 numerals. Critics argue that the minute hand should extend further to meet the minute markers, enhancing readability and aesthetic harmony. Meanwhile, the absence of lume on the key numerals is seen as a significant drawback, especially for a watch with a legacy rooted in extreme conditions where readability in low light is important.

For some, these elements are flaws that mar an otherwise perfect watch. But for me, they are the very features that give the Explorer 1 Mark 1 its character and uniqueness.

A Reflection of Life’s Imperfections

Life itself is far from perfect. It is filled with moments of regret, decisions we might wish to change, and paths we could have taken differently. Yet, it is these very imperfections that make life rich and meaningful. This watch, with its minor “flaws”, serves as a daily reminder of this truth.

There is a certain beauty in things that are not entirely perfect or complete. This watch’s imperfections make it more approachable, more human. It is not a sterile object of mechanical precision but a watch with a soul, reflecting the idea that a complete life is not about achieving flawless perfection but about appreciating the beauty in what is, including the rough edges and the unfinished chapters.

The imperfections of this watch are also analogous to the regrets we all carry in life. However, just as these watch “flaws” do not diminish its overall value, our regrets do not detract from the richness of our experiences. They are integral to our personal narratives, adding depth and complexity. My appreciation to this watch, despite – or perhaps because of – its controversies, mirrors the acceptance of life’s imperfections as essential to a complete and fulfilling existence.

Attachment, Loyalty and Identity

The emotional attachment toward an object such as a watch is not unique; it reflects a broader human tendency to form deep connections with entities, whether they are objects, sports teams, or even nations. This phenomenon is deeply rooted in the psychology of attachment, loyalty, and identity.

Fans of sports teams often remain loyal even when their team performs poorly. This loyalty is not purely rational; it is emotional, tied to a sense of identity and belonging. Similarly, nationalism often involves a strong emotional bond with one’s country, even in the face of its imperfections. People justify and rationalize their attachment to their nation, often overlooking or downplaying its flaws. In both cases, the attachment is about more than the object or entity itself; it’s about what it represents – identity, history, and a sense of belonging.

On a more extreme level, there is a psychological phenomenon known as Stockholm Syndrome, where hostages develop a bond with their captors, often rationalizing their captors’ actions as a way to cope with the trauma. While the context is vastly different, the underlying mechanism – justifying flaws to maintain a sense of connection – is similar. In the case of my watch, am I over-justifying its flaws, clinging to its imperfections as a way to deepen my emotional attachment to it? Perhaps. In any case, it highlights how the human mind can create strong bonds with even imperfect entities, often finding meaning in the very flaws that others might see as detracting from value.

The Perfectly Imperfect Companion

The Explorer 1 214270 Mark 1 is, to some, a watch with flaws. But to me, it is a symbol of life’s imperfect perfection. It is a reminder that true beauty lies not in the absence of flaws but in the presence of character, authenticity, and meaning. This watch is more than just a timepiece; it is a reflection of my life philosophy: a belief that imperfection is not something to be corrected but something to be embraced.

In a world that often demands flawless perfection, it stands as a testament to the value of imperfection. It teaches that completeness comes not from eliminating flaws but from appreciating them as part of our unique journey. Just as this watch remains one of my most cherished possessions despite its controversies, so too does life become richer and more meaningful when we accept and embrace its inherent imperfections.

And perhaps, I am indeed over-justifying its flaws. But in doing so, I find a deeper connection, not just to the watch itself but to the larger human experience of loving and cherishing what is imperfectly perfect.

Web3 and Advertising

Sun, 05 Feb 2023 00:00:00 +0000

Marc Andreessen famously attributes the proliferation of internet advertising today to browser’s lack of built-in payment support from the beginning. He calls it the original sin of the internet. The downstream from advertising, he argues, is everything people are anxious and worked up about today: privacy, user data collection, misalignment of the incentives, etc. The assumption is that if crypto were around in the early internet, it would be much easier to incorporate financial transactions into the browser and the landscape of the internet economy could look vastly different compared to what we’ve seen today.

In general, advertisement has a negative connotation in the Web3 community. It represents a “legacy” business model from the web2 era that web3 is set out to disrupt. Sovereign individuals in the next stage of the internet evolution are supposed to not only take back the control of money but personal data as well. With the help of blockchain technologies, new waves of web3 applications will finally be able to deliver on products that align incentives, respect privacy, promote economic fairness with superior user experience. Isn’t that great?

The reality is that a class of existing web3 projects struggle to find sustainable business models. Many projects (especially some of the X2Earn ones) rely on Ponzi tokenomics where earnings of the participants come from the funds collected from the new investors. When no new speculative capital flows into the system, the party stops and the project goes into a death spiral. Web3 projects, like any projects, need external sources of revenue to maintain a sustainable token economy.

Advertising should be appreciated more despite many of its real issues. Some of the internet’s most important “common goods” are funded directly or indirectly by advertising: search engines, social networks, browsers, public town halls (e.g. twitter), etc. One thing in common about these services is that their usage is typically non-transactional: “pay per use” model introduces friction and negatively impacts their user experience. Subscription model fixes some of the issues, but as Vitalik pointed out, advertising is in some cases a superior model: it massively improves accessibility to a large portion of the population who are unable or unwilling to pay by providing free (in money terms) products . It accomplishes near-perfect price discrimination where the price of users’ attention is usually proportional to their income. Without advertising or similar mechanisms, it is unclear if the Web3 version of the “common goods” such as social network could reach a similar level of mass adoption as its Web2 predecessors.

Advertising played a crucial role in Web2 also because people’s attention is one of the rare mechanisms that naturally bridges the online/offline world. Another example of such bridges is Bitcoin’s PoW algorithm: an onchain hash that meets the difficulty target mathematically demonstrates the burning of a certain amount of energy offchain. This allows Bitcoin to programmatically control participants’ behavior and establish a vibrant ecosystem (both on and off chain) around it. Similarly, leveraging people’s attention allows a class of online services such as search engines and social networks to trigger both online and offline economic activities in a relatively easy and scalable way, which is crucial for generating revenues. That is why I believe even without its original sin, advertising would still have been one of the most important business models on the internet. It existed in the age of newspapers and it will continue to exist in the era of Web3.

How advertising would play out in Web3 is a question worth exploring. The airdropped tokens and NFTs are certainly a form of advertising since it demands attention and incentives certain measurable behaviors. Crypto wallets and DID has the potential to expand ads from pure impressions to rich and interoperable objects. Self custody of identity and personal data in combination with well designed tokenomic systems and crypto primitives such as zero knowledge proofs might offer new ideas as to how advertising could be done in a fairer and more private way. The design and tradeoff space is massive, hopefully a better form of advertising can come out of the Web3 movement that addresses most of the current issues while preserving its enormous benefits.

Advertising in Web3 also has the potential to make a new positive impact to the world. For example, the financial component of Web3 is a great tool to incentivize human behavior that in accumulation has long term benefits with short term sacrifices. That includes health, environmental protection, fundamental research, etc. With the right tokenomics design, Web3 projects can incentivize such behaviors and build a community around it while leveraging Web3 version of the advertising as the mechanism to keep the tokenomics sustainable. A coherent community with a common goal might also be a valuable target for like-minded merchants. Advertising helped us fund many “common goods” in the past, it could continue to help us fund new types of “common goods” in the future with new tools and technologies.

In summary, advertising should not be disdained by the Web3 community, it is just a tool that can be improved and leveraged to the benefit of Web3!

Deep Dive into Ethereum Logs

Sat, 22 Jan 2022 00:00:00 +0000

Logs in Ethereum are very useful since they are the underlying mechanism for events, which is the recommended way for smart contracts to communicate with the outside world. They also provide a significantly cheaper way to store data on-chain.

As an example, the following code snippet from the UniswapV2ERC20.sol contract emits a Transfer event whenever a transfer of tokens takes place.

event Transfer(address indexed from, address indexed to, uint value);

function _transfer(address from, address to, uint value) private {
  balanceOf[from] = balanceOf[from].sub(value);
  balanceOf[to] = balanceOf[to].add(value);
  emit Transfer(from, to, value);
}

For a more detailed description of the Ethereum logs, including the concept of indexes/topics, data and cost, etc, highly recommend Luit Hollander’s excellent blog post Understanding event logs on the Ethereum blockchain. This blog post will instead focus on how logs are actually implemented in Ethereum, specifically in Geth.

When an event is emitted from a smart contract, one of the LOG opcodes will be generated by the smart contract compiler. Events can have maximum 4 topics/indexes, which is why there are 5 LOG opcodes (LOG0, LOG1, …, LOG4) defined. The Transfer event in the above example has three indexes/topics in total: two explicit indexes from and to, and one implicit index which is the hash of the event signature (see Luit’s post), in this case Transfer(address, address, uint). As the result, the generated opscode is LOG3.

LOG opcode is then interpreted by the makeLog(size int) function, which basically reads the indexes as well as a blob of arbitrary data from the stack, uses them to construct a log object and then adds it to StateDB. StateDB is an EVM data structure that stores anything within the merkle trie, and is the general query interface to retrieve contracts and accounts. It’s used to store data during transaction execution, including logs.

func makeLog(size int) executionFunc {
	return func(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
        // ... skip ...
		for i := 0; i < size; i++ {
			addr := stack.pop()
			topics[i] = addr.Bytes32()
		}

        // ... skip ...
		interpreter.evm.StateDB.AddLog(&types.Log{
			Address: scope.Contract.Address(),
			Topics:  topics,
			Data:    d,
			// This is a non-consensus field, but assigned here because
			// core/state doesn't know the current block number.
			BlockNumber: interpreter.evm.Context.BlockNumber.Uint64(),
		})
        // ... skip ...
	}
}

When a transaction is executed using the applyTransaction function, the generated transaction receipt contains logs that are retreived from StateDB together with a bloom filter that statistically keeps track of all the topics of the log as well as the address of the contract that emits the logs. The reason to use a bloom filter here is to strike a balance between query efficiency and storage space. If a user wants to search for logs with a set of topics, these topics can be run against the bloom filter to probabilistically determine if any log match the search criteria exist in this transaction receipt. False positives are removed by checking with the search criteria again.

func applyTransaction(msg types.Message, config *params.ChainConfig, bc ChainContext, author *common.Address, gp *GasPool, statedb *state.StateDB, blockNumber *big.Int, blockHash common.Hash, tx *types.Transaction, usedGas *uint64, evm *vm.EVM) (*types.Receipt, error) {
    // ... skip ...

	// Set the receipt logs and create the bloom filter.
	receipt.Logs = statedb.GetLogs(tx.Hash(), blockHash)
	receipt.Bloom = types.CreateBloom(types.Receipts{receipt})
	receipt.BlockHash = blockHash
	receipt.BlockNumber = blockNumber

    // ... skip ...
}

When a block is created in the NewBlock function, it creates a bloom filter in the block header which essentially combines the bloom filters of all the transaction receipts included in this block. This allows quick check of whether any logs with matching criteria exists in this block.

func NewBlock(header *Header, txs []*Transaction, uncles []*Header, receipts []*Receipt, hasher TrieHasher) *Block {
    // ... skip ...

	if len(receipts) == 0 {
		b.header.ReceiptHash = EmptyRootHash
	} else {
		b.header.ReceiptHash = DeriveSha(Receipts(receipts), hasher)
		b.header.Bloom = CreateBloom(receipts)
	}

    // ... skip ...
}

When a block is persisted using writeBlockWithState function, it persists all transaction receipts with logs per block. The format of the key value pair is blockReceiptsPrefix + num (uint64 big endian) + hash -> block receipts.

func (bc *BlockChain) writeBlockWithState(block *types.Block, receipts []*types.Receipt, logs []*types.Log, state *state.StateDB) error {
    // ... skip ...

	rawdb.WriteBlock(blockBatch, block)
	rawdb.WriteReceipts(blockBatch, block.Hash(), block.NumberU64(), receipts)
	rawdb.WritePreimages(blockBatch, state.Preimages())

    // ... skip ...
}

There are a few ways to consume the emmited events. After a transaction is mined into the blockchain, eth_getTransactionReceipt can be called with the transaction hash to get the transaction receipt, which contains a logs field that carries an array of log objects that this transaction generated. DApp frontends can also leverage the combination of the eth_newFilter and eth_getFilterChanges method to poll the new events of interest. Web3.js abstracts this away by providing the subscribe(“log”) method to help real time consumption of the incoming logs using the subscription model.

Let’s look at these JSON-RPCs in more details:

eth_getTransactionReceipt. Return the transaction receipt for a transaction id. Since transaction receipts are stored per block, this basically fetches all the receipts for the block that this transaction belongs to and only return the requested one. As mentioned before, logs are part of the transaction receipt.
eth_newFilter & eth_getFilterChanges. Return logs that match the search criteria such as the block range, contract address as well as topics. This leverages the bloom filter both in the block header as well as in the transaction receipt to determine which logs should be returned. False positives are filtered again using the search criteria. The filter logic can be found here. There are also some index optimization so that it doesnt have to iterate through each blocks in the block range while searching for the matching logs.

Hope this blog post has shed some light on how logging is implemented Ethereum. The overall design feels pretty elegant and efficient. One tradeoff here is how much data should be indexed on-chain v.s off-chain. Ethereum decided to have max 4 topics per log, perhaps a good balance between searchability and storage, but one can make an legitimate argument that indexes should be pushed more to the application layer since data is more understood there and it is easier to make changes afterwards.

Reference:

Alephium Stack on GKE

Sun, 09 Jan 2022 00:00:00 +0000

Alephium is the first operational sharded blockchain that brings scalability, ETH-inspired smart contracts and dApps capabilities to Bitcoin’s proven core technologies while ensuring better performance and improved energy efficiency. Alephium is one of those rare gems in the crypto space that has solid innovations, high code quality and great mindset for decentralization.

The project comes with a docker setup that helps to run the entire stack, including the full node, block explorer (frontend & backend), GPU miner, as well as monitoring (prometheus & grafana). This is especially convenient if you want to experiment with the entire stack on your local machine. For more details, please consult the documentation.

It might also be a good idea to run the Alephium full stack on K8S cluster. Here are some of the potential benefits:

Expose Alephium stack to the public
Mine with the rented GPUs in the cloud
Develop against remote Alephium stack locally
Run applications that depends on Alephium full node in production
Scale different components of the Alephium stack depending on your use case
Leverage managed service such as CloudSQL for Postgres
Ease of operation if you are already familiar with K8S

I have setup the Alephium stack on GKE, mined some ALPHs and and exposed the following sites:

Alephium Explorer (alephium.softfork.se)
Alephium Monitoring (grafana.softfork.se)
Alephium API Documenation (alephium.softfork.se/docs)

It’s comforting to be able to monitor the status of your full node wherever you are:

It is also pretty easy to develop against the remote Alephium locally, e.g.

# Port forward alephium from Kubernetes cluster
➜ kubectl port-forward svc/alephium 12973
Forwarding from 127.0.0.1:12973 -> 12973
Forwarding from [::1]:12973 -> 12973

# Curl locally
➜ curl localhost:12973/infos/self-clique
{"cliqueId":"03764042ab3c875481e5eed6d7a59027a7232582c189e1c266f57b62591ae0d8e0","networkId":1,"numZerosAtLeastInHash":18,"nodes":[{"address":"127.0.0.1","restPort":12973,"wsPort":11973,"minerApiPort":10973}],"selfReady":true,"synced":true,"groupNumPerBroker":4,"groups":4}

The code for setting everything up is open sourced in the alephium-stack repo. Checkout the README.md for more details. Happy Hacking! :fire::fire::fire:

Part of "The Game"

Sat, 25 Dec 2021 00:00:00 +0000

Complains

Some Challenges of Freedom of Speech

Tue, 24 Aug 2021 00:00:00 +0000

If there exists a superintelligence system that posesses all the knowledge and truth of the world and is able to always process it with the most “optimal” algorithm, no matter what circumstances are, perhaps planned economy would become a better mechanism for resource allocation and growth generation than market economy. In fact, if such a superintelligence system happens to have the capacity and intention to advance human society as a whole, maybe the most sensible thing for us to do is to follow its lead.

Fortunately and unfortunately, this superintelligence doesn’t exist, at least not yet. History seems to have shown repeatedly that no matter how capable and well intended an individual or a group of individuals are, it is difficult for mere mortals to be the guardians of information for everybody without suffocating the society. On top of that, such power almost always leads to Orwellian like state: Power corrupts; absolute power corrupts absolutely. Many have fought and continue to fight for the right of freedom of speech as a response to that.

From the societal perspective, freedom of speech as a mechanism as done a remarkable job so far to continuously generate ideas based on new circumstances so that humanity can be equipped with more knowledge and societies can evolve from one consensus to the next. It encourages the contribution from individuals with different skillsets and perspectives; It provides a market place where ideas can be challenged, debated and tested; It also protects the “unorthodox” ideas from being suppressed by the powerful status quo consensus. At a higher level, it is a dynamic, decentralized, bottom up approach to achieve collective goals, analogous to biological evolution or market economy in their respective domains.

However, information has some interesting properties. One of them is that the cost of verification is asymmetrically higher than the cost of generation. This might not be very obvious before the age of Web 2.0, when both information generation and distribution were still controlled by mainstream medias. In that era, the flow of information within society was still relatively simple due to its largely hierachical nature. The media outlets basically took on the responsibility to verify and filter their contents for their audiences. However, in the past 15 years or so, new technologies such as social media platforms have essentially democratized the ability to generate and distribute information. Putting aside the benefits this must have created for a moment, with the explosion of user generated content and the flow of information that is orders of magnitude more complex, the overall cost of information verification at the societal level must have skyrocketed. This puts companies such as Facebook in an extremely tough spot. With billions of users from different countries, the sheer amount of information that needs to be moderated as well its complexity is astonishing.

This begs the question: should they play the role of truth arbiter? If they should, can they theoretically and practically keep up with the continued explosion of information when it has such an inherent asymmetric property? If they shouldn’t, what is the effect of forcing this responsibility to the individuals when most people neither have the time nor expertise to sufficiently identify misinformation? When freedom of speech is enhanced so much by technology, it seems logical that more moderation (i.e. censorship) needs to happen somewhere in the information flow to keep the verification cost in check and prevent the overall quality of the information from decaying. Who should do that? To which extent should they do that? Is this against the very spirit of freedom of speech?

Another property of information is that it thrives in big networks and therefore creates network effect. If there are many diversified, competing platforms that people can easily migrate, these platforms could compete on the ways that the information is moderated and probably wouldn’t cause significant issues at the societal level. The problem is that due to the network effect, we end up with a handful very large and powerful ones that are not diversified enough when it comes to information moderation, which poses systematic threat to the freedom of speech. These companies are also dorminated by similiar business models: harvest user data, create echo chambers to increase the stickiness of the platform and make money by selling ads to the users. Freedom of speech includes the freedom to hear. These profit oriented algorithms implicitly impose constrains to the flow of information and have profound impact to the quality of the information we consume. “Garbage in, Garbage out”. The implication of this to the quality of the democracy over the long run remains to be seen.

Media Echo Chamber, Wikipedia

Even though the quality of information is crucial to the quality of democracy and there is a risk that the ads model is fundamentally incompatible with societies’ larger goals. It seems that the industry still struggles to find a good replacement for it. Ads model has an ingenious property that is often underappreciated: it is incentive compatible for most of the participants within the system. Majority of the users always prefer convenience and immediate economic benefits. A “free” product paid by your attention instead of money is still winning the usability battle at least with the current state of the technology.

Another threat to freedom of speech is the extent to which its alternative models can succeed, even temporarily. Human societies have gone through times where there were explosions of scientific and technological breakthroughs. However, other parts of the human history is filled with incremental improvements or even staganations. Freedom of speech as an idea generation and selection mechanism is much more valuable in periods of breakthoughs. Arguments can be made that science has been staganating in the past 40 years and we are just reaping the benefits from the research done by the generations before that. It is unclear if this is temporary and how long this would last. Under this assumption, societies emphasizing more on freedom of speech might not get enough benefits for its cost, whereas countries that actively censor information might be able to reach social consensus much more effectively without incuring an unbearable cost of losing the battle of innovation. Of course, this dynamic could change under different circumstances, perhaps this is one of the hidden forces that can influence the rise and falls of the civilizations that focus more on individualism vs collectivism.

How many flowers should be let bloom?

Constraints and Liberties

Sat, 03 Jul 2021 00:00:00 +0000

In The Shawshank Redemption, Brooks Hatlen was released from the prison after being locked up for 50 years. He finally regained his liberty and yet his inability to adjust to the outside world gives him constant fear and desperation. He commited suicide. The freedom from the constraints of the prison killed him. Similiarly, after Booker T. Washington was emancipated as a slave, his initial rejoicing was soon overwhelmed by the sense of deep gloom due to the realization that without money, education, skills and property, life is not significantly different after liberation.

Instead of drowning in desperation, Booker spent his life promoting education, hard work and material prosperity among the blacks. Ultimately, without a fairer access to education, health care, security and other social rights, liberty would be an empty slogan for a large portion of the population. However, enforcing those social rights requires the redistribution of wealth and resources, therefore inevitably infringing the liberty of other portion of the population. The balance of this tension is one of the most important topics in the debate between liberals and conservatives in contemporary politics.

An important question to answer when discussing constraints and liberties is who are we optimizing for. The goal of most of the societies is to promote long term freedom and happiness of the entire population. Isaiah Berlin articulated in his essay Two Concepts of Liberty about the idea of negative and positive liberty. With only negative liberty, which focuses primarily on the freedom from interference by other people, the collective liberty and happiness can neither be maximized nor fairly distributed. As a balancing force, positive liberty emphathizes the importance of population’s collective capacity to act upon their free will, which can be achieved by applying certain constraints to the society. In that sense, negative liberty alone constrains the society from reaching its full potential, whereas proper constraints at the right level librate society at large.

Constraints and liberties seem to have similiar dynamics at smaller scale as well. For example, without the constraints of the rules, the game of Go will not be able to librate the mind-blowing creativities from the players. The limited form of expression offered by the likes of Tiktok, Twitter and WeChat seems to have unleashed the creative energy from their users and therefore created more sticky networks. Often times, less is more, constraint is liberty. This probably has to do with our limited mental capacity as human beings. Constraints abstract things away, sometimes at the expense of choice, but as a tradeoff we get to focus our precious cognitive effort somewhere else. This is not to say all constraints are well designed. Countless games must have been invented throughout history, the set of constraints Go offers stood the test of time.

Another example is programming languges. C is a great language for system programming with very little constraints, but at the same time it is also a double edged sword that can cut both ways. People who mastered the language (e.g. Linus Torvalds) might feel that nothing is better than C. However, for many programmers, having to worry about the countless traps and pitfalls of C severely limits their capabilities to create. Many languages try to fix this by enforcing different constraints. One example is functional programming, where mutation of variables are strongly discouraged or even disallowed. As it turns out, programmers’ creativity are liberated by these types of constraints because now their cognative energy can be spent more on solving the actual problems. In general, when we are trying out different ways of working, we are applying different constraints and see which one yields the best result. Liberty in the context of work usually constrains our ability to perform.

Constraint and liberty are also multifaceted. Even at the individual level, one freedom might come at the cost of another. The constraint of being monitored by the surveillance camera might give you the freedom to walk around safely at 2am anywhere in the city. The unregulated freedom of speech in the age of information explosion could significantly constrain your freedom to understand the truth due to the asymmetric cost to prove false information. Financial freedom at certain age might require very displined life style and prudent management of wealth at earlier age. The liberty to smoke many packs of cigerettes a day could deprive of any other freedom you might have the chance to enjoy prematurely.

Constraints Liberate, Liberties Constrain.

References:

Project K2

Sun, 21 Feb 2021 00:00:00 +0000

The purpose of the project is cryptographically (sha256) committed to: f3b0ce65c0e350236ac89bb59acfdb7c90cdddad90366918aaa1b67f57ad00d1

Places to be Visited

[-] California (USA)

Golden gate bridge original image

[-] Japan

Tokyo original image

[-] Koh Samui (Thailand)

Koh Samui original image

[-] Verona (Italy)

Arena di Verona original image

[-] Amsterdam (Holland)

Amsterdam original image

[-] Iceland

Blue lagoon original image

[X] Hangzhou (China)

West lake original image

[X] Sanya (China)

Sanya original image

[X] Zhuhai (China)

Zhu gang ao bridge original image

[X] Lianyungang (China)

Lianyungang original image

[-] Sydney (Australia)

Sydney opera house original image

[-] Vienna (Austria)

Vienna Musikverein original image

[-] Paris (France)

Paris original image

[-] Athens (Greece)

Acropolis original image

[-] Istanbul (Turkey)

Hagia Sofia original image

[-] Egypt

Pyramid original image

[-] South Africa

Safari in SA original image

[-] Jerusalem (Israel)

Western wall original image

[-] Dunhuang (China)

Dunhuang original image

[-] Hoh Xil - Kekexili (China)

Kekexili original image

Emacs is the 2D Command-line Interface

Fri, 25 Dec 2020 00:00:00 +0000

One of the most popular arguments against Emacs is that it is “a great operating system, lacking only a decent editor”. The promotion of the idea of “Living in Emacs” by some of the hardcore Emacs users only make this argument more compelling. At the first glance, using a single program for “everything” does seem to contradict the Unix philosophy, which favors single-purposed programs that compose really well instead of monolithic systems that try to solve many complex problems at the same time. In this article, I’d like to argue that Emacs largely follows the Unix philosophy in its problem domain: working with text, and can be seen as a two dimentional version of the command-line interface (CLI).

This is the Unix philosophy: Write programs that do one thing and do it well. Write programs to work together. Write programs to handle text streams, because that is a universal interface.

McIlroy, head of the Bell Labs Computing Sciences Research Center

Many CLI tools stood the test of time. Programs like find, grep, awk, etc have been indispensable for IT professionals for decades. They are effective, sometimes more so than their GUI counterparts, because command line interpreters such as Bash provides an environment where they can be composed together to accomplish tasks that the original designer of the individual program have never thought about. For example, through the composition of kubectl, grep, awk and base64, the following command displays the content of the tls.crt certificate in a Kubernetes secret called nioctib-tech-it-tls:

The following two things are quintessential to the composibility and extensibility of the CLI programs:

Text streams as the univeral interface
Command line interpreter as a programming environment

There are definitely disadvantages to use text streams as the universal interface between programs due to its lack of structure. But the timelessness of many of the programs following this pattern and the prosperity that it brings to the CLI ecosystem proved its effectiveness as a design choice. Text can be read by both human and programs. It can be manipulated, printed, stored, trasferred, version controlled with the tools of your choice. For programs that do not inheritantly require structured data, using text streams as interface provides the most flexibility and composibility.

However, the flip side is that for programs that do require structured data, such as browsers, image viewers, music players, etc. Their text based versions usually become the toys of the hobbyists with neglectable impact.

Lynx: a text based browser with tiny user base

Another important contributor to the success of many of the CLI programs is the fact that they live in a programmable environment. In Bash, programs can be written from scratch or glued together using Bash script. This makes the CLI environment infinitely extensible. By enabling smaller programs that “do one thing and do it well” work together to accomplish more complex tasks, it becomes an environment that boosts synergy, productivity and creativity.

The word “line” in the CLI (Command-line interface) environment indicates its one dimentional nature. For programs that potentially need to interact with (two-dimentional) text files, Emacs offers an environment with similiar characteristics that makes CLI enviornment successful: A universal text interface and a programming environment which enables infinite extensibility.

Self described as “an extensible, customizable, free/libre text editor”, GNU Emacs’s infinite extensibility is enabled by a Turing-complete language called Elisp, which also is used to write most of Emacs itself. This is similiar to how for example Bash achieves its extensibility through Bash script. Just like most of the programs that thrives under the Bash environment are inheritantly text focused, most of the popular Emacs programs are text focused as well, such as Magit and Org-mode. They also tend to integrate very well with other Emacs programs, creating synergy similiar to that of the CLI programs. For example, you can look at the commit history of a Git repository using Magit, jump directly to the diff of a commit, and then jump straight to the source code in the diff. In the following example, the source code is written in Scala, you can then edit the code with Emacs’s exellent Scala support thanks to lsp-mode and lsp-metals, which are programs in the Emacs ecosystem that Magit is not aware of at all.

Magit: jumping from commit to diff to source code

If Emacs is an environment for programs that focus on two dimensional text, it is also more than capable of running programs that deal with one dimensional text. In fact, many CLI tools such as grep, find and many file system management utilities (Dired) are implemented in Elisp and thus integrated into the Emacs ecosystem as well. This is one of the reasons that if your main workflow is text focused, “Living in Emacs” is probably not a terrible idea due to the synergy many of these Emacs programs produce.

However, that doesn’t mean that everything should be run in Emacs. Emacs is probably not the best tool for browsing web (EWW) or listening to music (EMMS), just like CLI tools such as Lynx will never have significant impact because they are fundamentally not text focused. The argument that Emacs is “a great operating system, lacking only a decent editor” tries to paint Emacs as a monolithic swiss army knife ambitious enough to run any programs. In fact, Emacs is more like a two dimensional CLI environment that embraces the same Unix philosophy: enable simple, elegant programs interacting with each other using an univeral interface.

Edit: