Brian T. Rice

• Products
• APIs
• Libraries
• Frameworks
• Firmware, Daemons, Services
• Scripting or Domain-Specific Languages
• Programming Languages

• Forensic Code-body Analysis
• Post-hoc Technical Documentation
• Design Abstraction Discovery
• Recommendations on Technology Roadpaths

• Business Idea Brainstorming
• Business Model Research
• Rapid Product Design and Prototyping Iteration
• Online Social Data-Sharing (Web 2.0) Market Analysis

Slate is an open source programming language whose design philosophy accumulated from my research for Arrow. It represents a hybridization of the object-oriented models of Self with the patterns of BETA, as well as employing the abstract-syntax tree form and closure-based semantics of Lisp and the multi-dispatch semantics of its object system. This allows for some surprising results in unifying programming paradigms. However, not only is Slate a language, it is also an entire programming system philosophy, complete with a graphical direct-manipulation mode and a reflection system. We are currently bootstraping an implementation based on the code resources of Squeak, but with a totally novel run-time system, based on some concepts from Self and Strongtalk.

This project is very far-thinking, and has been a constant source of inspiration since I first discovered it in 1995. However, the goal is only just now visible on the horizon of the state of the art. My Slate and Arrow projects are two different kinds of attempts to further the progress along. I wrote a draft for a new website home page for it some time ago, explaining in the way I could what it meant and what was required to make it happen. If you're curious about it, there is a mailing list and an irc channel #tunes on irc.freenode.net.

I have currently (2003) committed myself to developing the TUNES Project in various ways. My first act was to undertake the deployment and use of a TUNES CLiki to create a more useful environment for accumulating and discussing useful background and explanatory information for the project. This was completed in early 2003, although much work remains.

My second and most current focus has been the development of the main site documentation and description up to the point of providing some attempts at formal specification separate from the main TUNES site. This consists of a technical specification document and some prototype code illustrating the ideas in Maude.

I am generally taking on the role of coordinator there, and my general intent is to bring the project to a point of maturity and demonstrability that will attract some funding or volunteers suitably skilled to bring its target goals to fruition. If you are interested, please contact me; I have a preliminary business license, plan, and proposal that I am developing to contract work for projects such as these, entitled LOGOS Research and Development.

This project builds on two major concepts:

1. That information apart from having signalling and algorithmic aspects, also has a referential structural aspect which can be minimally expressed by the notion of a directed link between two things. In particular, this is without regard to algorithmic constructibility or existence within a state-space (as, say, numbers or symbols). By using such a formulation, numbers and symbols and grammar and algorithmics may be expressed within a uniform framework.
2. By being able to express with the afformentioned atoms the structural content of a complex system and capture its relation to its context, a large system of information processing may be built wherein information transforms (encodings, splits, merges, and renderings) can be shown to preserve information according to a specifiction. Furthermore, if one step can be validated, then a network can be built of such pieces with guaranteed safety from end-to-end.

The purpose of the arrow project is to design and build a system of handling every-day formal and informal information in this significantly novel way. Modern computer science research has yielded hundreds of meaningful distinctions of possible programming semantics and syntax. These include procedural, functional, object-oriented, declarative, and a range of languages that solve higher-order terms in the most abstract sense. The arrow system would perform a networking task for formal languages: it supports a new unified system of understanding computations, data, and formal linguistic expressions in terms of arrow atoms. These atoms have no intrinsic semantics, and so can be applied to use in many differing cases both of semantics (interpretation by others) and syntax (shape and form). However, there are many difficult design considerations when attempting this, particularly keeping the relation of the arrow construct to the various semantics formally understandable and easy to manipulate as needed.

Recently, I am deferring work on this project into my work on TUNES noted above. The conceptual overlap between the ideas is extensive, so there is no potential loss of progress.

Basically, a language (or language system, rather) designed to support the arrow information environment in speech. The intent is to act as a language and concept translation and generation scheme.

So far, no formal documents are yet online, but I will say that the tense system is integrated with a phonetic alphabet, unifies all sorts of inflections, and provides 4096 reference points for inflection of the central grammatical type. The system allows for any speaker to dynamically create new tense systems and meanings. In fact, the goal is to allow anyone to re-rcreate any part of the language, given that it has some meaningful semantic link to an existing form. To facilitate this, speakers would agree on standard forms and parts of forms of the language, and publish them on publicly accessible places like the internet and its future derivatives. This would facilitate sharing of knowledge and specialized terms in a constructive way, which would ease automated translation while allowing each group of specialists to use their own most conveniently chosen forms freely.

The computer revolution that started at Xerox PARC Labs in the 1970's is reborn in a much truer form as an open-source, highly portable, platform-independent Smalltalk-80 system with a powerful set of programming tools as well as some advanced applications and user-interface features that all enjoy the benefits of Smalltalk's dynamic programming system. The development cycle of applications within this project is extremely short due to an enthusiastic user-base and a great sense of community (and of course the development tools and environment).

I have contributed to its:

• Wiki-Web System
• Online package catalog system SqueakMap with in-system application for automated installations and management.
• IRC Channel, which I founded to assist newcomers. Connect to irc.freenode.net and join channel #squeak for quality help in learning and developing on Squeak.
• SIMS ("Simulator for Interactive Mobile Sentients") agent simulation framework, intended as a simulation and game engine framework based on the general qualities of a MOO or the commercial game, The Sims. Primary features:
  • Totally modular AI system and actor construction.
  • Hierarchical logic of places, and mappings to real-world coordinate regions.
  • Full generic use of prepositions.
  • More general than any commonly used Object-Oriented MUD, and of course you can script it in Smalltalk.
  • Uses peer-based processing to manage the complexity of handling large worlds, instead of relying on a central server.
  • Let me know on the wiki what you'd like to see added to the framework, I'll receive automatic email notices.

See my profile on Squeak People.

The Common Lisp community has its own:

• Cliki Collaborative Web
• Directory of projects, libraries, and resources
• Programming Cookbook
• Association of Users

See my profiles on CLiki.net and the ALU Wiki.

Maude is a reflective, executable specifications language based on algebraic concurrent term-substitution (or equational rewrite). Maude is powerful because it is a meta-logic: you can specify the logic of your system without regards to whether it terminates or is consistent, simply by describing the possible inferences or state-transitions with directed equations. What makes this work is that you can specify a reduction strategy in Maude itself. This is far more powerful than other logic languages which perform back-tracking or only give limited control over their own model.

The research demonstrated at the site explains how this can be applied to many different domains that are useful to describing and learning about well-behaved systems and software, even in distributed or systems-software settings.

I was involved with the Maude 2.0 effort, which is GPL-licensed software.

The Strongtalk dialect of Smalltalk was a foundation of the Java HotSpot runtime optimizer and promised an order of magnitude (and quality) of performance improvements, such that it makes the writing of heavily protocol-layered code as economically viable as hand-tweaked manual code.

I am assisting with documentation and look forward to collaborating on applying their VM designs to other Smalltalk dialects, as well as contributing back to the organization of the user-land libraries.

Here are some fascinating topics you may like looking into. Truth and beauty were what people used to talk about mathematics. I believe in the beauty part, but only the truth part inasmuch as Heidegger's concept of aletheia as truth.

• Topology (Set-theoretic and Combinatoric), Network Theory, Combinatorics (various applications), Graph Theory, Knot Theory.
• Linear Algebra, Tensors, Vectors and Matrices, Inner and Exterior Algebras, Group Theory, Galois Theory.
• Geometry (Euclidean, Bolyai-Lobachevsky, Riemannian, ...), Homology Structures, Curved Spaces.

Atomic Logic, Axiomatic Semantics, Operational Semantics, Formal Language Theory, Model Theory, Category Theory, Substructural Logics, Arrow Logic, Linear Logic, Reflection.

Despite all of that formal logic and notation in the previous section, I generally have a very human and almost poetic perspective on things in general. In fact, I consider it essential to me that I bring these together.

The Stanford Encyclopedia of Philosophy is a great resource for a broad picture of philosophy and logic, as well as some decent explanations about the fields. Naturally very little of this can appeal to the average interest, but it's the place to go when you have just enough interest to look.

Philosophers or psychologists whose work I've found to reflect what I always thought most natural:

• Martin Heidegger (not for his Being and Time, but Introduction to Metaphysics, On The Way to Language, and even What is Called Thinking?)
• Friedrich Nietzsche, for many varied thoughts that helped define a century.
• Lev S. Vygotsky (for Thought and Language and Mind in Society).
• Lao Tzu, and many others, who made the great corpus of work behind what the modern world calls Taoism.

Mechanics, stress computations, aerodynamics.

Languages:

Practical:

Smalltalk, Lisp/CLOS and Scheme, Javascript/CoffeeScript/Coco/NodeJS, ANSI C/C99, C++, Objective-C, C#, Java, Pascal, Basic.

Familiar:

Beta, Forth, Haskell, Perl, ProGraph, Oberon/Juice, Maude, Self, J, ML, Clean, Joy, Erlang/OTP, Ada.

Assembly & Machine Code:

Intel 80x86 family and Pentium series, IBM PowerPC family (603e and 750), Motorola(?) 6502 and 65c02, Motorola 68k, Sparc 9, Alpha, MIPS.

Software Environments:

• AppleDOS, MS-DOS, DOS4GW, Windows 3.1, 95, 98, NT
• Linux, FreeBSD, BeOS, MacOS 8.0 - 9.1, NeXT and OpenSTEP, Mac OS X
• Language-based platforms are a particular favorite: Symbolics, Inc. Genera Environment for Lisp Machines (I personally own a MacIvory II), Squeak Smalltalk

Design Principles:

• Refactor a Program into its most natural and practical Ontology in small tested steps.
• Use design patterns to document and communicate ideas. Turn them into actual programs themselves when possible.
• Program functionally when the need arises.
• Use Reflection and partial evaluation whenever the costs are amortized.
• Use the right language for the right job!