Table Oriented Programming Example

I propose an example so we can see how TableOrientedProgramming would work in the real world. How about, say, a text editor... which can then be expanded in various ways to become a word processor, if we so feel like it. Hopefully TopMind and the TOP fans will help out, and the OOP fans will try to contribute and learn within the stylistic limits of TOP. Who feels qualified to start us off with a basic design? -- AdamBerger

Yea... I'd love to see this...

I generally don't write editors for a living and thus have insufficient experience to build a worthy TOP text editor at this time. (Although I have considered it in the past as an experiment.) I generally deal with custom business applications for a living and that domain is where I defend TOP. I don't claim it is necessarily a contendor for every domain. -- top

[I don't write text editors for a living, but I can whip up an example in an hour or two. It doesn't have to be "worthy", just show us how you would use TOP to tackle the problem.]

You may want to check out Compiere:

http://sourceforge.net/projects/compiere/

It is apparently quite table-driven.

For a "toy" example, check out:

http://www.geocities.com/tablizer/chal06.htm

It would be interesting to see an OO version of the same thing.

Myself, I might do something along the lines of

: Document //Table name
: Position Element //Key set
: Document.project({Position}).count() == Document.count(); //constraint (table)
: Content
: Element Text
: Content.project({Element}).count() == Content.count();
: Document.project({Element}) == Content.project({Element}); //constraint (database)

Normal editing of the text would occur by creating a new element and modifying/adding the Position to reference it. The advantage of the separation would be that certain search and replace operations would be trivial.

Of course, the more straight forward

: Document
: Position Character
: Document.project({Position}).count() == Document.count();

might be more appropriate for both operations anyway: search and replace would be handled by joining the table against itself 'n' times where 'n' is the size of the search; normal editing would occur through reindexing the structure as necessary. Both of these operations would be possible with reasonable efficiency by running differing data structures underneath the table: the same free-block oriented array used in simple text editors could be used, and that particular join could be special cased.

In other words, the power comes from the standard manner in which any data structure can be accessed and combined with any other data structure.

-- WilliamUnderwood

What does this line mean?

: Document.project({Element}).count() == Document.count(); //constraint (table)

Is "project" used as a noun or a verb?

It is a constraint, project refers to projection.

Can you express it in English? I'm unfamiliar with the notation you're using.

Projecting the table Document down to the keyset {Element} would result in a table containing one key: Position. The trick being that since this is relational, any duplicate values would collapse, and so the only way for a narrowing projection to have the same number of tuples as the original is if the resulting keyset is a candidate key for the original table. The effect is that we have specified a primary key for that table.

I'm still unsure how much I want to be primitive in that regard. For example, do I want a specific and special primary key constraint, or is it just as easy to have a function? If the latter, then the whole

: <Table>.project({<Key>}).count() == <Table>.count()

could be easily wrapped in a function, resulting in

: <Table>.candidateKey({<key>})

Really, the syntax may well end up more like

: (count (project Document to {Element})) == (count Document)

making the function version

: (key {Element} isCandidateKeyOf Document)

, seeing as I have a bit of a soft spot for lisp :)

-- cwillu

Can you try again? I'm also unfamiliar with the English you are using. What does "projecting" the table down a keyset mean? What's an Element, what's a Position?

Element and Position refer to the keys in the table definitions above. Projecting is one of the fundamental operations on a relational table, see RelationalProjection.

I see that Element and Position are keys in the tables. But what are they? What are they used for? What do they mean?

Quote: "Normal editing of the text would occur by creating a new element and modifying/adding the Position to reference it."

In other words, Element is some block of text, Position is where that element is in the text. But this doesn't really matter anyway, since it's already been stated that the more direct "Index Character" mapping is probably more appropriate.

-- cwillu

RPN Calculator Toy Example

This is from a usenet message on RPN calculator examples. It illustrates how TableOrientedProgramming can be used to simplify a project. Most of the information about the calculator keys is in a table (see bottom of listing) rather than in code. The table-lized version is easier to read than the same info as code in my opinion (especially in a table browser as opposed to ASCII).

Here is a quicky FoxPro-based Reverse Polish calculator script that uses a table to define the buttons and their action. Given a choice, I would probably have used parameters to pass around more record references instead of leaving it to global context (one of XBase's S.E. weaknesses) For example, passing around a PHP-style associative array for references to the looked-up Keys (a table) record.

It only does integers, and the validation is rather skimpy. Also, I don't really need the "Op" column since the operations happen to fit the display characters. However, I assumed that they could be different, such as displaying "X" for multiplication instead of an asterisk.

(Shayne originally requested floating point. I skipped that this time around and just did integers because it would have added more validation and formatting nitty gritty that I thought perhaps distracted from structural issues. I hope this is not a problem. Also, some news-readers may mangle the formatting and indentation. If so, I apologize. Try a Courier font if you have problems. Tabs also somehow got mixed in, and you know what they do to formatting.)

Regarding this line here:

calc = operand1 &theOp operand2

The single ampersand implies a syntactical substitution. Thus, if TheOp? is "+", then this gets executed:

calc = operand1 + operand2

Note that I still don't consider this example very representative of applications that I encounter. But, I thought it might be interesting to see what and how people think of it.

(begin program code)

***** Procedure calculator

set compatible foxplus set readborder on set deleted on set exact on set confirm on set safety off

close data select a use keys.dbf alias keys select b use stack.dbf alias stack zap

butno = 0 dusplay = "" && number display ("display" is a reserved word)

*---define GUI window and event handling IF NOT WEXIST("form1") DEFINE WINDOW form1 ; AT 8, 40 ; SIZE 14,28 ; TITLE "Calc" ; FONT "Courier New", 10 ; FLOAT ; CLOSE ; MINIMIZE ; SYSTEM ; COLOR RGB(,,,192,192,192) ENDIF

activate window form1

&& displays buttons generated from table

select keys scan temp = charcode tempparm = '"' + charcode + '"' @ Yloc, Xloc get butno ; picture "@*HN " + temp valid butpress(&tempparm) endscan

activate window form1 read cycle modal

return *-------------------- procedure butpress parameter theKey select keys locate for upper(keys->charcode) = upper(thekey) do case case keys->optype = 'K' && digit constants dusplay = dusplay + charcode case keys->optype = 'C' && commands do commands case keys->optype = 'P' && math operation do operations with keys->op endcase &&----display update @ 1,1 say dusplay + space(25 - len(dusplay)) show gets return *-------------------------- procedure commands do case case keys->charcode = 'P' && push do push with dusplay dusplay = "" case keys->charcode = 'C' && clear dusplay = "" case keys->charcode = 'Q' && quit deactivate window form1 close all cancel endcase return *-------------------------- procedure operations parameter theOp raw1 = pop() raw2 = dusplay raw1 = iif(empty(raw1),'0',raw1) && convert blank to zero raw2 = iif(empty(raw2),'0',raw2) operand1 = val(raw1) operand2 = val(raw2) && [insert division by zero check here] calc = operand1 &theOp operand2 dusplay = ltrim(str(int(calc))) return *-------------------------- procedure push(pushme) select stack append blank replace thevalue with pushme return *-------------------------- function pop select stack result = "" goto bottom if .not. eof() result = stack->thevalue delete endif return(result) *--------------------------

(end program code)

Table: Keys

Charcode Optype Op Descript Xloc Yloc

0 K 5.00 10.00 1 K 5.00 4.00 2 K 10.00 4.00 3 K 15.00 4.00 4 K 5.00 6.00 5 K 10.00 6.00 6 K 15.00 6.00 7 K 5.00 8.00 8 K 10.00 8.00 9 K 15.00 8.00 P C Push 10.00 10.00 + P + Plus 20.00 10.00 - P - Minus 20.00 4.00 * P * Times 20.00 6.00 / P / Divide 20.00 8.00 C C Clear 15.00 10.00 Q C Quit 5.00 12.00

The other table, "stack", has only one column, "theValue".

-T-