This tweet by George Hotz hits home as I am someone who has been experiencing this VISA process for years now.

Let me give you an example. If you are an Indian Citizen who has studied in a pretty good engineering college in India and wanted to come study and/or work in the US, the process is quite intimidating and it doesn’t end. First, you get an F1 visa for studying, and then once you graduate you work on OPT (which has certain years you can work on) in parallel, you apply for your H1B, which is a lottery-based system, that is capped at 85000 per year (60000 for general and 20000 for higher education). Close to 500k people apply each year for H1B.

Now once you have an H1B, it’s not over because it’s only valid for around 3 years. Every 3 years you have to renew - submit a lot of documents and if you go out of the US, you have to get a stamp on your passport. This process is so painful since you have to fill out online forms every time.

And if you change your job, your visa needs to be transferred to the new company. H1B is tied to your employer.

Ok, so what about Permanent Residency? If you are an Indian in an EB2 category, you can forget about getting a green card. Legally on H1B, you can’t earn money from other jobs and if you get laid off, which has been happening quite frequently, you just have 2 months to find a job otherwise say goodbye to your American Dream.

In addition to all of this, you are always tense about your visa status, travel, etc.

Even though I just described how the process is for Indians, I think the general work VISA process applies to a lot of other countries.

Now why am I talking about the VISA process? Well, people want to come to America to pursue their dreams for multiple reasons: Good quality of life, access to capital, hustle culture, and a lot of great diverse-minded people to work with. So even though the VISA process is so stressful and painful, people still want to come here and build great things.

But recently the rules of the game have been changing. Why?

• General globalization and access to most things over the internet

• The COVID-19 pandemic has proved that people can work remotely and they don’t need to physically be present in the office to be successful

• The rise of countries like India and China has seen capital moving toward Asian countries

Because of the changes, people have started evaluating whether is the process worth the pain or if they can achieve whatever they want in their home country or any other country. The rules of the game are changing and the US Visa process to let people come in is still old and not keeping up with the pace of the changing world. Particularly somehow it’s becoming hard for people who are highly skilled to have more opportunities.

There are also some concerns about more seamless immigration

• What happens to the American people? Do they lose their jobs?

• People only immigrate to only few cities like San Francisco, New York, Seattle, etc., driving the prices up and pushing the less skilled people out of that area

I agree those are valid concerns but the solution is to not make high-skilled immigration hard. America is the land of immigrants. Maybe government should try to incentivize people to move to tier-2, and tier-3 cities and provide good infrastructure for someone to up their skills. With a lot of issues bubbling up with respect for China, maybe America can bring up more manufacturing industries.

Let’s be clear about one thing - the world works on survival of the fittest. If an adult person doesn’t up their skills game (considering the government provides enough access to good infrastructure) then they will not survive. If America doesn’t attract highly skilled people from all around the world to come work in America, sooner or later innovation will move out.

I think it’s worth making sure America remains what it has been, a place for great technological innovation. I believe America does need a lot of great leaders in higher government positions who, instead of stopping finding ways to curb the speed of innovation, can push innovation faster. The world will not stop and America needs enough manpower to roll with it.

If you enjoyed reading this you may be interested in following me on Twitter and Medium. 

Seema thought about it and the first question came to her mind which she immediately spit out “What does it mean to retire?”. As with most of life’s questions, this is another subjective question which when asked to 100 other people, everyone has a different answer. Answers like I should have $10 million dollars or some arbitrary amount of money are very common.

They both thought about it for a minute.

Robert started thinking about another strain of thoughts — does retirement also mean I will stop working? He asked Seema this question and now there are two questions to answer - When to retire (retirement criteria)? and does retirement also mean you are not working?

Seema: “I think for me retirement is something when I’ve enough money so that I can work on things which I really want to without worrying about if I’m making money off those things or not. I do want to work after I retire but only on things of my choice.”

Robert: “That does come with a question that how much money is enough. Is there an absolute enough? Would you stop if you have an absolute enough? With more money habits also change.”

Seema: “You have to promise yourself that you will live the same life even if you get enough but I get your point. Things can change when I’ve more money — I could want to go on more vacations, but more stuff. Oh well my enough money will not be enough”

Both giggled at that sentence and continued sipping on their coffee.

Seema: Hmm I also think that retirement could be an overloaded term. Are you considered retired if you quit your 9 to 5 and work on your own stuff?

Robert: Maybe not

Seema: Then maybe it’s a wrong question to be thought about. Maybe the right question is, what would it take for you to quit your 9 to 5 without having to worry about money?

Robert took a deep breath and thought about this question. Seema observed his face with a slight smile.

Seema: I can see it on your face that you are as confused as I am but we don’t have to think it right now.

It was almost lunchtime now and they both thought it would be good to head out and get something to eat.

What does retirement mean to you? Give it a thought.

What does SoulBound mean?

According to Vitalik’s writings here:

A soulbound item, once picked up, cannot be transferred or sold to another player.

In this article, he also mentions bringing this property to NFTs where once you acquire (mint or airdropped) this token, you can’t transfer it. This means you won’t be able to sell it in any marketplace.

One of the clear use cases of this property is in POAP. As Vitalik writes:

Perhaps the best example of a project trying to do this is POAP, the “proof of attendance protocol”. POAP is a standard by which projects can send NFTs that represent the idea that the recipient personally participated in some event.

This is a pretty interesting concept to me so I wanted to implement it myself for one of my projects (more on that in future posts). Therefore I am also sharing a quick tutorial to write a very simple ERC-1155 contract with this property.

Prerequisites

• Basic knowledge of smart contracts

• Basic knowledge about Solidity and ERC-1155

• Foundry installed — You can also use hardhat if you are more familiar with it, but this tutorial assumes you are using Foundry

Steps

1. Create a new project using

forge init soulbound

This will create a new project with a sample smart contract Counter and your project structure should look like this

2. You can either create a new contract under the src directory or work with the existing Counter.sol

3. We will be using the OpenZepplin contracts library for implementing our token so we need to install that. Foundry uses git submodules for importing libraries. The below command will help you with this installation

forge install OpenZeppelin/openzeppelin-contracts

4. Once installed you are ready to write your smart contract. The next step is to import your dependencies into your contract. You can use the below command to import the ERC1155 library you just installed

import "openzeppelin-contracts/contracts/token/ERC1155/ERC1155.sol";

5. Since we are focused on soulbound tokens in this tutorial, we will just see how to make your contract behave like one. The rest of the code remains the same as what a normal ERC-1155 contract would look like. ERC-1155 has a method called _beforeTokenTransfer which is a Hook that will be called before any transfer of token is done. We will override this method so that it behaves like a soulbound token

function _beforeTokenTransfer(
   address operator,
   address from,
   address to,
   uint256[] memory ids,
   uint256[] memory amounts,
   bytes memory data
) pure override internal {
  require(from == address(0) || to == address(0), "This a Soulbound     token. It cannot be transferred. It can only be burned by the token   owner.");
}

Let me explain the most important piece of code from == address(0) || to == address(0). The first condition says that if the token is minted (minted token originates from 0 address) and the second condition says if the token is burned (tokens get burned to 0 address). So only if the token is minted or burned, this method will execute the transfer otherwise it will fail in this require condition. One line of code and you can make it a soulbound token. Pretty impressive.

6. You can now deploy your contract using forge create command and after you mint a token if you try to transfer that it won’t allow you to transfer. The only thing you can do with this token is to burn it.

If you want to look at the full example you can take a look here. I hope this was useful. Please subscribe to my newsletter if you want my writings directly in your inbox.

If you enjoyed reading this you may be interested in following me on Twitter and Substack.

I recently learned about Go Embedding structs and interfaces and I was quite impressed by how powerful it can be. So in the process of learning and exploring, I thought it might be good to share what I have learned with a small and hopefully easy example.

I have divided this example into 3 simple projects which will explain the use case and how embedding can be a really powerful programming paradigm.

The first project is where we define an interface with two methods:

package types

import "context"

type Client interface {
	MethodA(ctx context.Context, message string)

	MethodB(ctx context.Context, message string)
}

And then we also define a service which is used to initialize a client that will implement these methods

package types

import (
	"context"
)

type Service struct {
	client Client
}

func NewService(client Client) *Service {
	return &Service{client: client}
}

func(s *Service) MethodA(ctx context.Context, message string) {
	s.client.MethodA(ctx, message)
}

func(s *Service) MethodB(ctx context.Context, message string) {
	s.client.MethodB(ctx, message)
}

This means that when we initialize using NewService using a client then it will use the client implemented methods.

Now the third project (pardon my ordering, second will come in a bit) is a library which has an implementation of first.Client

package third

import (
	"context"
	"fmt"
	"github.com/shrimalmadhur/playground/interfaces/first/types"
)

type Client struct {
	 client types.Client
}

func (c Client) MethodA(ctx context.Context, message string) {
	fmt.Println(fmt.Sprintf("client impl message MethodA: %s", message))
}

func (c Client) MethodB(ctx context.Context, message string) {
	fmt.Println(fmt.Sprintf("client impl message MethodB: %s", message))
}

func NewClient() Client {
	return Client{}
}

Here is the final second project which brings it all together and where we will see actual power of embedding.

It has a file called client.go which contains

import (
	"context"
	"fmt"
	cl "github.com/shrimalmadhur/playground/interfaces/third"
)

type Client struct {
	cl.Client
}

func (s Client) MethodA(ctx context.Context, message string) {
	fmt.Println(fmt.Sprintf("Override MethodA message: %s", message))
}

func NewClient() Client {
	sdkClient := cl.NewClient()
	return Client {
		sdkClient,
	}
}

Now what you see here is

type Client struct {
	cl.Client
}

This above syntax is called embedding where you import and override the methods of the actual client if you want.

In the NewClient function we initialize the the sdkClient with third.NewClient which will import the two method using Go embedding. But here we have an option to override any of the MethodA or MethodB, so we override MethodA to see what happens.

To run all of this here is our main.go file

package main

import (
	"context"
	"github.com/shrimalmadhur/playground/interfaces/first/types"
	"github.com/shrimalmadhur/playground/interfaces/second/client"
)


func main()  {
	ctx := context.Background()

	myClient := client.NewClient()

	service := types.NewService(myClient)

	service.MethodA(ctx, "hello")

	service.MethodB(ctx, "hello")
}

So now here is what it prints

Override MethodA message: hello
client impl message MethodB: hello

We can see in the above print messages that the first line has been printed using the overridden MethodA in the main package and the second line is printed using the client library in the second package. This way you can import a client package and then override the interface methods as needed.

I hope this makes it easy to understand Go embedding. Any feedback is welcome.

You can see the full code here.