Janus SOAP User Language Interface: Difference between revisions

From m204wiki
Jump to navigation Jump to search
No edit summary
m (add link; change link)
 
(68 intermediate revisions by 6 users not shown)
Line 1: Line 1:
The ''Janus SOAP User Language Interface'', also referred to as the ''Janus SOAP ULI'', is a collection of extensions to User Language intended to simplify the coding of
The Janus SOAP User Language Interface (aka Janus SOAP ULI) was a collection of extensions to <var class="product">User Language</var> originally intended to simplify the coding of
Janus SOAP applications. Although the Janus SOAP ULI may be applicable to
applications that used the <var class="product">Janus SOAP</var> product. In version 7.5 of Model 204, the <var class="product">Janus SOAP ULI</var> features were incorporated into Model 204. <var class="product">Janus SOAP</var> continues as a separate product providing support for [[Janus SOAP|XML processing]], but no separate <var class="product">Janus SOAP ULI</var> product is available.  
applications that don't actually use the Janus SOAP XmlDoc API (XmlDoc, XmlNodelist,
and XmlNode methods), most Janus SOAP ULI facilities are restricted to Janus SOAP,
hence the name.


As indicated, the Janus SOAP ULI is a collection of extensions to User Language so
The <var class="product">Janus SOAP ULI</var> extensions included these areas:
does not alter the behavior of User Language. This is important on two counts.
#User Language applications will continue to work as they always have even after Janus SOAP is installed (and thus the Janus SOAP ULI enabled).
#All manuals related to Model 204 User Language are still valid, and information about User Language programming can be found in many manuals outside of this one. Primary sources for information about User Language include:
#*''The Model 204 User Language Manual'' from Rocket
#*[http://sirius-software.com/maint/download/funcr.pdf ''The Sirius Functions Reference Manual'']
#*[http://sirius-software.com/maint/download/factr.pdf ''The SirFact Reference Manual'']
#*The assorted Sirius product-specific API references, such as the ''Janus Web Server Reference Manual'', the ''Janus Sockets Reference Manual'', the ''Janus Open Server Reference Manual'', the ''Janus Open Client Reference Manual'', and the ''Fast/Unload Reference Manual''. All [http://sirius-software.com/maint/manlist Sirius Software Documentation] is a available for download in PDF format.
Many of the extensions in the Janus SOAP ULI come from [http://en.wikipedia.org/wiki/Object-oriented_programming Object-Oriented Programming] (sometimes abbreviated O-O) concepts that are implemented in many
languages. These languages include [http://en.wikipedia.org/wiki/Visual_Basic Visual Basic .Net] (often called VB.Net), [http://en.wikipedia.org/wiki/Java_%28programming_language%29 Java], [http://en.wikipedia.org/wiki/Eiffel_%28programming_language%29 Eiffel], [http://en.wikipedia.org/wiki/Perl Perl], [http://en.wikipedia.org/wiki/C%2B%2B C++], [http://en.wikipedia.org/wiki/C_Sharp_%28programming_language%29 C#], [http://en.wikipedia.org/wiki/Smalltalk Smalltalk], [http://en.wikipedia.org/wiki/Python_%28programming_language%29 Python], and [http://en.wikipedia.org/wiki/Ruby_%28programming_language%29 Ruby]. While most languages
differ in the implementation details of O-O concepts, especially in syntax, the basic
concepts are incorporated in all these languages, and once a programmer understands
these concepts, it is usually relatively easy to move between the languages.


The Janus SOAP ULI, first available in [[Sirius Mods]] version 6.5,
<ul>
has support for many but not all the concepts
<li>[[Object oriented programming in SOUL|Object oriented programming (OOP)]] </li>
discussed in books about object-oriented programming.
 
Specifically there is no support for [Interfaces|interfaces], though multiple inheritance
<li>[[Release notes for Model 204 version 7.5#New SOUL statements|New User Language statements]] </li>
provides all the functionality provided by interfaces with more flexibility.
 
Overloading is also not supported but optional parameters provide most of what overload is used for much more easily.
<li>[[Release notes for Model 204 version 7.5#Non-OO enhancements in SOUL|Additional non-OO enhancements to User Language]] </li>
===Terminology===                                                                           
</ul>
One of the difficulties of learning new programming concepts is that if they
are sufficiently complex, like those of object orientation,
their explication can seem circular:
the explanation of concept A refers to concept B, which refers to
concept C, which refers back to concept A.
In the introductory stages, you may may have little choice but to
understand that this problem exists,
use this understanding to avoid getting &ldquo;stuck&rdquo; on a concept
that is not fully understood, and move on until the complex web of
concepts become clear.
                                                                                   
To facilitate the initial learning process and to provide a quick reference for when the
concepts become clearer, brief definitions of key object-oriented terms are descibed here:
<dl>
<dt>[[Classes and Objects|Class]]
<dd>A description of the information held in a particular type of object
and the methods (actions) that can be performed on the object.
A given class may contain many object instances.
<dt>[[Collections|Collection]]
<dd>A special class that, as the name suggests, is used to manage
collections or groups of variables.
A collection provides the same functionality as
an array, though with much more flexibility.
The term ''collection'' is not standard object-oriented programming terminology
but it is used in Visual Basic in almost exactly the same way, and it is a concept
present in most object-oriented programming languages.
<dt>[[Constructor]]
<dd>A method that processes an object immediately after the object is
instantiated (created).
The term ''constructor'' is standard object-oriented programming terminology,
but it does not appear as an actual keyword in most object-oriented programming languages.
<dt>[[Enumerations|Enumeration]]
<dd>A special class that is used to denote a group of names with a limited
set of values like, for example, True and False.
The term &ldquo;enumeration&rdquo; is not standard object-oriented programming terminology
and, in fact, appears in many object-oriented languages as a procedural
language leftover often called &ldquo;Enum.&rdquo;
<dt>[[Methods|Function]]
<dd>A method that returns a value and cannot be set, that is, appear on
the left side of an assignment.
The term ''function'' is not standard object-oriented programming terminology,
but it is used in Visual Basic in almost exactly the same way.
<dt>Instantiation
<dd>The process of the creation of an object, that is, an instance of a
class.
<dt>Member
<dd>A method or variable in a class.
A class is completely defined by its members, that is, its variables and methods.
<dt>[[Methods|Method]]
<dd>A block of code that performs a particular task in a particular class.
In the Janus SOAP ULI there are four kinds of methods: subroutines, functions,
properties, and constructors.
Methods can be ''shared'' that is, perform work independent of any instance
of a class; or they can be ''non-shared'', that is, perform work
on an object, a specific instance of a class.
<dt>[[Classes and Objects|Object]]
<dd>A collection of information that describes some entity, usually
some &ldquo;real world&rdquo; entity such as a customer or an order or a part.
Objects have state, that is, information contained in the object can change
over time, usually as a result of methods (actions) performed against the
object.
Objects are never accessed directly but are accessed via ''references''.
Most important among these references are [[Object Variables|object variables]] that,
in User Language, look very much like regular %variables.
The specific information held in an object and the methods (actions) available
on an object are described by the object's '''class'''.
<dt>[[Methods|Property]]
<dd>A method that reflects the state of an object (class instance) or, in the
case of a shared property, the state of the class as a whole.
Properties can be ''read-only'' or ''settable'', that is, valid
on the left side of an assignment statement.
Properties appear to users of a class to be almost identical to class variables,
but they actually have code behind them that is run when the property value is
set or retrieved.
The term ''property'' is not standard object-oriented programming terminology,
but it is used in Visual Basic in almost exactly the same way.
<dt>[[Structures|Structure]]
<dd>A standard layout of variables.
A structure is similar to an image, except a structure can have many instances
while an image can only have one.
Structure variables have the layout indicated by the structure definition, and
they can be assigned to each other.
Structures are different from objects in that structures are passed by value
rather than by reference.
Structures can be thought of as composite datatypes.
<dt>[[Methods|Subroutine]]
<dd>A method that does not return a value and cannot be set, that is, appear
on the left side of an assignment.
The term ''subroutine'' is not standard object-oriented programming terminology,
but it is used in Visual Basic in almost exactly the same way, though in VB
subroutines are denoted by the word Sub.
<dt>Variable
<dd>A container for a value.
In addition to the standard User Language variables, the Janus SOAP ULI provides
[Classes and Objects|class variables]], which are associated with one object or all objects in a
class, and which are accessed via an object variable or a class reference.
</dl>
===Other User Language Enhancements===
Sirius Software enhances User Language in ways that really have nothing to do with object-oriented programming, per se. Also, some of these enhancements are available to Sirius customers that don't have a Janus SOAP license, though all these enhancements are available to customers that do have a Janus SOAP license.
As such, all these enhancements are listed here, whether or not they are, strictly speaking, part of the Janus SOAP ULI:
*The [[Assert Statement]]
*The [[AuditText, PrintText, and TraceText Statements]]
*The [[Copy Qualifier for Subroutine Parameters]]
*[[Group Field Presence Tests]]
*[[Longstrings]]
*The [[Loop Next Statement]]
*[[Mixed-case User Language]]
*[[Text and Html Statements]]

Latest revision as of 16:37, 18 September 2015

The Janus SOAP User Language Interface (aka Janus SOAP ULI) was a collection of extensions to User Language originally intended to simplify the coding of applications that used the Janus SOAP product. In version 7.5 of Model 204, the Janus SOAP ULI features were incorporated into Model 204. Janus SOAP continues as a separate product providing support for XML processing, but no separate Janus SOAP ULI product is available.

The Janus SOAP ULI extensions included these areas:

Retrieved from "https://m204wiki.rocketsoftware.com/index.php?title=Janus_SOAP_User_Language_Interface&oldid=80830"