W. Kandinsky, Landscape with rain, 1913.
The Ultimate Programmer's Tool
CASE tools are all about scaling and abstracting, so the real questions are what
scale we should use and how to abstract.
The UPT consists of two parts : SourceView
and object-oriented design tool.
SourceView is or entirely or in some dergree language-dependent.
But OODT is independent tool for object-oriented analysis and design.
I want to be able to do diagram "debugging" - walk through the
diagrams with attributes of objects changing according to the current
diagram. And this could be integrated with an usual source code debugger
when instead of stepping from one line of code to another, the program
"jumps" from one node in diagram to another. And those "jumps" could be
done not only in run-time but also when a programmer is doing some
research.
The program should be very very customizable, but it should have
some predefined profiles. The customization must be very easy to use.
It means the user can easily navigate through numerious options without
getting desperate.
We should add features : precondion and postcondition for functions and/or objects.
Sometimes we could set them automaticly, but in most cases it would be set manually.
Based on the code we can enforce it through out the whole function calls chain.
The competitor's program, Rational Rose, provides:
- A code generator that automatically carries forward
user-supplied declarations and definitions from the previous
iteration, and annotates generated code with design
information not representable in C++.
Annotations are structured comments
- An analyzer that reverse engineer an implementation's
classes, class relationships, logical packages, components,
modules, relationships, and component packages from
implementation source code, utilizing information contained
in annotations when present.
- A model differncing mechanism that reports architectural
differences between an iteration's initial design and
the "as-built", reverse engineered, impementation design.
- A design update mechanism that updates the iteration's
initial design to reflect architectural changes introduced in
its implementation.
Open questions
-
Is it good idea to make a version control system to work on level
of functions, variables, classes?
- Is it feasible to differentiate between editor and browser?
The browser could be any standard VRML brower and the editor
will create VRML worlds of programming projects. Thus all of
researching, searching, and debugging could be done in a
standard VRML browser.
- How can we do the tool more popular. We can do it by making
it easy to use. This is the key feature (easy to use) on which
we can build the base for competition. We have to merge somehow
the OMT concepts with the diagrams' drawing program.
- How can the changes done in source files effect the diagrams
or vice versa? How could software construction iteractions and
maintenance be handled properly? There are too many troubles
with PVCS.
- Macro Language?
- We need to think how a team of programmers could use the Tool
together. Should it be something like newsgroups reader? Every
object has links to newsgroups where it is being discussed. Does
this mean that we need to write a newsreader application or we
can use a user-defined one, or both of them using ours as a
default.
- If we want to post our project files on the internet server,
should we have a some sort of ftp gadget?
Design
- Every application consists of one or several projects. Each project has
several versions. Each version is a collection of files or directories + files.
-
- Application
- Project
- Version
- Directory
- File :
- Name
- Date
- Time
- Revision Number
-
Implementation details