iModernize - The Profound Logic Software Blog

Components of Profound.js 2.0 (Part 3)

Posted by Tim Losee on Jun 27, 2017 4:32:18 PM

Over the next several weeks we will be taking an in depth look into Profound Logic's newest product... Profound.js 2.0. We will be discussing the benefits, the different components as well as the easiest ways for you to access Profound.js 2.0 for your needs. Profound.js 2.0 enables you to easily adopt Node.js in your business, and to take advantage of the many benefits of Node, including access to a much larger pool of developers for IBM i and access to countless reusable open source code packages on NPM (Node Package Manager)

Last week we continued to discuss the components of Profound.js 2.0 by beginning to discuss the Converter Module of Profound.js 2.0. This week we are going to finish our discussion on the Converter Module and its benefits:

The Profound.js Converter (currently available as a service) automatically converts existing RPGLE code into clean Node.js (server-side JavaScript) code. Unlike most code conversion tools, Profound.js actually simplifies programs, and generally creates less lines of code than the original RPG. The Conversion module allows you to replace any RPG program with a Node.js module while maintaining the integrity of the entire application. Here are some more of the benefits to the Converter module:

Code Becomes More Self-Explanatory

Not only do converted programs use JavaScript (a language that is well known throughout the world today) but they also become more self-explanatory. The statements in the new code are more verbose and there are less abbreviations, this allows an easier understanding of the code. Obscure abbreviated operations like "SETGT" or similar become self-explanatory method names like "positionAfter()." 

Adding Object-Oriented Capabilities 

The Converter module automatically introduces more mainstream object-oriented patterns into your traditional purely procedural code. For example, objects with properties and methods are created to represent the user interface. The same goes for database access - each database table becomes and object accessed by methods. 

Making it Easy for RPG Developers to Transition to a New Language

Profound.js creates code that is easy to understand for both experienced Node.js developers and RPG developers that are new to Node.js. The simple transition to Node.js is made possible by the easy to use Profound.js API that provide virtually all capabilities of RPG, including:

  • Record Level Access for database tables
  • Ability to working with display files concepts, such as record formats and sub-files
  • Top-down transactional programming without any requirement to use JavaScript callbacks
  • All RPG data types, including complex data structures
  • Data manipulation API for common RPG operations 
  • Integration API to seamlessly call existing RPG programs, CL programs, and IBM i commands

Portability

Node.js is inherently portable, which opens up exciting new possibilities for your applications, such as offering offline mobile capabilities to your users or being able to do development without a connection to the server. A converted program will generally still require an active connection to IBM i at run time in order to access your IBM i database tables and other IBM i resources. However, the Node.js code itself can be tested and executed on IBM i or other types of servers, including directly on your development PC. This provides flexibility in how you can work with the programs and what tools you can use for debugging and testing. 

Full Integration with Existing IBM i Resources

Converting RPG programs to Node.js opens them up to many new capabilities, including direct usage of any open source NPM component.

Fortunately, Profound.js does this in a way that doesn't take away existing capabilities of RPG and IBM i. RPG programs are known for tight integration with the DB2 database, other ILE programs on IBM i, and IBM i resources like data areas. The new Node.js code has all of the same IBM i integration capabilities. In fact, the converted Node.js module can run just like any other ILE program on IBM i, and has access to API for tasks like:

  • DB2 Record Level Access and SQL operations, including support for overrides and QTEMP in an interactive job
  • Calling other RPG, CL, and COBOL programs seamlessly
  • Ability for Node.js modules to act like native ILE programs on IBM i, with full support for traditional object authority settings
  • Calling 5250 green-screen interactive commands from Node, and having them render as HTML5 on-the-fly
  • Ability for Node.js to be called from RPG, CL, or the command line using a standard IBM i CALL operation or command
  • Support for all native IBM i data types and seamless handling of parameters between native programs and Node.js
  • Calling any service program procedure on IBM i from Node, including operating system API 

With all the abilities that the Profound.js 2.0 Converter Module provides, you can see how modernizing your applications with Profound.js 2.0 can accelerate the power of your IBM i. 

Tune in next week where we show you how you can get started with Profound.js 2.0's. See you next week!


Profound.js harnesses the power of Agile Modernization and Node.js for IBM i application modernization. Join our live Webinar on the power of Profound.js 2.0 on June 28th, at 10:30am PDT. We will be giving a step by step look through our newest product and be able to answer questions for you afterwards. Sign up today!



 

Topics: Node.js, Profound.js, IBM i applications, IBM i, RPG Development, RPG, Application modernization, AS400 modernization, IBM i Modernization, Agile modernization

Subscribe to Blog Updates

...and get the The Node.js for Enterprise
IBM i Modernization White Paper!

Node.js cover page option 2-1.png

Recent Posts