Some ideas for computers I thought of that I enjoyed thinking about and writing down. Please see the other pages of the series.
- Follow me on Twitter
- If you like my ideas, please start a chat or discussion with me. I'd love to hear your thoughts!
- Please use issues to start discussions on ideas.
- The first page of this series 100 Ideas for Computing
- The second page of this series Another 85+ Ideas for Computing
- The forth page of this series An Additional 100 Ideas for Computing
- Looking for business ideas? Checkout my startups repository where I list business ideas.
Themes:
- global deduplication of effort
- software breakage no-more
Reading code that uses awful names is painful. We could improve the code we write by collecting peer contributed and voted names.
A web based framework codebase that everyone shares the same codebase for. Allows optimisations by people to benefit everyone simultaneously.
Applications advertise that they can be searched. When you activate the system wide search, a subquery is made for each application. So on Android, a search for an application that is not installed will create a query onto the Play store amongst a web search with the browser.
A language with search built-in: any use of an undefined symbol causes a lookup request to a server that monitors library packages for exports. When a symbol is found, it is downloaded for the system for use as library code.
See importless lang for a proof of concept with Python
A desktop distribution of Linux that has a deep lever into a custom web forum. Translations and GUIs are rendered in the web forum and people vote on things such as layouts. People decide how the desktop should work by talking of it in threads because threads decide how the desktop works. People can go against the grain and vote for their desktop to work in a way that is not the consensus.
Run a small program from a startup company to extract all running servers (from DNS) and SSH hostnames, bastion host, send this to startup, the startup works out how to configure complicated software like Envoy for you, with your configuration based off of your environment. Once this configuration is generated, a dynamic program is ran regularly to update this configuration (as service discovery).
Rendering engines throw a lot of content away. I wonder if some content can be recognised as being static, as unchanging and re-used between frames. Or If there's a list of thousand items, is it possible to recognise that the content of each list item is static and the only thing that changes is the ordering. So all that's needed is rendering cached bitmaps in a unique ordering.
Write HTML with a flat data structure to avoid nested editing and to stream data more efficiently.
See my repository https://github.com/samsquire/flat-html
Without downloading additional packages, a Linux distribution that can also run as a continuous integration server and build server. This means that the desktop can build .ISOs to distribute itself. The desktop can also build any package that is available in package repositories.
When making API calls, track the amount of time it takes to receive 0.3 seconds worth of items and return that many items.
A way of adding a budget to each request that is track resource budget usage with request. For example, if you have a budget of each request must take 100 milliseconds, this budget will tell you when you go over the budget and why you went over the budget.
An identifier that is appended to every request log entry and message headers to show the current budgeted amount used and deadline, like a TTL.
The unit of sharing in programming is quite large. It's rare that just a single class or set of classes is shared. I propose we make classes shareable. I would like rich class hierarchies to be shared to share models of how things work. I propose a Forum class and a Network class which are classes of how forums work and how Networks work.
In the Java ecosystem, ontologic class sharing would consist of a set of builders.
How can software be written so that other people can optimize it? This idea is so that I can write my software once and get performance optimisations from random people on the internet days after writing it. How do you write optimizable software? Some ways of writing self-optimizable software I can think of are:
- Reify (make concrete) technical decisions explicitly as modules in the system and provide a way to map between technical decisions
- Invert the control of the software so that the software is called by framework rather than as a library.
- Create interfaces that support usage in different ways
- Intent written code
The following are optimisations that can be reified.
- Change synchronous to asynchronous
- Change asynchronous to synchronous
- Partition the problem
- Run a function in parallel
- Run in a thread
- Map reduce
- Distribute between threads
- Distribute across machines
- Stream
- Buffer
- Execute as a vector (SIMD)
- Index
- Queue
- Send asap and flush
- Flow control
Software that is modular and written at a high level of abstraction can be optimized. I imagine a software viewer which lets users see the decisions made by a piece of software, such as architecture and queries made.
Use IRC to lock resources in a microservice architecture.
initiator: g393 LOCK users orders deliveries
initiator: g393 update users set last_use = date.now()
userservice: g393 ok
initiator: g393 insert into orders (user_id, product, qty) values (20, "Schlongs", 10) returning id
orderservice: g393 ok
initiator: insert into deliveries (user_id, order_number, address) values (20, 10, "120 pemwinkle drive, birmingham, uk")
deliveriesservice: g393 ok
initiator g393 COMMIT
userservice: g393 done
orderservice: g393 done
deliveriesservice: g393 done
Imagine if a codebase was like a magazine that you could flick through. Or print out in a glossy book. Each folder has a README and explains its purpose.
Database plans and histograms are uploaded to a Twitter of optimization for handmade plan optimisations.
A database system that stores queries like stored procedures but uses the plan of the query to optimize data storage format. The queries are analaysed to determine the optimal data structure to make the query fast at reading and writing. There would be tunables for optimising for read or write loads.
- The database might decide to store data in column orientated style if a query uses the whole table.
- The database can be automatically sharded for queries like
select * from table where category == "BLAH"in this scenario, the rows matching "BLAH" can be stored in a different file. I call this particular optimisation table promotion. - For a join such as
select people.firstname, orders.name from people join orders on people.id = orders.person_id where people.firstname = 'fuz46'we can store orders by people. If we were using LevelDB, we could store a key "person-1F40-order-0002" - The database would take consideration of the data structure of queries, if the data to be retrieved has various nested associations, it could choose to use a document orientated storage mode rather than one that uses joins over row based data.
When we write a request handler in a web framework, with most frameworks we are typically writing functions that are leaf nodes of the stack. They just call into the framework. This idea is to write a framework where your code is not so lonely and your code's output is used by other parts of the stack.
- Your code is hosted: it is ran with performance testing, timeline budgeting
- Your code implements an interface and has multiple entry points.
- Your code is part of a wider circuit
In most frameworks, it is dubious what the framework does for you.
Fetch data on mouseover, in the background for perceived performance.
Imagine a remote computer that has high bandwidth but high latency. The system would be frustrating to use with typical software. Assuming we can edit files locally without high latency. An approach to make this bearable is the following:
- Nested Branched Sessions You cannot work serially with high latency because you depend on the output of the previous step. So instead you work on things in parallel but independently.
- Isolated changes: Make changes to parts of files independent and queue them together. If they both work with tests independently, merge them together.
- Success detectors Write a detector of success, it detects if some thing works. For example, if you're trying to get a Docker image built, you would have a detector for docker image being built that passes some test. You might want to use the output name somewhere, in a future session. You can use a placeholder to do so.
- Fuzzy success matchings If you wrote an output match for success, it is fuzzily matched.
- Notifications interface The key to productivity with a high latency system is that you're always working while the remote machine is working. So we have a notifications interface that lets you create a session from a notification of completedness.
Systems should have a ceremony for calling an external system. I propose a general purpose library external call API:
- written to a log first
- be queuable
- be traceable
- be retryable
- be idempotent
Software is tied to an error server with an error subsystem. The error server is:
- responsible for monitoring a codebase for exceptions that could be thrown.
- should have a GUI which acts like a searchable database of errors that can be thrown
- It tracks call sites where errors are possible
- Has a studio component for running simulations of various exceptions that if thrown, run what-if scenarios against the system as a whole
- Allows you to define error handling later, when the error is better understood.
In a given piece of software, at startup the error subsystem is loaded with an error specification and the error specifications defines that actions to take if a given request errors.
- Allows the centralised definition of error handlers and what should happen when errors happen while recovering from errors.
- Allows centralised specification of error contingency.
- Outsource exception handling to the error server.
- Define what should happen while some thing fails while doing some other thing.
- Errors are provided with full context of the initiating request.
It should be possible to write a system that is cache-aware. There is process for loading data into each of the caches in the architecture. Even if its a warm up loop that loads data through the system. There are multiple levels of caches in modern computer systems:
- CPU caches: L1, L2, L3
- File system caches
- Disk firmware caches
- Network buffer caches
A personal knowledgebase of things learned.
There's few digital equivalent of the place prepositions of putting some thing on top of another in computing - except maybe Docker files or layered architectures. When we talk of tech stacks, we build on top of other things by using and depending on. There could be an interface of a surface and things placed on top of the surface act in a certain way. A surface offers a promise for things placed upon it. Like a game engine, objects in the engine obey the laws of the engine.
Some surfaces I'd like to rest my code upon:
- Function scaling A large grid where any function placed in the grid is deployed and scaled.
A surface is a precanned environment where every thing has already been set up for you to use and has a surface to place things on top of.
A user surfaceable measurement that is displayed when there is a progress bar and when an application is busy. It shows the throughput per unit time that some thing is taking. Perhaps copying files or a network connection or network transfer. It can show in the titlebar. There should always be a visible throughput number for reference and comparison.
Define what should be on a web page by making various 'has a' declarations which specify what components should be rendered on the page.
contactsPage is page
standardLayout hasA logo
contactsPage hasThingsFrom standardLayout
contactsPage hasA contactUsForm
contactUsForm hasA field:email
contactUsForm hasA textarea:body
Components have data dependencies which causes data queries to automatically populate data for them.
Backup is fundamental to running computer services, it should be available as a service. Postgres backup as a service. A dashboard should be provided to show available backups and to restore them.
When a request is received, serialize the request and write it to the machine readable log in the background. Do not acknowledge success until it is written to the per-server log. Aggregate the per-server write ahead logs every few minutes. Every request therefore has a write ahead log.
With configurable imports, we can have telemetry about what algorithms people are requesting. We can have a Leetcode style website where people's solutions compete and implement requested algorithms for different constraints. We know what's in demand.
For data that is not private, we can automatically upload data that is running through various algorithms and this can be uploaded to the algorithm server. People can solve challenges for different variations of the same problem to make things faster.
The goal of this idea is that there is a public interchange where you can see live algorithms running against live data, like a fusebox. People can submit code and optimizations to the public interchange to benefit everybody at once.
Photo by Markus Spiske on Unsplash
When an API is used, the usage of the API is reported to the API developers so they know if they will break any consumer.
This could be accomplished by using a code coverage tool to trace calls to APIs.
The naive way of doing some thing should be the correct way to do it. Optimisations behind the scenes can do things efficiently.
For example, there is a natural paging size for each object in your system. For a GUI component it might be how many items can be displayed efficiently.
- JSON Paging Imagine you have an application with buttons and the buttons load data that could possibly be millions of records, I should be able to write my code as if it is very naive and all the data fits in memory, even if it doesn't. Before the GUI code is scheduled to run, the plumbing should automatically make paged requests to the server.
Distill a tech stack into those people responsible and who worked on it to buy them all beer or support them via patronage.
Depending on a library or piece of software is to depend on a chain of people and organisations (that map to people). These people should be rewarded. Think of this idea as an index
A community where every reply is a piece of code. You must express your reply as code.
A digital organism, such that each phone is a node in a network of people that work together to fulfil some common goal. The organism software has a menu system that looks like the following:
- Move To physical move assets around, To take up some kind of position in the world
- Respire Controlled burning of resources, such as constructing new things or commanding work to be done
- Sensing seeing, information gathering
- Growth Advertising
- Reproduction Information needed to create additional nodes
- Excretion Cleaning up
- Nutrition Acquring resources and new people.
Each person in an organisation might want to control digitally how information is retrieved and goes through to them. I propose people define an API for themselves in how to get them to do what you want them to do. I offer a number of services, and this is the information I require.
Generate GUI data population with a data flow description of the GUI. For example, in an email client, emails flow into folders, when folders are clicked change the email list which when clicked flows into the mail preview.
Alternatively, each click changes the query of the widgets on the screen. Clicking an email folder changes the results that are in the mail list.
Desktops should have a built in queuing system for queuing up moves, copies, renames, installs.
See https://github.com/samsquire/cloud-desktop#desktop-queuing for an example
Each installation of a desktop environment is a set of resources that could be shared.
Text can be folded and made it so that more is available at a different zoom level.
<document>
<text level="1">I am visible at zoom level 1. <text level="2">I'm visible at zoom level 2</text></text>
</document>
The law system should be programmatic. It should be possible to fill in a form and get a legal result from it.
If we know it takes 100ms to render a page in our app, we could simulate an average journey for a user and cache the responses for performance.
When you write client or server side code, it would be nice if the other side wrote itself automatically. This idea is for a digital ghostwriter to generate code for an equivalent clientside.
- If you wrote readInt, in the client code a sendInt would be written. If you wrote sendInt, the other side would write readInt.
- If you write window.fetch("/data/blah") then a request handler for blah would be generated.
Browsers could cache your user data according to some browser defined API, first name, last name, email address, generated password. Without prefilling a form, you could sign up and have an account immediately.
There's somewhere someone that thinks exactly like you on all matters. Let's uses quizes and questionnaires to make them easy to find.
I propose a statement is shown and you say whether you agree or disagree with it. And you can specify clauses that you apply to the statement.
I see a synergy with 1. Digital contracts, the Person Coordination API and the World splitting app whereby people come to agreements through digital means.
The website would provide a community area for users that match up.
Identikit is my project that attempts to represent people's stances in a compact format.
A think tank sole purpose is to churn out business strategies which are a combination of job descriptions, operational manuals and business plans.
Companies are obliged to raise profits for their shareholders. Stakeholder capitalism means companies must also consider the demands of local communities, suppliers and employees. There are many demands on companies nowadays.
One cannot serve two masters: the shareholders and everybody else.
I propose a financial instrument to solve the problem, I call a non-core business wrapped instrument which is software and labour combined together. There's a digital marketplace that has a catalogue of products which are things like environmental friendliness or customer service.
A company can buy one of these assets and outsource customer service or environmental friendliness on the market of digital labour.
Continue processing requests before fsync is received but create everything in a pending state. Send an additional signal when fsync is received to activate pending requests.
A secret technology union for programmers and people in the computer industry. Run neural networks on salary data of members to calculate best combination to get a higher salary. Members share all communication of their employer with the union for group negotiation expertise recommendations.
An interactive tool that renders time charts of how long some thing takes. Imagine 60 frames a second visual output being a goal, you can drag pieces of work onto the chart to schedule it to run. Should cause it to be easy to schedule things in parallel or asynchronously and concurrently.
A mood tracking application that is aggregated across many different dimensions: every interaction with a company or government should produce an identifier. This identifier should be used to track a reaction to the interaction in terms of happiness. Scores can be aggregated by country, by council, by shop, by county, by month, by business.
There are tools to implement distributed tracing. How about a tool that takes spans as placements and uses the span placement to schedule code in parallel and asynchonously?
Break up your API call request handlers into a series of spans. Each span has an input data source and output. The DLS runs a server on every host (database, application, web) whereby any host can carry out any span. The DLS will try minimize data transfers and keep execution nearby data. So queries that deal with lots of data and reduce it to small amounts of data run on the database server and queries that return lots of data to clients run on the application tier.
There's a set of people responsible for some things. Finding these people is a challenge. I propose an index of responsibilities and a tracker of who is responsible for what. This way protest can be effective by targeting the right people. Currently it goes through representatives or through protests on the street, an ineffective way of getting things changed.
A database of problems.
Existing:
A stream based data encoding that lays out the data in the order that it appears on a screen. So the first block of data is the data needed to render onto the screen immediately. After the first screenful of data, include data for the next screen, once this screen has been tapped. The data following is additional screenfuls, such as the result of scrolling to the next page.
Could create two TCP connections to the backend server. One for the current screen and one for the screens to come.
An office suite program for editing graphs visually but are backed by a graph database.
Most application servers have the capacity to have objects that outlive requests. I propose this opportunity to load an object graph that represents application state in each application server. This model could be used for read only queries for added performance.
My phone should know where I'm going to be sleeping and where I'm going to be eating in advance. I liken it to another status indicator along the notification area of the phone. I should be able to swipe down the notification area and click food and click what I want to eat and have it automatically sourced.
- hotels/airbnbs/home
- travel purchase (flights, trains, buses)
- self storage
- food
Don't repeat yourself often means a single point of truth exists. But it's poorly implemented in practice. I'm going to come out and say a single point of truth is not always what you want. I want there to be multiple points of truth about a thing. But for them to be combined. You can say things about the same thing but from different perspectives and they might not always live in the same place.
- Security is a good example.
Truth should be defined closest to where the responsibility lies, so it could be defined in any of the following:
- BDD syntax
- Issue tracker
- In sourcecode
- In a JSON file on a server
A command line application that feels like Docker but actually generates Kubernetes manifests.
To get started in a job, you often need access to lots of separate systems. It would be nice if even the tracking of what dependencies you require were centrally tracked. You could even automate the provision of access.
We shouldn't have to write backup code manually each time anew for each system if the components in the system are the same at each company. I propose a backup server which speaks a protocol that other systems can implement for timely backups.
Companies could generate websites in advance as static websites that are downloadable as a single file.
Relative searches are the cause of not found errors. Computers could look everywhere for imported libraries to avoid unnecessary errors.
Imagine a JSON file that you could refer to a field at any level and have meaningful data returned. Without having to specify the path to get to that item.
Existing:
- jq: querying JSON data
Earn money solving implementing unit tests.
Imagine documentation that retained your goal that you're trying to solve. So every thing stems from a search parameter, you vote yes when the guided browsing took you to where you wanted to be.
We're often browsing to solve a problem. I want to browse with a context in mind. Perhaps I'm looking for API examples on how to call an API and want to "pick" a solution online. Or I'm browsing to follow a tutorial. I want some finality in the browsing concept, by picking or selecting the page with the answer I want to use on.
Picking the final page of the browsing session should import whatever machine readable context into the application that initiated the browsing session, such as an IDE call site search or a text editor.
Existing:
Amna - Write a task. Click on it. Get a browser just for that single context.
A single page application for defining cloud resources in YAML.
Sometimes I write naive code first, a simple for loop and a search. I think it should be possible to automatically detect naively written searches and generate more efficient joins such as hash joins or hash table lookups.
This code calculates build success in a hierarchy that is three levels deep: an environment contains components and components contain commands. Failures ripple out from commands; a component with a failing command is failed and an environment with a failing component (or command) is failed.
I'm effectively doing a manual join on a number of records in memory and I'm doing it more than once (5 times).
for environment in state["environments"]:
environment["status"] = "ready"
for component in state["components"]:
component["status"] = "ready"
component["progress"] = 100
component["build_success"] = "success"
for item in state["running"]:
provider, running_component, command, manual, local = parse_reference(item["reference"])
if "log_file" in item:
item["current_size"] = os.stat(item["log_file"]).st_size
if item["last_size"] != 0:
item["progress"] = (item["current_size"] / item["last_size"]) * 100
for environment in state["environments"]:
if item["environment"] == environment["name"]:
environment["status"] = "running"
for component in state["components"]:
component_provider, component_name = component["name"].split("/")
if item["environment"] == component["environment"] and component_provider == provider and running_component == component_name:
component["status"] = "running"
component["progress"] = item["progress"]
for latest in state["latest"]:
if latest["environment"] == item["environment"] and latest["name"] == "{}/{}".format(provider, running_component):
for current_command in latest["commands"]:
if current_command["name"] == command:
current_command["progress"] = item["progress"]
state["running"] = sorted(state["running"], key=lambda item: item["reference"])
for component_data in state["latest"]:
provider, component = component_data["name"].split("/")
component_data["build_success"] = "success"
for command_data in component_data["commands"]:
command = command_data["name"]
builds, last_build_status, next_build = get_builds(component_data["environment"], provider, component, command)
if builds:
current_build = builds[-1]
command_data["build_number"] = current_build["build_number"]
command_data["build_success"] = "success" if last_build_status else "failure"
if not last_build_status:
component_data["build_success"] = "failure"
if not command_data.get("progress"):
command_data["progress"] = 100
for component in state["components"]:
for component_data in state["latest"]:
if component_data["environment"] == component["environment"] and component_data["name"] == component["name"] and component_data["build_success"] == "failure":
component["build_success"] = "failure"
for environment in state["environments"]:
environment["build_success"] = "success"
for latest in state["latest"]:
if latest["environment"] == environment["name"] and latest["build_success"] == "failure":
environment["build_success"] = "failure"
"I would pay" is a community where people say how much they'd pay for certain things.
I have a file on my host machine that I want in my guest machine, usually in locked down environments I base64 encode the file and paste it into the guest VM and decode it. But what I want some thing more robust. A special string that encodes all the information needed to get to the file. When pasted, it contains the information needed to transfer the file from one environment to another.
A community of people that share their life strategy for different topics.
- Define an SQL query
- Define the query's React renderer function for that query.
- Define the relationships between the queries on the screen
widget title
return <h1>Welcome</h1>
---
comment
Query -> Widget Mapping -> Predicates
POST handler
---
query
select id, strategy_name from strategies
---
widget strategy_list
var items = items.map(item => {
return <li><input type="text" name="strategy[{item.id}]" value="{item.strategy_name}"></li>
})
return <div><ul>
{items}
</ul></div>
---
predicates
this atURL /strategies
this below title
this inForm action=/strategies method=post
---
widget submit
<button type="submit">Submit</button>
---
predicates
submit below strategy_list
---
POST /strategies
sql
update strategies set
strategy_name = c.new_strategy_name
from (values
(%gen_form_values_array("strategy")%)
) as c(column_id, new_strategy_name)
where c.column_id = strategies.id;
A community of people that define imaginary formats that they wish existed.
Use public transport and maps to work out where I can realistically go to within 20 minutes. I'd like to apply to jobs by physical area too.
Existing
We end up with a simple database when we put a trie in front of a hashmap. This allows for almost constant access times. See this repository.
There must be a way of getting the best of both worlds: an SQL database with the performance of a NoSQL database. I'd like to synchronize an SQL database with DynamoDB.
An PaaS that begins while the application is hosted on a single box and then scales out to load balancer boxes, database boxes -- all while being on the same platform. Can automatically determine when to scale based on rules.
Every domain should have a Wantsfile at the root of the domain which states what that person or organisation wants. Sellers can provide a Sellfile at the root of their domain.
Matching between Wantsfile and Sellfile is automatic with an order matching engine so that purchases are automatic, even handling the exchange of money.
- I can request coffee at £2.65 for 500g, milk for £1.50 for 4 pints and so on and have them automatically delivered to me.
- I can set a price for hosting some files and an archive and have someone automatically host them for me.
- I can request a Postgres database and its backups every day and have someone provide that interface for me.
When I'm with someone in person, my phone should show a screen with that person's profile on it and should show me all the things I can do with that person digitally.
Track all the entities you know, whether or not you trust them.
monetization.txt is a file you keep at the root of your web domain where you show people how to support you financially.
If you store data in a hashmap and use a trie in front of it, you can fetch all the data to render a webpage with a partition key and sort key and this can map to a hash map access for each object fetched. Much faster than an SQL query.
- /products/ can do a partition key search of PK=products SK="begins_with(products)"
- /products/product-100 can do a partition key search of PK=products SK="product-100"
Some algorithms are easier to explain when they are transferred to paper and moved around on a table with bits of virtual string connecting them. I propose a layer language for building algorithms this way.
Creating a movement of a layer, prompts the user for a machine readable reason for moving and what to move. I envision a btree being easy to create with layer language.
- Build server configured by YAML in Markdown
- Build server installer API Build server commands map to an installer API so that installers are easily created.
Why not embed CSS and Javascript in HTML and have an attribute to mark the resource as cacheable. There would be some way to communicate the fact that the resource is cached to the server. Perhaps a header. Can use serialized bloom filters to indicate what resources are cached. Then on other pages, we can include an empty CSS and Javascript block with an attribute to say use the cache.
Write the workflow of your distributed system as a simple program that can run on a single computer. Then scale it up by weaving the following:
- Define method call replacements with queries, queues or distributed logs.
- Introduce loops that stream data rather than wait for it all to be in memory.
A DSL for distributed systems.
If you write a microservice architecture and have every database separated from every other and you have a good service oriented system.
I propose a join service that allows joins between different microservices, for the join query:
select * from user_orders inner join users.id = user_orders.user_id where users.id = 20
- Bulk extracts
select * from user_orders where user_orders.user_id = 20from user_orders service andselect * from users where users.id = 20from users. - Transfers them to the join service database. Bulk imports.
- Run the join query.
https://jsfiddle.net/yLjuc1d0/
A GUI for tracking nouns and their relationships in a system. For example, a list of nouns that should be supported:
- iam roles
- kafka topics
- s3 buckets
- s3 objects
- producers
- consumers
- kubernetes objects
- ec2 instances
- request ids
Autodebugging is to take an entered identifier and turn it into useful information about whether or not some thing works. For example:
- Enter a Kafka topic name, get a list of consumers and producers. (Derived from your configuration files pointing to Kafka)
- Enter an s3 bucket name, amongst objects, get a list of iam roles that can write to the bucket (Derived from the AWS API and based off of assume role policies)
Write ingesters for each system tool or API and have it warehoused in one place for introspection.
- Borrow physical objects with your computer.
- Define a computer configuration with code.
Import Gigabyte X399 AORUS PRO
Import AMD Ryzen Threadripper 2990WX 32-Core Processor, 3000 Mhz, 32 Core(s), 64 Logical Processor(s)
Construct
Buying things and selling things are basic actions in the world that deserve decentralized infrastructure to action in the real world.
- Start a shop with just your desktop environment. Accept payments.
- Pay for bespoke software through the desktop with the option of making the resulting product open source.
- Trade menu - like a video game where you can trade items, a way of trading with strangers online.
- Auction
If we have a trading platform where people can list products to sell in a digital shop front, there needs to be some way of creating assets that is not necessarily a website even if web technologies are used. I propose users have the freedom of creating assets in various formats, videos, presentations and marketing materials in a common archive format. So we can realistically say that this file represents this product or service pretty accurately and completely.
The desktop environment would have a common powerful shopping interface that searches these products. The effort to build this shop front is paid once and maintained by the community. But who appears in this shop is also community defined.
- I propose a database of product features from all product fields.
- Every feature in a computer system is broken down into a list of SKUs. Such as "view files on filesystem" has an identifier.
- Marketing SKU database
- Calculation of ratios built into the shopping software.
A decentralized work community whereby you can depend on the work of others to benefit you personally. There are millions of people working around the clock on different things. Owning index funds allow those working at companies to benefit you financially directly by increasing the value of your shares and increasing dividends. There must be a way to make what other people do daily benefit you directly too. Person dependencies allows me to depend on the output of a particular individual. I depend on the creators and maintainers of Python3 who increase its performance, remove bugs and fix security vulnerabilities. I want to make this dependency on particular people explicit.
So, how can the work that other people do benefit me directly?
- Crowdsourced queries I'm moving to a new area and need to find a job. Can the masses of people online help me find a job quickly?
- Digital Work abstraction. Pattern match on what a person is doing at a high level on a computer system and see if this pattern can be applied in other areas by other people with the same patterns. If someone is iterating through a spreadsheet, this loop should be detectable based on the searches and copy and paste history of the user into which fields that they are copying into. This work could then be automated.
- Working games People can play a first person shooter and investigate performance problems on production hardware by investigating a virtual room of stats looking for enemies.
- Graph eyes Outsource looking at graphs to the community.
I want to be able to import a person by writing down an import statement.
import sam@samsquire.com:
ask "Can you review this idea https://github.com/samsquire/ideas3#94-person-dependencies "
Computers can calculate permutations and combinations ridiculously fast. The mouse creates a hard deadline on operational completion time for interactivity, the latency is very visible to computer users. I propose computers randomly generate solutions in the background for humans to review and like a slot machine, humans review the generated solutions for usage.
Examples where this is useable:
- For document outlines that follow a structure. Randomly generate presentations and word processed document formatting options.
- Web site design
- Data layouting
- Layout
A hotel whereby there is always a hackathon going on to build new things.
An online service whereby common dotfiles and configuration files can be protected by an online account and rsynced to the system at system login time.
This is what Ubuntu One should have been.
Services built into the desktop or phone to benefit your life:
- automated job search, monitors the market for for jobs with higher salaries
- spaced repetition feed, shows content that has been read before hand (Anki integrated into the desktop)
- gamified behaviour tracker (time management)
- budget tracking, virtual bank account buckets
- quote follower - change your life according to quotations, put quotations into practice
- flash polling - run a poll for everybody
- family software: family management, location tracking, decision making, voting, what's for dinner
Corporations often have processes and workflow engines to manage flow between states. This could all be standardized by an office suite programme called "Process" which manages the transition of work items through different procedures.
- Messenger bot to file Orchestrate software installation by talking to bots. So you might have a bot that installs services, by creating systemd services. Send the command to make a service from. So you would send a URL to untar to a bot, the bot would untar it, you would send a message to move the file to the right location.
- Desktop clustering and Desktop cloud Someone should be able to build a cloud infrastructure by networking desktop computers together. OpenStack could be integrated into the desktop. Desktops connect to one another to create a cluster.
- Instabusiness Business software built into the desktop, so people can run companies using just a computer.
- Metadata enhanced storage Instant storage consumption data due to indexes. Rather than running ncdu to calculate storage usage, we can get the information immediately. Would slow down the filesystem for a benefit in performance when running aggregations.
- Community Idea: Always there A community of people guaranteed to reply. You're in a supermarket and you have the option of two choices, at different prices. You're too lazy to work it out on your phone, so you take a photo of both price tags and ask people to help with the math.
- Dimensionality reducer Most people can handle a life of relative complexity, house, car, travel to work, rest, cook and sleep. Anything on top of this is complexity. I propose a computer system that tracks dimensionalities. Which are things to manage: If you have a car, you need car insurance and fuel, if you have a house you need house insurance. I propose the dimensionality reducer generates a stream of work to fulfil for other people, in return for payment. You get quizzed on your dimensionality score, which is how many dimensions of life you have to worry about, and then you are recommended businesses that manage these on your behalf.
- Bandwidth chargers Billing for users of bandwidth from services like AWS. So open source projects could create high data transfer services.
- Possession tracking
- Focal point We often lose track at what task we are doing. If we're making coffee and have a plan to make coffee and get into a conversation about some complicated thing, depending on our skill level, or if the task is more complicated, we lose the ability to make coffee. So we need a program reminding us what we are working towards. Perhaps a prominent word in a location on the computer screen which should be a focal point.
- SLA marketplace Buy an SLA
High level services such as delivery services that are broken up into subjobs for people to accept. Can be paid to do work without a job interview and are reviewed by other users.
There's more ideas in ideas4, it's not finished yet but you can give it a look.