Tip:
Highlight text to annotate it
X
Welcome to this Java Break with BASIS.
My name is Nico Spence, I'm the Chairman and CEO of BASIS International
and today we continue our series of success stories
but with a little bit of a different twist.
A more generic success of how one can caffeinate
your CUI or GUI app with GUI sprinkles.
So let's get started. Our session agenda today we're going to cover a technology overview,
look at the business challenge that many
of you face in your day-to-day delivery of solutions. We will look at the sample solution,
we'll look at a demonstration - this will be a very hands-on session today.
And then we'll cover in depth how we did it.
And then we will show you some Barista promotions, some programs that'll help
you get started.
I'll be joined by Paul Yeomans, our Product Manager, to take you through those.
And then we will look at the summary of benefits
and take your questions.
Firstly, our series technology overview, as we've seen before, we've looked at varied deployments,
and today we'll cover all of these- large user count PRO/5 systems can
invoke
BBj programs via the XCALL
or they could be run in concert against the same database with
the same file locking mechanisms.
We'll also look at moderate five to twenty five user count Visual PRO/5 systems and large user
count BBj systems.
Varied features - today we gonna look specifically at how Barista
can get you these GUI sprinkles in your
GUI or CUI application.
So what's our business challenge? We want to modernize
our legacy CUI or GUI application.
Essentially we want to give the user more control of their data via a GUI grid.
It's very hard to do in Visual PRO/5,
the logic for grids
is less well-developed in our Windows-only based product but much easier in BBj, our
cross-platform graphical development environment. BBj's grid support
is certainly a lot more powerful than Visual PRO/5's.
But we've abstracted it one further layer and we're utilizing Barista.
And in doing so,
we can do it in less than ten lines of code!
So our sample solution is going to take a step- wise approach.
We are going to use the Barista rapid application development tool to add the
GUI sprinkles to either our CUI or GUI apps.
And we are going to instantly receive some of Barista's enormous benefits.
We'll get the GUI lookup grid launched from
the CUI or GUI app. Today we'll focus on a character-based app.
And then we get built-in filtering of that data, the ability to reorder the columns,
we'll have
options of creating a print preview onscreen to page through,
or create PDFs, XLS, CSV, XML, or Google Doc formats. We can fax it,
email it,
and automatically archive it - all part of the built-in functionality
of the building blocks that are incorporated into Barista.
So a quick refresher of what Barista gives you.
It's our data dictionary-based application development framework
and runtime engine. We'll really be exploiting that
aspect of the runtime engine today.
It facilitates new GUI application development,
the conversion of
CUI apps to GUI and we'll will see this sort of bridging technology today by
incorporating GUI sprinkles into our CUI app.
And of course, we can modernize existing GUI apps if they don't have powerful
grid features by merely inserting those ten lines of code to invoke the Barista
grid GUI look-up.
Barista is a standard framework for handling navigation, display, search, and file maintenance
and it interactively links the database to the user and that'll be our big focus today.
It delivers functional GUI apps on multiple platforms, so not platform
specific to Windows.
It gives you a modern look and feel
and provides standardized keyboard and mouse navigation. No need
to have to always go to the mouse so,
there will be keyboard shortcuts
for anything you might need to do with the mouse.
And its going to leverage our built-in SQL-based inquiry engine. We'll see more we'll see more
about that in a bit.
The benefits are that the developers receive enormous productivity gains.
What does that mean? It translates into you being more efficient and being able to
serve more of your customers in the same period of time.
And of course,
lowers the development cost to your customers
by
potentially a factor of ten.
So it will save you on your initial product development,
your future application maintenance is significantly reduced,
and future enhancements are easy to apply and may even come courtesy of
the tool itself.
Users can then self-serve casual reporting needs via the inquiry engine
as we'll see in our demonstration.
So let's move on to that demonstration
and this session today is mirrored in our latest Advantage magazine which will be hitting your
mailboxes very shortly and your in boxes.
We have an article there that talks about Barista caffeinating a CUI app
with GUI sprinkles.
So, let's have a look
at this in action.
For our demonstration today we will start with the
lowest common denominator.
We'll be having a look at a CD Jazz character user interface application
and I've loaded this up into the BASIS IDE, mounted the file system.
If we look down here into the 'prog' directory,
I'll doubleclick on the employee maintenance program and let's actually
bring it up into full screen mode...
so familiar code to many of you,
very basic line numbered code. Let's run this code
and we'll see...
let me minimize that IDE and here it is
here's our program that allows us to
have a look at the employees within the company.
And of course, we probably have some character-based look-up, but let's have a
look at the new
GUI grid look-up that we've added.
Press F3
and up comes our GUI grid look-up.
So this is the default it comes out just...
from the very get-go but as we start saving some of the information
it will remember these as defaults for the next time it comes up.
The first thing I want to do
is go and toggle "Fit Columns to Grid."
That will just give us that more of a pleasing layout.
Make sure we not overusing the space that's in place.
And there it is. It all fits into this one screen
Let's show you some of the functionality you now have. So of course we could just be
looking at something sorted by last name, so I'll click on that and it will sort on last name. is like to come that'll sort by last
And then I can actually use the Shift button and sort by first name within
last name.
So thereafter, we will see "Abby" sorted by "Aaron" first and then "Steven Abby."
And if I 'double click' on one of these, it will return that value
back to the
character-based app.
But let's go and do the look-up again and let's see what other functionality we
have available to us.
Firstly, some quick visual clues - the little key down here tells us this is the keyed field.
If we had keys on the last name and first name
then those would show up as well. And of course, a quick reminder
you can always add keys without having to change any of your existing code. Just add
the keys
the write
record statement with the KEY=,
the interpreter is intelligent enough to know that it's a multi-KEYED,
MKEYED file for example
and it will be ignored the KEY=.
So, you're safe to move forward with that sort of change,
but let's make a few other changes. You'll notice up here on the top right we have
this option
to do some filtering.
So let's do some filtering.
What we're gonna do is select just our hourly paid employees.
So, this is a great tool for our users to be able to simply come in here
and start adding this sort of functionality. If we add that,
immediately it shows us with a little asterix at the top
that this column has had a filter applied to it.
And we can save this
and
that'll allow us to
look at this report later on...
merely by clicking
on this button at the top.
So we can have the dropdown list
clear it and see all employees
or
select just the hourly paid employees.
Your users could add a whole host of different subsets of the information
that you offer up to them in the query.
Now there are a couple other things we can do. Now that we've had just the hourly paid
employees, this column is pretty much redundant,
so let's go in and look at the inquiry columns and again the user can go and setup
that they don't want to see that column.
Similarly, they may decide that they want to see the first name before the last name so
we can change that.
Let's redo our sorting then.
So there it is - different order
that same information is now available to us.
Of course that is not all, what we can also do now is output this information
into a whole host of various formats
Firstly, let's have a look at exporting and our data selection mode is either
"All query records" or just the "Highlighted rows"
and then we could send it out to the DocOut,
the Document Output Viewer
or we can send it out to a PDF file...
XLS spreadsheet-type file. Let's first start off with the document output viewer.
And so there it is.
There's a report
that's available to us
and now we can go and 'Save As'
all the various options
that you might expect -PDF,
XML spreadsheet, etc...
Let's cancel that.
The other option we have, and that's the...
document output selection we saw early on, we can go directly there, but we can
determined that we want to save it,
we want to fax it, we want to email it.
we want to save it as a PDF...
We can also launch it thereafter, immediately after Saving.
Let's cancel that.
And so a lot of choices here... this is a print preview window...
really as I said it's like a simple reporting system.
The other option I wanted to show you is that we can export these records as well to
say a spreadsheet
and
by default
this is gonna be served up by my local machine which I don't have a
security certificate for, so I'll proceed anyway. You saw it did the download. This is from
Chrome
and it's automatically launching Excel, that's my default for opening up XLS
file types.
And here we are,
we have a chance to see that data
presented to us in an Excel spreadsheet.
And so we could do the similar functionality by
exporting to PDF.
So those options are all available to us. We could also just Copy and Paste into
another document
and we have further choices there including a database table and column name,
include the text column headings
set our Delimiters to whatever we would like them to be
and our Text identifier - single quote, double quote, etc...
So it's a really powerful functionality
all available to you
at your fingertips and available to the end users and helps them self-serve and
be more productive in their business operations
from a day today approach.
Let's have a look at one other really nice feature, the search. We can do a
wildcard type search.
As we'll show you later on, we've identified that both these columns should
be case insensitive in our searching
and so we could check for anything that has a wildcard like"erson"
and it brings up
the "Andersons" and the "Hendersons."
As an example here let's just
limit that just to the "sons"
and obviously a host more names that match those criteria.
So very powerful functionality. We could also, as I said earlier and just look at
the first day in case insensitive
brings up all of the "C"s under the last name.
So really powerful functionality
useful
productivity tool for your end users.
So I suppose the big question is "How much code do we have to write to make all this happen?"
Let's move on
and pick up
on the answer to that question in a minute.
I promised you less than ten lines of code
to insert
into your CUI app
to be able to invoke this grid look-up.
And as I promised there it is. Let's have a look
at these
in fact, eight lines of code
and step through them.
Firstly, we need to determine the BBj installation directorie. So these two
lines do that. 'System.getProperty'
of the 'configDirectory'
and we set 'bbjHome$'
to be that directory path.
Next, we set up a unique name for the group namespace veriable that we would like to
use for the return value.
All we are going to be doing is it's 'scalling'
in other words, running a system call to BBj
to generate this grid look-up.
And the way we're going to communicate back to our
standard character-based app is through the namespace. Namespace is a concept in BBj
that allows us to share information across
different invocations ,
different processes, different BBx interpreter sessions.
We set up the unique name with a
'pid' number, a process ID number
using the 'info(3,0)'
and
next we need to actually do the 'SCALL'
to invoke the bridge to created by the 'SCALL'
using the "-w" argument telling
Barista to wait until the user dismisses the query by closing the window or making a selection.
We pass that info back. Here we're actually specifying
the name of the query 'CDJ_EMPL' is the name of our query
as you'll see in a minute.
Then we created a group namespace variable to retrieve the
selected employee
numbers stored in value. If the user closes
the grid look-up without making a selection, the namespace will not exist and the
'err=' path will be followed or
it will be empty.
And if we had multiple selections that were being allowed, if we were selecting
multiple rows
you can handle that with the "^" character.
Then all we need to do is load the employee ID into the same input variable as though
the user had keyed the ID into the character program.
Let's go through the steps in sequence.
Firstly, we needed to create a Barista app. That means we tell Barista
that we want to create
some components to be used in our app and we need to give it a name.
We'll take you through that example in a minute.
In that same process we'll show you how to import the data dictionary into Barista.
What happens if you don't have a data dictionary?
Really there's no problem.
You can create one for the tables that you wish to import.
Cut the string template for your table
from your application code,
wherever you might have your I/O List or your string template.
Paste that into the Data Dictionary Editor in the Enterprise Manager or in the IDE.
And voila, you've got the data dictionary.
The Barista import creates and element types and table definitions
and from that generates automatic maintenance forms,
automatic reports, and inquiry system.
Let me hand you over to Ralph Lance
our senior software engineer responsible for the Barista project to show you how this is done.
The first thing you do in order to create an application in Barista is
going into the Create Application
menu item
and in our case for
this demonstration
we will choose from our 'training',
a 'cdjazz' configuration that
I pre-configured.
Essentially, you go through the wizard and you fill out the wizard
in order to identify your application. You click Next, and you choose which language
or which languages you'd like to make available for your application.
Choose Next, and you can define the modules
that your application contains.
In our case, it's just one module and we give it an ID CDJ.
Now a combination of what's called the company
and the product ID
allows you to
utilize
the BASIS licensing system to protect your intellectual property.
We'll choose Next and
Next a couple times in order to get these global variables set up
inside of the Barista configuration
so Barista knows where to look as well as for the query system which utilizes
the SQL engine
and the config any file
where
globals can also be used.
Click Next and we're all finished so we can create the application.
This will create the definition of the application and through the synchronized
process you pull in a
definition of an application into Barista and you make it available to Barista.
So that's done "lickety-split."
Now the next step that you will do is go into Barista
development
by a brand-new application
and you would need to import
the existing tables
that are contained inside the BASIS data dictionary for your application.
Ours is located in the
training project folder for
'cdjazz'
to 'bbdict' directory.
We'll give the application prefix 'CDJ."
The prefix is used to prefix things like table names and element names
which essentially hold description information about the tables and
elements and table columns
and allows us to more easily find our
application specific
objects inside of Barista. So, it's a good idea to have an application prefix.
We'll choose Next...
We see a list of the columns or fields that are contained within our
data dictionary
as well as the
general
data global
that we will want to change
to our specific cdjaz global.
We'll click Next a few times...
We'll choose the tables to import
and we'll let
Barista import these tables.
We're all done
and we see on the left hand side
Barista has built a menu for us
using the application description information.
Inside the menu we have the tables that were contained inside
of our BASIS data dictionary.
We're interested in seeing what Barista
has out of the box
for
the Employee table...
rather the Employees file.
So here's the GUI version of the employee maintenance that we looked at inside our legacy that we looked at inside our legacy
application.
Without
doing anything, I have record navigation,
record deletion confirmation...
I have a built-in record inquiry in order to very easily
search,
sort,
and filter my data inside of the file
and choose
any of the records that I'd like to manage.
So let's imagine we don't have data dictionary definition for our employees table.
How do we go about creating one?
Let's have a look at the BASIS IDE again
and let's have a look at that actual table.
Down here we have 'cdj_empls'
we'll right click on that and we can View the BASIS data file,
select the advisory locking or what kind of locking type you want
and there is the contents of the data file. We can Tab through it and have a look
at it.
We can also view it by providing a record template.
So let's go and start with looking at a record template. So if we double-click on this
second PRO/5 program here, we can see that here's out IOLIST...
so five elements
and here's a more meaningful
list of variable names but more readable
and to translate that into a string template we merely
need to add
the type, with its character and numeric,
the average length or
maximum length we expect the field to be
and the field delimiter - in this case, asterisk
it just tells us that it's a zero a.
And so we
go through the various values
and determine
the types and the lengths and that's our string template.
So, let's cut and paste that and
I'll go and pop it into
our little utility. So Ctrl+C
and let's go back to this utility and put our
record template in there and Refresh.
And there it is!
And you can see us moving through the
table looking at the various values.
So, that's pretty useful. How we turn it into a string template?
And how to turn that string template into a data dictionary?
So let's go back again to our tool
which is
the database configuration. You can either do this from Enterprise Manager
or you can do it from the IDE.
So if we right click on LOCALHOST and do a connect...
Do the standard BASIS delivered
User Name, Password - admin, admin123
and there's our list of tables and if we go to CDJazz
you'll notice that there's no CDJ_EMPLYEES. So let's go and create it.
This is how simple it is.
We'll go and put Table Name and we call it 'CDJ_EMPLOYEES'
And now what we need to do is add the columns. I don't want to have to type all that stuff so let's
paste in our string template
and there it is!
We'll need to go
and give it an Index. So let's add an Index.
Let's give that a more meaningful name
EMPL_ID
and let's add the Segment.
And the only Segment we're going to have is EMPL_ID.
And then if we Save Dictionary
that's created the table.
Let's double click on it again
and tell it the
details of the file.
Now if i remember that is
'cdj_empls'
Let's Save Dictionary...
let's Refresh this view...
and there we see it's MKeyed
we can analyze that table
and that will tell the SQL engine
a little more about the contents and how best to access that information.
We'll notice that we have a little Alert Status here. Let's see what that is. We have a new
feature in the data dictionary,
we can fix the Alerts on the selected tables
and it's telling us that it's found a department with a length of twenty-one
characters rather than the twenty we told it it would be.
So we are going to apply the fixes
and then we can rerun the analysis. It's a pretty small table so it shouldn't take
too long. Let's to a refresh
and there it is!
Status is good
and then we could simply proceed as Ralph showed us earlier,
to import that data dictionary into Barista.
So there we have it.
On with the data dictionary we can very quickly get our Barista app running.
Now our next step is to create a custom query.
So we'll run the 'Query Definitions' feature from within the Barista
application framework...
and we'll describe the columns or the fields for the query
and they can be sourced from more than one table. Our simple example today we'll just
use the Employees table.
We can use the Barista generated SQL to generate our grid query
or you could pop in your own SQL. So, very complex SQL can be placed
into custom query.
And then we need to test the SQL statement.
So let's have a look how we generate that.
Right, let's go across to the Barista application framework
and create that custom query. So we'll go to Barista Development,
select Query Definitions
and let's
create a CDJ_EMPLY query.
Let's call it 'Employee Lookup and Reporting'
because we still have access to the
whole of DocOut.
Our Table Alias
is our core
primary table That will be looking at is the 'CDJ_EMPLOYEES' table
and
we gonna give some options, allow some options, allow the user to move the columns,
allowed them to define filters
allow the output to the document output subsystem, and allow copying to the clipboard.
Let's select the Application Company ID unless you want copy protection
which we have available to you to protect your IP. Contact your Account Manager to
set that up.
Otherwise, let's just use the defaults here
and then let's save that information, that's the header information.
Now to get the columnsthat will be showing up in our grid
let's use this drop down menu list to generate the columns from the
data dictionary and definition for the CDJ_EMPLOYEES table.
We're going to select
all the fields
and bring those in.
Then we will make a couple of changes, I want case insensitive searching
on the last name.
So let's
tag that.
And the first name similarly,
we'll tag those.
And then let's also change this column header. It doesn't look all that
user friendly as a name.
Let's say Salary
or Hourly
as our title.
Let's save all of those.
Let's go up here to the SQL Syntax
The Barista RAD tool is an SQL capable tool so we can use SQL
to give us the
selections for our grid.
But that can be quite tedious to type it up yourself so let's go down here and
generate the SQL, have Barista do it for us.
So there is the simple SELECT statement FROM. Of course, this could be a very
complex
SELECT statement.
You could be joining multiple tables, retrieving information from secondary tables
and displaying them in this format.
So let's go back and save that
and now on our drop down list we can test our query.
And there it is!
That didn't take us too long.
The last and final step is the one we covered earlier.
Incorporating the new look up function into the character app.
That's our ten lines of code.
Add the new lookup, invoke the query via the SCALL
and use the 'namespace' to retrieve the user selection.
So what about performance? What happens if you don't get very good performance?
Afterall, the user could be selecting on any sort of column and sorting on any
sort of space.
Well, you can always add the appropriate keys to your table.
Use the Query Analysis tool which will tell you what sort of queries your users
have been running against the table
and then add the keys that you need.
Thereafter, re-apply the Table Analysis.
You need not be concerned about having added additional keys. PRO/5 and BBj
will automatically handled the change.
Any code that does a WRTITE or WRITERECORD with the 'KEY=' syntax
which assumes a SingleKeyed MKeyed file, will ignore that 'KEY=' clause.
The interpreters are intelligent enough to know what kind of file it is writing to
and deal with it appropriately.
All you might have to worry about
is to modify any of your utility programs
that may define or redefine that data file.
How can you get a hold of Barista? What's it cost?
Let me hand you over to Paul Yeomans, our Product Manager, to take you through some
scenarios and some choices that you have
that I think you'll find very attractive.
Thanks Nico.
We've devoted a lot of time presenting the power and functionality that can be
brought to your application by adding Barista. So how do you get Barista?
There's the traditional method of just adding Barista to your existing BASIS licenses.
And we have two other new ways to present today.
A short term Fiscal Cliff Promotion that we sent out
information concerning.
It's designed specifically to create quick
prototypes that you can get in front of your end user customers
and launch some projects.
Additionally, we have an ongoing program called Kick Start Program.
Let's start with that Fiscal Cliff Promotion.
From now through January 2013
what we will do is we will add a Barista license to your qualifying BBj
enterprise edition license at no charge.
On top of that you'll receive Barista training at no charge.
That Barista training typically goes for $1185.
Big value!
What you're responsible for is paying for the nominaSAM fee
for that Barista license.
What are some of those details? For BBj enterprise addition licenses, they must
be covered by SAM.
If your licenses are not on SAM, simply add it to qualify for this promotion.
What about that SAM coverage for Barista? I know you are thinking that.
For the one to ten user range that's $40 a user.
Typically, Barista would be $240 per user.
So you see the savings there as well.
there are some limits. The limit applies to any number of users up to 20%
of the total Enterprise license.
For example, if you've got a fifty user license
we supply you ten user Barista license at no charge.
The Barista training
is self-paced with extensive support
via the forum.
Let's take a moment also to talk about that Kick Start program which is an
ongoing program.
Typically the requirements for deploying a new Barista application included a
license upgrade,
any reinstatement fees,
the edition exchange - moving from Standard to Enterprise edition,
and the cost of Barista itself.
Under this program what we have you do is convert your existing BASIS license
to an annual subscription license.
BASIS waves the edition exchange fee,
moving from Standard to Enterprise,
and that can be a significant amount of money.
We also provide the Barista license at no charge.
So again, what do you receive?
One-year of our software maintenance coverage, SAM coverage,
the Enterprise Edition license,
and Barista.
What you're responsible for
is paying for the BASIS license upgrade
and SAM for Barista and the Enterprise Edition.
What the Kick Start Program is designed for is to create a fast track
for deploying Barista apps by lowering the initial cost to the customer.
The program offers substantial savings converting to a subscription license
we waive the addition exchange fee
and we would actually waive the cost of Barista itself.
So how can you get Barista?
You can simply add it to your existing BASIS license or take advantage of one of the
two promotions -
the short term Fiscal Cliff Promotion. Short term because it does end at the
end of January.
Or the Kick Start program.
The Fiscal Promotion is designed
to give you an opportunity to quickly develop a proof of concept
for your corporate buyers
and then,
perhaps down the road, you can convert those licenses through the Kick Start Program
to an annual subscription program.
If you have additional questions contact your Account Manager.
Let's look at our conclusions.
Im sure you'll agree that it was easy to accomplish our tasks today.
Very low risk.
Very little change to our existing application.
Huge dollar value saving to the users.
Productivity gains.
Better information equals better decisions
which equals better business results.
So what are your next action steps?
We suggest you develop a proof of concept,
probably less thank one day's effort,
demonstrate that proof of concept to your users,
have those selected users identify the priority for implementation,
and implement that proof of concept with the aid of the BASIS
Fiscal Cliff promo or Kick Start program.
In summary today, we've looked at how BASIS is supplying the tools, the license promos,
and programs
so that you can deliver benefits and value to your users with little effort
or risk.
So go and do it!
If you have more success stories to share with us
please contact your Account Manager.
Don't forget to put it on your calendars to attend
the TechCon in Las Vegas
May 13th thru 15th
and training to follow May 16th to 17th.
Of course, look out for that BASIS Advantage magazine in your mailboxes and
available electronically via our website and via an email we'll send out to you.
Let's take your questions.