Old Max Blurb

The below description may not remain accurate but is kept for reference.

TUNES

I think of TUNES as a standards platform; an interface that should act the same on every computer system that implements the standard. The standard would be created collaboratively through the TUNES project. TUNES will be a standard for a complete computing system where the source code to any running program is easily accessible and modifiable on the fly; in a word, reflective.

Max - A Framework for Reflection

Description and Scope

Max is a specific architecture designed to implement the principles (formerly called requirements) set forth by the TUNES HLL project. As such, Max should be perfectly suitable as the underlying system used to implement any other features desired by the TUNES project. However, Max's scope stops at the minimum requirements to implement the principles, for two reasons:

1. The newer HLL Definition was not written until after Max was already a fully-formed concept. That document is unnecessary for implementing Max.
2. I'm creating my own complete operating system based on Max. I have a lot of ideas for programs to write, but it would take too long to write them all with the current state of software development. I'm creating Max to allow me to create other programs using a method of specification similar to the way I think. I designed Max to work as the core of my OS because I know what my OS needs to have. I need complete freedom to make all design decisions for Max and my OS because otherwise it wouldn't be mine.

   On the other hand, TUNES does not have a design for an OS or for a core system, and I do not care to try to convince anyone that my design should be called TUNES (especially since my design hasn't been proven to work yet). Since my work is released publically with no restrictions (License heading below), members of TUNES are, and anyone else is welcome to make changes, add features and re-release it under any name they wish. It's more important that Max simply get finished. If I succeed, then members of TUNES can adequately evaluate Max and determine what relationship they wish to pursue with me. Until then, I'm in coding phase since I believe I have enough ideas to work with for now.

An integrated system

The essential idea is that existing software systems don't operate well together because the programmers thought their mission was to create narrowly-defined, specific behavior. Of course systems don't work well together when they weren't designed with that goal in mind. I intend to fix this with Max by thinking about the bigger picture the entire time: for each component, it must incorporate cleanly into the overall design. Max will be the center piece of the computing system; the core, which every piece of software will be integrated with, and through this core, all the other software that integrates with the core. To integrate software into Max, you use Max's type system for all your data (which should be expressive enough to include any type from any other language), and Max's flexible data flow specification system for all your code. The specification system connects components together using types, and should be expressive enough to support any language paradigm such as functional, procedural and declarative. Max will include a dynamic compiler that looks at the specification to generate code and schedule it for execution. The input specification to the dynamic compiler is integral, and its output is integral if it does its job in implementing the specification. Reflection is accomplished by having the DC running at all times and updating the implementation based on changes in the specification.

Efficiency

I believe a usable computing system based on a dynamic compiler is possible efficiently on current hardware, because reflective systems are inherently more efficient than non-reflective systems. My definition of efficiency is "how long it takes to do what the user wants." In the case when the programmer is a different person from the user, there will nearly always be impedance mismatch between what the programmer wrote and what the user actually wants done. There is nearly always inefficiency, therefore, unless users have the ability to adapt programs to their own needs. Reflective systems are adapted to just this goal, and therefore reach the highest possible efficiency according to my definition. The user in this case is me, and I want to create elegant, transparent, revolutionary code.

Features

• Pure functions. Any side effects will be explicit, and won't be called functions.

  Version 0.1: functions specified by listing tuples explicitly, and builtin functions implemented in LISP.

• Data-flow evaluation model. An evaluation frame consists of a function with all arguments fully specified, and a data sink to accept the result.

  Version 0.1: can build expressions from the bottom up and evaluate them

• Strong typing. All functions have an explicit domain and codomain.

  Version 0.1: Enumerated types, "infinite" types implemented by CLOS instances

• Expressive type system. Types can be created by combining other types using product, sum and quotient operators.

  Version 0.1: Product and sum types are present

• Generic functions

  Not in Version 0.1

• Partial evaluation

  Not in Version 0.1

• Persistence. Max treats all data as the cached result of functions. A persistent value is simply a continuation to write it, paired with a function to read it. Thus persistent values can be inserted anywhere in the evaluation process.

  Version 0.1: None, nothing worth saving

• Abstract addressing. There is one unified reference type in Max (currently called an address). All addresses and operations on addresses are fully opaque; the client of an address does not need to be aware of the underlying representation of the address. This is accomplished by allowing the address space to metaprogram its clients.

  Version 0.1: Several address types implementing ADTs demonstrate use of the unified addresses