jBASE-57-orange-white-clean-656x120

Download Your Free Trial of jBASE

Object & JSON Support

Object & JSON Support – Parse JSON strings into a jBASE, debug applications quicker and enhance support application with Dynamic Objects

Enhanced Encryption

Enhanced Encryption – Secure the valuable data in your PICK system with 256 AES encryption and the latest OpenSSL libraries

Massive File Support

Massive File Support – When combined with 64-bit operating systems, files can now be up to 16TB on Windows (64TB on Linux). Plus Dynamic Files perform up to 3 times faster!

System & User Profiles

System & User Profiles – Profiles dramatically simplify your system configuration and are stored as a JSON string. And jBASE Profiles require zero scripting skills.

Docker Containers (Development Only)

Benefit from Docker OS-level virtualization to deliver software in packages in containers (production certification expected in jBASE 5.8)

Watch the jBASE group – Greg, Pete, Ian, Patrick, and Bruce – talk through the latest developments in these casual short videos. Listen in as they touch on Dynamic Objects, JSON, Dynamic Files, Java Extensions, RESTFUL Services and more.

New Features in jBASE 5.7

Dynamic Objects

Create objects on the fly and program in a language that looks and feels like JavaScript.

Affectionately known as “JabbaScript”—jBASE 5.7 marries the language of MultiValue (BASIC) with a modern language similar to JavaScript, giving developers the best of both worlds. One of the main benefit of Dynamic Object is that it makes BASIC a true object-oriented language. Also, since the jBASE compiler produces native code, operations on dynamic objects are blazingly fast.

Dynamic Files

Improve performance and flexibility with automated file sizing.

As the name implies, the new files are dynamic, built from the ground up to continually work optimally as updates are made. They aren’t like traditional MultiValue files which are hashed files that get re-sized manually or in the background. Dynamic Files reduce administrative overhead and boost your application’s performance.

  • Use of memory maps. A memory map is where you do a one-off system call and this returns a memory pointer to file cache. This means that when accessing a file, instead of using the traditional call to the read() or write() function, which involve a system call, we simply access memory. There are restrictions and limitations to how much we can use this, but the overall effect is that we do fewer calls to read() and write() and hence fewer system calls.

 

  • Group locking. These locks are transient, sometimes for less than a microsecond, and protect the internal integrity of the database during CRUD operations.  They should not be confused with any other sort of locking we perform , for example read locks initiated by READU are something very different. In the past, we have used a locking type which involved a system call. We now use a memory based locking scheme that only requires a system call if the lock is busy.

Profiles

Eliminate the necessity of using environment variables to configure jBASE.

Profiles completely eliminates the necessity of using environment variables to configure jBASE by placing the entire configuration in a JSON file. In release 5.7, you can use either environment variables or profiles or a combination. The profile extends jBASE configuration allowing new settings which have never been available before. Also, 5.7 includes a new “zero configuration” mode that allows jBASE to run with zero external configuration.

RESTful Services

Integrate your business application with the web.

As a universal way for applications to communicate with each other, every major development language now includes frameworks for building RESTful Services. Native RESTful Services are built into jBASE allowing you to bypass proprietary APIs and open your Pick application to any language environment, web service or application.

Object Oriented Programming for PICK

Discover jBASE Dynamic Objects (jDO), an enhancement to the BASIC programming language. Dynamic Objects adds familiar mechanisms of Object-Oriented programming such as objects, methods, and classes expanding the functionality of any jBASE program. jDO is also not an ‘all-or-nothing’ approach to extending new or existing business logic as you can seamlessly inject as much or as little Object-Oriented code right alongside traditional BASIC. This allows a great amount of flexibility without being concerned with forklift-refactoring efforts. New Object-Oriented additions to the business logic become highly reusable and over-time your application will see faster implementation time with increased durability.

With jDO, there are built-in static methods available right out of the box like serializing/deserializing JSON strings to data objects. This brings an entirely new speed to application development while interfacing with the REST APIs out in the world. Here are some examples of working with jDO

$options jabba

RESULT.OBJ = NEW OBJECT; * build new object

OPEN "NW.ORDERS" TO FI.NW.ORDERS ELSE STOP "No orders file"

RESULT.OBJ->records = NEW ARRAY; * add an array called results inside result object

EXECUTE "SSELECT NW.ORDERS BY-DSND ORDERDATE"

CNTR=0
LOOP
    READNEXT ID ELSE EXIT
    CNTR+=1

    READ ORDER FROM FI.NW.ORDERS, ID ELSE CONTINUE
    ORDER.OBJ = NEW OBJECT; * build temporary object for this order

    ORDER.OBJ->orderid          = ID
    ORDER.OBJ->customerid       = ORDER<1>
    ORDER.OBJ->employeeid       = ORDER<2>
    ORDER.OBJ->orderdate        = OCONV(ORDER<3>,"D4-")
  
    NUMBER.ITEMS=DCOUNT(ORDER<10>,@VM); * count how many order lines we have

    ORDER.OBJ->items = NEW ARRAY; * add an array inside our order boject called items

    FOR V=1 TO NUMBER.ITEMS
        ITEMS.OBJ = NEW OBJECT; * temporary object for a single line item
        ITEMS.OBJ->productid   = ORDER<10,V>
        ITEMS.OBJ->unitprice   = OCONV(ORDER<11,V>,"MD2")
        ITEMS.OBJ->quantity    = ORDER<12,V>
  
        ORDER.OBJ->items->$append(ITEMS.OBJ); * append our item detal into our order items array
    NEXT V
    RESULT.OBJ->records->$append(ORDER.OBJ); * append our order into our records array
REPEAT

PRINT RESULT.OBJ->$tojson(1); * print our output to json

We can read it into a jBASE Dynamic Object, print the name, update the name and display the resultant JSON simply as follows. It is to manipulate a Dynamic Object created from a JSON string with constructs such as ‘print myobj->name’ – –

jsh Z2018 ~ -->BASIC BP NWORDERS.EXAMPLE
NWORDERS.EXAMPLE
BASIC_1.c
Source file NWORDERS.EXAMPLE compiled successfully
jsh Z2018 ~ -->CATALOG BP NWORDERS.EXAMPLE
NWORDERS.EXAMPLE
Object NWORDERS.EXAMPLE ( changed to nworders.example ) cataloged successfully
jsh Z2018 ~ -->GET-LIST EXAMPLE.LIST

 2 Records selected

>NWORDERS.EXAMPLE

 2 Records selected

{
   "records":[
      {
         "orderid": "10301",
         "customerid": "WANDK",
         "employeeid": "8",
         "orderdate": "09-09-1996",
         "items":[
            {
               "productid": "40",
               "unitprice": "14.70",
               "quantity": "10"
            },
            {
               "productid": "56",
               "unitprice": "30.40",
               "quantity": "20"
            }
         ]
      },
      {
         "orderid": "10258",
         "customerid": "ERNSH",
         "employeeid": "1",
         "orderdate": "07-17-1996",
         "items": [
            {
               "productid": "2",
               "unitprice": "15.20",
               "quantity": "50"
            },
            {
               "productid":"5",
               "unitprice":"17.00",
               "quantity":"65"
            },
            {
                "productid":"32",
                "unitprice":"25.60",
                "quantity":"6"
            }
         ]
      }
   ]
}
jsh Z2018 ~ -->

Create your own classes and convert output to JSON.

jDO enhances your ability to hire developers that don’t necessarily need to learn PICK BASIC to be successful and productive. Instead of spending time teaching people procedural code, let them work as they normally would in an Object-Oriented mindset and start delivering new innovations.

Enhanced Security

Unlike other database encryption solutions for MultiValue, ours just works!

jBASE encryption brings 256 AES encryption to all jBASE file types and indexes without changing your application. Benefit from the latest encryption algorithms for:

  • Strong encryption using AES-256 symmetric cipher • Latest OpenSSL library provides cryptographic functions
  • File encryption is stored in encrypted container requiring a separate key for access
  • Simple yet powerful, supports modern encryption algorithms, meets modern ata security requirements, easy to configure and manage, fast
  • Best of all, our encryption is safe and easy to implement.

Dynamic Files

Imagine your PICK system continually adjusting the size and structure of its data on its own? Welcome to Dynamic Files, a free feature that you can toggle on or off in jBASE 5.7. Underneath the hood, jBASE manages all the hash algorithms and disk allocation. But to the user, this means there is no more file resizing (as your data grows), and no more slowdowns if your file structure outgrows your file plan. In fact, Dynamic Files often run 3x faster that regular files and file sizes can grow up to 64TB on select 64-bit operating systems.

It’s easy to convert your existing files to Dynamic Files. Once converted, the maintenance on your data files should be significantly less. Also, there is no change necessary to your business logic to use this enhancement.

Docker Containers

Similar to the server virtualization revolution (led by juggernauts like VMware), containers are transforming software development. Containers automate the deployment of code by packaging everything up — the app, the operating system and all its dependencies — so your application runs quickly and reliably from one computing environment to another. Container technology uses only one instance of an operating system so images are small and portable.

Click here to watch a 60 second tutorial on running jBASE in a Docker Container.

REQUEST DEMO

Request a free evaluation version of jBASE 5.7

JBASE BROCHURE

A Database Built for the Future

RELEASE NOTES

Read the Official jBASE 5.7 Release Notes