Along with providing tutorial videos, we are
starting to create a video course in the Prograph language and the use of the Marten IDE.
We are planning additional lessons, so look for more videos soon.
The initial lesson, "Lesson Zero", illustrates how to install the Marten
integrated development environment (IDE) on your Mac after downloading it from the
Andescotia website. This lesson shows you where to
place the Marten libraries and application frameworks in the appropriate folders on your system.
In addition, the lesson
also demonstrates the creation of a simple "Hello World" application.
Prograph Lesson 00
The first actual lesson in the Prograph language starts with a demonstration of an actual industrial
application created using Marten and written (if we may use the phrase) in Prograph. Prograph and Marten
are not toy or demonstration languages and software. They are meant to allow professional developers to
create professional applications for the Mac OS X and soon, the Windows platforms. After the demonstration,
the lesson moves to a discussion of the various kinds of code operations that are supported and available in
the Prograph language. Among the operations discussed are the Constant and Match operations, the Persistent
and Instance operations, the Get and Set operations, the Input and Output operations,
and finally the Method and Local operations. An example
of a Primitive operation was provided in Lesson 00. The various External operations (external constant,
external match, external get, external set, and external procedure) are not discussed in this lesson.
Prograph Lesson 01
The second lesson in Prograph discusses methods and illustrates the External operations. Prograph categorizes
methods as Universal or Class methods. When Class methods are placed as operations in a case, they may be
executed in three different fashions. The most common is as a "data driven" operation but they can
also be executed as a "name driven" operation or a "context driven" operation. Of those three types,
Data driven and context driven
method operations are illustrated in this lesson.
Prograph Lesson 02
The third Prograph lesson starts with a discussion of the "context driven" method operation for a Class method.
Since the most common use of a "context driven" method operation is in conjunction with the
"super" control annotation, the discussion naturally moves on to control annotations and how the Next, Continue,
Terminate, and Fail control annotations work. Several examples are demonstrated in the debugger. The Finish control
annotation is not discussed in this lesson.
Prograph Lesson 03
The fourth Prograph lesson picks up where Lesson 03 left off, which was the discussion of the Finish control
annotation. To discuss the Finish annotation, Repeat annotations for methods and locals are discussed along with List and Loop
terminals and Loop roots. Basically, how to get operations to repeat and consequently execute multiple times.
Examples include the use of lists, loops, and repeats to modify the integer addition "++" primitive to
compute the sum of all integers in a list. That example is expanded upon by enclosing the "++" operation
in a repeating local that enables the summing to be finished
(using a Finish control annotation on the Output Bar operation) should the list contain a NULL element.
Prograph Lesson 04
This next lesson illustrates the use of the inject terminal. The inject terminal provides
a way for an operation to receive "meta data" in the form of the operation text. For example, an inject terminal
into an Instance operation allows you to create an instance of a class specified at runtime. This is done by supplying
the name of the class to the inject terminal. An example of using an inject terminal into the Evaluate operation leads to
a discussion of the uses of that particular type of operation in evaluating algebraic expressions. Finally, examples of
inject terminals into external procedures start a general discussion of external operations such as external get and set operations
along with external procedures. The lesson finishes with an illustration of two particular Cocoa external procedures and how they provide for
the execution of a Cocoa program.
Prograph Lesson 05
In this lesson we take a different tack. We illustrate how to create a "Tool" method, which is code that you write
and can call from the Marten IDE to perform a useful function. One use of a Tool method is to create a test of some sort, perhaps
a regression test of important but fragile code. In this example, we create a "documentation" tool that allows the user to
read and write documentation for any entity (class, method, or persistent) in their project. As we code up this tool, we illustrate
the very useful refactoring commands: "Operations To Local" and "Local To Method". In addition, we discuss various primitives
along with the "Create Accessor Methods", "Move To Section", "Reveal Container", "Tidy Operations", and other commands.
Prograph Lesson 06