Pretty Diff - Guide: A Poor Man's Artificial Intelligence

On the Nature of Intelligence

A person cannot appreciate the concept of an artificial intelligence without first appreciating a natural intelligence. Intelligence is not the measure of accuracy of data. In many cases intelligent entities make decisions completely in absence of desirable data merely because some stimulus demands a decision be made.

A decision-making capacity does not suggest a measure of accuracy or validity. Humans are generally considered substantially more intelligent than the most powerful computational devices even though humans perform simple arithmetic much slower and formulate incorrect decisions frequently. The advantage humans have over powerful machines is a decision-making capacity. This is the ability to spontaneously make an original decision unassisted.

A Brief Observation of Animal Neurophysiology

Animals of various species and capabilities are so far observed making, modifying, and manipulating the results of tool formations (Pickrell, 2003). There is not a single area of animal brains responsible for any single step in this process. Animal brains are not a single organ, but rather a tool box of various tools acting in concert. These different neurological tools are specially modified and honed through the life experiences of the given animal in a condition called neuroplasticity.

Ther are several important considerations relevant from the study of the brain.

• Intelligence is determined not by the size of the brain but by the variety of components that comprise the brain. Corvids are among the most intelligent animals on the planet (Owen, 2004), some posessing an intelligence almost comparable to a human, and yet their brain is the size of a pecan nut, at largest. Contrarily elephant brains be three times heavier than a human brain without the benefit of three times the intelligence (Herculano-Houzel, et al., 2014).
• Animal brains are neither a single organ nor a bag of isolated components (Newitz, 2015). Instead the brain is a mesh of different components performing specialized tasks and sharing their processing with other areas of the brain. It is the collectivized result of various different processing centers of the brain that results in a decision wherether cognitive or non-cognitive.
• Animal brains change and adapt in reflection to experiences at any point in the lifespan of the brain (Cherry, 2017).

These observations identify some of the capabilities that allow intelligence and responsiveness in animal brains, which are features software does not currently possess.

Creativity and Originality

Perhaps the most agreed upon definition of intelligence is creativity, which is the ability to create that which is unique or original. This can only be achieved through a series of decisions and evaluations that are independently and wholly internally open to modification without external assistance. This phenomenon is commonly referred to as brilliance.

Producing a creative intelligence comes with some challenges:

• Consuming modified application logic in applications accessible from the primary application stack.
• Setting appropriate boundaries so that self-modifying application logic doesn't modify continuously in an endless loop.
• Validating that a given objective is satisfied and thus an application should terminate from further self-modification.

Achieving creativity may likely require various different intelligent systems operating in concert so as to guide and limit each other to externally specified bounds.

End State

Simply speaking an autonomous intelligence is a system capable of forming original decisions spontaneously. That definition is challenging to measure in a qualitative fashion as the underlying qualifications are subjective in practice. Speaking analogously, it is hard to tell if you have crossed that proverbial line in the sand if the line is blurry and occasionally shifts in distance and direction. A more simplistic measure of intelligence is a system capable of making decisions that cast doubt on the system's prior assertions. According to Cartesian logic a thinking machine is that which is sufficiently able to doubt as the mere ability to doubt is a primal essence that cannot be reduced from an intelligent self (Descartes, 1993).

The Universal Constant of Parsers

Computers operate with machine language. Virtually no software in common use today is written by humans in machine language. As a result, a compiler is required for all modern software to translate instructions written by humans into the instructions executed by computer hardware. Compilers require a parser to decompose the instructions into small atomic pieces that can be described sufficiently for a variety of tasks, including translation. It can be reasoned that all modern application code passes through a parser, and possibly through many domain specific parsers for various different forms of interpretation.

It can be reasoned parsers are, perhaps, as universally present as the instructions they describe. Parsers fit this paper's definition of information as they associate data with a plurality of descriptions. If the parsed data were available for consumption to a variety of applications that act of sharing and the processing resultant from that sharing fit this paper's definition of knowledge. When that knowledge, or rather the application's reasoning of parsed information, is available for consumption by other applications wisdom is achieved. When wisdom forms a model for application modification artificial intelligence is achieved.

Contrary to a Data Economy

At the time of this writing the dominant economy of software development is a data economy composed of a few massively monolithic data brokers. Amazing conglomerates have risen up with astounding value to gather and horde treasure troves of data. Value and revenue are generated from transforming data into information that is partially transferred to the end user and partially transferred to advertising firms using data auctions. While it is the information that is responsible for the enterprise value this information is formed entirely upon data held in a secretive vault.

In order for this economy to generate wealth data is horded and never returned, unless so directed by law. Only information is returned. This ensures competing firms must independently gather their own data. Since that proprietary and heavily secured data is the foundation of the data economy it must never be shared with external parties.

An artificially intelligent system requires only minimal data to thrive. Speaking from human experience prior decisions are a more significant source of accuracy and validation than data. People typically refer to this as experience. Data on its own does not validate or qualify anything as data is too primitive. A qualifier, a purpose built application, must reason upon the data and generate a conclusion. To determine if data is valid or invalid a qualifying application evaluates the data against a know set of rules. The data isn't qualifing anything, but rather an application that produces a decision. The advantage afforded an artificially intelligent system is the ability to mreasure a current decision against a prior decision in consideration for whether that very decision-making ability is in demand of improvement, which serves as a far superior and autonomously improving qualifier than a data facet or a primitive collection of static rules.

The reasoning, that prior decisions are more valuable than hording data, introduces friction for an economy that derives its value solely upon its stored data. In this case an artificially intelligent system would render that economy largely obsolete. Stored decision points are a more valuable commodity than a vault of horded data. Additionally, the qualify of those decision points when increased sharing allows domain specific applications to independently contribute to an artificially intelligent system, which is contrary to the nature of hording and never sharing data. Data, due to its primitive nature, loses value with age faster than qualified decisions thereby creating a large diminishing return on investment over time.

Higher order sharing is the basis of an artificially intelligent system. As technologies advance and more domain specific technologies arise, in direct support of artificially intelligent systems, the value of closed systems will proportionaly erode in value and demand, economically speaking. This erosion of value is compounded in that artificially intelligent systems demand less data over time as their store of decision points increases from experience. These two economic factors represent value destroyers to a data economy as artifically intelligent systems, particularly open systems, come online.

Static Compilation

Traditionally, most applications are written in a computer programming language that is compiled to machine language and only this form of the application is available to the end user. In this case a parse step is available to the compiler when the application code is translated to machine language, but that parsed data is discarded and never shared. Such a disregard for code sharing is obstructive to an artificially intelligent system, but this is not incredibly harmful in the short term. In the near term a more potent consideration is to ensure powerful applications are capable of contributing information to an artificially intelligent system even if the application code cannot be modified by the intelligent system. While reasoning about the internal operations of large and powerful applications is not an immediate priority at the time of this writing this could change once artificial intelligence is better understood in practice.

Standard Format

Parsers most typically output in a format called a parse tree. Parse trees are commonly hierarchies with various different descriptions associated with different data facets in different ways depending upon a data facet in question. This is highly irregular and highly language specific. The heirarchal nature of parse trees also make them more costly to access, in comparison to a flat list, and more challenging to standardize into a universal format.

Instead of parse trees I propose a table as output. Tables are simple and regular.

An example of a parse table as a regular format for output is available from the Parse-Framework (Cheney, 2017).

Table 1, An example of a parse table expressed by the Parse-Framework using sample code: <a><b class="cat"></b></a>

index	begin	lexer	lines	presv	stack	token	types
0	-1	markup	0	false	global	<a>	start
1	0	markup	0	false	a	<b>	start
2	1	markup	0	false	b	class="cat"	attribute
3	1	markup	0	false	b	</b>	end
4	0	markup	0	false	a	</a>	end

Table 2, A second example processed through Parse-Framework illustrating a format, React JSX, comprised of multiple languages. The sample code is: var a = (<hr /* asdf */ />);

index	begin	lexer	lines	presv	stack	token	types
0	-1	script	0	false	global	var	word
1	-1	script	1	false	global	a	word
2	-1	script	1	false	global	=	operator
3	-1	script	1	false	global	(	start
4	3	markup	0	false	paren	<hr/>	singleton
5	4	markup	0	false	hr	/* asdf */	attribute
6	3	script	0	false	paren	)	end
7	-1	script	0	false	global	;	separator

It should be noticed the Parse-Framework example may not represent a complete or final information format for a general purpose artificial system. This format was specifically created to meet the demands of several specialized tasks relevant to a specific class of work. The wonderful quality of a simplified table format is that the format can be easily extended in future versions as additional needs are identified.

Example Use Case

There are many use cases for the parse table above. Perhaps a user must reason about the code sample or gather contextual information from it for accessibility or security purposes. A user could be evaluating a code sample and may need the code reformatted into a modified presentation that is easier to read such that the code is beautified. A user may need to know how a modified code samle changed compared to the unmodified code and find only the specific differences relevant to the code.

There are various different tasks a user may require upon a simple coded instruction all of which are achievable from the same single parse operation provided that parse operation returns a standard format that various other software applications understand. Sharing the same parse table between different applications that perform different unrelated jobs achieves knowledge so long as the output generated by each application is consumable to each requesting application.

Distribution Scheme

It is necessary to establish a standard scheme or protocol by which the standard format is communicated. The immediate advantage allows various applications to talk to each other, in a common language, and share their parsed information. Second and third order consequences of a standard distribution scheme allow applications to hsare in unexpected ways that contribute to more efficient knowledge creation.

A strong candidate for a standard information sharing scheme comes from Microsoft in the project Language Server Protocol (Sourcegraph, 2017). The Language Server Protocol (LSP) provides an interconnection mechanism to allow a local application to act as a central authority to monitor the edit status of code in a variety of supported languages and issue helpful suggestions or errors immediately to the application where the edit originated.

There are a couple of strengths in this approach. One strength is that the analysis occurs in near real-time using an asynchronous event model. This benefits speed of processing without locking an execution thread in the OS kernel. It also establishes a secondary processing stack to observe and analyze a different application stack which can provide a necessary form of bounds checking.

For more information LSP please view the supported documentation and associated Github project at:

• https://langserver.org/
• https://github.com/Microsoft/language-server-protocol

Immediately Practical Only to High-Level Languages

Modification of available applications is most easily accomplished if the comprised applications are written in a langauge that compiles at run time. JavaScript and Python are popular examples of such languages. In the case of these languages application instances compile generally quickly when executed which allows modification of source code with only the most minimal delay between code change and application response.

Application modification at high level application langauges is not efficient for complex math heavy tasks that demand many various considerations untense hardware constraints. Economically speaking, exploration for on-demand modification of applications in more computationally sensitive langauges will occur in proportion to the demand. Once this theoretical idea becomes a common practical implementation the probability of technical refinement and specific execution considerations, particularly among fast low-level languages, will become available in accordance with supply and demand.

Example Use Case

Under the Information Sharing section a use case example demonstrated modifying a small sample of XML for various processing considerations from a single parse step. Imagine a second application stack is running to observe the primary application stack in this same scenario. Imagine an observing application is a code coverage tool and realizes that out of a hundred execution cycles one of the applications in the primary stack, such as a code beautification tool, contains logic that never executes. This application can be modified by removing this unnecessary logic. Finally, imagine, that observing software identifies missed opportunities and inserts the necessary logic into the primary application.

In this set of imaginary hypotheticals there are severl implicit tasks. First, software writing software is a huge challenge. Identifying logic worthy of removal is less challenging than writing new logic and ensuring this new logic applied in the appropriate location in the application. For human developers this requires heavy manual and automated validation. The primary concern with application writing software is ensuring code changes occur with high confidence without major delays in execution time. Secondly, identifying missed opportunitie demands hueristics that are diffecult for people to identify must less for software to detect such in an automated fashion.

Nonetheless, challenges withstanding, these capabilities reamind completely possible and will certainly demand a lot of experience and refinement to operate correctly in a real-world scenario. In a lesser manner examples of automated application modification are already present with the options fix and correct from ESLint and Pretty Diff respectively. In these examples parsed code is modified to correct for minor syntax considerations. Correcting for syntax is more primitive than writing new logic with regard to decision points, but it is a similar precedent that is available in production environments.

• ESLint fix option
• Pretty Diff correct option