Forem: Leonardo Teixeira Menezes

The Rise of Flash Startups

Leonardo Teixeira Menezes — Tue, 19 Mar 2024 15:59:19 +0000

In the past businesses took pride in how long they lasted, from your local bakery to big corporations they all boasted about it, the idea behind it was simple, if a business was run well enough it should stand the test of time.

We were living in simpler times in a slow-moving world, where technical innovations were rare to come by and demand was not changing as fast as it is today. Steady, slow-changing demand from consumers breeds companies that spend decades, if not centuries mastering their craft, optimizing and perfecting each stage of its processes and details in its products. Back then, the expectation was that after a life’s worth of work, you could pass your company on to your kids and family, creating a long-lasting traditional business. However, this time is coming close to an end.

We are now living in a world where businesses and consumers are moving at a never-before-seen speed, this is due to two main factors: digital economy and AI.

The digital economy is fast-moving by its nature, it’s built on top of ever-changing software and products. Trends come and go in a matter of weeks. A product that might attract millions in a month might be irrelevant in the very next month.

An example of this was a Clubhouse, these two articles are less than 4 months apart and that was back in 2021. Clubhouse for those unfamiliar with it was one of the biggest social media apps in the world for a couple of months, attracting millions of users, celebrities, and politicians to have public conversations. It was so dominant back then that other apps tried copying it as fast as possible, one of the most popular copycats was Twitter, which launched ‘Twitter Spaces’ that had very similar features. Now, all of this area is practically gone, there’s simply no more demand for public audio chats anymore apart from very niche use cases.

The second biggest factor is AI. With the current boom of AI products, there was never an easier time to build new products. From the marketing material to the source code, you can use AI to speed up the process. There are AI apps to build marketing videos from words, to create a logo in seconds, and to build and design prototypes. This makes it easier than ever to start a small company and there was never a better time to market these products on the internet.

Given all of this, can we really say that companies like Clubhouse failed? This notion of success comes from an outdated perspective of what a successful company is. We can’t expect tech companies going ahead to adhere to old metrics of success, such as ‘standing the test of time’. The future of the vast majority of tech products will be to exist for a short period of time, to supply a specific temporary demand, make a profit, and vanish when they are no longer needed.

I call this type of company a Flash Startup.

The term comes from Flashmobs for which the dictionary definition is: “a group of people who arrange, by email or mobile phone, to come together in a place at the same time, do something funny or silly, and then leave”. This is close to a perfect explanation for what the future of startups is becoming. The default expectation should not be to build a long-lasting company anymore. Flash Startups should be okay with sunsetting when they are no longer needed. The success comes from effectively handling a temporary demand and disbanding before wasting all its profits chasing a non-existent mirage of a long-lasting prospect.

A good example of how a Flash Startup should operate is PhotoAI.com. Back in 2022, there was a huge demand for AI-generated photos of oneself, a kind of a photoshoot for yourself but instead of going to a studio, you would get it generated by AI. PhotoAI.com was created by @levelsio and it was one of the biggest apps on this trend, it made him a small fortune in the process. Less than a year later, the demand for it had already fizzled out:

PhotoAI will probably not exist in the future and that is okay, it was still a successful business. After all, Flash Startups are not meant to last forever. They are meant to solve a specific temporary demand and make a profit while doing so, which they did.

To build the future we need to get rid of outdated expectations of what a company should be and how they should operate. Next time that you are working on a project or investing in a company reflect on what’s your own definition of success for it, you might very well find out that you are building the next Flash Startup.

If you liked reading this article consider following me on Dev.to, on Twitter, or subscribe to my personal website.

ActivityPub, Fediverse and the Future of social networks

Leonardo Teixeira Menezes — Thu, 20 Jul 2023 20:20:12 +0000

With the recent growth of Mastodon and Threads, you might have heard about ActivityPub, a relatively new networking protocol that has gathered momentum and is on its way to change how social networks work on the web. This article will give you an introduction to ActivityPub, how it’s used on the Fediverse, and some insights into how it might grow on the internet going ahead.

A Crash Course into ActivityPub

The ActivityPub protocol is a decentralized social networking protocol, it defines how applications can represent and communicate classic social network interactions such as ‘Posting a Photo’ or ‘Following a person’, creating a standard with which decentralized social network servers and clients can communicate. ActivityPub is a real-time pub/sub protocol, based on HTTP and JSON.

Let’s start by breaking down an ActivityPub request with one example request, this is a request from UserA to follow UserB on a social network:

HTTP POST Request

{
  "@context" : "https://www.w3.org/ns/activitystreams",
  "id":"https://my-example.com/my-first-follow",
  "type" : "Follow",
  "actor" : "https://mastodon.social/users/UserA",
  "object" : "https://mastodon.social/users/UserB"
}

At first glance, you might notice how intuitive it is, we are making a request of type ‘Follow’ performed by the actor ‘UserA’ to the object ‘UserB. There are three sets of types in ActivityPub:

Activities: They describe actions that can happen on the social network.
Actors: Describe entities that can perform activities.
Objects: Describes an object of any kind.

With these three sets, we can describe classic social network interactions, such as posting an image, following someone, or checking in on an event. The value that ActivityPub creates is by defining a standard to communicate these interactions across federated social networks, creating the possibility, for example, for a user on a social network to follow and interact with someone on a different network.

In order to enable federated social network interactions ActivityPub created the definition of an actor Inbox and Outbox, these are a collection of every action published by the actors that are ready to be requested by other social networks (Outbox) and a collection in which an actor receives actions performed by other actors (Inbox).

In practical terms, your “Inbox” will be an endpoint in which other actors can do POST requests to inform you of new activities, and your “Outbox” will be requested using GET requests by actors to update themselves on the latest activities you created.

Your Inbox and Outbox exist on your ‘Home Server’, we are going to explore the concept of a ‘Home server’ later but for now think of it as the server that is hosting your social network account, this server is going to be responsible for the underlying infrastructure of your social network, for receiving new activities posted on your Inbox and for making your Outbox available for other networks to fetch.

The Fediverse

‘Fediverse’ is a combination of the words “Federated” and “Universe”, it’s also a term that was invented to describe a group of federated social networks that interact with each other using protocols such as the ActivityPub. It started out with a single social network in 2008 and now has more than thousands of live instances with millions of active users. Since the release of ActivityPub in 2018 most of these servers already added support for it and it’s now the most prominent protocol for this server-to-server communication.

In order to join the Fediverse as a user you need to either create your own server to host your account or to choose an existing instance to be your ‘Home server’. Your home server will be responsible for all your account infrastructure on the Fediverse, it will host your Inbox and Outbox and will be the source of truth for your account information.

Adding support for ActivityPub and joining the Fediverse means that a social network can leverage the existing user base of the Fediverse to create content for its own users and to increase the reach of users on its network.

One of the biggest drivers behind the growth of the Fediverse is the open-source project Mastodon. Mastodon is an open-source social network server based on ActivityPub that you can use to host your own social network, it’s also the backend for some of the biggest Fediverse projects that are currently live, such as the Mastodon Social (1M+ users) and Truth Social (2M+ users).

Why would users care about the Fediverse?

There are two main benefits of being part of the Fediverse, Freedom and Content.

Being part of the Fediverse means that you have the freedom to choose a network tailored to your specific needs as your home server, users are free to pick instances based on their content moderation policy, technical reliability, and others, while still being able to interact with their friends that are using a different network or even hosting their own instance.

Using a Fediverse social network also means that you are going to have more content than a traditionally upcoming social network. The Fediverse already has millions of users and several social networks have already announced that they are going to add support for it, such as Tumblr and Threads, this means that even if you are part of a small federated instance you can still consume content being posted on other social networks.

As Bill Gates once said, “Content is king” on the Internet, and since the beginning of social networks users have flocked to where content is being published, but this might change with the Fediverse. With content being available to the whole Fediverse as opposed to a single social network instance this means that each user can make their decision about their home server without taking content into consideration.

Challenges Ahead

Both ActivityPub and the Fediverse have several challenges ahead if they are to continue with their current growth rate.

The first and most pressing one is scalability, ActivityPub is a very recent protocol, it was published in 2018 and so far it has been an uphill battle to scale it with constant outages and degraded user experience. This could be a common case of scaling issues for an early-stage social network with a high growth rate however there are some design decisions behind this protocol that might make it especially hard to scale. Jeff Darcy, an engineer at Meta, wrote a post about this topic, I recommend the read for more context about some of these issues as well as some insights on scaling social networks: https://gist.github.com/jdarcy/60107fe4e653819138396257df302eef

Another important issue is privacy and safety, being a distributed and decentralized network the Fediverse doesn’t have guarantees on how instances are going to handle users right to privacy. Let’s walk through an example, a user posts a picture on their feed, the post is then distributed to all the instances connected to the Fediverse however the user realizes they made a mistake and chooses to delete the picture, in this scenario, a request to delete the picture will be sent to all instances but there are no guarantees that they are going to actually fulfill this request. This issue is not only about instances acting in bad faith, there might be legitimate instances with different policies regarding content deletion requests. In short, there are no guarantees on how instances and users in different instances will interact with the content you post.

Lastly, it’s not clear what the incentives will be for existing social networks to join the Fediverse. Networks in the Fediverse distribute all the content being posted on them, meaning that users will be able to access content that was previously only accessible on their own app/website on a completely different surface, over which the network has no control over. This creates several monetization issues, for example, websites won’t be able to display ads when you consume content shared by them on a different social network.

Keep an eye out

Regardless if you want to create an account in a Fediverse instance or if you use a social network that will add support for it, I recommend keeping an eye out for this space. It’s not frequent that we have an experience of a distributed and federated group of social networks at this scale and, given the current growth trend, it might just be the beginning of a new standard for how social networks operate on the web.

Liked reading this post? Follow me on @ltmenezes on Twitter to keep yourself up-to-date with my latest articles.

Automated Dapps Scrapping with Metamask and C#

Leonardo Teixeira Menezes — Fri, 01 Oct 2021 09:28:13 +0000

Hey everyone!
This article is a follow up on my last article about Daaps Scrapping, if you have not read it yet I suggest heading to:

Automated Dapps Scrapping with Selenium and Metamask

Leonardo Teixeira Menezes ・ Jul 28 '21

#blockchain #python #webdev #testing

Thank you all for the great feedback you provided in the last article, it's great to see people building their automations and sharing their own challenges.

One of my followers requested an example of how Metamask automation would look like in C#, so a built an automation for the same 'Import Wallet' flow:



static void Main(string[] args)
{
        ChromeOptions options = new ChromeOptions();
        options.AddExtension(EXTENSION_PATH);
        IWebDriver driver = new ChromeDriver(CHROME_PATH, options);

        // Navigate to Metamask extension page
        driver.Navigate().GoToUrl($"chrome-extension://{EXTENSION_ID}/popup.html");
        Thread.Sleep(1000);

        // Enter Metamask import wallet flow
        driver.FindElement(By.XPath("//button[text()=\"Get Started\"]")).Click();
        driver.FindElement(By.XPath("//button[text()=\"Import wallet\"]")).Click();
        driver.FindElement(By.XPath("//button[text()=\"No Thanks\"]")).Click();
        Thread.Sleep(1000);

        // Send recovery phrase, password to import the wallet
        IList<IWebElement> inputFields = driver.FindElements(By.XPath("//input")).ToList();
        inputFields[0].SendKeys(SECRET_RECOVERY_PHRASE);
        inputFields[1].SendKeys(NEW_SECRET);
        inputFields[2].SendKeys(NEW_SECRET);
        driver.FindElement(By.CssSelector(".first-time-flow__terms")).Click();
        driver.FindElement(By.XPath("//button[text()=\"Import\"]")).Click();
        Thread.Sleep(2000);

        driver.FindElement(By.XPath("//button[text()=\"All Done\"]")).Click();
        Thread.Sleep(3000);

        // Close Metamask 'What's new' popup
        driver.FindElement(By.CssSelector(".popover-header__button")).Click();
        Console.ReadLine();
}

The concepts used here are the same as the previous article, we load Metamask extension to our ChromeDriver, navigate to its extension page and then automate the import flow as we would with any webpage.

It's good to note that the XPaths and CSS selectors used here might differ based on your Metamask extension version, so if you have issues in any of these steps jump over to your local ChromeDriver window and debug which selector broke the automation.

Let me know in the comments for which Dapp you are building your automation for and which challenges you're facing, I will make sure to address them in the next article!

Automated Dapps Scrapping with Selenium and Metamask

Leonardo Teixeira Menezes — Wed, 28 Jul 2021 20:41:15 +0000

One of the newest trends in web development is the rise of decentralized applications, also known as Dapps. These applications are built leveraging decentralized networks in order to provide trustless interactions between users, using predefined interactions built as smart contracts (if you want to know more about dapps head over here).

To access Dapps users need to use a crypto wallet to connect with, this creates a new challenge for developers who want to scrap and/or test Dapps using tools like Selenium. In this post we will cover the basics on how to solve this using Python and Chromium, however, the principles described here can be applied using any programming language and web browser automation tool.

Most current Dapps depend on a crypto wallet being present in the user browser as an extension, injecting in the web page information about the user wallet and the network it's connected with. One of the most popular browser crypto wallet is Metamask. In order to successfully scrape a Dapp we need to interact not only with the target website but also with the Metamask extension simultaneously, to approve the app connection with our wallet and other possible transactions.

Compressing the extension

In order to load the extension on our automated browser we will first need to compress the Metamask extension to a .crx file, here are the steps:

Install Metamask on your regular chrome
Navigate to chrome://extensions/
Click 'Pack extension' and enter the local path to the Metamask extension This will generate a .crx file that you can use to load as an extension on Chromium. Save the name of the folder where the extension is installed, this will be the 'Extension ID' that we will use later.

Loading the extension

To load Chromium with Metamask installed run:

from selenium import webdriver

EXTENSION_PATH = 'ENTER THE PATH TO YOUR CRX FILE'
opt = webdriver.ChromeOptions()
opt.add_extension(EXTENSION_PATH)

driver = webdriver.Chrome(chrome_options=opt)

Interacting with Metamask

In order to interact with the dapp and Metamask simultaneously, we will need to have multiple tabs in our Chromium, one for the target Dapp and another one for Metamask itself.

When Chromium starts it will have a welcome screen for the Metamask extension, which will prompt you to setup your wallet, this is an example code to import an existing wallet (You may need to update some steps depending on your Metamask version):

driver.find_element_by_xpath('//button[text()="Get Started"]').click()
driver.find_element_by_xpath('//button[text()="Import wallet"]').click()
driver.find_element_by_xpath('//button[text()="No Thanks"]').click()

# After this you will need to enter you wallet details

inputs = driver.find_elements_by_xpath('//input')
inputs[0].send_keys(SECRET_RECOVERY_PHRASE)
inputs[1].send_keys(NEW_PASSWORD)
inputs[2].send_keys(NEW_PASSWORD)
driver.find_element_by_css_selector('.first-time-flow__terms').click()
driver.find_element_by_xpath('//button[text()="Import"]').click()
driver.find_element_by_xpath('//button[text()="All Done"]').click()

After this Metamask will be successfully set up in Chromium, ready to connect to a Dapp.
When you need to interact with Metamask again you will need to use it in a different tab, like so:

EXTENSION_ID = 'ENTER HERE THE EXTENSION ID THAT YOU SAVED EARLIER'

driver.execute_script("window.open('');")
driver.switch_to.window(driver.window_handles[1])
driver.get('chrome-extension://{}/popup.html'.format(EXTENSION_ID))

With this Metamask will be opened in this new tab, ready to be interacted with.

That's it, now you're ready to start automating interactions with Dapps.
Follow me for more articles like this and if you have any questions feel free to leave them in the comments below.