Tn

	A silver bullet?1

Goal:

	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
		Interoperability
			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

Summary:

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

Implementation Overview:

	Everything in Tn is either:
		Data
		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):
			Monolithic
			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:

	//Home/Readme The file “Readme” in the current user’s home directory
	//Storage/C/WINNT/WinNT The local C:\WINNT directory on a Windows machine
	//Processes/MPEG1ToMPEG4/14ae8ff0/Output 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
		//Network/http/www.nedprod.com/TnFOX/index.html The file “index.html” in the “TnFOX” directory on the HTTP server “www.nedprod.com”
		//Network/pop3/mail.nedprod.com/ned@pass/44 The 44th email in the “ned” POP3 account on the mail server “mail.nedprod.com”

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!