The Power of Find

My latest obsession takes the form of filtering & finding meaning in the tsunami of data sent to us at every possible angle.

The find() function is a theoretical function I came up with that will essentially turn all of our automatable thought processes (all the mental tasks you run) into callable micro-services.

The social value of this cannot be understated. Find() could democratize understanding itself, making understanding/intelligence a basic right for everyone.

In daily life, you could reduce the computational time it takes to get through your day by writing a few queries when you wake up.

Example Use:

  • find(‘schedule’, context = data about tasks that need to be done today)
  • find(‘route’, intent = optimized for efficiency, context = getting to work)
  • find(‘argument’, intent = to get my kids’ shoes on in time)
  • find(‘excuse’, context = getting to work late)
  • find(‘joke’, intent = smooth over awkward situation, inputs(audience=[‘coworkers’, ‘diverse’, ‘family-oriented’], cause=[‘late’, ‘meeting’], tone=’apologetic’)

Find Inputs

To break down the actual processing of the find function, you’d select a set of processing rules (an engine and its related functions) based on:

  1. the desired output object (like an optimized schedule, argument, route, joke, story, opinion, etc)
  2. the intention or purpose of the query (stated in plain language that can be reduced to a single verb + resource pair)
  3. the contextual resources (resources like cause, tone, audience, and other environmental information)

So for our examples above, the find() function would:

  1. determine the desired output object, and point itself to a server designed to handle that type of request
  2. determine the intention of the query (for our example above, ‘smooth over awkward situation’ would be reduced by our decrypt_intent() function into a simple verb + resource pair, like ‘dissipate_awkwardness’. So now we have a more structured input value for the Intent parameter:
    find(‘joke’, ‘dissipate_awkwardness’, context=[audience=’coworkers’,…])
  3. Once we have the intention in a structured format (verb + resource pair), and we have our target server for this type of desired output object, we can then throw these parameters to the target server, with the contextual resources included with the request.

Actual Find Logic

And the target server could handle the above request with the following pseudo-code:

A. Check for desired output engine

Do I have a joke engine?

  • Yes, I have thousands of servers which have joke engines running; one of them is local & trusted by my user so I’ll use that one.

B. Analyze Intent

Let’s analyze the intention input (reduced to ‘dissipate_awkwardness’ by our meaning reduction function decrypt_intent()):

  1. find_verb(‘dissipate_awkwardness’) = ‘dissipate’;
  2. find_resource(‘dissipate_awkwardness’) = ‘awkwardness’;
  3. find_resource_type(‘awkwardness’) = ‘personal quality’;

C. Function Access & Selection

Do I have access to a function with dissipate in the name, or with dissipate as a metadata keyword included with this function in the function database?

  • Yes, I have a function called dissipate_resource().

Is this function abstract enough to apply to the ‘personal quality’ resource, or is it too specific to be useful?

  • Yes, the input parameters of dissipate_resource are:
     dissipate_resource(resource Any, resourceType String, context Any)
     which means it will accept a resource of any type.

Before I use that function, check if I have access to a function that enacts actions specifically on resources of type = ‘personal quality’:

  • Yes, I have a function called dissipate_quality(); the input parameters of dissipate_quality are:
     dissipate_quality(quality Any[‘personal’, ‘abstract’], context Any)
     which means it should accept a quality of any type, specifically including qualities of type ‘personal’.

D. Run Functions & Analyze Output According to User Configuration

Just to be safe, let’s run both functions since there are < 1000 functions found, which is what this user configured as the limit of functions I should compare.

1. JokeEngine.dissipate_resource(‘awkwardness’, type=’personal quality’, context) = “I thought you guys wouldn’t think I was cool if I wasn’t late occasionally so I waited five minutes in the parking lot.”

2. JokeEngine.dissipate_quality(‘awkwardness’, context) = “I was debating if I should wear this [X] or not and my heart said yes but my body said no; it took five minutes for my heart to win.”

You’ll see that there’s a difference in quality in the jokes returned by our two different joke engine functions, and also one of the functions determined that we need more contextual information to complete the joke, since we didn’t tell it what we were wearing that day.

So the next step is requesting that input X from the user, and then requesting a rating for the function performance as well as sample data for input X.

E. Return Output to User for further Input

Since function 2 requested more input, let’s ask the user which joke they want to use, and if they want to offer more input for joke 2.

  1. User Selection: User selected joke 2
  2. User Function Rating: User rated joke 2: 4 out of 5 stars
  3. Sample Data: User volunteered sample data for extra parameter X: tie, socks, ring

Let’s store that sample data for suggesting future jokes for our other users who want us to fill in extra parameters for them, instead of letting them decide.

With the above pseudo-code, you can see how we would build the find() function from an abstract level, leveraging libraries of community-supplied functions to handle atomic mental tasks, like coming up with a new communication object such as an excuse, explanation, story, joke, or argument.

There are many ways to further parameterize the logic above, with more contextual information; we could have run a function-ranking function to identify which joke would have been superior to the other based on whether it was work-appropriate, whether it would improve your standing, whether it would make you appear strong or otherwise compliant with the company’s values, whether any of your coworkers would have been sensitive to a topic or implication of the joke because of recent meaningful events, etc. But I oversimplified today because the potential of find() is clearer with a concise example.

I bet you can also see the potential value in having a library of functions to generate these objects, so we can delegate our effort to community tools and instead allocate our scarce attention to the most complex & interesting problems we encounter. I’ll go into more detail on building functions to generate these communication objects in a future post.

One clap, two clap, three clap, forty?

By clapping more or less, you can signal to us which stories really stand out.