ROBACUS
Joe Ching （郑佐）
李佳敏 （Jamie Li）
DECEMBER 2018
CONTENTS
ROBACUS INTRODUCTION
ROBACUS INSTALLATION
COMPUTING LANGUAGE
ROBACUS CURRICULUM
NAMING CONVENTION SPECS
USER INTERFACE SPECS
EDITOR SPECS
DIAGNOSER SPECS
NATURAL LANGUAGE SPECS
SOFTWARE ROBOT SPECS
FORTRAN SPECS
DATA FILE SPECS
ROBACUS VIDEO CLIPS ON YOUTUBE
ROBACUS INTRODUCTION
Abacus, slide rule, calculator and
computer have served engineers
well as valuable tools. But two
characteristics of these tools have
limited their usefulness. The first is
the private-ness, each
communicating with and serving
only one private owner. And the
second is the subservient role they
play in relation to their users.
How can we make a tool that is
public and open, and acting as a
partner rather than a servant? How
would such a tool increase our
ability to do engineering and other
analyses?
Briefly, this tool is both a translator
of engineering capabilities and a
communicator of analysis
collaborations. As a translator, it
translates language humans
understand to a language that
computers understand. But the real
advantage is its ability to burden
the difficulties in thinking for
humans.
As a communicator, it uses a
technology called software robot to
make sure that all the analyses
done by one engineer can be
understood, reused and added onto
by others. The software robots are
simply executable documentations
that allow the computer to redo
exactly what are formally
documented, on its own
independent of the engineers who
created them.
The ROBACUS project shall initiate
itself by creating a core of
developers in the academic
environment. Courseware and
software are to be passed on to
interested teaching staff. Once the
communication links are put in
place among collaborative R/D
nodes, this tool will start to grow by
being used, maintained and
developed by users.
The translator, communicator and a
third component, OUTERNET,
would be described below, with a
focus on how they would be
constructed.
I. TRANSLATOR - NATURAL
LANGUAGE PROGRAMMING
The natural-language programming
program translates user's English
answers to questions asked by the
computer into Fortran statements
that computers can understand. In
practice, a user would be
generating functional modules for
specific tasks. Eventually, the
Fortran statements would be
mostly CALL statements of modules
already constructed.
A core of software engineers would
be responsible to develop and
maintain this natural-language
programming program. But the
users of this program for
productions would contribute new
modules to it in their routine
chores.
The technical aspects of
natural-language programming
program is described in the section
on Natural Language Specs.
II. COMMUNICATOR -- SOFTWARE
ROBOTS
In ROBACUS, the user is either
engaged in the generation of a
robot or using an existing robot to
perform a prescribed task. The
variety of tasks that the robots are
capable of performing ranges from
writing a program to preparing an
input model or an output plot.
Besides documenting what the task
is, a software robot also performs
the task verbatim documented.
Thus, ROBACUS shifts the focus
from "what has been done" to
"how it is done". But the most
important impact is that now we
can communicate among ourselves
without ambiguity thru the
software robots, or more exactly,
their executions.
The technical aspect of software
robots is described in the section on
Software Robot Specs.
The spontaneous accumulation of a
knowledge and experience in the
software robots in each ROBACUS
node points to the benefits of their
shared uses. This brings us to the
concept of OUTERNET.
III. OUTERNET -- WWW OF
SOFTWARE ROBOTS
OUTERNET is a network of
distributed personal servers made
up of ROBACUS'ized home PC's. It
can be looked upon as an
encyclopidia of how-to's.
After the initial stage of
development by software experts,
the next stage could be a coming
together of generations -- the old,
previous generation and the young,
next generation.
With letters enlarged and computer
skills simplified, many of the retired
technical professionals can learn to
help develop ROBACUS. Without
the pressure of short-term returns,
the focus can be concentrated on
future. Once all the inner working
of ROBACUS is made operational
and natural, the youngsters would
be introduced by the elders to a
virtual world of computing that is
void of all the idiosyncrasies that
hallmark our irrational world of
expediencies.
The long term development of
ROBACUS would be spontaneous,
since these youngsters will find
themselves in a robotically
computerized world that they grew
up in.
ROBACUS INSTALLATION
I. Install Linux Mageia 5
Install mageia 5
0. create a user "robacus" with password "000000" (our
universal password, for authorless software)
1. choose KDE (GNOME will lock keyboard and mouse)
2. get all mageia updates and archives downloaded
3. goto Mageia Control Center(option MCC)
4. click "Install & Remove Software"
5. turn upper left option boxs to "All"
6. search for "gcc", and click to uninstall "gcc 4.82"... and click
"Apply"
7. search for "gcc" again and click "gcc3.3"(if nonexistent, then
download other config media and updates )
8. search for "tcsh" and install("Apply")(insert the dvd, but take
out after done with all the installs)
9. search for "ncurses" and click all the "libncurses*" and
install
10. search for "libx11" and click all "libx11-devel" and install
11. also install "ncftp" and "gnuplot"(which only mageia4 has)
the same way
12. quit and goto the "boot" option and select it autologin to
IceWM
13. take out the dvd and restart(be sure to get back on IceWM)
II. Install ROBACUS
0. switch to the iceWM windows manager and open a xterm
(select from(lower left corner)Tool/More/Konsole, not
"Terminal", which will hang the keyboard) in the directory
robacus.
1. get a version of "robacus.tgz" or download and save it
2. open a "Konsol,NOT "Terminal"" and enter & execute "cp
Downloads/robacus.tgz robacus.tgz"
3. "tar -xvf robacus.tgz"
4. enter "su" then password(000000)
5. enter "./instal"
6. enter a "./useint"
7. use only the [Enter] and [End] keys to see how the software
robots work
8. try the right mouse key to show robot in slow motion
9. when u r ready, u can start move the mouse and
pick ur own options
10. once u r sure of how a problem is solved, u could enter over
the yellow letters to modify the problem
11. finally, u can use the [ADD] suboption to add a new
problem/robot and answer each of the questions like how robot
does it.
Beyond this point, u have to be a developer. there u have to
learn the naming convention used by the computer, thus, also the
users. and u need know how to use the robotic editor and
diagnosing debugger.
电算盘安装
I.安装Linux Mageia 5
安装Mageia 5
0.创建一个密码为"000000"的用户"robacus"（我们
的通用密码，用于无作者软件）
1.选择KDE（GNOME将锁定键盘和鼠标）
2.下载所有mageia更新和档案
3.转到Mageia控制中心（选项MCC）
4.单击"安装和删除软件"
5.将左上角的选项框转为"全部"
6.搜索"gcc"，然后单击卸载"gcc 4.82"...并单击"应
用"
7.再次搜索"gcc"并单击"gcc3.3"（如果不存在，
则下载其他配置媒体和更新）
8.搜索"tcsh"并安装（"Apply"）（插入DVD，但
在完成所有安装后取出）
9.搜索"ncurses"并单击所有"libncurses *"并安装
10.搜索"libx11"并单击所有"libx11-devel"并安装
11.同样安装"ncftp"和"gnuplot"（只有mageia4）
12.退出并转到"boot"选项并选择它自动登录到
IceWM
13.取出DVD并重启（务必回到IceWM）
II。 安装ROBACUS
0.切换到iceWM窗口管理器并打开一个xterm（从（左下角）Tool
/ More / Konsole中选择，而不是"终端"，这将挂起键盘）在
robacus目录中。
1.谷歌"robacus下载"并下载并保存
2.打开"Konsol，NOT"终端""并输入并执行"cp Downloads /
robacus.tgz robacus.tgz"
3."tar -xvf robacus.tgz"
4.输入"su"然后输入密码（000000）
5.输入"./instal"
6.输入"./useint"
7.仅使用[Enter]和[End]键查看软件机器人的工作方式
8.尝试用鼠标右键以慢动作显示机器人
9.当你准备好了，你可以开始移动鼠标并选择你自己的
选项
10.一旦确定问题是如何解决的，你可以输入黄色字母来
修改问题
11.最后，你可以使用[ADD]子选项添加一个新问题/
机器人并回答每个问题，比如机器人如何做。
除此之外，你必须是一名开发人员。 你必须学习计算机使
用的命名约定，因此用户也要学习。 你需要知道如何使用
机器人编辑器和诊断调试器。
COMPUTING LANGUAGE
ENGLISH WORDS
英语计算机单词
EDIT,DOWN,WHAT,SINGLE,KEY,FOLLOW,
编辑, 下， 什么，单一， 键， 依照，
VANPOOL,CHANGE,ALL,SUBSEQUENT,
共乘制度， 变， 所有， 随后,
BOTTOM,AGAIN,DOWNWARD,SUBROUTIN
E,
底部， 再, 向下， 子程序，
AWAY,GET,EXTERNAL.GUIDE.THE.INSERT.JA
CK.
离开， 得到，外部. 引导; 这。 插入; 举
起;
OVER.FROM.REVERSE.MOVE.BLOCK;LINE;O
VER;
以上; 从 ; 相反 ; 移动 ; 块 ; 线 ;
以上;
TOP;PUT;QUIT;DONT;SAVE;ANY;RESTORE.
顶部; 放 ; 停止; 不要 ;保存；任何; 恢复。
ORIGIN;AFTER;BEFORE;UPWARD;CONSTRU
CT;
原点 ; 后 ; 以前 ; 上升 ; 构
造 ;
SEQUENCE;WRITE;NUMBER;BE;SPECIFY;
序列 ; 写 ; 号码 ;是; 指明 ;
》》》》》》》》》》》》》》
FARSIDE;SCROLL;TAB; EXTREME;LOCATE.
远边; 卷起; TAB键; 极值 ; 查找
HOME;FORM;WHILE;COPY;AT;COLUMN;CA
N;
家 ; 形成; 当 ; 副本; 的; 柱 ;
能; FOR;WITHOUT;IS.SET;BY;
INTERNAL;EACH;
为; 没有; 的，置;靠; 内部 ; 每 ;
DIAGNOSE;AUTOMATE;INNER;ONLINE;TRA
CK;
诊断 ; 自动化; 内 ; 在网上; 跟
踪; ALSO;MANUAL;RECOVER;
MENU;READ;
也 ; 手工的; 恢复 ; 菜单 ; 读;
METHOD; ENTER; COMMAND;CLICK; OR;
方法; 输入; 指挥 ;按下鼠标器;或;
BACKSPACE;ADD;REMOVE;MESSAGE;
退一格; 增加; 删除; 信息；
TASKS;HELP;RESEARCH;DEVELOPE;XEROX;
任务; 帮助; 研究; 发展; 复印;
WINDOW;NATURAL;LANGUAGE;PROGRAM;
窗口; 自然; 语言; 程序;
SELECT;MODEL;FOR;PROCESS; ANALYSE;
选择; 模型; 为; 进程; 分析;
WEBPAGE;DOCUMENT;OPERATE;PROCEDU
RE;
网页; 文件; 运作;
程序;
PHYSIC; SIMULATE;SPORT;HEALTH;
物理; 模拟; 体育; 健康;
PREPROCESS; GENERATE;POSTPROCESS;
预处理; 产生; 后期处理;
COMPONENT;TO;MODIFY;LIST;NONE;STRIN
G;
构成要素; 到; 改; 名单; 无; 字符
串;
SEARCH;SKIP;SAME;MARK;WITH;NEXT;OCC
UR;
搜索; 跳过; 相同; 标记; 与; 下一个; 发
生;
END;REPEAT;STATEMENT; DESCRIBE;VALUE;
结束; 重复; 陈述句; 描述; 价值;
INPUT;VARIABLE;SUBTRACT;MULTIPLY;DIVI
DE; 输入; 可变素; 减去; 乘;
除;
ARRAY;BRANCH;ANIMATE;PREPARE;
一系列; 支线; 动画; 准备;
DOCUMENT;INCREMENT;MODULE;ARITHM
ATIC
文件; 增一量; 模块; 算术;
DELETE;UPGRADE;FIRST;SECOND;THIRD;
删除; 升级; 第一; 第二; 第三;
CONFLICT; FILE;TEXT;GRAPHIC;FUNCTION;
冲突; 文件;文字; 图; 函数;
GEOMETRY;DO;YOU;WANT;SINGLE;YES;NO;
几何; 做; 你; 要; 单; 是; 不;
INTEGRATE,CHARACTER;CONVERT;MAXIM
UM;
结合； 字; 变换; 最大;
OF;TWO;VALUE;MINIMUM;A; OTHER;
的; 两个; 价值; 最小; 某一; 其他;
STRING;WHICH;PROBLEM;DISPOSE;SUBMIT;
字符串; 哪些; 问题; 处理; 提交;
DISPLAY;FLOW; CHART;ROBOT;MAIN;TIME;
显示; 流动; 图; 机器人; 主; 时间;
MONTH;DAY;YEAR; DONE;DATA;BASE;
月; 日; 年; 完成; 数据; 基础;
CONTROL;NETWORK;
OPTION;SCHEDULE;ICON;
控制; 网络; 选择; 时间表;
图标;
THEIR;SUB-TASK;LIST;OUT; UP;GIVE;
他们的; 子任务; 清单; 出; 上; 给;
QUESTION;ANSWER;IF;THEN;UNIT;HOUR;W
EEK;
问题; 回答; 假如，然后;单位; 小时;
周;
PERFORM;GO;ON;RESPONSE;ACTION;THIS;
执行; 去; 在上; 响应; 行动; 这;
STEP;PARAMETER;BELOW;RADIUS; NAME;
步骤; 参数; 下面; 半径; 名;
INITIAL;EXECUTE;SPACE;NUCLEAR;DESIGN;
初始; 执行; 空间; 核; 设计;
OPTIMIZE;LOWER;LEFT;
COMPUTE;TYPE;POINT;
优化; 更低; 左； 计算; 类型;
点;
INTEREST;DRAW;FACTOR;ZOOM;IN;HERE;S
TOP;兴趣; 绘; 因子;
画面推近;在;这里; 停止;
FULL; VERTICAL,HORIZONTAL,VIEW,
满; 纵向; 横向; 看景;
BOUNDARY,GROUP,BEGIN,SCALEUP,BALL,
边界; 团体; 首先; 扩大; 球;
BOUNCE,BACKGROUND; RECTANGLE;OVAL;
弹起; 背景; 长方形; 椭圆
形;
TRIANGLE;DIMENSION;ARBITRARY;SHAPE;
三角形; 层面; 任意形; 形状;
CIRCLE;SIZE;AGAINST; SIDE;LABEL;OBJECT;
圆形; 大小;以...为背景；方面; 标记; 物体;
COORDINATE;RANDOM;VALUE;VELOCITY；
坐标; 随机; 价值; 速度;
EQUAL;NOT;GREATER;LESS;
LEFT;RIGHT;LINK;
相等; 不是; 大于; 小于; 左; 右; 链
接;
LOGICAL;CONDITION;CONTINUE;FINISH;CL
OSE;
逻辑; 情况; 继续; 完成;
关闭;
ELSE;START;NOW;
DEFINE;AVAILABLE;GRAVITY;
其他; 开始; 现在; 定义; 可有的; 地心
吸力;
ACCELERATE;INTERVAL;STEP;FLOW;TABLE;G
OLF;
加速; 间隔; 步骤; 流动;表/桌；高
尔夫;
WATER;RATE;PUMP;TOTAL;MASS;CYCLE;AR
EA;
水; 率; 抽水机; 总数; 质量; 循环; 面
积;
LENGTH;PIPE; HEIGHT;WIDTH;TAX;RETURN;
长度; 输送管; 高度; 宽度; 税; 返回;
AMOUNT;PAYMENT;BASE;INTERPOLATE;H
OW;
数额; 付款; 基础; 插算; 如
何;
MANY;ELEMENT;THESE;HUMAN;DOCTOR;
许多; 要素; 这些; 人; 医生;
PINGPONG;WIN;CONTROL;PARAMETER;US
E;IT;
乒乓; 胜; 控制; 参数; 用;
它;
SETUP;EXIST;LOSE;EXPRESS;CONSTANT;PLU
S;
设置; 存在; 失; 明示; 常数;
加;
SHOULD;AMONG;SUB-OPTION;SUB-LEVEL;
应该; 在...之中; 子选项; 子分段;
POINT;COUNT;STATISTICS;RANGE;THEY;
ARE;
点; 计数; 统计; 范围; 他们;
是;
LOW;HIGH;LIMIT;QUANTITY;SERVICE;LOWE
R;
低; 高; 极限; 数量; 服务; 更低;
HIGHER;RACKET;CHARACTER;BLOCK;
较高; 球拍; 性质; 块;
SHAKE;HAND;MATCH;STYLE;KUNGFU;LETTE
R;
握; 手; 比赛; 风格; 功夫; 信;
EMAIL; NEW;RANK;PLAYER;ADDRESS;
电子邮件; 新; 等级; 运动员; 地址;
YOURS;HANDICAPE;VIRTUAL;WEB;SHUTDO
WN;
你的; 残障比赛; 虚拟的; 网; 关机;
POWER;EXIT;
电力; 退出;
ROBACUS CURRICULUM
The following are the subject
matters to be taught in schools
from elementary schools onward:
1. Installation of ROBACUS on
mageia linux
2. Learn some computer English
3. Know the naming convention
4. User-interface
5. Robotic editor
6. Diagnostic debugger
7. Natural language
programming
8. Software robots
9. Basic fortran, unix, c
10. Data linkage
11. ROBACUS video and files
The following schedule should be
used to get students familiar with
the inner working of ROBACUS:
Grade 1 to 3:
* Learn some computer English
Grade 4:
* Know the naming convention
Grade 5 and 6:
* User-interface
* Robotic editor
* Diagnostic debugger
* Natural language
programming
* Software robots
Grade 7:
* Installation of ROBACUS on
mageia linux
Grade 8 and 9
1. Basic fortran, unix, c
2. Data linkage
3. ROBACUS video and files
In high schools onward, qualified
students will be taught to become
developers of ROBACUS. And in
colleges, the selected few will learn
the control and coordination of the
ROBACUS network, OUTERNET.
Finally the most innovative and
reasonable among the ROBACUS
developers will be recruited to
expand and maintain the Universal
Centralized Processor, UCP. But
only those among them who have
managed to dissociate themselves
from all worldly lures of money,
power and fame will be invited
onboard UCP as policy makers.
NAMING CONVENTION SPECS
Programming is essentially an
exercise in naming. If only the
computer can do the naming itself,
it could do the programming itself
also. This is where naming
convention comes in.
So, in a way, naming convention is
aimed at making the computing
environment nameless to the user
-- no files and no variables! This is
the criteria for full automation and
natural-language programming.
But, before we make computer
follow the naming convention, we
must ourselves follow it, too.
I. NAME STRUCTURE
* All names for files and variables
are 6 lettered.
* Each name is divided into two
3-letter parts, except for
single-word name, which can use its
first 6 letters, padded by 0's if
needed.
II. PROGRAM FILE NAMES
1. The first 3-letter part describes
the program, and the last
3-letter part describes the
data.
2. Program Description
(1)Each program is identified with
2-letter unique prefix. It will be
chosen from the first 2 letters of
the program name, on a first come
first use basis, and also special
priority may be given to important
programs to use their first 2 letters
(see file, namrec).
(2)The types of processors for all
programs are identified in the third
letter as follows:
* i = input processor
* e = execution processor
* o = output processor
* 1 = generator of preprocessor
* 0 = postprocessor generator
* l = library source
* m = menu files (robmen) for
processors possessing robots
* r = reserved for hardwired menus
3. Data Description
* The file type is identified in the
fourth letter by:
* r = robot file (robcod=list of code
robots)
* i = input file
* e = execution file
* o = output file
* u = update source listing of
processor
* s = schematic boxes representing
components in a model that
processing can be skipped to
* f = figure schematics of
components
* g = graphics data
* m = menu file(men)(mencod=list
of code menus)
* h = how files
* a = absolute module of machine
instructions
* l = library or base module of
machine instructions
* p = plot data file
* b = box data file for selection
* t = tabulated data file or tree
structure
* d = data files summary listing out
all the linking data files named with
the 4th letter, d, replace by 0 thru 9
and their respective data argument
list and any format(if not binary).
(1)The last two letters are used to
uniquely identify the problem
model, which is formed by the 1st
letter of the 1st 2 keywords of the
model description, unless conflict
with other models occurs.
(2)Listings of identifiers（to avoid
conflicts） for files are
automatically kept in files:
* namrec = names of programs and
their prefixes
* menrec = menu names and
descriptions structure(updated
manually)
* rob*** = names of robots for a
prefix(***) for duplication check
* men*** = names of menus with
prefix(***) of processors possessing
robots
* ***nam = code subroutine names
and description
* **dvar = code variable
names( only available for generated
programs)
* mailog = names of current file
being
editted or diagnosed,etc.
* namlog = name of file being
processed
* roblog = robot name file being
processed
* autlog = automation control file
for demonstration
* collog = color identification
numbers for menu display
* ibmlog = 0 if PC or IBM
workstation, 1 if SUN
(4)VARIABLE NAMES and UTILITY
FILES
* Two key words are to be picked
from the description of the file or
variable. When picked
automatically by the computer,
either the first 2 words or words
preceded by an extra blank are
considered key words.
* Names are formed with the first 3
letters of the first key word and
first 3 letters of the second key
word. If only one key word is
available, use it as is with '0'
padding or truncate it to 6 letters if
longer than 6.
* Temporary or local names have
repeated letters such as "nnn",
instead of "num"ber or "vvv",
instead of "var"iable.
* Temporary, dummy indices use
"i", "j", "k", "l", "m" or "n".
* Temporary, dummy real variables
use "x", "y", "z", "u", "v" or "w".
5. MAJOR SOFTWARE LIBRARIES
AND FILES
* iolupd = i/o library source
routines in c-language and
Xwindows calls
* useupd = user interface fortran
source
* edeupd = editor fortran source
* dieupd = diagnoser fortran source
* ge1upd = code generator fortran
source
* na1upd = natural-language
programming program fortran
source
* pauupd = to pause the user
interface by showing the
background output
* ???lin = the linking file where ???
are 'use', 'ede', 'die', 'na1' and
'pau'.
* anrmen = the main menu
* edev?? = built-in hardwired
editor's robots where "?" typically
represents the basic command, but
can be easily expanded to include
combination or vanpool of
commands.
6. FORTRAN GRAMMAR
* limit statement length to 40
columns
* use statement numbers ending in
'0' for DO loops
* use statement numbers ending in
'5' for GOTO/CONTINUE statements
* the rest(1 to 4 and 6 to 9) are
used for ending FORMAT
statements
* for diagnostic debugging
statement's formats, use 4 digits
starting with '9'
* dont use any fortran rules that
are not specified in file forrul.html
7. I/O FILE UNIT NUMBERS
* 1 = for the major output
generated, such as the generated
fortran program, the input data
deck from preprocessor, or
debugging source files, etc
* 2 = the major input file
* 50 = the input robot file
* 60 = the output robot file
* 70 = the debugging output,
normally at the start and end of
subroutines executed
8. QUESTION/ANSWER routines
with robot
-reading and -writing capabilities
*QUEREA/QUEINT/QUEALP/QUEST
A/QUESTC/QUEMST
... are, respectively, for answers in
real, integer, alphanumerical,
statement, capital-letter statament,
multiple statements...
9. Menu selection routines(calling c
routine, selop?):
* MODSEL = select from a menu
* SELMEN = select from internally
described options
* MENPR? = menu processing used
in the user interface
10. Writing out statements:
* WRIMEG = writing out long
messages in one or multiple
windows
* WRISTA = writing out direct onto
terminal screen
11. Debugging considerations
* The following statements are
placed, respectively, at beginning
and end of a subroutine:
IF(LOGBUG.GE.1)WRITE(LOGDEB,90
01)...
CALL BUGFLU
9001 FORMAT('$$$ ENTERING
SUBROU')
IF(LOGBUG.GE.1)WRITE(LOGDEB,99
99)...
CALL BUGFLU
9999 FORMAT('$$$ ENTERING
SUBROU')
along with the COMMON/AUTDAT/
in which contains the control
variables, LOGBUG and LOGDEB.
The BUGFLU routine is used to flush
out the debugging statement right
after they are written, in case the
code bombs out unexpectedly.
* Other normal debugging write are
done with such statement as:
IF(LOGBUG.GE.2)WRITE(LOGDEB,99
11)...
And for long output, use
IF(LOGBUG.GE.3)...
* When debugging the editor, the
output unit should be the same as
the editor robot, or 60.
USER INTERFACE SPECS
User interface is a graphic display
using plain English that are
originally created by users. The user
interface provides the major
categories of analysis. Click to
invoke the particular category of
interest. You can also type in 1,2,3...
for the 1st, 2nd, 3rd ... category.
Pressing the [Enter] key invoke the
robot value, which is indicated by
where the mouse pointer is
situated.
The super-options at the upper
corners, Edit and Diagno, can be
clicked or invoked by entering 'e
filnam' and 'd', respectively.
Simply entering an 'e' edits the
previously edited file. Similarly, the
sub-options at the bottom can be
invoked by clicking or the first letter
of the option name.
Besides the e and d, and other
sub-option commands, you can set
up (3-letter) alias by entering
ALI=actual command, which can be
either ROBACUS or unix command
strings. Enter an = will display all
available alias. Doing an ALI= will
delete the "ALI" command.
Pressing [Backspace] brings you to
the background terminal display,
which is just the unix environment
showing the processing of
ROBACUS. Pressing [Enter] brings
back to the user interface.
[Ctrl+C], [Esc] or [Tab] closes the
user interface. "u" will restart it.
When processing is deep into an
actual analysis, the press of the
right button of the mouse will cause
the execution to perform on its own
automatically, with possible user
intervention by clicking the mouse
at a specific step.
The use interface is invoked by file
'useint', which iteratively execute
file 'tooexe' and 'useabs'. 'tooexe'
contains the next process requested
by the user, and 'useabs' is just the
absolute module of the user
interface program, which also does
automated bug check to see if the
process runs successfully. If not, it
proceeds to do automatic
debugging.
EDITOR SPECS
Today's editors, though useful, still
carry much unnecessary baggage.
The extra pressing of the [Ctrl] and
[Enter] keys are a truly waste for a
multitude of users. Unreasonable
designations of commands put a
strain on the brain, not to mention
the mistrust it contributes to the
users toward computing.
And finally the future of editing is
forever doomed, in that we will be
doing editing forever into the
future, as manual editing is in
essence a bottle neck for software
automation. The ultimate objective
of a good editor is doing away with
editing altogether.
ROBACUS' editor is designed to be
an extension of our hands, and
possibly also that of our brain. For
example, it's made as much
case-insensitive as possible. Also, it
is testing out a feature in which
typing of a string would mean
automatic search of the string
without first to have to type the
searching command -- kind like the
editor will go whereever the user is
thinking to.
This editor is robotic so that
eventually all editing sessions can
be performed by editing software
robots that can perform the
necessary string manipulation or
even programming thru editing, all
transparent to the users. In short,
this editor's mission is to make
itself disappear.
Another indispensable function of
the editing robot is in debugging.
The robot can be made to provide
as extensive a record as a user
wants of what truly occurred under
the hood, with the help of the
diagnoser's command option that is
set beforehand.
The use of the mouse is avoided as
much as possible, even though
some features have been
programmed in it. Any user, who
wants to use the mouse, needs to
make a strong argument to
reactivate these features. Thus, it's
deemed the mouse is too clumsy
for ultra-fast computing that
ROBACUS is designed for. On the
other hand, whenever the mouse
click is the most natural way to go,
ROBACUS go to extra effort to
provide equivalent key press
whenever possible.
So, as expected, this editor, during
its development, can be as handy as
it's unstable, much like our own
hands. The debugging can also
become extremely uncanny, much
like diagnosing our own brain.
However, this is the only way to
avoid the dead end to automation
mentioned above. The users
definitely need a lot of patient with
many of its defects. Why, it's only
human.
The editing commands are
presented and explained below:
I.HELP commands
h=summary list of commands
?=summary list of vanpool, or
users-generated string of,
commands
II.POSITION commands
[Page Down],[Page Up], up,
down, left and right arrows
[Tab] first go to middle of nonblank
part of the statement, second
pressing to end of line, then bottom
of page, then top of page
t=Top of file and search in
downward mode.
Second pressing of a 't' will display
the
top-down tree structure of the
subroutine
name entered.
b=Bottom of file and search in
upward mode.
Second pressing will display of
bottom-up tree structure of the
subroutines name entered.
d=Downward search to the string,
which is entered immediately
afterward
u=Upward search to the string,
same as in 'd'
&=Repeat previous search in
downward direction
^=Repeat search in upward
direction
n=Number of the line to go to,
2nd 'n' gives current line number,
and
next 'n' gives total number of lines
in the file
s=Go to start of subroutine
e=Go to end of subroutine
l=List of subroutines is displayed to
go to
c=Repeat previous string change
command in its next occurrence.
The old string is first searched to,
and then it is being typed over in a
uniquely defined area by the new
string with the use of left/right
arrows, Insert/Delete and
Backspace keys. The typing is
terminated by End or Enter keys.
r=Restore original line after
unwanted change with 'c'
a=Change all occurrences following
the current statement(caution, the
changed string must be made
unique)
[End]=Move the cursor to leftmost
so that
single-key command can be entered.
Also
in combination with first [Home] to
forms a
block of coding to be moved,
inserted or
deleted, written out, with,
respectively [Ins], [Del] and 'w' key
pressing.
[PgUp],[Pgdn]=In column > 1,
allows search up or down. But next
pressing gives the desired intends.
The above 1-letter command used
with
an [Enter] is also applicable when a
question is asked to prompt a
command or a string. In column>1
mode, any command can
be invoked by simultaneous
pressing of the [Ctrl] key. A better
way is the use of [PgUp] and [PgDn]
first.
The far right - and + can be used to
scroll the screen, respectively.
III. MODIFICATIONS
1. REPLACE
Simply type over the
characters to be replaced.
The entire string
surrounded by the leftmost
and rightmost characters typed
will be considered
as the replacement segment.
This replacement can be
repeated to other string in the
previously specified direction
by entering a 'c' in column 1.
End the replacement with
[Enter] or [End].
Enter an 'a' in column 1 will
change all occurrences
following the current
statement.
[Ctrl/] deletes everything to the
left, then moves down 1 line
[Ctrl\] deletes everything to right,
then moves straight down 1 line
2. INSERT
(1) New Text - start with 'i' and end
with [End].
[Space] means blank line.
(2) Imbedded String - start with [Ins]
and end with any arrow or [End]
(3) z=Zero in on a FORTRAN
statement to write out all of its
variables for future debugging
write.
3. DELETE
(1) Delete a Line -- [Backspace] in
column 1
(2) Delete a Character -- [Del] in
column > 1
(3) Delete a Block - - [Del] in column
1
VI. END SESSION
f=Finish and save
q=Quit and discard change(note:
the robot recording is saved,
however, to be used later if
needed.)
V.BLOCKING
1. Create a block by typing [Home],
then reposition and end with [End].
2. Immediately after forming a
block, a question will be asked for
the file name to which the block
can be extracted and appended
(same as 'w'riteout command). But
single-key command with [Enter] is
also allowed here.
3. Use [Ins] and [Del]
to insert and delete the block (no
[End]ing
is necessary, as it would be
automatically inserted by the Insert
and Delete command.
4. [Home] and [Insert]
duplicate the line, same as 'x'erox
command.
5. m=Move the block to the current
position
6. g=Get external file
7. j=Jack a subroutine from other
ROBACUS update source files.
8. w=Write out the block to
external file
9. p=Print block as hardcopy( no
[End]ing the block is necessary)
VI. SPECIAL FEATURES
A. ROBOTICS
1. All editing actions are recorded
2. The last editing session can be
reenacted out a line at a time with
the [Enter] key
3. The default action activatable by
[Enter] is displayed at the top of the
page
4. '$%' causes the robot to perform
rest of the editing (To enter a
character '$', enter '$' twice)
5. The robot file can be shifted up
or down with '$^' and '$&' to align
with the current editing
B. VANPOOL COMMAND
1. v=create vanpool, or
combination of, commands and
make them available to be invoked
by a digit.
The '?' gives description of available
vanpool commands and '#' for
deleting existing commends.
First "v" is used to start forming the
vanpool COMMAND, when
done specifying all editing
commands, a second "v"
terminated the process.
2.Digits "0" to "9" (and letters "a"
to "z", though not recommended)
can be used for vanpool
commands for used as "[1-letter]"
3.*=a variable command inside a
vanpool command
4. Vanpool commands, once
created, can be manipulated
externally and issued to perform a
capsulated task(to be completed in
a background batch mode).
C. ZERO IN ON A STATEMENT
The "z" command writes debugging
statements around the statement
to be zeroed in on and causes a
pause after the execution of the
statement and writing out of the
debugging statements.
D. FAST-TYPING SEARCH
COMMAND(temporarily disabled
due to varying speed of the
computer.)
An automatic search command is
invoked when the first two letters
are entered in rapid succession in
column 0 or in full screen editing
mode during a searching processing.
This feature needs more work to
eliminate the risk of unintentional
editing and timing adjustment of pc
of varying processing speeds.
E. KNOW VARIABLE DESCRIPTIONS
IN A STATEMENT
The "k" command would give the
description of each variable in the
statement, if a 'variable description'
section is available. This file is
automatically generated in
natural-language programming by
the software generator.
A 2nd "k" would explain the fortran
rule used.(i forget what the 3rd "k"
does。 go try it out yourself.).
F. YANK IN AN EXISTING
SUBROUTINE CALL STATEMENT
The "y" command provides easy
accessing of available library and
program subroutine modules.
G. JACK OVER A SUBROUTINE
FROM AN EXTERNAL FILE
The "j" command jacks a subroutine
over from another file.
H. EXTRACT COMPILATION AND
LINKING BUGS
The "x" command xtracts the bugs
occurred during compilation and
linking if the execution is submitted
to be offline in the background. The
editing robot that performs this
debugging exercise also can display
the actual error message by
'i'nserting the statement when the
[Enter] key is pressed after the bug
position is located.
I. BRACKET A BLOCK OF CODING
AND MAKE IT A SUBROUTINE
The 'o' command converts a block
of coding into a subroutine or
object and replace the block with a
CALL statement to the subroutine.
VII.EDIT TIPS
Some simple rules to remember
are:
* Ctrl+letter, when entered
anywhere, is the basic editor
command. But the most handy way
to use the editor is to avoid the Ctrl
key. Instead, make a habit of
pressing the [End] key after a full
screen edit sequence, so that the
1-letter command can be issued
from column 0.
* Once in column >0 full screen
editing is invoked(with space, right
arrow or tab keys)
* column 0 and after every
question(in combination with
[Enter] key) will honor the 1-letter
command.
* [Enter], [Home], [End] and moving
to column 0 cause editing to
leave full screen mode
* When it is important to keep a
record of the editing session for
someone else to see, "q"uit out the
edit session so the robot can be
used to repeat verbatim every step
of the session by simply pressing
the [Enter] keys, or '$%' to do it all
at once.
VIII. EDITOR DEBUGGING
* The editor is debugged by writing
debugging statements into the
robot(60).
* An old file 'edeabo' should be
copied from the
current 'edeabs' so that it can be
copied
back in case the editor is disabled
after
modification.
* For extensive modification,
relevant
subroutines should be moved to
the
small 'na1uuu, from which the
editor can
be modified at a faster speed.
IX. FINAL WORD
* This editor is handy and
powerful, rather than complex and
stable, in order to relieve the mind
to think about the problem at hand.
* To let computer do as much of the
work as possible, the user needs to
adjust to a bilateral interaction with
the computer. In practice, the user
needs to do more anticipating than
dictating.
Remember: The scenarios we
anticipate are those we set up for
ourselves, not that dictated by the
computer.
* The ultimate goal for ROBACUS is
to make editing unnecessary. This
can be realized once we identify all
the individual and combinatorial
functions that the editor performs.
All we need to do then is to
transparently send the robot to
perform those functions we desire.
The full-screen data entry as if one
is filling a standard form is an
example of the application of
the editor.
IX.PLANNED MODIFICATIONS
When running into a bug in editor,
the user can send for help, by
providing either the file fil060, if
bomb out unexpectedly, or the file
eder??, where ?? is the prefix of the
file being editted, if the editting
session ends normally.
* implement the fast-typing, direct
search(without typing the "d" or
"u")
* clean up full screen editing
involving
multiple use of [Ins] and [Del]
in one line
* clean up [Ins] and [Del] of
[linefeed](or [Enter]) at the end
of statement
* catch a scenario in which the
editor mysteriously inserts a "C" or
some Cntrl* in column 1
* why does repeated [Ins] of a block
at different locations produces
infinite loops?
* "o" option lacks some external
files
* block changed by deleting( or
inserting) lines
* move block addresses to new
locations with insert, move, and get
* use '*' as wildcard letters in
search
* 'c'hange move to 1st character
changed(use ctrl+c afterwards)
* automatic paging
* automatic inserting of
[linefeed] at column 41
* dont cover the top or bottom line
with question, such as "SEARCH...?"
* e at bottom of file goes to end of
last subroutine(above the job
control statements)
* "c" should change upward if
previous search is ^ or ctrl ^
DIAGNOSER SPECS
Debugging can be as nerve racking
as programming can be fun.
ROBACUS tries to balance the two
by put enough discipline in
programming that debugging
becomes manageably predictable.
In fact ROBACUS has made
debugging so systematic that it can
be fully automated.
ROBACUS' commitment to full
automation, when it applies to
debugging, however, represents by
far the greatest challenge
undertaken by any software group
in the world of computing. This is
where software robots become
indispensable.
We just need to create some real
hardworking robots to handle the
works that are too cumbersome to
do manually. The time-consuming,
iterative nature of debugging fits
nicely with the emerging, new,
processing-hungry computers.
The basis of debugging is diagnosis.
We simply let the bug reveal itself
by revealing the processing around
it.
This is done by systematically
putting
"IF(LOGBUG.GE.1)WRITE(LOGDEB,9.
..)..." statements at the start and
end of each subroutine, as well as:
"IF(LOGBUG.GE.2)WRITE(LOGDEB,9.
..)..." in places relevant to the
troubled area, where LOGBUG can
be set to 1,2 or 3 and LOGDEB can
be set to 70 or 6 or, 60 for editor.
Pushing this to the limit, ROBACUS
actually perfected a scheme where
every statement is written out
dynamically in the path of the
subroutine's execution. This allows
revealing of the execution flow
path and pinpointing the statement
where the execution gets bombed
out.
To diagnose/debug, simply enter:
'd' or click the Diagno button at the
upper right. Then select one of the
following option:
1. TRACK ROUTINES
2. ALSO INTERNAL VARIAB
3. MANUAL DEBUG AND TRACK
4. AUTO DEBUG COMPILE EXE
5 LINE TRACK OF ROUTINE
These are 5 levels of background
tracking of the execution.
In the case of the editor, we can
also take advantage of the robot
file that keeps a log of all the
commands issued. In this robot file,
we could also write in it via unit 60
all the debugging statements, and
when intermingled within the
sequences of editing command, it
gives a clear picture of what's going
on during the editing session.
The diagnoser will set up two
update source files that contain
debugging statements. The first file,
codu0c, where 'cod' is just the
3-letter ID of the code, does a full
compilation of all the subroutines
to generate the new library for
linking. The second file, codu0d,
then can be used iteratively to only
modify and compile the troubled
subroutine.
The line-by-line tracking is pretty
much a full-brute-force, fool-proof
way of tracking down the bug. It
guarantees to pin down where the
bug occurs and the
statement-by-statement execution
that leads to it. But this process
may be very lengthy, so it will be
automated soon.
In the automated debugging
process, the diagnoser would
automatically bring you to editing
the troubled statement, inside the
troubled subroutine, and also make
it ready to be submitted and
executed again.
The detailed auto debugging
strategy is described below:
1. search out in which subroutine
the bug exits
2. search out at which statement
the bug exits
3. the file containing the subroutine
is edited and the subroutine and
then the statement are searched so
that the cursor will end up at the
bug position
4. this file can be modified and
recompiled iteratively until the bug
is resolved
The automated process involving:
* read the last record of unit
70(fort.70) to see if the
"SUCCESS..." statement
exits(written out in SUBROUTINE
AUTPUT) that indicates no bug
occurred
* if SUCCESS is nonexistent, then
unit 70 is searched backward to
locate the 1st 'ENTERING...' that
does not have a matching
'EXITING...' statement for the
particular subroutine. This indicates
a subroutine, that has been entered,
but never exit, thus, contains the
bug.
* generate codu0c and codu0d for
the file that contains the bug
subroutine.
* codu0c is compiled to produce an
executable that produce a
line-by-line tracking, capable of
pin-point the line at which the
execution bombs out.
* problem is automatically
re-executed by the problem's
software robot using codu0c's
executable
* the bug statement will be read as
the last statement in the debugging
output
* codu0d is then edited by an
'edirob' which robotically search for
the bug statement.
* if the nature of the bug is known,
a bug-fixing robot will be used to fix
it automatically.
* otherwise, codu0d can be used
iteratively to fix the bug.
* if the same kind of bug is
expected to occur in the future, an
editing robot can be constructed to
fix the bug automatically. A
search and selection scheme is also
constructed to selectively activate
the bug-fixing feature during
automated debugging.
NATURAL LANGUAGE SPECS
Natural language is the most
natural way to express a physical
phenomenon or an operational
procedure, through native language,
which we should use an
abbreviated set of English that we
call universal language.
"Natural", however, does not imply
natural only to human, although it
intends to mean ultimately the
most natural to humans. This is
because many of what humans
consider to be natural are really
what are only most familiar to them.
It is therefore only making sense
that humans should give
themselves ample chances to
become familiar with new
environments that are potentially
more natural such as a fully
automated computing platform in a
logical society.
And also, the computer does have
its preferred ways of behavior and
the human can definitely benefit
from learning and appreciating
some of them before deciding what
is natural.
In fact, being not aware of the
better ways, with which computer
could perform certain tasks, has
been the downfall of previous
attempts to naturalized
programming language. In a way,
natural language is built upon the
foundation of computer intelligence,
rather than human artificial
intelligence.
Practically, the whole effort is one
in which we are trying to shift the
burden of thinking from human to
the computer. It is hoped that once
the difficult work of thinking is
taken over by the unlimited
capacity of the computer, the
limited precious resources of the
human brain could be put to more
high-quality, specialized uses.
So what are natural? Let's count the
ways.
First, in all derivations in the
solution of a problem, the starting
point should be the question for the
final answer. Once the human
describes the answer he is seeking,
the computer would take over the
line of questioning. Leading the
human down a structured and
disciplined way of answering the
questions, the computer would lead
the human on a logical path of
processing while, at the same time,
carrying on the cumbersome chore
of bookkeeping the variables and
the conditions, or equations,
toward bring in the solution to a
close.
Once the computer determines that
the problem is solved, it would flip
the whole processing procedure
upside down and translate them
into computer coding, which we
shall make it universally Fortran,
plus some c-language whenever
necessary.
In converting operational
procedures to computer programs,
the natural language programming
program simply guides the user in a
structured way down the
procedures. In this case the
computer would track all branch
points and, in turn, bring each to
termination.
In graphics and animations, most of
the programming should be built-in.
User should be facilitated to pick
and choose from a self-sufficient
set of features, which could be
generated either manually or by
natural language beforehand.
Eventually all programming will be
done with the natural-language
programming language. And as
much as possible everything will be
vocalized, instead of using
keyboard and mouse control.
The natural language programming
has thus far tried to address all the
basic areas in computer analyses.
These include:
1. Analysis automation is
achieved with the help of
preprocessors and
postprocessors. The
automation loop is completed
when the preprocessors and
postprocessors themselves are
generated in natural language.
2. Operation procedures are
automated by using a systematic
and versatile truth-table
constructor. The result is a
graphics-driven operational
procedure that can be generated
and executed in the same session.
3. Flow network of various types of
components, such as those found in
piping system and any dynamic
structure, can be set up to produce
the graphic analysis model for large
production codes or built into such
codes themselves.
4. Schedulings of projects and
inventory control are hardwired
into the natural language program
based on previously constructed,
natural language programs.
5. Multi-level-menu driven
modeling of various physical or
social phenomena, such as health
care and sport analysis, have been
naturalized to allow an expert in
certain field to computerize his
knowledge and experience without
having to know anything about
computer.
6. Simulation of general physical
phenomena, often via animation,
will be the major thrust of the
natural language programming
effort. The goal is to rewrite in
natural language all the existing
simulation programs that have
been written in computer
languages.
Extensive benchmarking efforts
need to be carried out between the
natural-language programs and
those of the computer language, as
well as with experimental data. This
would be the only way that the
computing community can free
itself from the restriction by the
large sizes of the programs and the
large numbers of programmers that
can be involve in its development.
Natural language programming,
with the aid of software robots, is
designed for collective
programming that would be
comprehensible to all the
programmers, whose number,
therefore, can be unlimited.
SOFTWARE ROBOT SPECS
All the processing on ROBACUS are
recorded into verbatim document
files. These files are called software
robots, as they can re-enact the
processing on their own.
To invoke robot processing, simply
click the option down the
processing route you want, Or use
the [Enter] key to accept the robot
default value and mouse
click(indicated by the mouse
pointer). Clicking the left mouse
button invokes the step-by-step
processing. Clicking the right button
invokes automated processing by
robot. You can always interrupt and
take over the control by clicking the
left button. At that point, you can
just modify the processing by
entering new data.
For lengthy processing, a schematic
is displayed at the beginning of the
processing that contains all the
components of the processing. By
clicking a component box will direct
the robot to execute to that
component offline, so that the user
can start processing at that
component. A clicking of the right
button would again direct the robot
to execute automatically to the end
of processing, unless interrupted by
a left button press. Press the [End]
key would take a user directly to
the end results.
The robot file is named with the
fourth letter being 'r'. The first 2
letters indicate the program. The 3rd
indicates type of processing - input,
output, generation, preprocessing
and post-processing. The 5th and
6th letters indicate the problem
model. In certain cases it is possible
to modify the robot file directly to
make the desired modification to
the problem. But this does not
guarantee the processing will be
consistent and correct. So such
practice is not recommended.
FORTRAN SPECS
FORTRAN is used to develop
ROBACUS because of its simplicity.
In fact, only a subset of FORTRAN is
allowed to be used to achieve
maximum simplicity. All English
alphabets are capitalized for easy
visibility. Furthermore, a variable
naming convention and strict
grammar is followed to allow users
to expect maximum consistency
and structure in the program
modules. All this is extensively
planned out in preparation for the
ultimate aim of finally passing all
the programming to the computer.
The FORTRAN rules are described
with the help of actual sample
statements. The naming of variable
and FORTRAN grammar are
explained in the naming convention
file, namspe.html.
1. Comments are precede by a "C"
in column one:
C*** EXECUTION FLOW CONTROL
***
2. Subroutine statement with name,
SUBNAM, starting in column 7, with
arguments, ARGNA1 and ARGNA2,
which are passed between the
subroutine and its calling routine:
(6 spaces)SUBROUTINE
SUBNAM(ARGNA1,ARGNA2)
3. Character strings are declared for
argument and other variables with
length=40.
(6 sp)CHARACTER*(*) ARGNA1(1)
(6 sp)CHARACTER*40 TITLES,QUESTI
where the character length for a
string only needs to be declared as
'*(*)' and the size of an array as (1).
4. the RETURN/END statements are
used to end a subroutine
(6 sp)RETURN
(6 sp)END
5. Calling statement of this
subroutine:
(6 sp)CALL
SUBNAM(ARGNA1,ARGNA2)
6. Dimension statement declare
array
dimension:
(6 sp)DIMENSION REAARR(10)
7. Integer variables are prefixed by I,
J, K, L, and M. All else are real
variables.
8. Common block, AUTDAT,
declares common use of variables
in different subroutines. Any
numbers enclosed in
parentheses(see rule 7) are the
number of elements in the arrays:
(6sp)COMMON/AUTDAT/LOGAUT,
NUMAUT,LOG
9. Continuation signal is a '+' in
column 6:
(5sp)+COL(20),LOGBUG,LOGVER,IDE
AUT(1050)
10. Character string operation
where the resultant string is equal
to 1st NUMCHA characters
combined with the segment
between 5th and 10th character
and attached by the last LASCHA
characters of, respectively, RESSTR,
STRONE and STRTWO.
(6 sp)CHARACTER*40
RESSTR,STRONE,STRTWO
...
(6sp)RESSTR=RESSTR(:NUMCHA)//S
TRONE(5:10)
(6 sp)+//STRTWO(LASCHA:)
11. Assign a string value to QUESTI
(6 sp)QUESTI='TIME INCREMENT?'
12. Initialization of variables is done
with DATA statements:
(6 sp)CHARACTER*6 ANIFIL(2)
(6 sp)DATA
ANIFIL/'table0','boubal'/
13. GOTO statement goes to a
CONTINUE statement:
(6 sp)GOTO 155
...
155 CONTINUE
14. IF/THEN/ENDIF block enclose a
contingent execution process:
(6 sp)IF(LOGFIR.EQ.1)THEN
...
(6 sp)ENDIF
15. DO loop indexes sequential
execution involving elements of
arrays:
(6 sp)DO 100 I=1,IM
(6 sp)SUMVAL=SUMVAL+EACVAL(I)
100 CONTINUE
16. Arithmatic operators are:
+,-,*,/,** for add, subtract, multiply,
divide and raising to the power,
with precedence start with:
(**),(/,*),and (+,-) ,and parentheses
can be used to force the operations
enclosed to be executed as a group
prior other executions.
* Relational operators are:
.EQ.,.NE.,.GT.,.GE.,.LT.,.LE.,.AND.
and .OR. for equal, not equal,
greater than, greater and equal,
less than, less or equal, logical AND
and logical OR.
* External files can be OPENed
with:
(6 sp)OPEN(11,FILE='extfil')
where both '11' and 'extfil' can be
replaced by an integer and a
character variables, respectively.
17. READ and WRITE statements are
used to read in data from
keyboard(on unit 5), robots(50),
and other files, and write out data
to screen(6),robots(60), debugging
file(70, except editor on 60), and
other files:
(6sp)WRITE(NUMINP,1111)REAVAR,
INTVA1,
(5sp)+INTVA2,CHAVAR
1111 FORMAT('REAL
VARIAB=',1PE12.4/
(5sp)+'INTEGE VARIABS=',2I5/
(5sp)+'CHARAC VARIAB=',A40)
18. Unformatted READ(N)/WRITE(N)
can also be done without specifying
a format number.
19. Where the format statement
1111 FORMAT specifies the format
of the variables to be outputted,
with real number formats being the
floating format, 1PE12.4, meaning 1
non-zero digit to the left of decimal,
a total of 12 spaces and 4 spaces to
the left of the decimal, and also the
fixed-point format, F10.2, with
similar meaning except the
exponential part,...E0?, absent.
2I5 means 2 integer variables in 5
spaces and A40, 40 spaces.
The single quotes are used to
enclose string to be directly
displayed in the output. Double
quotes can also be used when
single quotes are to be displayed.
20. A check for the end of file can
be included in a READ statement:
(6sp)READ(11,1111,END=185)STATE
M
...
185 CONTINUE
21. Files can be released or deleted,
respectively, by:
(6 sp)CLOSE(11)
(6 sp)CLOSE(12,STATUS='delete')
22. Main-program subroutine does
not need a subroutine statement
C***** MAIN PROGRAM
********** C SUBROUTINE MAIN
23. The execution can be stopped
by:
(6 sp) STOP
DATA FILE SPECS
ROBACUS would have a difficult
time understanding the big fuss
people made about data base. This
is because ROBACUS never needs to
be conscientious about the
existence of a data base. Everything
is done in the natural course of
action, with data files automatically
managed by ROBACUS via a
unambiguous naming convention
built into the software modules.
The only time things becomes
nontrivial is when data files are
used to link independent processing.
Yet, still, everything is in the names.
We need a versatile naming
convention with a file bookkeeping
system that is clearly understood by
all ROBACUS modules.
As described in the file
namspe.html, or naming
convention html file, the file
bookkeeping is done by the data
file that has the alphabet, 'd', as the
4th letter. This data file summarizes
all the linking data files named with
the 4th letter, d, replaced by 0 thru
9 and their respective data
argument list and any format(if not
binary).
At the beginning of a processing
where data or graphics files are
generated, the user would be asked
whether where each of the files is
linked to. This and other
information about the file would be
stored in the file, ???d??, where the
1st 3 '?'s are the prefix and type of
the processing module to be linked
and the last 2 '?'s identifies the
problem modeled of the linked
processing.
Specifically, after prompting for the
information about ???d??, a check
of the file would be performed to
see if the generated file is already
listed in the ???d?? file to
determine if writing it in is needed.
Then at the beginning of the linked
processing, a check would again be
made of the existence of the ???d??
file. If it does, the data file names
would be read off and provided for
selection by the user during the
processing. In the menu for the
selection of all the files in ???d??,
an option for removal of a
particular file should be provided in
case a file is found that is now
useless.
ROBACUS VIDEO CLIPS
ON YOUTUBE
ROBACUS DEMOS FOR BALL DROP
AND SPACE NUCLEAR REACOR
DESIGN
https://www.youtube.com/watch?v
=jzEj6rQOWfU
ROBACUS song -- RObotic aBACUS,
in Chinese
https://www.youtube.com/watch?v
=nGoMIqJx120
ROBACUS song -- RObotic aBACUS,
in English
https://www.youtube.com/watch?v
=_8SqrU4nfeo
Video presentations of ROBOCOM,
predecessor of ROBACUS
ROBOCOM PREFACE -- Robotic
Computing
https://www.youtube.com/watch?v
=aUhNe1l6spc
ROBOCOM Overview -- Part I
https://www.youtube.com/watch?v
=jr91NedvVV4
ROBOCOM -- Overview -- Part II
https://www.youtube.com/watch?v
=4EKZNTOK6vM
ROBOCOM -- Introduction -- Part I
https://www.youtube.com/watch?v
=QXRn-agiIeo
ROBOCOM -- Introduction -- Part II
https://www.youtube.com/watch?v
=H_XcpqtU6-I
0:03 / 5:18
ROBOCOM Development -- Part I
https://www.youtube.com/watch?v
=p9X4iS6xW-I
ROBOCOM Development -- Part II
https://www.youtube.com/watch?v
=BNYeaOj-6Ak
THE DREAM MACHINE, the ultimate
computer game for materialist
https://www.youtube.com/watch?v
=RmvitF6LEss
Major program sources of ROBACUS:
iolupd = c-language program(with
xwindows system) for i/o and windows
management
na1upd = natural-language
programming language in fortran,
interpreted by f2c
edeupd = robotic editor(use "e filename"
to edit filename) enter "h" to get help
dieupd = diagnostic debugger
useupd = user interface controller