A silver bullet?1

Tn seeks to vastly increase productivity in computer software by maximising its network effects
Software is an ecosystem like economics or a society
Therefore biological and quantum mechanical theory applies

Network Effects Are Good:
Is the basic “value added” mechanism – examples:
Information e.g. the Bible is valued more because it’s so popular
Mobile phone standard valued more if it’s universal
Software is an information good
But unlike all other information goods, it’s also an engineering solution (like a pump)

Therefore to maximise software’s usefulness & productivity, we must maximise its network effect
- we already have seen this through what the internet has added to the value of computer software

Potentialising Ecosystems:
Each ecosystem has an optimum point
Arrived at by maximising the tradeoff between all competing factors
An ecosystem through competing interests will tend to gravitate towards a point set by the regulatory framework supporting that network
That point may or may not be the optimum point

Software As an Ecosystem 1:
There is a complex set of relations between the user, their tools and the work in hand
There is a further set of relations between all users, all tools and all pieces of work
There are further relations again between the constituent parts of a tool
Especially when that tool is made up of smaller tools

Software As an Ecosystem 2:
All software is defined as a set of relations between algorithms
You could call software organised maths
Programming is “an exercise in manipulating complexity”1
i.e. programming productivity is a function of how much complexity can be manipulated against time

Ecosystem Design 1:
Break software into recursive orders of increasing complexity
Webs of components interlinked with other components
Least possible constraints on possible relationships between components
Yet maximise relationships between components – as so to maximise the network effect

Ecosystem Design 2:
Also must maximise relationships between the user and the software
Extreme customisability
Also must maximise relationships between all users of the software
Online community
With software
Computer grouping e.g. distributed processing

Using & Programming:
What is the difference between programming a computer and using a computer?
Both manipulate complexity and information
Historically there was no difference
Society has now internalised computer use, therefore now is ripe for UI changes
e.g. mobile phones, digital cameras etc.

Human Computer Interface 1:
A major bottleneck for maximising relations between the user and their software is the user interface (UI)
It’s also a bottleneck for how much complexity one can manipulate
=> Therefore we need a radical overhaul of the HCI

Human Computer Interface 2:
Only physical limitations are the keyboard & mouse input interfaces and 2D colour screen for output
However there is the limitation of established convention
Therefore interface should be workable by anyone familiar with computers

What does software do?
Computer software applies algorithms to information
i.e. processes data
Therefore our software components should do nothing more than process data
No more, no less

Tn: A set of data processing components which can be arbitrarily organised to solve any problem

Implementation Overview:
Everything in Tn is either:
A processor of data
Data is strongly typed in a hierarchical fashion
e.g. Data=>Document=>HTML=>4.0

Processors of Data 1:
Take input and generate output
Can perform operations on the data flowing through it
(Tn calls this a capability, represented as Tn::TCapability)
Streams of data flow between data or outputs to inputs or data
Tn calls these data streams, represented as Tn::TDataStream

Processors of Data 2:
Processors of data (Tn calls these components, represented as Tn::TComponent) can be organised as a parameterised generic solution
Similar to C++’s templates or C’s macros
Tn calls these schemas
Schemas can be defined by the user or automatically
Can be persistent or temporary (more later)

Backwards Compatibility 1:
Tn is a fourth generation software organisational paradigm
The previous three are (in order):
Shared Library (DLL)
Object Repository (Java, COM, .NET)
Advantage: We can incorporate older existing code very easily with thin wrappers

Backwards Compatibility 2:
All software can be seen in terms of processors of data operating on data. Therefore:
All Unix-style command line software can be offered as a Tn component with a simple generic wrapper:
There exists vast range of free software from compilers to sound filters, all of which can be immediately made available
With custom wrappers, .NET and CORBA objects can be fully & natively exposed
A generic wrapper could expose all .NET and CORBA objects, but it wouldn’t be very efficient
Word, Excel and ODBC/ADO (MySQL) would be very useful

Kernel Namespace:
All data, components, inputs, outputs – everything – appear in the Tn kernel namespace
The namespace varies according to who’s looking at it
There is one namespace in all the world
All computers in the world appear in it, often multiplely

Kernel Namespace Examples:
The file “Readme” in the current user’s home directory
The local C:\WINNT directory on a Windows machine
The output data pin of a MPEG1 to MPEG4 data converter running on a local machine

But there’s more:
The real power of the namespace comes from the network:
//Network/My Family/Sheila/Storage/C/Readme
The file “Readme” on C drive on the computer called “Sheila” within the “My family” computer group
The file “index.html” in the “TnFOX” directory on the HTTP server “”
The 44th email in the “ned” POP3 account on the mail server “”

Even more still:
Any protocol or method of transferring data can be added to the namespace1
This unifies all computing resources, even if they aren’t running Tn
To the user and all Tn components, to operate any protocol is identical
Simply tie together elements of the namespace

Schemas 1:
What happens when the user double clicks some data in Data=>Image=>PNG format?
System tries to find a PNG viewer component
If it can’t find one, has the user specified a schema for this type? If not what about this class of type?
Schema for class of Data=>Image is to find a component capable of converting from PNG to RGB image for which there is a viewer.
Therefore you get [PNG file]->[PNGToImage]->[Image Viewer]

Schemas 2:
Conversely, if a component takes only a Data=>Image typed input, the system will automatically generate a temporary schema for converting from whatever input is supplied to what is wanted
This automatic generation is configurable by installable components
Since under Tn there is one namespace for all computers, “friendly” nearby computers may know more than the local machine about some type of data
They may be better equipped to handle it (more data conversion options), faster at processing it etc.

Schemas 3:
Users can attach schemas to global key shortcuts
The best example is Ctrl-C and Ctrl-V. Tn has made the clipboard obsolete but for interoperability, Ctrl-C invokes a schema which takes the currently selected item in the current document and places it on the clipboard. This is possible because all data within data appears as output points from that data – this is how Zip archives are handled
Another example is “Email and Print” which when invoked, emails the current document (by connecting it to //Network/smtp/mailserver/account/Batch) and prints it (by connecting it to //Devices/Printers/HP Laserjet)
This can get very powerful very quickly …

Creating a webpage 1:
Here’s how you would create a webpage on Tn:
Launch HTML editor component
Create new HTML data. A viewer opens
Double click on the viewer. A text editor opens in-place. You type some text
You find a picture in PNG format in //Home and drag in into the HTML viewer. The picture is copied (if you use alt-select, it’s inserted)
You think the picture is too dark. You double click on it and an image editor opens in-place (the image is converted to RGB, put through the editor and converted back to PNG in situ)

Creating a webpage 2:
You do some more of the above
You find you need finer control of the HTML so you open the save box using F3, drag the icon to a text editor on the icon bar using alt-select and the same data opens in the text editor. As you edit the HTML manually, the view in the HTML viewer updates
Being finished, you drag the icon from the save box to //Network/ftp/website/user@pass/folder which uploads the file. Or if you prefer a schema which translates to using FTP for upload and HTTP for download e.g. //Home/My Website

Summary 1:
Manipulation of data is totally generic
The same very small set of components do everything, they are merely recombined in different ways
Existing software can be very easily repackaged as Tn components
Everything can be found in one place
The system can infer what you want without you having to specify exactly what
This is called “functional programming” and is a feature of all higher-order programming languages

Summary 2:
Execution automatically spreads across the best available computing resources
These tend to remain local as the network is slow, but not always
Whole applications no longer exist on Tn1
Just fine-grained single-objective components the user ties together to solve the task at hand
There is a programmer saying: “Let your program do one thing and one thing well”

Advantages 1:
The user is entirely in control of their application environment
No more irritating (mis)features common in today’s application software
Simple, single consistent interface
Users will favour the best components and hence a competitive state is created, propelling the system towards optimal
All computing resources are utilised to the maximum instead of mostly wasted like as currently
As the number of components and schemas grow, new orders of manipulating complexity automatically emerge

Advantages 2:
The user forges a far deeper set of relations with their tools
The tools forge a far deeper set of relations with each other
We have two out of the three goals covered
What about users with users?

The Tn website:
A home for all Tn components and all Tn users
Used to provide authentication for Tnmail, Tn’s spam-proof secure email & discussion service
Used by users to find new components and each other
Two thirds of forecast revenue for the first 18 to 24 months will come from advertising
The other third from sales commissions i.e. through our sales or from the 5% levy on sales through our site

The security model 1:
User’s computers can interact with untrusted computers because of Tn’s security model
Use of capabilities1 makes Tn intrinsically secure unlike Access Control List (ACL) based systems
It’s extremely easy to group together a set of computers according to a schema and specify what capabilities the members of that group will have
By default all external access is encrypted with 128 bit AES and data you deposit on remote machines is similarly encrypted so only you can use it

The security model 2:
There are no executables on Tn (obsolete), so you can’t run a virus
Even if there is a malicious component, the default capabilities ensure that it cannot alter anything except itself and the data you feed it. It could not copy itself (except into its output), damage data or do anything worthwhile unless you permit it
Everything, absolutely everything, can specify what can access it and additionally for processors of data, what they can access

Efficiency 1:
Isn’t all this very inefficient?
The system chooses how to implement a data stream connection
This could be in-process or use shared memory for extra speed
Endian conversion can be disabled if each end is the same endian
Uses the fastest processing capacity available (multiple processors, NUMA clusters, LAN clusters)
System dynamically adjusts its caches according to memory availability

Efficiency 2:
Most operations e.g. calculation of capabilities are cached
Tn is totally dynamic, so if something changes the effect promulgates throughout the system. This makes rescinding capabilities easy
There will be some cost, but we think it will be unnoticeable on modern computers

A Silver Bullet?
Fred Brookes predicted that no one single invention would increase computer productivity by 10 times within a decade
Tn is not a single invention exactly, but it is a different way of doing things
Likelihood is that Tn will enable a 10x productivity improvement within a decade. This in my opinion is good enough!