Skip to main content


OOEL - Blog Quick Links

Posted in

I. Objectives of OOEL Blog
II. An Introduction to Object Oriented Programming and Design, and OOEL
III. Introduction: What Is a Full Blown Object Oriented Programming Language
A. What is an Object?
B. What is an Object's State and Behavior in Object Oriented Programming?
C. What Are Class Events in Object Oriented Programming
D. What is the Scope of an Object, Their Variables, and Its Methods in an Object Oriented Language?

Coming soon…

E. An Introduction to The Four Main Features of an Object Oriented Language
F. What is Encapsulation? - One of the 4 Main Features of an Object Oriented Language
G. What is Inheritance? - One of the 4 Main Features of an Object Oriented Language
H. What is Abstraction? - One of the 4 Main Features of an Object Oriented Language
I. What is Polymorphism? - One of the 4 Main Features of an Object Oriented Language
J. A Summary of the 4 Main Features of an Object Oriented Language
K. An Object Only Based Language
L. The Final Chapter: The Differences of an Object Based Language Versus a Full Blow Object Oriented Language

I. OOEL (Object Oriented EasyLanguage)

Posted in

Welcome To Our Blog All About OOEL !

Our objectives for this blog are:

1. To learn Object Oriented (OO) concepts such that one is able to place themselves in a position in which they can harness OO powers to the max.

2. To learn OOEL (Object Oriented EasyLanguage) concepts such that one is able to place themselves in a position in which they can harness OOEL's powers to the max.

3. The difference between a language being full blown object oriented, to a language that is simply Object based (like EasyLanguage OOEL currently is).

4. To provide great resources about OO and OOEL. As they say, give a man/woman a fish and they have diner. Teach them to fish and they can have as many diners as they wish.

5. Most Importantly: To break down any walls of anxiety or fear of what OO is and how to use it. Especially when you have mastered a non OO language like EasyLanguage, but is slowly headed down the road to becoming a full blown Object Oriented language. This can be frustrating for many. So if you are a master of EasyLanguage, but know next to nothing about Object Oriented programming and design, I hope this blog will help you feel you can learn and master the new EasyLanguage OOEL abilities.

6. To provide a free single point of contact for everything about OO and about OOEL.

Here is the link to the Main OOEL Blog.

See some powerful OOEL Indicators and Strategies "OOEL Indicators and Strategies".

Please feel free to comment on what you would like to see in this blog.

II. Object Oriented Programming and Design

Posted in

An Introduction to Object Oriented Programming and Design, and OOEL (Object Oriented Easy Language)

A. The Beginning of Object Oriented Programming

The first language to use the concept of Objects was Simula 67. It was created in the early 1960's by Kristen Nygrad and Ole-Johan Dahl in Norway. As the name suggests, it was created to make simulations easier to program and maintain. Simula was the first to introduce the concept of a class**.

However, the first language to be considered full blown Object Oriented was Smalltalk. Smalltalk was somewhat of a spin-off of Simula 67, but was the first language to introduce the concept of inheritance**. It was this feature that allowed Smalltalk to surpass Simula 67 in both commercial and experimental use. It was created by Alan Kay from the University of Utah, and was later sold to Xerox Parc. Interestingly, Smalltalk still exists today but is used very little in the commercial world.

B. The Results of the Object Oriented Movement

The idea of using objects as the basis for a language caught on fire in the 1970's and early 1980's. As a result, Bjorn Stroustrup, the Chairman of Computer Science at Texas A&M University, took the language C and integrated object oriented capabilities. The experiment resulted into the creation of the OO programming language C++, which would quickly became the most widely commercially used language in the world. To this day, C++ is still one of the most commonly used languages and Stroustrup is considered one of the most distinguished software engineers ever.

C. The Influence of C++ on Modern Object Oriented Programming

In the Early 1990's, a software engineer from SUN Microsystems, named James Gosling, a PHD from Carnegie Mellon, along with Patrick Naughton and Mike Sheridan set out to create a new technology that could take advantage of the internet boom. The group would eventually end up calling their endeavor the Green Project. It was a 2+ year project that resulted in to a new programming language called Java.

Why another object oriented programming language?

Java was a spin-off of C++ but was meant to remove all of the weaknesses of C++ and to make it easier for programmers to write internet based programs. Along with that, the second aspect of Java, and many world argue the most important, Java is platform independent**. At the time, a language that was platform independent was considered an extremely novel idea. This means that a Java program could be run on a windows platform, Macintosh platform, UNIX, and such, without having to change the code.

The promises of Java created a massive amount of attention. But that was the very thing that hurt Java when it was first launched. It was a language that had many promises but failed to live up to those novel ideas. It was extremely slow and creating a GUI for the internet or a simple application was a quite a project.

However, from its launch in 1995, version 1.0, to the modern Java, version 6, the majority of those who have used Java would probably say it has met its promises and went way above and beyond. It is now one of the most, if not the very most commercially used language in the world. There are companies and internet sites, such as, that measure the commercial uses of programming languages. Java is ranked the highest according to most sources. However, determining the most commercially used language is without question not a science. And many would argue that C++ is still the most popular.

From a commercial standpoint, whether its C++, Java, or Visual Basic, Java has without question brought to the world of software engineering a very flexible and easy to use object oriented language.

D. In Conclusion

As mentioned above, C++ and Java, by most measures, are the most popular languages for creating commercial and IT programs. However, the number of Object Oriented languages since the turn of the millennium, has exploded. To even begin to touch on them is way beyond the scope, and point, of this brief introduction.

Further, what has also occurred, is that languages that have existed for years, that were not Object Oriented, have implemented OO abilities in to their language. From Cobalt to Turbo Pascal, to Microsoft's Visual Basic. And for those who use Easy Language, they are well aware of this movement. In other sections of this Blog, we will examine why OO abilities seems to be a natural part of the evolution of most languages. Then, how to deal with this evolution if one is not familiar with Object Oriented Programming and Design.


For an extensive look at the origins of Object Oriented programming, you can find it at:

It goes into great details, but somewhat assumes the reader already has a strong background in Object Oriented Programming.

Any topic marked with a double asterisk ( "**"), will be disguised in great detail in future blogs. However, for those that are curious, using Google will provide more information that you could ever need. But you can be sure future blogs will provide an enormous amount of information and examples in a well organized manor.

The three topics marked with a double asterisk are:
1. Classes
2. Inheritance
3. Platform Independent.

I searched multiple web sites, and for those who do not want to wait until this blog covers those topics, you may be interested in the following sites:

1. Classes -

2. Inheritance -

Platform Independent -


BLOG Resources:
1. The Java Handbook by Patrick Naugton
2. The Java Class Libraries by Patrick Chan and Rosanna Lee
3. Patterns in Java by Mark Grand
4. Sun Certified Programmer and Developer for Java 4 by Kathy Sierra and Bert Bates

See some powerful OOEL Indicators and Strategies "OOEL Indicators and Strategies".

III. Introduction: Full Blown Object Oriented

Posted in

What Is a Full Blown Object Oriented Programming Language Versus an Object Based Only Language

To examine the differences between a full blown Object Oriented (OO) language, versus a Object based only language, we must first define a full blown Object Oriented language. Then, define an Object Based language and investigate the differences.

A full blown Object Oriented language is one that supports the following four features, or you could say functionalities. To be consistent, lets refer to them as features throughout this blog (Also, because there are languages termed "functional", that have different characteristics than an Object Oriented language, we will stick with the term "features").

The four features that make a language full blown Object Oriented are:

1. Abstraction
2. Encapsulation
3. Inheritance
4. Polymorphism

Now, this is the hard part to teaching those not familiar with OO languages. In order to define these four features, you must give examples. So, I could give examples in Java, C++, or any full blown Object Oriented language. But because my reader base are mostly easy language developers, that would defeat the point. I cannot assume my reader base knows any one particular language except Easy Language.

So, then naturally that begs the question "why not use EasyLanguage OOEL (Object Oriented Easy Language) to create examples." Well, because OOEL is not yet a full blown OO language, it of course is not possible to create 4 original examples. So now what? Well, thankfully, OOEL does provide a full blown OO library that we can use for examples. Again, I would prefer to create my own examples, because it makes learning these four features easier, however, again, because OOEL is not yet full blow Object Oriented, the libraries will have to do the job.

However, before we start that, I must assume the curious reader. For the curious reader, I am going to provide some links. I apologize the constant use of Wikipedia, but to be honest, and I have taken my time in finding resources, and Wikipedia provides not only some of the best definitions, but other resources. Thus, before I move forward, let me provide some resource links.

And again, we are going to go over each one in depth, so my reader is familiar with each feature. But there is always the eager reader that does not have time to wait for me:)

One more thing, I will be using pseudo code in order to generate what a future class in OOEL may look like. So what is pseudo code? Pseudo code is basically a way to express code that could apply to any language. Pseudo code could never be compiled, because, well it's not an actual language. It’s a high level description of a computer program, or lines of a program, that expresses any language, but reads like English (assuming one speaks and writes in the English language). Feel free to Google on "pseudo code" for those not familiar with the term. I will take actual code in Easy Language and express it in pseudo code so one gets an idea of how and why pseudo code is used.

Here are some resources, on the four features mentioned above, for the curious reader that will assist them understand what exactly makes a language Full Blow Object Oriented.

1. Abstraction -
a. science)

2. Encapsulation

3. Inheritance

4. Polymorphism

One should also be familiar with classes:

5. Objects and Classes

See some powerful OOEL Indicators and Strategies "OOEL Indicators and Strategies".

B. What is an Object's State and Behavior?

Posted in

What is an Object's State and Behavior in Object Oriented Programming?

For the most part, you can count on Objects having 2 very important characteristics:

1. a STATE and

For example, using our Vector class, first mentioned in the blog A. What is an Object, we defined a class like the following:

Vector closingStockPrices(null);

closingStockPrices = new Vector; // This creates an instance of the class Vector

We created an instance of the Vector class, closingStockPrices, to hold the closing prices
of "X" number of stocks.

An example of changing an Object's "State" would be manipulating its Easy Language OOEL Count variable, which is the number of elements (closing stock prices) in the Vector. If our "closingStockPrices" Vector holds 10 stock prices, its Count "State" would equal 10.

A Behavior of a class are defined by their methods. Their methods of course manipulate an Object's State (It's important to know there are other usages of an Object's methods that will be discussed later).

As an example of manipulating a classes' State, would be adding elements using the Vector's "Insert" method, and removing elements using its "Erase" method, both manipulate the State "Count." Further, the methods Insert and Erase are part of a Vector's behavior ( The full definition of a Vector's behavior is defined by the rest of the Vector's methods).

The Following is a TradeStation OOEL Code Example:

{The code to increase the Vector's Count "State" by one may look like the following}


{Then to decrease the Vector's Count "State" by one may look like the following.
Note that the variable "ElementX" represents a number to the element you wish to erase. In this case the element is the closing price of a stock.}


From that, I hope my readers now understand, in most OO languages, including Easy Language OOEL, we manipulate the State of an Object via its methods. And the methods define an object's "Behavior", and its "States" are kept in Class variables, such as the Vector's Count variable in the example above.

See some powerful OOEL Indicators and Strategies "OOEL Indicators and Strategies".

C. What Are Events In Object Oriented Programming?

Posted in

In B. What is an Object's State and Behavior?, we discussed two characteristics the vast majority of object's hold:

1. a STATE and

There is another characteristic that one most learn to fully understand Object Oriented Programming. I separated this characteristic from an object's State and Behavior, because it's not nearly as common. Nonetheless, it is a very powerful characteristic that in many ways separates an Object Oriented programming language from a none OO language such as Easy Language prior to version 9.
NOTE: If you are familiar with Java, C++, or C#, or any other OO language, then you have probably used events and event listeners. The event design in OOEL is very similar.

So what exactly are Object Events?

The most precise definition is certain object's kick off Events when their State changes.

But as always, the easiest way to explain this is through an example. Lets use TradeStation's OOEL class "Button" (this can be found in the WinForms.ell library). Now, imagine you have a window that processes the selling and buying of stocks. On this window is a Button titled "Execute".

So what do you do with a button. Well you press it to create a particular Event. When you press a button, its "state" changes from "not pressed", to "pressed". Thus, this sparks an event. In this case it would process the buying or selling of a stock. Now, each event is given a name. In this case the event a OOEL button kicks off is called "Click".

So, now that we have explained what an Event is in Object Oriented Easy Language, what happens when the event kicks off. In the example above, we want the event to kick of the buying or selling of a stock. To do this we have to assign to the event an "Event Handler". In OOEL, an event handler is nothing but a method that gets kicked off and processes any logic you have placed in the method. Again, in our example it would be the buying or selling of a stock.

The following code examples are what Object Oriented Easy Language my look like when assigning an event handler to an Event. For example's sake, we will assume we have created the window for buying and selling stock. Further, we can assume we have created a button called Execute_Button, which is titled "Execute". The user enters the stock information in the window, and uses the Execute_Button to process
the buying or selling of the stock.

{First we create a method that assigns the events. In this case we assign the event
handler "processBuyOrSell". This method gets called when the user presses the
button "Execute_Button" and the event "Click" gets kicked off}

method void assignEvents()

// This says when someone clicks on the button, call the method
// "processBuyOrSell" += processBuyOrSell;


{This is the event handler method for the button - Execute_Button. It is called by the runtime system when a user presses the button and the event "Click" is kicked off.
By "runtime system" I mean it is kicked off automatically. You do need to call this method directly in the program. Again, it is called automatically when someone presses the "Execute" button.}

{Notice the parameters "elsystem.Object sender" and "elsystem.EventArgs args".
These must be there or the program will not compile. The "sender" parameter
is a handle to the object that kicked of the event. In this case it would be our button -
Execute_Button. The parameter "args" is a handle to the event that was kicked off.
in this case it will be the event "Click". Having these handles can be extremely
helpful. In this case you probably would not use them. But you can assume they
come in handy given Tradestation OOEL forces you to create them, as do many
languages when creating an event handler method }

Method void processBuyOrSell(elsystem.Object sender, elsystem.EventArgs args)

//Depending on what the user has selected, the code in this method
//will perform the actual buying or selling of stocks
process buy….
process sell…


So again, think of an Event as something that kicks off when the state of an object changes. Once you assign the event handler, and the event is kicked off, you can think of it as an Object as saying "My state has changed, please handle my event so the appropriate action can take place and the program stays in a logical state."

Once the event handler method has been assigned, the method can be placed anywhere in the program. Its order in regards to other methods has no bearing. The logic in the program is not executed from top to bottom. Instead the appropriate logic (method) is kicked off whenever and wherever the event occurs. This separates Object Oriented Easy Language from Legacy Easy Language.

Although an Object's State and Behavior are the main essence of an Object, in many ways it's Events that separate Object Oriented languages from top-down languages. These languages are simply programs with lines of code that a processed in a top-down manor. As mentioned earlier, this describes Easy Language before version 9.0. With Events and methods, now you can have your code executed in a more logical manor, and the design of the program is much more flexible. Which is one of the very reason Object Oriented concepts evolved. After all, the mother of invention is necessity.

See some powerful OOEL Indicators and Strategies "OOEL Indicators and Strategies".

A. What is an Object?

Posted in

Before we dive in to the four features mentioned in III. Introduction, to discuss Object Oriented Programming we must define what exactly is an "Object".

An object can be considered a group of code, related to one another, to represent an "object or concept in the real world". Most only use the word Object. However, as you read more, I will explain why I mention the term "concept" also.

An object my be a person, car, house, a Tradestation chart, or an MS excel sheet. A concept could be a Vector, a TradeStation Strategy, Indicator, and the such. However, to be consistent with Object Oriented language we will group everything in to an Object. Although as someone's "thought" is not an actual object, it is more of a concept, in the Object Oriented world it would be considered an Object. If a programmer started to design a program to represent people's thoughts, they would design it such that their thoughts are objects. Which is why it's not called Object Concept Oriented Programming. It of course is only called Object Oriented Programming

The actual code implementation, and an actual instance of the object, is created using a "class". Thus, a class simply represents the object in terms of actual lines of code. Whether that code be in Java, C++, C sharp, and OOEL. An example of a class in OOEL is a Vector. To actually use that object, we "instantiate" the class that represents the object.

Lets look at this in TradeStation OOEL. Vector is an Object in programming, the code behind the vector is a class. To create an instance of the Object, we declare a variable to the class, and use the EasyLanguage OOEL key words "new".

Vector LastNames(null).

LastNames = newVector;
{This creates an instance of the class Vector. The class vector has been created for us by TradeStation to represent the concept, or should we say object - Vector. In this situation we create an instance to hold Last Names}

See some powerful OOEL Indicators and Strategies "OOEL Indicators and Strategies".

D. What is the Scope of an Object in Object Oriented Programming and OOEL

Posted in

Section 1. What do We Mean by Scope?

One must not forget, during this entire discussion on Scope within an Object Oriented Program (OOP) we are not talking about just the Scope of Variables, but also Classes and its Methods. Thus, to make it clear, scope in OOP deals with:

1. A Class
2. A Classes Variable and
2. A Classes Methods

The following subject is not extremely complicated, but the hard part of explaining this in OOEL terms is problematic because TradeStation does not provide the code behind the Object Oriented Easy Language classes they provide us. Because of the limitations of not being able to see the code behind the classes, I will do my best in creating hypothetical examples in the following sections to fully explain the concept of Scope in the vast majority of Object Oriented Languages (I use the terms "vast majority" because there are always OO languages that have exceptions).

But before we examine the scope of an Object or an Object's Variables and Methods, we must first define what we mean by "Scope".

So what is Scope?

Scope is often referred to as Visibility. This is important because if you understand the concept of Visibility in OO programming, you will more than likely understand the material in this blog.

Before we dive in to the different scopes in an Object Oriented Language, lets simplify things and look at variable scopes in a standard Easy Language program. This we help in understanding the main concept of Scope.

We can define scope more easily using concepts that everyone is familiar with.
Since anyone who has programmed with Easy Language, has of course used variables. If you specify a variable at the top of a program, meaning not in a method, what is it's scope? Well its scope is universal within that program. You can use it, and change it, anywhere.

For Example, lets say we have a program called DisplayAverageVolume. At the top of that program we declare two global variables:


Because these two variables are declared at the top of the program, and most importantly outside any method, they have "global" scope within the given program. Which again, means a programmer can use and change the variables anywhere in the program.

Now, if you create a method and declare a variable within that method, what is its scope? Well you can only specify and use it within that method. This means the variables have
"local" scope, not "global".

However, you can extend the scope of a local variable by passing it to another method using the method's parameters. By doing this, now you have extended the scope of the local variable from not just the method in which its declared, but by passing the local variable to another method. However, this is the only method you can use to extend the scope of its local variables. By Easy Language forcing you to extend the scope of a local variable through a parameter, notice it makes it clear to those reading your program, where that local variable is being used, and maybe more importantly, not used. This is unlike global variables, where the reader has to search for global variables throughout the program to see where they are not only used, but changed. This is an important concept we will be covering in further sections and blogs. But for now, lets just focus on the
concept of Scope.

For Example, lets say we create a method "Main" with two local variables: l_Stringx and

method void Main()
string l_Stringx,
int l_Counter;

Now lets say we create another method named processVolume, with one parameter that is type "int".

The signature of the method may look like the following:

// The parameter is "int p_Counter"
method void processVolume(int p_Counter)


Now, if you had the following statement below, inside processVolume, or the method Main, you would not get a compiler error because aVolume has a global scope.

// This would not create an error because remember, we declared
// the variable aVolume as global. Thus it can be referred
// to anywhere.
aVolume = Volume;

Now, if inside the processVolume method, you placed the following lines of code:

// This would create an compiler error. Why? Because we
// declared the variable local to the method "MAIN". Thus, it
// can only be directly referred to inside the method Main,
// and only Main.

if l_Counter = 1 then

What about if you want use the variable l_Counter inside of processVolume? You can pass the variable l_Counter in to the method processVolume as a parameter.
For example, inside of the method Main you would have the following line of code:

// This calls the method processVolume and passes in l_Counter
// as a parameter that can be used in processVolume

Then, inside of the method processVolume(int p_Counter), you can now use the local variable declared inside the method Main, l_Counter, through the parameter p_Counter. Thus you could have the following line of code that would not create a compiler error. And notice we have now extended the "scope" of the local variable l_Counter, by passing it to processVolume as a parameter.

// The parameter p_Counter refers to the local variable
// l_Counter declared local inside the method main

if p_Counter = 1 then


In an Nutshell, this is the definition of scope. So far we have dealt with scope by examining where you can use a variable within a program in standard Easy Language code. Although the concept's of scope we have discussed apply in the Object Oriented Easy Language world, it extends to classes, their methods, and its variables. They too have certain scopes as we shall see in the next few sections. But the important thing to keep in mind, are the different type's of scopes become much more complex in nature.

See some powerful OOEL Indicators and Strategies "OOEL Indicators and Strategies".


Coming soon…..

Section 2. The Different Types of Scope In Most Object Oriented Languages

Section 3. The Scope of a Class in OOP

Section 4. The Scope of a Class Method in OOP

Section 5. The Scope of a Class Variable in OOP

Section 6. Introduction of Get and Set Methods

Section 7. Conclusion

Here is the link to the Main TradeStation OOEL Blog.

Syndicate content