var course_array = new Array();
function Course(courseNum,courseLevel,courseDuration,courseTitle,courseDesc,courseKeywords)
{
  this.courseNum      = courseNum;
  this.courseLevel    = courseLevel;
  this.courseDuration = courseDuration;
  this.courseTitle    = courseTitle;
  this.courseDesc     = courseDesc;
  this.courseKeywords = courseKeywords.split(",");
}
course_array["PRC-01001"] = new Course("PRC-01001",0,90,"Introduction to PRC","In this course we take a first look at Project Revision Control (PRC), the revision control software from SJ+ and Associates.  We'll look at: <ul> <li>Revision control and the problems it solves;</li> <li>Important PRC terminology;</li> <li>The basics of using PRC including opening and closing projects, rolling and unrolling changes.</li> </ul>","ADMIN,GEN,BASIC,ENT,INQ,RPT,GUI,MENU,UPD");
course_array["SB-01001"] = new Course("SB-01001",1,60,"Introduction to SB+","This course is intended for new SB+ users, administrators, and management considering pursuing SB+ for future projects.  Topics explored in this course include: <ul> <li>Logging into an SB+ application;</li> <li>Logging out of the SB+ application;</li> <li>A brief look at the tools that are available and the kinds of programs  created using SB+;</li> <li>An overview of SB+ group and user security.</li> </ul>","GEN,ADMIN");
course_array["SB-01002"] = new Course("SB-01002",1,90,"Fundamentals of SB+ Screen Development","This course takes a first look at the SB+ Screen Definitions tool (/SD), demonstrating proven techniques for constructing a basic entry or query screen with minimal effort.  Topics explored in this course include:<br> <ul> <li>Overview of the primary tools directly related to screen definitions;</li> <li>Understanding the difference between the screen definition and the input process;</li> <li>Creating files;</li> <li>Creating fields;</li> <li>Placing fields on a screen definition;</li> <li>Rearranging fields on the screen;</li> <li>Changing prompting sequence of the fields on a screen;</li> <li>Adding graphics to a screen definition;</li> <li>Running the screen.</li> </ul>","ENT,INQ,GEN");
course_array["SB-01003"] = new Course("SB-01003",0,120,"The Right Stuff: Validating User Entries With SB+","This course explores the various options available for validating user input on an SB+ entry screen. Topics explored in this course include: <ul> <li>Where validation fits into the &quot;big picture&quot;;</li> <li>Understanding the different types of validation options  available and any limitations for each;</li> <li>General format and structure of validation codes;</li> <li>Understanding validation overrides - how, when, and where;</li> <li>Error messaging options.</li>","ENT");
course_array["SB-01004"] = new Course("SB-01004",1,90,"Using SB+ Field Defaults","In this course we'll look at a number of options available for calculating and setting field level defaults for an SB+ entry screen.  Topics explored in this session include: <br> <ul> <li>What is a default?</li> <li>Literal defaults;</li> <li>Conditional defaults;</li> <li>File read defaults;</li> <li>Calling a process and/or subroutine to calculate a default;</li> <li>Default overrides - how, when, and where?</li> <li>Understanding the features and limitations of &quot;defaults up front&quot;;</li> <li>Mandatory defaults;</li> <li>Skip Defaults;</li> <li>Mandatory Skip Defaults.</li> </ul>","ENT");
course_array["SB-01005"] = new Course("SB-01005",1,90,"Assisting Your Users with SB+ F1 and F3 Help","This course will take a first look at the F1 help and F3 intuitive help, demonstrating how you can easily add these powerful features to your own application without working too hard in the process.  Topics explored in this course include: <br> <ul> <li>Easily building great F1 help;</li> <li>An introduction to selection processes;</li> <li>Various ways to display a list for selection.</li> </ul>","ENT");
course_array["SB-01006"] = new Course("SB-01006",1,90,"Using SB+ Function Keys/Action Bars","In this course, we'll explore the wide, wide world of effectively using function keys and action bars in an SB+ application, including: <br> <ul> <li>Internal vs. external function key sets, pros, cons, and quirks;</li> <li>Dynamically loading function key sets;</li> <li>Implementing popup subscreens using function keys/action bars;</li> <li>Using standardized paragraphs to ease repetitive tasks;</li> <li>Using @RTN.FLAG to press function keys automagically.</li> </ul>","ENT");
course_array["SB-01007"] = new Course("SB-01007",1,90,"Deep, Dark Secrets of SB+ Menus","A menu is a menu is a menu, right?  Well, not always.  With 5 different menu formats, two distinct menu purposes, and a whole load of less-than-perfectly documented functionality, the menu definition tool in SB+ is surprisingly agile.  Join us while we investigate the secrets of this tool and how you can leverage its power in your own application development.","MENU");
course_array["SB-01008"] = new Course("SB-01008",2,90,"Introduction to SB+ GUI Programming","Ask any long-time SB+ user which features of the product have matured the most over recent years, and you're sure to get a load of GUI in the response. This course explores the GUI features of SB+ - particularly the screen painter - and takes a look at how you can best utilize these tools to make the most of your application with the least amount of time and effort.","GUI,ENT,INQ");
course_array["SB-01009"] = new Course("SB-01009",1,120,"Creating Effective SB+ Query Screens","This course takes a first look at the different types of inquiry screens that can be created with SB+, and how these screens can be linked together into a cohesive query system for a given application.  Topics explored in this course include: <ul> <li>Output processes vs. non-amendable input processes;</li> <li>Various options for linking query screens together;</li> <li>Opportunities and issues that arise from converting an input screen to a query screen;</li> <li>Cruising, Zooming, and other stupid Pick words (that are easy to do with SB+!)</li> </ul>","INQ");
course_array["SB-01010"] = new Course("SB-01010",2,90,"Introduction to SB+ Periodic Updates","This course takes a first look at the SB+ periodic update tool, what it is, what it's for, and when you might want to use it.  Topics explored in this session include: <ul> <li>What exactly is a periodic update and why do I need it?</li> <li>Integrating an update into another program;</li> <li>One-to-one, many-to-one, and many-to-none (!) updates;</li> <li>Common misunderstandings about periodic updates that make it one of the least used and still very valuable tools in the SB+ environment.</li> </ul>","UPD");
course_array["SB-01011"] = new Course("SB-01011",1,90,"Introduction to SB+ Query Reports","This course is designed for users of SB+ applications who have little to no programming experience and yet need to get information out of your application.  Topics explored in this course include: <ul> <li>The query reporting tool and its relationship to the application;</li> <li>Creating simple listings of application data;</li> <li>Adding totals to numeric and monetary columns of information;</li> <li>Adding sort and break features to your query report;</li> <li>Exporting the query report information to Excel</li> </ul>","RPT");
course_array["SB-01012"] = new Course("SB-01012",1,90,"Getting Started with the SB+ ReportWriter","This session takes a first look at the features available in the SB+ ReportWriter. Topics explored in this course include: <ul> <li>An introduction to the ReportWriter tool;</li> <li>Creating columnar reports vs. form reports</li> <li>Understanding report sections;</li> <li>Introduction to derived value fields;</li> <li>Creating grand totals and counters on the report;</li> <li>Selecting and arranging information for the report;</li> </ul>","RPT");
course_array["SB-01013"] = new Course("SB-01013",1,90,"Handling Breaks with the SB+ ReportWriter","This course takes a first look at adding breaks to columnar reports created with the ReportWriter. Topics explored in this course include: <ul> <li>Adding a single break to a report;</li> <li>Adding multiple breaks to a report;</li> <li>Using conditional fields for breaks and more.</li> </ul>","RPT");
course_array["SB-01015"] = new Course("SB-01015",0,60,"SB+ Process Calling Conventions","This course explores the many and varied ways that a process can be called from an SB+ application. Did you know there are 8 different syntax variations used to call a process in SB+? (Actually, depending on your perspective it might be argued there are more ways than that!) In this course we're going to look at all the different ways that a process can be called in an SB+ application, the context for each different syntax, and -- in Precision Solutions style -- discuss the good, bad, and ugly of using inline paragraphs. ","GEN");
course_array["SB-01016"] = new Course("SB-01016",3,60,"Fundamentals of SB+ Screen and Report Drivers","Despite intentionally being invisible to the user of the SB+ application, drivers are a crucial element to the operation of screens and reports. By understanding the basics of how drivers &quot;behave&quot; you can often diagnose weird things that can happen in your own programming with less effort. Topics explored in this course include: <ul> <li>What are drivers and where do they come from?</li> <li>Why drivers make it a universally bad idea to modify production code directly;</li> <li>Revision control strategies for maximizing application performance through minimal driver manipulation.</li> </ul>","GEN,ENT,INQ");
course_array["SB-01017"] = new Course("SB-01017",0,120,"Basic SB+ Configuration","&quot;Basic SB+ Configuration&quot; explores the /SB.PARMS and /HK.CONTROL configuration screens, allowing you some flexibility in customizing your SB+ installation.  Come learn about the settings that you can freely change and those you probably want to stay away from!","GEN,ADMIN");
course_array["SB-02001"] = new Course("SB-02001",3,90,"Creating the Parameter Driven SB+ Application","In this course, we'll explore some ways that you can generalize your application with parameters. Some of the topics we'll explore include: <ul> <li>Why parameterize an application?</li> <li>Creating a parameter entry screen;</li> <li>Adding parameters to an existing application without adding a performance burden;</li> <li>Understanding the Proc At Set Common;</li> <li>An introduction to Global Equates.</li> </ul>","GEN");
course_array["SB-02002"] = new Course("SB-02002",0,120,"SB+ Paragraph Language Primer","The SB+ Paragraph language provides the SB+ developer with a great deal of power without a lot of syntax - usually far less syntax than doing the same tasks in BASIC! This can save you loads of time, though if you're unfamiliar with the language it can unfortunately add time to your project. So unless you have time to burn, come join us and find ways that you can: <ul> <li>Get the most from the paragraph definition tool;</li> <li>Understand the different syntax and structures available in the paragraph language;</li> <li>See how small, reusable code fragments can actually save your company tons of money over the lifecycle of a project.</li> </ul>","GEN");
course_array["SB-02003"] = new Course("SB-02003",2,90,"Using Indexes With SB+","In this course, we'll look at ways to use file indexing to improve the performance of an SB+ application. Topics explored in this course include: <ul> <li>Benefits and limitations of indexing <li>The difference between SB+ and OE (Unidata/Universe) indexing <li>Creating simple SB+ and OE indexes <li>Creating derived indexes <li>Adding new selection functionality to SB+</li> </ul>","RPT,GEN");
course_array["SB-02004"] = new Course("SB-02004",3,60,"Using Indirection In Your SB+ Application","While SB+ code tables are commonly recognized for their value in conversions, validation and intuitive help, they can also be very useful deep inside the code to manage your ability to grow the application in the future. In this course we'll demonstrate how your application can be enhanced and matured over time without actually having to make infrastructure changes all along the way.","GEN");
course_array["SB-02005"] = new Course("SB-02005",2,90,"Enhanced SB+ Screen Definitions","This course is an in-depth exploration of the process slots on the Screen Definition F6-Params screen, with special emphasis on: <ul> <li>Easy ways to implement complex multi-file updates that anyone can understand six months later.</li> <li>Uncover secrets of the Process After Read, it's real purpose, and limitations.</li> </ul> <p>Process slots discussed include:</p> <ul> <li>Process Before Screen</li> <li>Process After Display</li> <li>Process After Read</li> <li>Process After Screen Accept</li> <li>Process After Update</li> <li>Process After Esc</li> </ul>","ENT");
course_array["SB-02006"] = new Course("SB-02006",2,60,"Implementing Sequential Keys on SB+ Screens","Perhaps you've seen screens with &quot;NEW&quot; displayed for the key - how exactly do they do that? And what's the point? Are there any variations on that theme? In this course we'll explore a number of techniques for implementing sequential keys and show you that regardless of the variation you use, sequential keys can be easy to implement and a powerful addition for the users of your application. ","ENT");
course_array["SB-02007"] = new Course("SB-02007",2,90,"Enhanced SB+ Query Screens","This course will demonstrate how you can improve the functionality of your query screens with advanced navigational features including forward and backward paging through a list of records, using indexing and selection processes to tie applications together that otherwise wouldn't be able to share information easily, and seamlessly integrating a query into an existing application to provide read-only access to information previously unavailable.","INQ");
course_array["SB-02008"] = new Course("SB-02008",2,120,"Summary and Analytical Reporting with the SB+ ReportWriter","The SB+ ReportWriter provides some very capable features for summary and analytical reporting but you may not have heard about them because, well, these features aren't all that obvious. In this course we'll explore a step-by-step approach to generating complex analyses with the SB+ ReportWriter using very little - if any - additional code. Topics explored in this course include: <ul> <li>Designing a summary or analytical report from the ground up;</li> <li>Summarizing information that may not even exist in the application;</li> <li>Creating combination detail + summary reports;</li> </ul>","RPT");
course_array["SB-02009"] = new Course("SB-02009",3,120,"HTML/XML Reporting with the SB+ ReportWriter","Despite a lot of press about new HTML reporting features with SB+, the SB+ ReportWriter has always had the ability to output not only to HTML, but XML and other formats as well. In this course we'll take a look at how you can create a report that outputs your information in HTML and/or XML, regardless of the version of SB+ you're using. <br><br> <i>(Note: This course does not include discussion of how to launch the report from the web.)</i>","RPT");
course_array["SB-02010"] = new Course("SB-02010",3,90,"Advanced SB+ Reporting Using Work Files","While the SB+ ReportWriter is an immensely powerful tool, it  can still be enhanced with a little support from the outside.  This  course will focus on the relationship between periodic updates and the  ReportWriter with special emphasis on how you can use updates and other  types of processes to build information to be shown on a report.   Topics explored in this course include: <ul> <li>Reporting out of multiple otherwise unrelated parallel files (such as a GL.2003, GL.2004, et al.);</li> <li>Using a work file to establish relationships between otherwise unrelated data files;</li> <li>Exporting to Excel without actually writing any export code;</li> <li>Creating a super-report that can be used to view virtually anything;</li> </ul>","RPT");
course_array["SB-02012"] = new Course("SB-02012",3,90,"Secrets of SB+ Conversions and Derived fields","Quick question - what's the difference between a conversion and derived field? What about a conversion vs. an input conversion? And what the heck is a &quot;reverse&quot; conversion? As an SB+ developer, there's a great deal of power in conversions and derived fields that often goes underutilized. Come join us and find out what more is available using these nearly infinitely powerful features of SB+. ","GEN");
course_array["SB-02013"] = new Course("SB-02013",0,120,"Debugging Tips and Tricks for the SB+ Developer","With SB+, debugging an existing application can often be more art than science. Come join us and see how a few key tools and even a bit of trickery can help you get to the bottom of even the most difficult problems in your application without working too hard in the process. <br><br> <i>Note: This class does incorporate Unidata-specific techniques that may not be applicable to other SB+ platforms.</i>","GEN");
course_array["SB-02015"] = new Course("SB-02015",2,60,"Understanding and Using SB+ Logical Files","The concept of a <i>logical file</i>, while older than the SB+ toolset itself, is still largely misunderstood and often misapplied to common programming situations. In this course we'll take a look at the concept of logical files, the SB+ Logical File Definitions tool, and how this technique can provide very workable solutions to many programming problems. ","ENT,RPT");
course_array["SB-02017"] = new Course("SB-02017",3,90,"Augmenting SB+ Security","While SB+ security provides a number of features for controlling who can, and who cannot do certain tasks, there are a number of ways it can be enhanced in your own application. In this course we'll look at augmenting the standard SB+ security features by: <ul> <li>Implementing a custom program handler;</li> <li>Using the slash intercept process to prevent programs from being run out of context;</li> <li>Controlling the display of sensitive information in your entry and query screens.</li> </ul>","GEN,ADMIN");
course_array["SB-02018"] = new Course("SB-02018",0,90,"SB+ Printer Management","Printer classes? Physical printers? Stationery? Locations? Setting up SB+ printers can be a mind-bending experience! In this class we'll explore the components of a workable SB+ printer configuration and how you can get the most from your printer configuration without spending all your time in printer administration. ","GEN,ADMIN");
course_array["SB-02019"] = new Course("SB-02019",2,60,"Creating Break Summaries With The SB+ ReportWriter","This course explores the typical mistakes made when a person tries to build a summary of information in the break section. In short, if you follow common reasoning there's a greater than likely chance of falling into these traps and working extra hard without the payoff of a good working solution. This course helps define the reasons for these common &quot;mistakes of reason&quot;, proposing quick and effective solutions for avoiding the hard work and pitfalls. ","RPT");
course_array["SB-02020"] = new Course("SB-02020",2,60,"Implementing Multiple Part Keys","Typing in a customer number may be no big thing, but what if that customer happens to be specific to a given company, branch, division, shipping warehouse, a can you expect your users to accurately enter all this into one prompt? Multiple part keys provide a great solution to complex problems like this, and best of all, by following some simple rules you can easily implement the biggest, baddest key in town and not even break a sweat in the process!","ENT,INQ");
course_array["SB-03001"] = new Course("SB-03001",2,90,"SB+ Selection Filtering Tricks","This course takes a look at selection filtering, a technique commonly used with indexes to improve the performance of the application. In this session we'll create a selection filter that will remove duplicate entries from a by-word index. Through this, course participants will see how filtering can be used to enhance indexed selections, resulting in the best overall application performance possible. <br><br> <i>Course participants should have experience with SB+ and/or Unidata indexing before taking this course.</i>","ENT,GEN");
course_array["SB-03002"] = new Course("SB-03002",0,90,"Selecting the Best SB+ Process Type","SB+ provides a lot of different shapes and sizes of processes that serve as the building blocks of your application. Many problems can be solved by more than one process type - how will you know which is the best for that given situation? In this session we'll look at the good, the bad, and the ugly of the different types of processes and help you make the best choices in your own application development.","GEN");
course_array["SB-03003"] = new Course("SB-03003",0,60,"Programming for Portability with SB+","Though SB+ mitigates a lot of the issues in moving your software from one operating environment to another, developers are not completely removed from the process. In this course we'll examine some of the issues to consider to allow your software to move easily from one platform to another. ","GEN");
course_array["SB-03004"] = new Course("SB-03004",3,90,"Getting the Most from SB+ Selection Processes","In this course we'll take a deep dive into the /PD.S (Process Definition - Selection) tool in SB+.  This tool may have very few prompts, but don't let that simplicity fool you!  We'll explore the many features of this tool with special emphasis on: <ul> <li>Understanding Selection Criteria Options;</li> <li>Using Selection Process Options;</li> <li>Rolling your own selection;</li> <li>Boldly going far beyond intuitive help.</li> </ul>","ENT,GEN");
course_array["SB-03005"] = new Course("SB-03005",0,120,"Exploring the SB+ Common Map","The variety of common variables that are used throughout SB+ provide the &quot;keys to the kingdom&quot; for getting the most from your SB+ development experience. In this course we'll look at each of the variables in the common map, how and when you need each one, and things you may want to do (and a few things you may want to avoid!) to prevent unexpected bumps along the way.","GEN");
course_array["SB-03006"] = new Course("SB-03006",0,120,"Express Yourself with the Expression language","The expression language is the foundation of so many SB+ features. Conversions, derived values, defaults, validation, and even the paragraph language are all built on expressions. With so many features using this one common language, it's a good thing to know expressions well! In this course we'll take a look at the basic structure of an expression, how simple expressions can be built on one another to form more complex expressions, with a thorough expose of the variety of functions available in the expression language.","GEN");
course_array["SB-03007"] = new Course("SB-03007",0,120,"Effectively Using SB+ Programming Standards","Whether working in a team or as a lone wolf, standards are a crucial element of productivity, saving you time, money, and energy in your application development efforts. In this course we'll examine how standards can assist you in your efforts, including: <ul> <li>The do's and don'ts of naming standards</li> <li>Using implementation standards to keep everyone on the same page six months after the fact (even if you're everyone!)</li> <li>Making it readable: Effective approaches to documentation</li> </ul>","GEN");
course_array["SB-03008"] = new Course("SB-03008",0,60,"You Got Your BASIC in my SB+ / You Got Your SB+ in my BASIC!","Integrating BASIC routines with SB+ is really very simple but it's not necessarily always the best thing to do. In this course we'll look at: <ul> <li>When is BASIC the best solution?</li> <li>The elements that make a BASIC subroutine &quot;play nice&quot; with SB+;</li> <li>Making it seamless: Calling BASIC from SB+ and SB+ from BASIC;</li> <li>The SB+ subroutines: What are they and why do I need them?</li> </ul>","BASIC");
course_array["SB-03009"] = new Course("SB-03009",3,120,"Creating Custom Tools for and with SB+","While SB+ provides a rich suite of tools for your application development, at some point you may need a special something that's above and beyond the abilities of the boxed SB+ development environment. In these times, with a pinch of &quot;out of the box&quot; thinking and a little bit of code, you can create brand new tools that leverage all of the power of SB+ for your own purposes.","GEN,BASIC");
course_array["SB-04001"] = new Course("SB-04001",0,60,"SB+ Mentorship","In this hour - or however long it takes - bring your problem to class and we'll solve it together!  It's your task, your solution, and you'll even drive the keyboard while getting expert SB+ assistance and guidance to help you avoid the traps and pitfalls along the way.","ADMIN,BASIC,ENT,GEN,INQ,RPT,MENU,UPD,GUI");
course_array["U2-01001"] = new Course("U2-01001",1,120,"Introduction to U2","This course provides a &quot;first-look&quot; at the Unidata and Universe database environments. Intended to answer the question &quot;so what exactly is U2?&quot;, this course addresses the what, where, why, and when of U2, preparing the participant for the later courses explaining how U2 can be used to develop world-class application software. Topics explored in this course include: <ul> <li>What is U2?</li> <li>Where does U2 run?</li> <li>When is U2 a good (and not so good) choice for a development platform?</li> <li>Logging in and out of the U2 environments;</li> <li>NF2 and the dynamic database;</li> <li>Introduction to the command line.</li> </ul>","GEN");
course_array["U2-01002"] = new Course("U2-01002",1,90,"Working with Unidata Files","As a database, the primary focus of the Unidata environment is the storage and retrieval of information. This course takes a first look at how to create, delete, and manage Unidata files. Topics explored in this course include: <ul> <li>Understanding the different types of Unidata files</li> <li>Understanding the different parts of a Unidata file</li> <li>Creating and deleting files</li> <li>Managing files, including clearing and resizing</li> </ul>","GEN");
course_array["U2-01004"] = new Course("U2-01004",0,60,"Unidata AE Fundamentals","<p>Out of the box, the AE editor is one of the primary - if not THE primary - input tool for Unidata. This simple and yet powerful line editor combines ease of use with flexibility to enable you to quickly and easily get information into your Unidata app.</p> <p>This course explores the basics of this tool and discusses how you can leverage AE to create and/or modify everything from data records to dictionaries, processes to programs, and everything in between.</p>","GEN");
course_array["U2-02001"] = new Course("U2-02001",1,90,"Getting Information Out: Fundamentals of the Query Language","Okay, so you've put information into your U2 database - now what? This course explores the basics of the query language, including: <ul> <li>Defining dictionary records for the query language;</li> <li>How to formulate a query statement to get the answers you need;</li> <li>Outputting to the screen or printer;</li> <li>Limiting the output of the report;</li> <li>Arranging information in a particular order;</li> <li>Handing breaks and totals in your query reports.</li> </ul> <p><i>Note: While this class uses Unidata for illustrative purposes, all material is applicable to both the Unidata and Universe environments.</i></p>","GEN,RPT");
course_array["U2-02002"] = new Course("U2-02002",2,60,"Improving Performance with Indexing","If your application seems to be running slow, a lack of indexes may be a big part of the problem. In this course we'll look at how indexes can improve the performance of your files, and possibly even improve the performance of your system as a whole. Some of the topics explored in this session include: <ul> <li>The TCL verbs used for index management;</li> <li>Features and limitations of U2 indexing;</li> <li>Understanding when indexing is a good (and not so good) solution;</li> <li>Using derived indexing to quickly determine data relationships and state.</li> </ul> <p><i>Note: While this class uses Unidata for illustrative purposes, all material is applicable to both the Unidata and Universe environments.</i></p>","GEN");
course_array["U2-02003"] = new Course("U2-02003",1,60,"Working with Select Lists","Select lists enhance the functionality of the query language by providing a mechanism for managing subsets of records to be processed for update, query, or basically for any other purpose. In this course we'll look at the verbs in the query language for managing select lists, and also take a look at techniques you can use to enhance the abilities of the query language. Some of the topics we'll discuss include: <ul> <li>The TCL verbs used for list management;</li> <li>Using cascading selects to leverage index usage.</li> <li>Creating data value lists (in contrast to key lists)</li> <li>Sampling records for later processing</li> <li>Understanding the value of &quot;exploded&quot; lists</li> </ul> <p><i>Note: While this class uses Unidata for illustrative purposes, all material is applicable to both the Unidata and Universe environments.</i></p>","GEN,RPT");
course_array["U2-02004"] = new Course("U2-02004",2,90,"Creating and Using Virtual Fields","Calculated fields, also known as &quot;virtual fields&quot; (in Unidata) or &quot;I-descriptors&quot; (in Universe) add a great deal of power to the query language. With these types of fields you can read information from other files, calculate new values, even call BASIC subroutines to get the information you need. In this course we'll look at a number of examples of calculated fields and see how you can use this powerful feature to significantly extend the functionality of your U2 application. <p><i> Note: While this class uses Unidata for illustrative purposes, all material is applicable to both the Unidata and Universe environments. </i></p>","RPT");
course_array["U2-03001"] = new Course("U2-03001",1,120,"Introduction to U2 BASIC","The BASIC programming language forms the foundation for implementation on the U2 platforms. In this course we'll take a first look at the U2 BASIC language with specific emphasis on: <ul> <li>Creating, compiling, and running programs;</li> <li>Understanding variables in the BASIC program;</li> <li>Exploring the differences between dimensioned and dynamic arrays;</li> <li>Using simple screen and printer I/O to capture input and produce output;</li> <li>Fundamentals of BASIC programming style.</li> </ul> <p><i>Note: While the examples in this course will be illustrated on a Unidata platform, the material presented in this course is universally applicable to<br>all Multivalue platforms.</i></p>","BASIC");
course_array["U2-03002"] = new Course("U2-03002",1,120,"U2 BASIC Control Constructs","In this course, we'll look at the common conditional, iterative, and control transfer constructs of U2 BASIC, including: <ul> <li>BASIC constructs for iteration and conditional execution;</li> <li>Internal vs. external subroutines;</li> <li>Structure and optimization techniques for creating the most readable, functional, and performant code possible with the least amount of effort.</li> </ul> <p><i>Note: While the examples in this course will be illustrated on a Unidata platform, the material presented in this course is universally applicable to<br>all Multivalue platforms.</i></p>","BASIC");
course_array["U2-03003"] = new Course("U2-03003",1,120,"Working With Files in U2 BASIC","<P>While the I/O statements available in U2 BASIC are remarkably simple to use, there are many variations available to give you plenty of choices for your implementation needs. In this course we'll look at the different BASIC statements available for file I/O, including:</P> <ul> <li>Opening and closing U2 files in BASIC;</li> <li>Reading, writing, deleting, and clearing records;</li> <li>The relationship between dimensioned arrays and file I/O;</li> <li>Setting and releasing record locks;</li> <li>Reading from an active select list;</li> </ul> <p><i>Note: While the examples in this course will be illustrated on a Unidata platform, the material presented in this course is universally applicable to all Multivalue platforms.</i></p>","BASIC");
course_array["U2-03004"] = new Course("U2-03004",2,120,"Working With Sequential Files in U2 BASIC","Sequential files provide an efficient way to move information into and out of your U2 application. In this course we'll explore the BASIC commands available for importing and exporting data using sequential files. Some of the topics we'll discuss include: <ul> <li>Advantages of sequential files over more &quot;traditional&quot; U2 storage options;</li> <li>Opening and closing sequential files;</li> <li>Reading from, and writing to, a sequential file;</li> </ul> <p><i>Note: While the examples in this course will be illustrated on a Unidata platform, the material presented in this course is nearly universally applicable to both Unidata and Universe.</i></p>","BASIC");
course_array["U2-03005"] = new Course("U2-03005",2,120,"Formulating U2 BASIC Expressions","&quot;Expressions&quot; provide the tools in U2 BASIC for calculating values. In this course we'll take an academic look at formulating expressions in your own BASIC code, including: <ul> <li>Literals, variables, and arrays (oh my!)</li> <li>Common conversion codes;</li> <li>Using operators to combine literals and variables into more complex calculations;</li> <li>Common functions that U2 BASIC programmers use every day.</li> </ul> <p><i>Note: While the examples in this course will be illustrated on a Unidata platform, the material presented in this course is nearly universally applicable to all Multivalue platforms.</i></p>","BASIC");
course_array["U2-03006"] = new Course("U2-03006",2,90,"Optimizing Unidata BASIC With Code Profiling","As code &quot;matures&quot; its performance can begin to suffer under the weight of new code and changes to existing code.  The boss wants every program running at peak efficiency - and why not?  But how can we know where the bottlenecks might be?   In this course we'll explore Unidata BASIC profiling and how this feature can help you maximize the performance of your programs without wasting a lot of time with experiments or guesswork.","BASIC,ENT,INQ,GEN,RPT,UPD");
course_array["U2-04001"] = new Course("U2-04001",3,150,"Writing Reports with BASIC","While the query language provides features for reporting in the U2 environments, there are times when it is woefully inadequate for real-world reporting. In these situations, it's BASIC to the rescue! In this course we'll look at techniques for quickly and efficiently building a report using U2 BASIC that includes all of these common reporting issues: <ul> <li>Implementing up-front prompting for run-time parameters;</li> <li>Selecting the records for output and sorting the results on the report;</li> <li>Implementing breaks in the output;</li> <li>Implementing summary, detail, and combination (summary + detail) reports;</li> <li>&quot;Future-proofing&quot; your report.</li> </ul> <p><i>Note: While the examples in this course will be illustrated on a Unidata platform, the material presented in this course is universally applicable to<br>all Multivalue platforms.</i></p>","BASIC,RPT");
course_array["U2-04002"] = new Course("U2-04002",3,120,"Importing and Exporting Information Using BASIC","This course is a follow-up for the U2-03004 (Working with Sequential Files in U2 BASIC) and provides a step-by-step exploration of writing your own import and export utilities in U2 BASIC. Topics discussed in this course include: <ul> <li>Writing your own import tool for moving information into your U2 application;</li> <li>Writing your own export tool for extracting information from your U2 application;</li> </ul> <p><i>Note: While the examples in this course will be illustrated on a Unidata platform, the material presented in this course is nearly universally applicable to all Multivalue platforms.</i></p>","BASIC,RPT");
course_array["U2-04003"] = new Course("U2-04003",0,90,"Coding U2 BASIC with Style","In the world of software, the only constant is change! Therefore, in this course we'll look at how you can leverage programming style to future-proof your application. Topics explored in this course include: <ul> <li>The &quot;Six Month Rule&quot; and why you DON'T want to break it!</li> <li>When is a comment a bad thing?</li> <li>What's in a name?  (The importance of naming conventions and standards);</li> <li>Using structural standards to improve code readability and maintainability.</li> </ul> <p><i>Note: While the examples in this course will be illustrated on a Unidata platform,  the material presented in this course is universally applicable to all  Multivalue platforms.</i></p>","BASIC,GEN");
course_array["WEB-01001"] = new Course("WEB-01001",1,90,"Introduction to Web Technologies","There's a wide open future of opportunities for web-savvy software  artists.  In this course we'll demystify the various technologies that  work together to make a typical website.  From the browser to the server,  from HTML to CSS, Javascript to PHP and beyond, we'll look at what's  available, how much it costs, the role each technology fills, and how they  play nice with one another (or not in some cases!).","GEN");
course_array["WEB-01002"] = new Course("WEB-01002",1,90,"Downloading, Installing, and Getting Started with the Apache Web Server","<p>The Apache web server has consistently been the most popular web server application since 1996.  Rock solid, secure, easy to deploy yet massively configurable, Apache is a great choice for any kind of web application imaginable.  As an open source application, Apache can not only be downloaded and deployed for free, an extensive network of volunteer contributors work to keep the server secure, stable, and up-to-date with the latest and greatest features needed to satisfy the most sophisticated web hosting demands.</p> <p>In this course we'll download, install, and configure the Apache web server program on a typical Windows laptop, take a quick look at the massive documentation available, and test the environment to be sure it's ready for further web development and experimentation.</p>","GEN");
course_array["WEB-01003"] = new Course("WEB-01003",1,90,"Downloading, Installing, and Getting Started with PHP under Apache","<p>Combining an extensive list of features with an easy to use language structure, PHP is quickly becoming one of the top programming languages, especially for web development.  Join us in this session as we demonstrate how you can download, install, and begin learning more about this remarkable language.</p>  <p><i>Course participants are encouraged to have Apache installed or have attended WEB-01002 prior to attending this course.</p></i>","GEN");
course_array["WEB-01004"] = new Course("WEB-01004",1,120,"Introduction to HTML","<p>The World Wide Web is made up of millions - possibly billions - of web pages constructed using the HTML markup language.  Join us in this session as we look at several flavors of this markup language, starting with the basics and working through links, images, lists, tables, plus a brief walkthrough of scripts and styles.</p> <p><i>Please Note: Styles, scripts, frames, and forms are not explored in  any depth in this course.</i></p>","GEN");
course_array["WEB-01005"] = new Course("WEB-01005",1,90,"Introduction to CSS","<p>While the World Wide Web is intrinsically a bunch of text, HTML  documents by themselves can be really quite boring.   In this course,  we'll use some basic CSS to spice up a document with various colors,  fonts, spacing, and images to help make it really POP!</p>","GEN");
course_array["WEB-01006"] = new Course("WEB-01006",1,90,"Introduction to Javascript","<p>Every modern web browser in use today runs the Javascript language,  which gives it the ability to take a normal static HTML document and  render it as an interactive experience!  In this course we'll take a first  look at the Javascript language, its integration with HTML, and a couple  of cool browser tricks you can use right away without investing a lot of  time or effort.</p>","GEN");
course_keywords = new Array();
course_keywords["RPT,GEN"] = new Array("BI-01001","BI-03001","SB-02003");
course_keywords["GEN,RPT"] = new Array("BI-02001","BI-03002","U2-02001","U2-02003");
course_keywords["ADMIN,GEN,RPT"] = new Array("BI-04001");
course_keywords["ADMIN,GEN,BASIC,ENT,INQ,RPT,GUI,MENU,UPD"] = new Array("PRC-01001");
course_keywords["GEN,ADMIN"] = new Array("SB-01001","SB-01017","SB-02017","SB-02018");
course_keywords["ENT,INQ,GEN"] = new Array("SB-01002");
course_keywords["ENT"] = new Array("SB-01003","SB-01004","SB-01005","SB-01006","SB-02005","SB-02006");
course_keywords["MENU"] = new Array("SB-01007");
course_keywords["GUI,ENT,INQ"] = new Array("SB-01008");
course_keywords["INQ"] = new Array("SB-01009","SB-02007");
course_keywords["UPD"] = new Array("SB-01010");
course_keywords["RPT"] = new Array("SB-01011","SB-01012","SB-01013","SB-02008","SB-02009","SB-02010","SB-02019","U2-02004");
course_keywords["GEN"] = new Array("SB-01015","SB-02001","SB-02002","SB-02004","SB-02012","SB-02013","SB-03002","SB-03003","SB-03005","SB-03006","SB-03007","U2-01001","U2-01002","U2-01004","U2-02002","WEB-01001","WEB-01002","WEB-01003","WEB-01004","WEB-01005","WEB-01006");
course_keywords["GEN,ENT,INQ"] = new Array("SB-01016");
course_keywords["ENT,RPT"] = new Array("SB-02015");
course_keywords["ENT,INQ"] = new Array("SB-02020");
course_keywords["ENT,GEN"] = new Array("SB-03001","SB-03004");
course_keywords["BASIC"] = new Array("SB-03008","U2-03001","U2-03002","U2-03003","U2-03004","U2-03005");
course_keywords["GEN,BASIC"] = new Array("SB-03009");
course_keywords["ADMIN,BASIC,ENT,GEN,INQ,RPT,MENU,UPD,GUI"] = new Array("SB-04001");
course_keywords["BASIC,ENT,INQ,GEN,RPT,UPD"] = new Array("U2-03006");
course_keywords["BASIC,RPT"] = new Array("U2-04001","U2-04002");
course_keywords["BASIC,GEN"] = new Array("U2-04003");