Proto Software

Docs

Getting Started

Introducing Proto

This short introduction to Proto will give you the necesssary background to move through the tutorials with ease. There are a couple of vocabulary words to learn like Builder, Viewer, Entryset, and Attribute. Once you have those down and understand conceptually how data flows between modules, you are ready to go.

Proto Financial consists of two different environments: the Viewer and the Builder.

The Viewer window is the interface that a user will see when using your application. It will display the Tables, graphs, and other UI elements that you want to expose to the user.

The Builder window is the place where you design Proto applications. Here, you develop your program's underlying logic using Proto's basic building blocks: modules.

There are many different types of modules in Proto and each performs a different function. Some modules are invisible to the end-user and are available only for data manipulation. For example, there is a module that sorts the rows in an Entryset based on the values in one of the columns. Other modules, called User Interface (UI) modules, will affect the way your application looks to the end-user. Some examples of these are sliders, buttons, checkboxes, and pie graphs. Each UI module that you use will have a corresponding UI element in the Viewer; meaning, once you place a Pie Graph module on the Builder, there will be a Pie Graph on the Viewer (although simply doing this won't produce a very interesting Pie Graph since there will be no data to plot). The last type of module is the Custom Module. Custom Modules are built from a combination of basic modules and therefore can greatly extend the module palette. Many custom modules exist online at www.protosw.com/mods. You will learn how to integrate them into your applications later in the tutorials.

Each module has a label to help you identify its use. When placing a module on the Builder, it will start off with a generic label that corresponds to its function (e.g. a Pie Graph module's generic label is "Pie Graph1"); however, you can assign any label you want to each module.

This is an example of a module in the Builder:

The modules in the Builder interact with each other via connections that are made between their output and input connectors. The connections are represented by black lines that connect the modules’ outputs and inputs, indicated by small blue arrows on the sides of the modules

You can think of each module as holding data or performing some task. As one might expect, data that resides in one of these modules will flows out of its output connector, travel through a connection, and then flow into the input connector of an attached module. Every time an action occurs, like a button press or when a new connection is made in the Builder, this flow begins again. When a module receives data at its input connector, it will perform whatever function it is designed to do and then pass the data out of its output connector.

Although each module looks like it only has one input and one output connector, many different types of connections can be made to/from each. For example, open up Proto Financial and click on the button labeled “New” to create a new Proto application. When you do, the Proto Viewer will pop up, and it will look blank. This is because we haven’t built anything yet. The Builder window will have also loaded, and is simply behind the Viewer window. Click on View in the menu bar, and then Builder. This will show the Builder window.

Let’s take a look at the Builder window. Here you will see a toolbar at the top that will allow you to insert modules, a guide on the right that when you move your mouse over an object, will give you information about it, and the main building area, right in the center.

Click on a Table module from the toolbar found along the top of the window, and a Table module will be added to the building area.

Notice that when you run your mouse over the Table module, the right-hand section of the screen (called the Guide) contains a description of it.

The Guide is useful for quick reference in Proto. It will display basic information about modules when you place your mouse is over them. Most module inputs and outputs will also have a Guide entry. So if you forget the difference in the Table between the “Get Entryset” output and the “Get Selected Entryset” output, you can roll over each output with the mouse and glance at the Guide. Lastly, you can click on the links in the Guide to jump to help contents on the web. To do so, hold down the “F” key (for freeze) to keep the Guide content from changing when you move the mouse. Speaking of connections, let’s take a look at the output connections available from the Table module.

Click on its output connector and notice the many options that are provided.

Notice that in the Guide you can see a quick explanation of what the “Get Entryset” output does:

Each module has its own individual set of inputs and outputs. They also have inputs that are common to all, held in the “General Module Connectors” list.

In these tutorials, we will touch on many of the possible input and output connections for each module.

Each input and output connection from a module has a different function and the "logic" of a Proto application is defined by the modules and connections you make. Therefore, if you want to inspect how a module works, the first place to look is the connections. Whether debugging something that’s not working as expected or learning from someone else’s component or application, the connections give you an "always on" state of the Proto module. When you mouse over a connection you can see the connection details as well as the last data that traveled across the connection. For example:

Some module inputs are created only after configuring the Property Panel. Consider the Formula above or a module like a Filter. In the Formula, the input menu looks like this when you first click on it:

After configuring the Formula with the expression, “x+y” in its Property Panel, you would see:

Note that the module input includes the name of the variables, “x” and “y”. Because of this, keep in mind that some connections will look different depending on how you name variables or other configuration properties of modules. For example, the Formula shown previously could have the same functionality with the expression “xValue + yValue”, but the connection would look like:

Viewer Representations

As mentioned before, some modules have a representation in the Viewer, while others are used for behind-the-scenes data manipulation and gathering (from Excel or any ODBC compliant database).

The modules that have Viewer representations are mostly located at the left side of the toolbar in the Builder.

These modules include a Button, Checkbox, Slider, Textbox, Listbox, and Date Chooser, as well as XY, Bar, Pie, and Contour Graph Modules. All other modules either handle filtering, manipulating, or editing data or pulling it in and pushing it out to Excel, an internal Proto Database structure, or an ODBC compliant database.

You can check this for yourself by creating one of the UI components and one of the behind-the-scenes manipulation components by clicking on them in the toolbar. Then, click the large button near the bottom right corner of the Builder window that says “Switch to Viewer” to show the Viewer window.

You should see some type of representation for the UI module in the Viewer, but none for the manipulation module.

What are Entrysets and Attributes?

There are several terms that are important to touch upon before proceeding with the Builder tutorials. The most important term is “Entryset”. An Entryset is a structured block of data made up of rows and columns with column names and row numbers.

In Proto, there are many ways to create Entrysets or to read them in from other systems such as Excel or a database. All of these methods will be discussed in the tutorials that follow. What is important to get your head around now is that the word Entryset will be used over and over again in these tutorials, so it is a good time to start thinking of tables of data as Entrysets now to avoid confusion later on.

If you break the word down you’ll notice that an Entryset is merely a set of Entries or rows, which if you think about it is a useful way to refer to a table of data, especially if you want to manipulate its contents in some way. In Proto, you are able to add, delete, sort, and filter Entries in an Entryset using a number of basic building blocks that act on Entrysets (and usually named “Entryset Something”).

You can also add, delete, sort, and rename different columns in your Entryset as well. In Proto, columns are called Attributes and the building blocks that deal with their manipulation are typically named “Attribute Something.”

To reiterate, in Proto, a table of data is called an Entryset, its rows are called its Entries, and its columns are called Attributes. Similarly, the column names are referred to as Attribute names. The graphic below shows you the parts of an Entryset in a pretty picture.

One term we have not used yet is "Cell." This is the same term used in Excel to refer to a container for a single piece of data. Each cell belongs to a specific Entry (Row) and a specific Attribute (Column). There are many different data types that you can hold in a single cell. Among them are text, numbers, dates, true/false values (or Boolean), and even entire Entrysets (an advanced topic discussed in another tutorial).

What can you do with an Entryset?

Now that you have learned the terminology, here are a few Proto examples to help you become more comfortable with it.

(Using some simple modules, you can modify Entrysets in a series of flows to accomplish the following transformations.)

Suppose we want to add several Entries to an Entryset. That would look like this:

You could do this by typing new rows into a Table, or you could merge or add rows programmatically. To read more about the basic module that performs this transformation programmatically, look at the Entryset Module. If you would like to look at a couple components that perform a similar transformation, look here and here.

We could now sort our Entries using the values in the “Money Owed” Attribute. In this case, we will sort the Entries so that the numbers in the “Money Owed” Attribute will be sorted from highest to lowest (descending).

To read more about the basic module that performs this transformation, look at the Entryset Sorter. If you would like to look at a component that performs a similar transformation, look here.

Now, suppose we want to filter out all of the Entries in the “To Whom” Attribute that are not equal to “Bob”. If we do this, our Entryset will look like this:

To read more about the basic module that performs this transformation, look at the Entryset Filter. If you would like to look at a component that performs a similar transformation, look here.

We could then add an attribute to the end of our Entryset called “Number” and fill it with values like this.

To read more about the basic module that performs this transformation, look at the Attribute Editor. If you would like to look at a component that performs a similar transformation, look here.

Now, let’s change the Attribute name “Number” to “Phone Number” and move the Attribute so it is the second Attribute from the left.

To read more about the basic module that performs this transformation, look at the Attribute Editor. If you would like to look at a component that performs a similar transformation, look here.

Lastly, we’ll delete the “To Whom” Attribute since it is assumed to just be “Bob”.

To read more about the basic module that performs this transformation, look at the Attribute Editor. If you would like to look at a component that performs a similar transformation, look here.

Next Steps

Now that you have seen some very basic Entryset manipulation examples, you should take a look at our All About Entrysets module to see how you can create, modify, combine, and do simple calculations on Entrysets in Proto. This will get you used to working in Proto using the concepts outline above.

When you open the module, the following window will appear:

Each button will take you to a different window that will step you through the process described on the button’s label. For example, when you press “Edit them in a Table” you will be brought to a screen that shows you how you can edit Entrysets inside a Table.

If you take a few minutes and step through each part of this module, it will help you a great deal as you move through the rest of the tutorials.

Already using Proto? Log In | Register