You are visiting an archived page!

Computing Pages

by Francesc Hervada-Sala

Web Log

Next Steps

Sun Apr 29, 2012

After almost three years I am announcing that I will not extend this website any more. New releases of Universaltext Interpreter, if there are some, will still be available here, but the chapters about computing critics and about my own theory, text-orientation, will not grow.

This site remains online because I still feel that text-orientation is the right approach to be pursued. I still perceive the Project Universal Text as the next step to be done.

If you have similar ideas about computing, do not hesitate to contact me.

Updated Sep 5th, 2015: I am currently developing a text engine. See The Text Engine.

UText v. 1.2 Updated

Sun Aug 7, 2011

The third revision of UText v. 1.2 has been released with some bugfixes and a new settings parser.

[Added Aug 14th:] Forth revision published with a bugfix and a new tag [z] in the CMS add-in module.

[Added Oct 15th:] Fifth revision published with two bugfixes and these enhancements:

Change in the *script parser. The result string returned by the script instructions is now fed into the interpreter (it was output to the console).

Selector intersection with * introduced (more).

Some shortcuts added to the file module (more).

[Added Jan 21th, 2012:] Sixth revision published with a bugfix (selectors having dots inside binary data did not work).

[Added Jul 25th, 2012:] Seventh revision published adding time zone support to the tag [time] in the CMS add-in module.

[Added Aug 11th, 2012:] Added the env add-in module for reading environment variables.

[Added Jan 26th, 2013:] Eigth revision published, preprocessing of ^ character now inactive by default (see

[Added Aug 19th, 2015:] Some bugfixes, details in changelog.

Text as Type

Mon Jun 6, 2011

Seen as a data structure, text is similar to the common definition of a data type as consisting of some parts, each havig itself a data type. Each current programming language implements some basic types and allows the programmer to build software on them. The traditional approach has this implicit underlying model:

New Type : Base Type { 
  Child 1 : Type 1
  Child 2 : Type 2

For example, in C there are ”functions“ and ”variables“, in Lisp there are ”lists“ and ”macros“, and in Java there are ”classes“ and ”methods“. A C compiler implements the base types ”function definition“, ”parameters“, ”function call“, etc., and a C program combines them, for example it instantiates ”function“ to define a function ”main“, which consists of some instantiations of ”variable“ that declare variables, etc. The same does a Lisp interpreter and a Java Virtual Machine, the difference being what basic types are implemented. But with this model there must be necessarily some basic types that can only be implemented at language and not at program level. This is because this model is not reflexive, it cannot describe itself: each ”new type“ must base upon some already implemented ”base type“.

The text definition proposed at my book Text-Oriented Software is slightly different:

New Type : Base Type { 
  Child 1 ~ Role 1 : Type 1
  Child 2 ~ Role 2 : Type 2

There is one more degree of freedom, children units do not only have each a type, but they play also a particular role among their siblings, being the possible roles the children of the base type. As a consequence of this, the text is reflexive, that is a text unit can define itself: A unit can have itself as parent, as base type, and as a role. That fulfills the integrity rules. A programming system based on such a text structure is therefore not limited to ”functions“ or ”classes“, it implements just the one type ”text“, the programs themselves can define ”objects“ or ”lists“ or whatever and instantiate them.

Note also that the name ”text“ for such a basic type is extremely clean. If you call your base units ”objects“ you will tend to see programming in analogy with the physical world of objects, that might be useful for example for simulations, but as a general approach it is very limiting. The same with other base types, their ideological load makes them suitable only for particular purposes. The name ”text“ instead is free of bias, because it designates the symbolic structure itself, not what you make or mean with it.

Project Universal Text

Tue May 10, 2011

Now I feel it is time to unveil the whole Project Universal Text. I will obviously not be able to complete it by myself, so I am not anouncing it before doing it. It is just important for me to express the idea of text-orientation, an idea that is so simple and clear to me but, as far as I know, no one else has ever got, and I think a concrete software proposal is a good complement to the prose of my book.

The project passes through some stages until it arrives to a whole new operating system. I think experienced programmers with vivid imagination can realize that such an OS is possible and that it would be extremely powerful.

Designing a text-oriented operating system one rethinks all tools and applications: shell, window manager, editor, spreadsheet, database manager. One finds many commonalitites with already existing software, such as the Unix/Plan 9 file principle, the Lisp programming language, the Emacs text editor. Each of these has an underlying principle that is right and important, text-orientation represents a generalization of these principles that integrates them all in a single one: everything is text, being text not a particular representation such as a character string or a file, but parsed text. This single principle leads to a work environment as Unix/Plan 9, to programming languages as Lisp and to an all-embracing editing facility as Emacs. These are in a text-oriented system not separated, incompatible things, but different aspects and consequences of the text implementation and ways of interacting with it.

The Nature of Lisp

Sun May 1, 2011

Slava Akhmechet wrote the interesting article ”The Nature of Lisp“ that introduces Lisp to people that know other programming languages. It compares Lisp instructions with XML expressions and shows that they are more expressive than languages such as Java or C because of an extensible syntax. Further Lisp macros allow code generation done by the Lisp interpreter itself without supplementary extensions. I think this article can serve as a good introduction to my book Text-Oriented Software because my approach can be perceived as a generalization of Lisp. My approach is not centered on a language but on the underlying general text structure instead and extends this notion not only to source code but to the whole software, including the operating system, and even more in general to anything that a computer processes.

On Natural Language

Tue Dec 21, 2010

Harrison Ainsworth has recently made some considerations about natural language and programming languages. For him natural languages are used by humans for communication purposes, whereas programming languages represent a machine. He also finds unfortunate to use the term ”language“ in software. I think that this line of thought is erroneous and counterproductive.

This approach is erroneous because neither is natural language essentially a means of communication between humans nor do programming languages build machines. Natural language can be used to communicate but it is not restricted to it, for example laws are expressed in natural language and build real contracts between citizens and state constitutions, and the laws of geometry or physics can also be formulated with natural language and represent reality. In addition the idea that when you look at software you see a machine is unsustainable: you see the rules that a machine follows, not the machine itself. In fact both natural and formal languages are exactly the same phenomenon, and the expression ”programming language“ is not a metaphor but literal speak.

But the approach is also counterproductive, because it gets stuck on software implementation. The source code is not an ”implementation“, it is rather an algorithmical ”specification“. Source code is not something ”executable“ but a text that can be interpreted by a machine in many ways.

Develop an OS

Tue Apr 6, 2010

Some ressources are on the Web to help you develop an operating system.

MMURTL v.1.0, a book by Richard A. Burgess documenting how he build an operating system for x86.

The OSKit Project by the University of Utah, a set of components to build your own OS., community around OS development. In German Lowlevel., OS development tutorials.

OS News, including news about new releases from small/hobby OS.

See also:

Open Directory, Programming, Operating Systems

Linux from Scratch, a book explaining how to compile and configure a customized Linux operating system.

[Added 2010/12/22]Genode, an Operating System Framework.


Sun Apr 4, 2010

FUSE, Filesystem in Userspace, is a software that makes it possible to write a custom file system for Linux with an incredible ease.

Look at the simplicity at this sample. The following is a filesystem that provides a single file ”hello“ with the content Hello World!


This is a real sample session:

francesc@pc64:~$ mkdir hi
francesc@pc64:~$ ./fuse/fuse-2.8.3/example/hello hi
francesc@pc64:~$ cd hi
francesc@pc64:~/hi$ ls -al
total 4
drwxr-xr-x  2 root     root        0 Jan  1  1970 .
drwxr-xr-x 74 francesc francesc 4096 Apr  4 07:02 ..
-r—r--r—  1 root     root       13 Jan  1  1970 hello
francesc@pc64:~/hi$ cat hello
Hello World!
francesc@pc64:~/hi$ rm hello
rm: cannot remove ‘hello’: Function not implemented
francesc@pc64:~/hi$ touch xx
touch: cannot touch ‘xx’: Function not implemented
francesc@pc64:~/hi$ cd ..
francesc@pc64:~$ fusermount -u hi
francesc@pc64:~$ rmdir hi

There are even bindings for many higher-order languages including C#, Java, Haskell, Python, and Perl.

The logical next step for a Universaltext System is to serve as a file system for current applications to work with text contents, mapping directories and files to repository queries. This seems now a lot more feasible thanks FUSE.

Web site:

Onward! 2010

Sun Apr 4, 2010

A conference of the ACM for new ideas to be held in Nevada, USA on October 17-21.

Onward! 2010

The conference for new ideas, new paradigms, and reflections on everything to do with programming and software.

There is a call for papers, essays, workshops and films.

Web site:

Plan 9 activity

Sat Apr 3, 2010

Recent Plan 9 activity:

See also this interesting trail at comp.os.plan9, where Russ Cox and Rob Pike explain that they do not use Plan 9 for their work at Google any more.


Sat Apr 3, 2010

Plan 9 seems to stagnate, but its inventors are not inactive. Rob Pike and Ken Thompson are now at Google creating the programming language Go, an experimental systems language designed to be efficient and safe. Keywords: strong typing, concurrent programming, garbage collection. The language is somewhat object-oriented, although they try to avoid some problems of object-orientation.

Watch this video on YouTube

Video (2009): Rob Pike, The Go Programming Language

Official Site:, blog

Hello World:

package main
import "fmt" // Package implementing formatted I/O.
func main() {
	fmt.Printf("Hello, world; or Καλημέρα κόσμε; or こんにちは 世界\n")

Haiku OS

Sat Apr 3, 2010

Just noticed that BeOS is still alive now as the open source project Haiku. It looks nice, a clean, consistent UI and system free of the legacy ballast of the current mainstream systems.

It targets personal desktop computing and multimedia use for the non-specialized end user.

The file system is extended with customizable attributes that are internally indexed and can be queried.

Watch this video on YouTube

Video (2007): Haiku: The Operating System

Hello, World

Sat Apr 3, 2010

Let us start a web log in the proper sense of the word — a web-based log book to keep track of computer-related things, people and thoughts I came across.

Print Contact

Notes on computing.

RSS Feed RSS Feed