Problems that exist that desktop could solve (non-exhaustive)
- mobiles are resource limited
- many communicate via their desktop/laptop
- there aren’t enough nodes in the various networks being used
- node management is hard
As we’ve built out the Status mobile app, we’ve increasingly realized how resource restricted these devices are. Our reach continuously exceeds our grasp, and we have no base to maintain decentralization as we continue to host more infrastructure in response to user growth. This is exactly what we do not want, and it is not sustainable.
We have tried to tell people they can run their own node, not depend on us (which has always been true!), but the user has no real reason to get over the barrier of entry other than if they are super paranoid or really altruistic. Running a Status/Ethereum/IPFS/etc node(and other infrastructure) serves no purpose to the user, and is based in altruism or severe personal preference/requirements.
The Status Desktop client serves as a reason a user runs all of these things. If it optional to run all of these services in the background, and mange them via the application, then a user can easily transition from a leech in the network, to the backbone, depending on their available resources.
Furthermore, for hairy feature situations (push notification, mailserver privacy, persistance of any kind, social backup, etc), the desktop may provide a layer of acceptable compromise as a user will either run a desktop node themselves, or know someone who is running one that they trust.
If we look at the typical hardware of a desktop user, it is:
- on the majority of the time
- varies with latpop
- connected to a constant power source
- varies with laptop
- typically connected to a stable, high bandwidth network
- varies with laptop
- typically low on resource consumption during normal use
- running a OS that is amenable to OS software installation
- isolated and trusted physically
- varies greatly with server/desktop/laptop
A case for modularity
To move things even more forward, designing desktop appropriately allows us to run various services indenpendantly, and desktop be the management interface. For instance, one could delegate their Status node and mailserver to a rasberry pi like device, their Ethereum/IPFS node to a NanoPC T4, and their desktop client to a laptop.
The desktop client becomes a management/monitoring interface to their Web3 world, all the while allowing them to connect to their respective social groups, access the world of Web3, and supporting the underlying infrastructure that runs all of these networks while simultaneously providing value to the user. It gives options to the user to conduct themselves the way they want to. For those that done care, download a client, get started, flip a switch to run it in the background, stop caring.
Modularity also allows us to create client interfaces that serve various purposes a user may have:
- slack/discord like communication platform
- decentralized application browser
- asset management
- telegram-like public chat
- twitter-like social broadcasting service
- an ETH2 staking node interface
Support the mobile app while it needs it
That is just an interface that links to backends properly, but the infrastructure HAS TO BE RUN by the community, and mobile phones can’t do it (at least yet, or in the forseeable future). As we grow, the supporting infrastructure MUST grow with us, and the balance of who runs it MUST rely on the community to do, even if they don’t realize their doing it. Our comms are always obfuscated and encrypted, so a user supporting the network does not give them extra information to hoard, in fact, it does exactly the opposite as we spread the load across a larger distribution of people.
If the underlying network infrastructure is large, we can then lean on them as the technolgoy grows, and it’s developme serves as the basis of functinalty as mobile functionality grows to be able to meet its demands. In other words, a robust desktop client ecosystem becomes the feature set mobile works to acheive, and if built correctly, ends up being a flip of a switch when the hardware / resource constraints dissappear. Think about what you do with your phone now, 99% of that function was delegated to specialized hardware at one point, until the technology caught up.