Self-Describing Software
The blockchain industry as a whole is still young, yet even in these early years, the back end systems are developing rapidly while the front end interfaces and practical applications still haven’t begun to take root. While blockchain as a concept seems ideal for use in highly sensitive application domains with real-world import and consequences, the blockchain apps we see today are largely either fluff pieces: proofs of concept, toys, demos, and games; or else they are so complicated and esoteric that only relative experts can use them, and even they are often surprised by the results.
To be fair, even outside of the blockchain industry, the development of intuitive apps that the general audience understand quickly and easily is incredibly expensive and difficult. To put it simply, it’s easy to make apps that are hard to use, and hard to make apps that are easy to use. This is true in all application domains and technologies, but blockchains exacerbate this issue by changing the ways in which people interact with the software, defining rigid protocols and formal transactional operations. While these features are part of what makes blockchain so ideal for sensitive application domains, they also make it more confusing for the layperson, thus compounding the problem of application understandability in precisely those domains where clarity and intuitiveness matter most!
In such sensitive applications, where actions taken may be irreversible and often have implications that meaningfully influence people’s lives, it becomes imperative that people using those applications must be able to accurately predict the outcomes of their interactions with the software. If the usage of such an application yields a result that could not have reasonably been anticipated, it must be seen as a failure of the technology. While software intended for such sensitive applications must specifically be held to such a standard, it would be ideal if all software applications were designed according to this principle.
A New Approach to Software Applications
To make it easy to make apps that are easy to understand, Follow My Vote envisions a fundamentally new approach to app development. This new approach encompasses virtually all aspects of how apps are created; it is not simply a particular perspective or methodology, nor a new development framework or technology stack. Indeed, it is a multifaceted approach that encompasses all of these things and more. The approach can be described in four interrelated facets which describe, in order, the proposed approach to app development.
- Application Design Methodology
- Self-Describing Software
- Application Development Framework
- Automated Composition
Application Design Methodology
The first facet is an application design methodology, wherein the application developer considers the intended audience of the app. The developer takes on the mindset of a person for whom the app is intended, and considers from their perspective the things they need from the software, what they expect the software to do, and in what order. The developer designs the app based on what the intended audience will expect from it, to present them with options that will make sense to them, and to introduce features at the times and places where they become relevant during the usage of the app.
Self-Describing Software
The second facet is to design the app to describe itself by drawing the person using it into a conversation, to help them understand the app the way the developer envisioned in the first facet. This includes a sort of introductory experience the first time someone uses the app, and also includes human readable descriptions of all of the controls, buttons, and indicators within the app. The descriptions will be a few lines of text that make fully clear what the described component does or means; for example, what an icon means or what happens when a button is pressed.
Application Development Framework
The third facet is an application development framework which supports the creation of applications designed according to the first two facets. This framework will allow the developer to create the app as a set of composable modules, with the descriptions colocated in the code with the modules they describe. The framework will additionally define structures for concerns like the first launch introductory experience, hints on how to compose the modules, and solutions for many of the problems commonly encountered during the development of self-describing software applications.
Automated Composition
The forth facet is a deployment model wherein the app is created automatically by composing the modules according to structures defined in the code, depending on the target environment, incorporating factors like screen size and device characteristics. This approach gives the app descriptions of its own structure, meaning the app can ensure that all content is appropriately sized and visible on screen, is searchable, and can be queried for the descriptions. The app can also support querying technical information such as ongoing or recently completed processing, diagnostic logging, application settings, errors encountered during operation, and similar information.
Where it Goes from There
In its earliest iterations, this approach may seem underwhelming. The apps will have some fancy in-app documentation and be intuitive to use, but otherwise, they will probably seem like typical apps. The power of this approach, however, is that, by making the app structure information inspectable and processable, it lays the groundwork for many exciting possibilities in the future.
For example, apps using these technologies could someday support myriad possible multi-device scenarios where an app can be arbitrarily split over several devices to show one display on a computer and another on a phone, and keep them in sync during edits as though they were one device. Such scenarios could be supported ad-hoc, on demand, without the developer having to plan for them or consider them in advance, and all without relying on a remote service to organize the devices, or even requiring an internet connection.
Another possibility is that, as the app’s internal structure is recorded and processable, one could explore how the app works while they use it, similarly to how they inspect an item to see its description. For instance, they could inspect a button and see a visualization of the internal modules of the app which may be involved in processing a press of that button, and explore the internal structure of the application deeper from there, gaining an understanding of how it is programmed, and possibly making small modifications to it, without ever looking at code. And, of course, at any point during this exploration, they could opt to see the source code that makes it all work.
People could make their own updates, personalizations, or new features in the apps they use, then share those online in a sort of social media of apps, all without necessarily working on code. Updates could be distributed this way, and people could customize those updates to their tastes, for example taking a security fix but rejecting a change to the look and feel of the app because they preferred the old style. Such customizations could be curated, commented, rated, and reviewed, creating an ecosystem of community-contributed or tailored software alterations that can be added or removed with the click of a button.
Finally, the advanced insight into the structure of the applications would enable powerful security models. Because the structure of the code and the ways data move through it are processable, software alterations that access unexpected data or modules could be flagged for review automatically. New applications could be given access privileges appropriate to their declared purpose, and any access to unusual data or functionality in the system could be controlled or audited, and of course, the described purposes of those modules could be used to determine whether the access is legitimate. This level of insight into the structure and behavior of software would lead to much more powerful automated computer security than we can achieve today.
While it starts small and simple, the proposed approach to software development has enormous potential for growth and could someday form the basis of a completely new computing paradigm, making software easier to understand, modify, and share, all while supporting a higher standard of security than is presently possible. Follow My Vote is excited to explore these possibilities and share them with the world.