The people   Coding standards   Design   Rewrite rule   TODO   DONE   Sun Java  

Javadocs   Class Hierarchy   Index   NAWS   MTRX   security   servlets   Skang   Squeal & Stuff   zen developer  

TODO

The following is some developer notes on what needs to be done to the entire system. Note that I may have done some of these already, and forgotten to update the document. This will be fun, the internals are not documented much. In case it's not mentioned elsewhere, dropping a file called "TESTING" into the matrix-DFS directory will turn on a boolean called "isTesting", which can be used to enable or disable things during testing. Redirection of STDOUT and STDERR to the bottom widgets is one thing that is disabled during TESTING.

While Java (with C for JNI) is the official language of matrix-DFS, early development of any particular part can be done in whatever language is convenient for the programmer at the time. Whatever language is used for early development, it MUST be translated into Java before any real release. The Java MUST be made as portable as possible before the second release. Java 1.1.5 MUST be used. Support for Java versions less than 1.2 will be dropped after 2008.

If you ever stop and ask yourself "What the hell was onefang thinking?", then have a good read between the lines, and you may discover what the hell onefang was thinking B-).

Eric Raymonds "The cathedral and the bazaar" and related works, in particular the book version, should be used as our "open source development bible".

Make matrix-DFS RFC 3271 compliant (The Internet is for everyone). RFC 1958 compliant (Architectural principles of the Internet).

Latest generic RFC's to conform to - 3365, 3339, 3272?, 3254, 3238, 3237, 3235, 3234?, 3184 (probably broken it already), 2223, 2119, 3157?, 3150:4.0, 3148?, 2026, 2306, 2434, 2277, 2506?, 2611, 2717, 2964.

Other RFC's of interest - 3205, 3156, 3135, 3117, 3081, 3080, 3040, 3143, 2659, 2616?, 2648, 2504, 2397, 2388, 2384, 2345, 2245, 2186, 2169, 1925, 1727, 1287, 1281. Add RFC 2550 to Watch. Add a RFC 1437 viewer B-).

New RFC's of interest - 3401, 3402, 3403, 3404, 3405, 3406.

matrix-DFS is currently undergoing a massive ro-organization and split up, including many code reviews. It's still a bit of a mess at the moment though. A recent employer said that my Java skills are second to none. I write better than this, I promise B-). Most of the recent stuff has been just a brain dump, get it working and move on, sorry, hope it makes some sort of sense. Lots of little hard coded things sprinkled throughout.

I'm probably trying to recreate a few things that exist in Java already. During a recent code review I found out that I had duplicated the exception system, so I rewrote it to use actual exceptions. Other things I might be trying to recreate, and which should be the subject of later code reviews - beans, RMI, listeners, name space management, media framework, factory methods, the schedular, etc. On the other hand, some of that stuff is so loosely defined that everybody does it different, and you are better off doing it yourself than trying to work around all those differences. Since I'm just doing a quick brain dump into Java of all the recent stuff, recreating things is often quicker than trying to figure out how it works B-).

Some of this stuff we are duplicating coz while the 1.2 version works well, the 1.1.5 version still sucks, and that is what everybody is using.

The other major thing we are probably gonna recreate is the entire XML morass. Note, this is a seperate issue from the actual XML support we will need for Ant, Jabber, and Servlets. XML is a nightmare, looking worse every day, and specifically for business. matrix-DFS is for the masses, and needs to be efficient. Let the commercial world stick with their typically bloated procedures, it's what they are comfortable with. Also note that the transmogrifier can reduce XML bloat.

I now use ANT to build and create distributions. Due to a bug in the way I used to create distributions, and during my recent dump everything and start life over, a version that was archived with Distribute.class was all that was available, and some of the images got currupted. Java provides no access to file permissions, so the dist ANT target makes copies that have standard permisions (no execute for instance). A good place for some JNI, keeping in mind that a file browser is planned. Under Unix, ANT can use chmod to restore permissions, and my build file does that for the install target.

Client users should have a one button install, and it should do NO MODIFICATIONS to their system, except to create an icon on the desktop and dump everything in a directory. We should push this feature as part of the security - "matrix-DFS will not modify or screw with your system, so your OS remains stable". There are some things which will screw with the system, like auto install of the proxy stuff, these should be manually started processes, that carry big warnings.

Install web page / skang module. Web page displays skang module, which points user at OS specific download bundle, instructs them to download it, unpack it, and run the INSTALL executable (INSTALL.sh, INSTALL.BAT, INSTALL.EXE, whatever). The OS specific download bundle contains the INSTALL executable, and matrix-DFS.jar, which everything can now run out of. Install web page includes links to downloadable JVM's for as many different OS's as possible, but only as the applet ALT content. Install skang module has generic instructions and a downloadable matrix-DFS.zip for OS's without a specific download bundle. Main matrix-DFS host site should have downloadable JVM's for as many different OS's as possible.

We should write an apache 2 mod_matrix to use the matrix protocol, which could actually be the only apache 2 tranport protocol ever written, since our own transport modules will do everything else automagically B-).

matrix-DFS should be made to live entirely within it's own jar file, then the user doesn't have to extract anything. The install procedure can copy OS specific script files out of the jar file for startup purposes, and user specific properties / skang files residing outside should override whatever is found inside the jar. Then we can start joking about letting genies out of jars and such.

Setup autoproxy config files for the proxy, later have matrix automagically grab previous proxy settings from legacy browsers.

A fancier splash screen to distract the impatient.

Start with UberMatrix, but with few, if any, Scrolly's.
    Move to a new class (Splash.java).
    Remove Graphling, fortune, sniff, etc.
    Add those bits of What that are needed.
    Subclass UberMatrix from Splash.

Add Scrolly "Boot strapping matrix-RAD".
Boot strap matrix-RAD.


@_LABEL_@


Add a few random Scrolly's.
Add all output and error as Scrolly's.
Add executing Skang commands as Scrolly's.
Add all server responses as Scrolly's.
Add text of widgets as horizontal Scrolly's.
Add images for widgets as Scrolly's.

Current module Scrolly is white, changing to a random color when finished.
One Scrolly per module that morphs as needed -
    net.matrix_rad.booker.Booker - Loading module
    net.matrix_rad.booker.Booker - Loading extension
    net.matrix_rad.booker.Booker 0.1 prototype Copyright 2004 David Seikel
    Booker 0.1 prototype Copyright 2004 David Seikel
    Booker 0.1 prototype Copyright 2004 David Seikel - Loading properties
    Booker 0.1 prototype Copyright 2004 David Seikel - Loading skin Booker.skang
    Booker 0.1 prototype Copyright 2004 David Seikel - Loading skin Header.skang
    Booker 0.1 prototype Copyright 2004 David Seikel - Loaded

When ready -
    Set widget Scrolly's to move to proper row at next wrap around.
    Set all others to vanish at next wrap around.
    Accelerate all Scrolly's.
    When widget Scrolly's get to their final position -
	Stop.
	Draw rest of widget graphics for that widget.
	Activate it.


When loading a new skin that starts with "clear" -
    Remove rest of widget graphics.
    Start current widget text/images as non widget Scrolly's.
    Add all module Scrolly's as they last were.
    Morph What.me module Scrolly -
	Booker 0.1 prototype Copyright 2004 David Seikel
	Booker 0.1 prototype Copyright 2004 David Seikel - Loading skin Admin.skang
	Booker 0.1 prototype Copyright 2004 David Seikel - Loading skin Header.skang
	Booker 0.1 prototype Copyright 2004 David Seikel - Reloaded

    Goto @_LABEL_@.

The exception handling currently only uses SkangException, although several others are defined. SkangExceptions must currently have a two digit error code at the beginning. These error codes are defined in the Skang docs, note that they all start with "-", so they are really only one digit. When we are using the other Exception types, the two digits can go away, they are just a temporary thing to pass the same info.

I suspect that reflect.getDeclared*() and reflect.get*() act differently in different JVMs. That part needs a code review.

isValid() should set an isValid boolean in the widget object, and the invalid widgets should have red backgrounds, or other similar visual cue. An error message explaining what is wrong should also be set in the widget object, and displayed in ERR during widget hover, also in red. POST should refuse while postable widgets are invalid. Should also use isValid() for parameters, complaining and ignoring invalid parameters. Will need to solve the repeat parameter parsing problem mentioned above to avoid complaining about them many times.

Javadocs are supposed to be programmer documentation, but I've been using them as user docs. So, add a @.userhelp tag. First sentence is tooltip / status line help, the rest pops up in the help browser. The current "browse to package/class.html" should be expanded to "package/class.html#Thing.name". Have javadoc create these HTML files, naturally.

Change to the Java 1.5 Annotation Processing Tool -

DECLARE

@Documented
@Retention(RetentionPolicy,SOURCE)
@Target({ElementType.TYPE, ElementType.METHOD, ElementType.FIELD})
public @interface Secure
{
    String value();
}

@Documented
@Retention(RetentionPolicy,SOURCE)
@Target({ElementType.TYPE, ElementType.METHOD, ElementType.FIELD})
public @interface Owner
{
    String value();
}

@Documented
@Retention(RetentionPolicy,SOURCE)
@Target({ElementType.METHOD, ElementType.FIELD})
public @interface Name
{
    String value();
}

@Documented
@Retention(RetentionPolicy,SOURCE)
@Target({ElementType.METHOD, ElementType.FIELD})
public @interface Help
{
    String value();
}

@Documented
@Retention(RetentionPolicy,SOURCE)
@Target({ElementType.METHOD, ElementType.FIELD})
public @interface Shortcut
{
    char value();
}

@Documented
@Retention(RetentionPolicy,SOURCE)
@Target({ElementType.TYPE, ElementType.METHOD, ElementType.FIELD})
public @interface Skang
{
}

@Documented
@Retention(RetentionPolicy,SOURCE)
@Target(ElementType.METHOD)
public @interface Params
{
    String[] value();
}

@Documented
@Retention(RetentionPolicy,SOURCE)
@Target(ElementType.FIELD)
public @interface Required
{
}



ANNOTATE

(@Skang is not needed if any of the annotations listed above are used, they imply @Skang.)

/** matrix-DFS front end.
 *
 * @author David Seikel
 * @.copyright 2001 David Seikel
 * @version 1.21 2003-09-01 01:49:00
 *
 * @.requires Java 1.1.5.
 */
@Skang
public final class Matrix extends Skang
{
  ...
}


  /** Do something with data.
   *
   * @param aName of the Thing we are processing
   * @param aBlah The data we are processing
   * @throws IOException if an input/output error occurs
   * @return int number of sub datas found
   */
  @Skang
  @Secure("SSS")
  @Owner("Owner")
  @Name("something")
  @Params({Skang.NAME, Skang.DATA})
  @Help("User friendly help should go in here.")
  public int doSomething(String aName, String aBlah)
    throws IOException
  {
    String result = "";
    ...
    return result;
  }
  

  /** Some parameter.
   */
  @Skang
  @Required
  @Shortcut('p')
  public String parameter = "Default";



APT

cd matrix-RAD
apt -classpath "...:." -sourcepath src -d . -s src -factorypath net/matrix_rad/skang -factory SkangAPTFactory -Aversion="${app.version}" -nocompile **/*.java

If source file MDATE is later than build.xml->app.version
    If @version->date is ealier than build.xml->app.version
	Update @version->date in source file.
	Add 0.001 to @version->number in source file.
@Skang on a class means we create a Skanglet for it.

/** First sentence.
 * @author David Seikel
 * @.copyright 1999 David Seikel
 * @version 0.72 2004-11-19 14:40:00

Font and Textfield sizing seems to be a moving target. First, look for a JVM/OS specific FontDetails.class, and ask it for details. If that isn't found, or when the user asks for it, do a calibration. The font calibration routine first allocates a bit plane of ten times the size it thinks the font is and fills it with white. Then it prints the first 256 characters in the middle, overlapping each other. Finally, it scans in from the edges to find out how big the font really is and the baseline, etc. Textfield calibration must first use the pixel scanning technique to find characters that will go to the edges selected from the usual suspects (!|\/_$%#ypgj{}?wmWM). Then starting from the the bare minimum size (max font height), add widget of that size to big blank canvas, scan it to check if all of the text is visible, and increase the size by one to try again if not.

I thought of doing something similar to find invalid characters for UberMatrix. The JVM/OS specific FontDetails.class can either use the 1.2 API if available, "just return valid" all the time, or do a pixel by pixel compare to a known invalid character. Pixel by pixel compare will be very slow, so we need to cache results and/or do the compare at the beginning. The main problem with that is that the old computers with ancient JVM's that are likely to need this won't have the RAM or performance to spare, hence the "just return valid" option. For the "Font Challenged", "just return valid" only for 8 bit ASCII, all others are "invalid".

Actually make use of the parameter stuff in the SKANG array.

Make everything public in a class a method or feild Thing, and do away with some parts of the SKANG and USAGE arrays. For access to private stuff use Javabeans style getX(), setX(), and invokeX() but access them via get("X"), set("X", ), and invoke("X", ). This allows data hiding when needed without the overhead of method calls for changing the majority of stuff that doesn't need it.

Make the parser understand method types and signatures.

We now have SkangAWT, we need to write SkangSwing etc. This gives us independance from the widget set, so that I could write my own widget set. Then skang files can just include the module for the widget set they want to use. This will make life easier when porting to handhelds and mobile phones. Just found out that reflection is back into J2ME, time to try porting it again. That seems to be a rumour, I can't find confirmation from Sun.

A bit more support for reloading skang files and multiple windows is really needed. All the Thing code should be made late binding, so that a module can set the value of some Thing before it gets created. Carefull checking of concurrency issues still needs to be done. Testing on non SuSE 6.4 linux platforms has not really been done, I've run it a few times under windos is all. On the other hand, BPC_NO and earlier versions of Skang have been extensively tested on as many OS / JVM combinations as I could get, and are very portable.

If the name of some Thing is passed as an argument, find it's object and pass it along as an argument to the Command.

Extend the skang command with replacable parameters -

TestWidget=skang file.skang arg1 arg2 arg3

// This is a skang subroutine!
set DebugWidget 'Our name is %0' // Just cause Java doesn't B-).
set SomeWidget '%1'              // arg1 goes here.
action OtherWidget '%2 %3'       // arg2 & arg3 go here.
get ReturnThing                  // return a string value.

action Widget1 'Widget2=get Widget3'

define sub1 'name,data,action'
get %1
set %1 'The data is - %2.'
action %1 '%3'
end sub1
oldGrid1=sub1 Grid1 'some data' 'skang'

{ Widget aName Button
  @0 _1 20 100                 // Position and size
  ='Text.'                     // Widget text
  >dosomething                 // Action
  ?'Help text'                 // Help text
  ]1,2,3,4 5,6,7,8             // Colours
  #'normal.gif' 'pic2.png' 'pic3.jpg' 'pic4.png' 'pic5.png'  // Later ones are optional
  >'dosomethingelse'           // Optional alternate action
}

{ Widget aName TextArea
  @0 _1 20 100                 // Position and size
  ='Text.'                     // Widget text
  +'Another line of text.'     // Optional
  +'Yet another line of text.' // Optional
  >dosomething                 // Action
  ?'Help text'                 // Help text
  ]1,2,3 5,6,7                 // Colours with no alpha
  #normal.gif 
  #'pic2.png'
}

{ Widget aName Tree
  @0 _1 20 100                 // Position and size
  ]1,2,3                       // Background colour
  ='Text.'                     // First text
  >dosomething                 // First action
  ?'Help text.'                // First help text
  [5,6,7                       // First foreground colour
  #normal.gif                  // First image
  +'Another line of text.'     // Second text
  >dosomethingelse             // Second action
  ?'Help text.'                // Second help text
  [8,9,1                       // Second foreground colour
  #pic2.png                    // Second image
  +'Yet another line of text.' // Third text
  >dothing                     // Third action
  ?Help text.                  // Third help text
  [2,3,4                       // Third foreground colour
  #pic3.jpg                    // Third image
}

{ Stuff net.matrix_rad.whatever.SomeStuff "SELECT foo FROM bar"
  // First, the meta data
  +name|substuff|meta,data|acl
  +name|substuff|meta,data|acl
  +name|substuff|meta,data|acl
  // Then the data
  =field|field|field
  =field|field|field
}

• @.nowidget - Action gets no widget.
• @.above @.topof name - This action goes above the named action.
• @.below @.bottomof name - This action goes below the named action.
• @.leftof name - This action goes to the left of the named action.
• @.rightof name - This action goes to the right of the named action.
• @.offset - as per new offset command.
• @.tell - Hard code the details for this action as a "tell" command.
• @.command - Hard code other skang command.

• 0 - do the default (left, top, full width, one character high.
• x - pixels from left, from top, wide, high.
• _x - characters from left, from top, wide, high.
• -x - pixels from right, from bottom, subtract pixels from width, subtract pixels from height.
• _-x - characters from right, from bottom, subtract characters from width, subtract characters from height.
• x% - percentage of total pixels from left, from top, wide, high.
• -x% - percentage of total pixels from right, from bottom, subtract % pixels from width, subtract % pixels from height.
• _x% - percentage of total characters from left, from top, wide, high.
• _-x% - percentage of total characters from right, from bottom, subtract % characters from width, subtract % characters from height.
• + at end - expand / contract to fill.
• - at end - relative to what's left rather than relative to total.
• ^ - above last widget.
• v - below last widget.
• < - left of last widget.
• > - right of last widget.

FORMS backup.

• Allow Resume.java access to its SQL data somehow.
• Generalize the above, if the data is part of the applet, then security is pointless.
• Compare our ACL's against POSIX ACL's, they suck but conversion may be possible.
• Sanatize all network traffic.
• Call the user module Human.class.
• Call the non-user module Puter.class (for access by non humans).
• Call the corporate module Suits.class (for corporate details).
• ParanoidFascist.class will recheck the Who credentials every time.
• Things like Squeal should recheck the Who credentials every time.
• Do a quickie security review.
• Do a real security reveiw B-).

• secure name boss acl

• table name owner acl (table members id 'RW-~,---,RW-admin')
• Owner is what field identifies the owner of the row.
• ACL is the default ACL.
• Any field not explicitly mentioned gets the default ACL.
• field table.name acl
• id R--~,---,RW-admin
• name R--~,---,RW-admin
• firstname RW-~,R--,RW-admin
• lastname RW-~,R--,RW-admin
• aproval_date R--~,---,RW-admin

RFC 2616 HTTP 1.1. RFC 1867 multipart/form-data definition. RFC 2025,2046,2047,2049,2049 MIME messages.

Big security problem with Servlet standard for deploying servlets, the damn things are visible on the web! Same with web.xml. Extra security has been added to the apache and tomcat configs to help solve that. Tomcat seems to solve it, but you can't rely on that.

Servlets can be run two ways - by a servlet engine, or by the CGI wrapper. The CGI wrapper will convert CGI environment variables to a command line, and pass STDIN and STDOUT to the servlet.

The tomcat servlet engine can reload a servlet from the ANT reload task, we should get the matrix-DFS web app servlets to reload themselves if their class file is newer.

Add a CLASS_ String CLASS_ACL for the modules default ACL, use this for Squeal's default ACL of "SSS". NOTE Resume run as an applet uses an applet based Squeal, so it will load Squeal with a different ACL ("rwx").

Applets scan through their modules Things looking for servlet ACL's, if they find any, then mark themselves as servlet based applets and "post ..../applet.svlt?do=load package.applet". NOTE some Things may never be used, and we don't want to be marked as servlet based if we never use them. Guess we could only invoke "servlet based applet" mode when we hit the first servlet ACL. Applications can explicitly set themselves into "servlet based applet" mode and should then act like applets.

The Master servlet responds to a load command by loading the module into a (possibly newly created) ThingSpace and attaching that to a (possibly newly created) session. Authentication should probably be triggered now if the user has not already been authenticated. NOTE ThingSpaces are per session, and sessions are per user, thus every module a servlet loads for a user gets added to the same ThingSpace via that users ThingSpace.

Later, the applet is instructed to post some stuff, including a possible "do" list of skang commands. Master intercepts these, grabs the ThingSpace from the users session, processes the params + "do", then returns the results. "do" strings can include EOL, cause they get encoded. Should experiment to see if POST file stuff is supported by servlets, even if it isn't, support it from TeenyWeb.

Servlet and Applet keep track of changing Things, and send differences. Both ends have a "dirty" bit in every Thing, set the dirty bit when you change it yourself, clear the dirty bit when the other end sets it. At transaction time, send skang for each dirty Thing.

The pendingDoThing methods should add a structure to the ToDo vectors instead of just the command. The structure will include details of who is trying to run the command. Be secure, we don't want people using this as a back door by pending Things before authentication to be done after authentication.

Some method of preventing the user from running multiple instances of the same ThingSpace should be used. The servlet spec says that all user windows must be assumed to be the same session.

Adding a serialize Skang module for sending Java objects across the net should round out servlets.

Streaming skang.

"Zen developer, if you sit and stare into space, inspiration will come; if you wait long enough, it will write itself." When the coder is in the Zen editor, just sitting and thinking, maybe moving the mouse slowly (in a mandala pattern even), go off and get the API summary of the current word, and display it tooltip style. Do the same for the words around it, expanding slowly outwards to cover the whole set of words currently displayed in the editor. Start expanding the summaries to a paragraph or two. If full articles are found, add them as links in the summary tooltip. Search the current project for similar patterns, and display them, then go out and Google search for appropriate open source snippets. The coder can indicate that some of these ideas floating in front of her are completely wrong, so ignore those paths of research and concentrate on the rest. Have the tooltips in a variety of pastel colours, and drift them around slowly. Eventually, if the coder waits for long enough, the solution will present itself. Allow modular search algorithms, and drift patterns. This is called "Zen contemplation mode". Just keep getting fancier.

Together with the "instant compiling in the editor" mentioned in maintainable.html, we can use genetic algorithms to search the code space for the current problem if the coder is quietly contemplating the code as mentioned above. We could use RFC 2795 to help implement this B-).

TeenyWeb needs to be made into a module, and then used to serve the help files and be the proxy. TeenyWeb will mostly be used to serve local help files, as a transport agent between two clients, and as the HTTP proxy. Other transport agents should be added, TFTP and FTP at least. A modular transport agent system should be invented, as this is one of the major matrix-DFS things needed. Someone may want to implemet XYZmodem across the net and add them as matrix-DFS transport agents.

matrix-DFS aware servers should tokenise the input from non-matrix-DFS aware clients, so that it always interprets the tokens. Call the tokeniser "Transmogrifier".

One other major matrix-DFS thing needed that TeenyWeb can help with is the matrix-DFS aware HTTP proxy. It will sit between the users normal browser and the web (or their ISP's proxy) and intercept all transfers to matrix-DFS aware servers, implementing the matrix protocol instead of the usual HTTP. Then we can advertise it as speeding up legacy browsers B-).

Once we have browsers using matrix-DFS aware proxies, we can implement the alternate root servers hack. The "official" Internet root servers have put an artificial monopoly on the host name space. With three letters, a lot more combinations are available other than .com, .edu, .gov, .org, .net, and .mil. It took the Internet authorities many years to agree to add a few more. I wont even mention names longer than three letters. There are unoffical root servers out there that split up the rest of the enormous name space that has otherwise been wasted. With requests going through our proxies, we can implement a DNS system that not only uses these alternate root servers (and the official ones of course), but can automagically add more root servers as they become available. Some mechanism for dealing with name space collisions will be needed. Naturally we should have our own root server managing the .matrix space B-). Should chuck in the Anarchadian name space .ia or .aa. Two letter names MUST be reserved for country codes, although three letter country codes may be used in the future.

NOTE - RFC 2826 seems to be an official excuse to keep the monopoly on technical grounds. I don't disagree with the technical issues, just the political ones. The Internet authorities have all they need to remove the artificial monopoly, except the willingness to do so. On the other hand, probably should make alternate root servers adhere to RFC 2870, except for requirements to be authorized by IANA and such.

The local matrix-DFS aware proxy can also be the local firewall / IDS, with browser / skang controlled servlets (listening only to the local machine) allowing control of not only the firewall, but other net stuff. Then we can add controlling the computer as well (webmin style). Filter virii and spam out of emails, popups out of porno sites, banner ads out of commercial sites. Filter these things by not downloading if at all possible (matrix-DFS aware server should have already classified these and informed the client). The local proxy can also enable the use of PGP signed SSL links and PGP signed applets, and all those other things we wish the major browsers allowed. Local proxy can fix broken web, mail, FTP, etc clients & servers. It can also automatically setup your ISP's services and stuff, being an ISP's front end, giving us another vector for spreading matrix-DFS. Firewall, IDS, filters, usage meters; matrix-DFS making the net safe, fast, and fun!

The above mentioned proxy stuff is the same as the fancy "proxy can rewrite ANY web page" stuff that I developed for schoolsnet. Be very careful to make sure that the USER / SURFER is always in control. This differentiates from schoolsnet where the ISP was in control. The other major difference, schoolsnet had only one real goal, we have lots. While this paragraph borders on breaking my schoolsnet NDA, any web savy user of their proxy will figure out what is going on, and that will include about half of the 6000+ school kids that use it.

Split of the actual http file transfer protocol, just as an example.

Add /dev/null.

Write a Squid module.

The network checking code in BPC_NO needs to be split off into a module. Since BPC_NO is a separate project, and it needs to be very robust, it is probably a good idea to keep it in BPC_NO as well in an unchanged state. The same goes for BPC_NO's debugging system. IPScan was origanally given to me for inclusion in BPC_NO, it needs to be included in the module system somehow, it is currently stand alone. A builtin DHCP client makes the IP scanning part of IPScan obsolete, as we are now the first thing to find out about IP changes, but the DNS updating part will still be relevant, especially when we implement our alternate root server hack.

The network checking code could be used to check the health of TeenyWeb B-).

The throbber should become a general health indicator. If the network checking code figures out that a whole country is down, then we should change the color of that country to red or something, maybe transparent. If any module has a problem, the rotation should be retarded one frame, that way minor problems will slow the world, major problems will stop it turning, and fatal problems will have it spinning backwards rapidly. If the world starts spinning backwards rapidly, then you are obviously in deep shit B-). The world melting down means "Death of the Internet, film at eleven.".

(You will note a little cartoon of me (onefang) in the lower right corner, kindly watching over what the user does. I will either smile B-) or frown B-( [currently alternates every time "Copyright" updates]. runestone has the job of modifying that so that we have finer granularity. onefang helpful, smiling, waiting patiently, tinkering, frowning, concerned, worried, very worried, panicing, fleeing in terror. The user is strongly advised to flee in terror long before onefang does B-). Whatever you do, don't turn me into Clippy.)

The network health checking code needs to be explained a bit. The intention is to have it perform two tasks. Check the health of the network by regularly trying to connect to some servers, if they are all down, the network is down. The other task is to regularly check those things that the user wants to check. Check for new email from your email server/s, check for new news from your favourite news server, check web pages to see if they changed, check time servers to keep your clock sync'ed, check for updates to your matrix-DFS modules, etc. This second task gives us some servers to check, and stops us from banging away at the same servers constantly by EVERYBODY. Most of those would be local servers run by your ISP, making them quick and reliable checks of the network that keep traffic on the whole net down, if you can't talk to your ISP, the network is REALLY down.

When checking the network to see if a whole country has gone down for the purpose of displaying the correct thing on the throbber, DON'T have the client do the checking, it's a server job. Say some australian sheep farmer digs up one of Telstra's main cables with a back hoe, the last thing the australian network needs is twenty million internet users from all over the world constantly checking a variety of servers just to see if they are up. If a client suspects that sort of problem, inform their local matrix-DFS server, a search party of servers will then go and look for the alleged MIA country, report back to all the other servers, which will in turn report this info back to ALL clients. That way we wont even have twenty thousand servers knocking on the door asking 'You right mate?', only twenty, and Telstra can use their limited remaining bandwidth to route around the problem until they find the offending farmer.

The throbber should also display the users current network links on the globe, using lat/long info from DNS servers. If this becomes popular, then maybe host admins will pull their finger out and add those details to their name servers. The network link display should be as informative as possible. Use colour coding, ant animations, and line thickness. See the UI prototype image for an example.

The throbber should display day / night shadows, with city lights in the currently dark section of the globe, probably linking the lights to the network health checker.

There are two major systems used to identify file types, MIME and magic. MIME types are used extensively on the Internet, and our web server has to support them, usually it is based on file extension. Magic can identify file types based on their contents, and is extendable, but DOESN'T return a MIME type. I'd love to get magic to return MIME types. We should extend the MIME type definition to support that, and to support file type associations in an RFC style. Any particular file association should be able to handle having multiple modules. display/image/png for instance could have half a dozen modules on any particular users system, with only one as the designated module, the user should be able to easily choose between them at any time. Apache seems to have extended magic in the way that we need.

Then we could extend the MIME types to transport protocols and stuff, giving as an extendable system for finding things. At this point an example may clarify things.

A windows user uses matrix-DFS to access a new file, the URL specifies a transport protocol that their matrix-DFS doesn't already have called new.

new://host.com:2784/file.blah

Wrap Jabber compatible XML around skang files.

Do the Jabber OOB stuff.

Figure out the JabberBeans.disconnect() and presence problems.

Put a Jabber (1.4 at least) server up permenantly and point the default properties files at it, so people have some place to go when they first fire it up, and people have some place to go from our own web served version. Put up our own web served version, preferably served by matrix-DFS itself off course B-).

An IRC version of Yabba should be written, and called Yabbi. Yabbies are an australian shell fish that is eaten often by australians. I'm not into shell fish, but I will probably get tired of lizards B-). Yabba needs to be completed as an example / basic client. Don't add anything fancy, remember it is an example. Fancy stuff can be written as a Skang module that uses Yabba as the basic Jabber transport mechanism. The registration and subscription stuff is mostly what needs finishing. A similar client that talks to unix "talk" and it's variants should also be designed. No other IM systems will be supported, write a Jabber transport instead.

Jabberbeans is now 1.2+, and all other Java Jabber libraries are also 1.2+. So now we gotta write our own damn Jabber library. We also need a small JAXP SAX parser for ANT, might as well use it for Jabber. Jabberbeans used SAX as well. The Yabba module is on hold until this is sorted out.

AM - 00:00 - 11:59
PM - 12:00 - 23:59

Use audio files for the alarm sounds.

Fix Watch time editing in different formats. The time and date formatting code should be split up into seperate classes, so that they are independant, and someone can always whip up a quick one to support a new time format. Watch may very well be the first clock software that is ready for a trip to Mars B-). Gotta add a fuzzy time option to watch, and make it work for all time formats.

While it is more obvious in Watch, the problem is in other modules as well. This problem is that Java's time zone handling sucks on some platforms, just being hard coded to one particular time zone (probably the authors). What makes this worse is that the platforms with the problem generally have the best time zone / daylight savings time handling. This looks like a good candidate for JNI code so that it works perfectly EVERYWHERE!

Watch is actually a protoype of a real watch I want to build. I have had my current watch for decades, and it is the second one of that model that I have owned, the first got stolen. It is a great watch, and I have not found anything as good in two decades of searching. I can no longer get parts for it, and it is on it's last battery. So I wanted to build my own watch (did I mention that I also design electronics?). Watch.java started off as a prototype based on my watches original design, using Skang to quickly whip up the GUI. I made it a module and added it to matrix. All functionality and intended functionality of Watch.java would be put into the watch. Both my original watch and the new watch are solar powered, the difference being that the original used a rechargable battery that needed to be replaced once a decade, but the new design will use a super cap and be maintenance free. Since I intend to put NTP code in the watch, but not a whole TCP/IP stack with BOOTP / DHCP / whatever, software will need to be written to let the watch NAT through a PC to the Internet to get the time. Plug the watch into a serial port, run the PC software and push the sync button. The watch will also be completely sealed, with no moving parts. How you press buttons underwater with no moving parts is something I am still working on. The backlight will be a LED, so that it never burns out (the light on mine hardly ever worked).

I should mention that Watch is now very different from the original actual watch. The button layout and major functions are the same, the display is almost completely different now.

Seiko have my permission to use the Watch code in a watch, so long as they follow the above design, make it waterproof to 100 meters, and send me three copies B-).

Clicking on a file name allows rename. Clicking on a permission bit toggles it. Clicking on a timestamp will 'touch' the file. Owner and group are drop downs to change. All these things are just labels if user can't change them. Context menu for an item replicates the status line and adds more.

Status line shows -

• user level
• type - bar graph of file testing progress / mime type / unknown
• open - if the data type can be opened like a directory, enabe this button.
• mode - replace / window / tab / panel, click for menu of open modes.
• show - button to use default show / menu of proggies that can show
• edit - button to use default edit / menu of proggies that can edit
• other verbs as above.

Investigate using mozilla's gecko as a "display/text/html" MIME type association. We already default to using it for help via mozilla itself. Just had a quick look, it's written in C++ (not one of matrix-DFS's development languages), and currently only supports unix, windos, and mac. Should maybe translate it into nice, portable Java, which will lose some of it's speed. There is a Java API for embedding gecko, but they have hidden the source code. It's JNI, which does fit our development model.

PNG now includes vector stuff, gotta support that! Mind you, this is rumour at this stage. PNG should be our official graphics format, as soon as one of us writes a module for it. Just found the sixlegs PNG java stuff, looking into it.

The "dump" command is for dumping the last half hours worth of debugging info, in exactly the same way the BPC_NO dump command works. Gotta standardize that.

Chat, mail, and news are the major community building parts of the Internet, and they should figure prominantly in matrix-DFS, coz the matrix is a community building tool. Chat is already implemented, mail should be next. That will solve my "all mail and news clients suck" problem B-). We should even include RFC based audio and video conferencing, IP telephones and video phones. Since free wireless networking can now replace BPC as the overriding test bed for the original matrix-DFS concept, lets see if we can beat the mobile phone system at it's own game B-).

Port it to organizers, and write a decent extensible graphing calculator, readers for the various document formats, file transport, an interface to OmniRemote, health checking module, random password generator, etc.

There should be one official matrix-DFS TCP/IP port, with all other port details available through that port. That way we won't get people complaining that matrix-DFS users are port scanning. When contacting matrix-DFS, use the official port to ask "What other ports do you answer on?". Maybe two official ports, client and server.

NAWS needs to be written.

More docs need to be written, but since I am one of the best doc writers known to the matrix-DFS team, and I have already done a lot of docs, there is little chance of more being written. When I showed the team members the first working node (plus docs), they described my documentation skills as "insane", they meant that in a good way B-).

3D world stuff should be added, based on VRML. See NAWS for how that should fit into the 3D world. We need to make it "matrix / cyberspace" like. We should also make a GURPS like RPG system, real time computer based naturally. Have a localised combat warp bubble to slow down time during combat. This gives players that are slower than their characters a chance to keep up. Use the "sit around and pant" recovery period after combat to buffer back to real time.

All the rest of matrix-DFS needs to be written B-).

Some notes I haven't had time to do anything with yet:

• Write decent string to long and string to double functions.
• Write up the mouse following stuff I wrote and lost notes for earlier.
• The Amiga user interface style guide is an excelent work on how to design UIs, try to follow it. In particular, try to follow the annotated version that onefang has B-).
• Wrap borders around each module to make the separate major functions more obvious.
• Usage meter stuff, and anything else mentioned in BPC_NO.java.
• Code bloat reduction review.
• Add SETI and a framework for similar things, look for good scientific example to port.
• Adjustable timeouts.

This file was last modified on Saturday, 20-Aug-2005 08:59:02 EST