Docs‎ > ‎Home‎ > ‎

FAQ

The following are some of the questions we often get about CA Live API Creator.

How does this compare to a design-first approach?

Some API developers are accustomed beginning API development with design tools like RAML, followed by a development cycle using various frameworks. We believe this reflects the lack of automation in traditional API creation, resulting in a waterfall-like design-then-build approach to reduce rework.

Our approach combines the process of definition and creation into one step, made point-and-click through leveraging of the data model. This results in running (live) APIs in minutes, even faster than API definition. Such microservices can be built in very small teams, and require zero compile or deployment. The resultant API is consistent, both in style and in functionality (for example, optimistic locking and pagination).

Live API Creator further separates the concerns of API interface from API semantics: your custom resources automatically invoke the underlying logic and security. This means development can not only proceed in parallel, but your APIs can use future logic definitions, without effort or risk. API flexibility is preserved with JavaScript extensibility. If you require RAML-like approaches for flows that fit into a larger production, you can enable this by way of the admin API.

For more information:

Are there Automation Trade-offs?

Automation technology can entail trade-offs, as listed on this page.

Can automation deliver Enterprise-class performance?

Yes. Live API Creator delivers enterprise-class performance. API Server leverages cloud technology for elastic scalability, so that you can meet demand by dynamically adding server instances. A key consideration is latency. To address latency, you can:
  • Choose the location of your server to minimize latency.
  • Define resources that deliver multi-table results in a single response, with provisions for pagination and refresh automation.
Database overhead is reduced by eliminating/minimizing SQLs, caching, and careful lock management. Client results are delivered with paginated, optimistic locking. Update processing is highly tuned to prune and optimize SQLs and defer write locks until late in the transaction.

Direct capture of declarative, end-case requirements enable such global optimization, just as a SQL optimizer is now relied upon to deliver retrieval performance equivalent to manual coding. Live API Creator provides business logic performanceThe same maintenance/iteration value is provided. You can alter the storage configuration, and all of your use cases accrue the benefits.

Are all problems automated? If not, is it extensible?

Logic automation is extensive and complemented by server-side JavaScript. JavaScript provides an effective, standards-based solution where automation does not apply. Automation is inevitably based on identifying key patterns and providing simple ways to declare their use. Business logic is no different in this respect.

Live API Creator keeps the language small and easy to learn. You can add new patterns, as well as solve one-of-kind problems provide, using the provided extensibilityIn particular, you can complement your logic with server-side JavaScript. You can also directly specify your SQL with provisions for merging security. When SQL is not enough, you can materialize resource JSON with JavaScript.

For more information:

Is it opaque? Difficult to debug and extend?

Live API Creator is transparent, so you can easily diagnose issues. This is because even when automation is impressive, there are always issues. We have all been in the unpleasant situation when a piece of software just doesn't seem to be able to do what we want, or worse, it provides the needed service but silently fails ("what is it doing"?).

Live API Creator provides:

    • Extensive Logging. The console always lists what rules fired.
    • Debugging. You can use the API Creator to review rule and sql execution.
    • Extensibility. You can always call out to server-side JavaScript.

Will I have to deal with ugly code?

Automation often depends on code generation, which can be very difficult to read, to debug, and to extend. Live API Creator does not generate code. Manage your API using logging, debugging, and extensibility.

Can I use Live API Creator with NoSql Databases?

Our transactional logic depends on DBMS transaction support. You can integrate MongoDB data into your SQL-based resources declaratively, although Mongo support does not include rules or security. You can also use JavaScript Sub Resources to integrate any data source.

I see other products with Business Logic. What's the difference?

The difference is automation. All the products we know about provide a framework-oriented approach to enable you to write 500 lines of code (for example, JavaScript and 4GL). Live API Creator replaces this with 5 lines of logic. That's a 100X difference, addressing as much as half your project.

How can rules in JavaScript be "declarative"?

Most of your logic will be simple expressions (for example, row.price * row.quantity). Using JavaScript for these expressions leverages technology you already know, and fully enables extensibilityWhile using a familiar language, rules are fully declarative.

Rules exhibit the following key characteristics not present in procedural languages:

  • Ordered. Live API Creator parses your logic and orders it per dependencies.
  • Re-used. Your logic is automatically executed whenever referenced data is altered.
  • Optimized. Conversely, your logic is not executed when its dependencies are not changed.
  • Automated data access. Your SQL is fully automated and fully leverages the cache.

Can I use existing Technology?

Do all of my existing Database apps and tools work with Live API Creator?

Yes. Live API Creator does not replicate your schema. It is acquired from the database, eliminating synchronization issues. The DBMS manages locking and concurrency, so existing apps continue to work without change.

Are Rete Business Rule Engines appropriate for Business Logic?

RETE inference engines are a complementary technology, suitable for decision logic. Live API Creator provides a superior choice for transaction logic, since it is SQL-aware, is high performance, and provides active integrity - all within a RESTful interface.
  • Performant aggregate processing
Aggregate processing is a well-known challenge for Rete engines.  The root cause is that Rete engine interfaces do not presume a transaction that can be compared to an existing database to compute adjustments, and use these to prune processing logic. So, to define a sum, they must bring all the child rows into memory. Particularly when such aggregates are Forward Chained on other aggregates, this can be prohibitively expensive.  By contrast, Live API Creator injects logic into all updates, enabling it to automate key pruning and optimization logic.
  • Active integrity
    Live Creator rules are automatically invoked for all updates.  By contrast, Rete rules require explicit calls.  Integrity that is elective is not reliable, and does not meet the requirements of regulatory compliance or system integrity.  
    • Higher Expressive Power
      Rete engines do not have concepts like old values, so there is no natural way to express state transition logic. They also do not provide advanced logic such as copy and allocation.
      • Simpler to debug
      Live API Creator provides full logging for all logic / SQL, and a debugger for detailed diagnosis.
      • Automated SQL and Object Model
      Live API Creator automates - and optimizes - all of the read/write SQL, so your app is focused on a higher level of abstraction.  Live API Creator also creates your Object Mode, whereas you must create such a model manually as a requirement to use a RETE engine.

      These technologies are complementary. Decision-oriented applications often operate without update transactions, and are quite appropriate for Rete engines. Further, Rete engines often include services such as Decision Tables, which can be invoked from Transaction Business Logic to provide End User access.

      Are Process Business Rule Engines appropriate for Business Logic?

        Process Engines provide excellent value in workflow and system integration processes, where a sequence of steps is inherently manually ordered. They are a poor fit for transactional business logic, which provides great value in automatic ordering.

        Are Visual Rule Designers a better alternative?

        No.  Visual Rule Designers provide a graphical (flow-chart like) way to program your business logic.  While visually appealing, these are really totally procedural, suffering from all the liabilities of programming:
        • Ordering. Your diagram is inherently ordered, so changes must reconsider dependencies
        • Re-use: your logic is not called without explicit invocation, so re-use is not guaranteed. Worse, re-use is of the procedural variety, not re-use of declarative logic (such as a sum, which is automatically re-used over inserts, updates and changes).
        • SQL: such engines typically require you to manually invoke SQL calls.  This is a very low level of abstraction and obviates the possibility of optimizations

        • Optimization: such procedural approaches require you to manually code optimization techniques such as pruning or adjustment, which must be reconsidered on each maintenance change.

        Are JPA Validations sufficient for Business Logic?

        No, JPA validations are static - they do not constrain the results of declarative derivations, and they are single field or, at best, single-table. You can use multi-table derivations, validations, and actions.

        Is this a 4GL?  Can't I use an existing language?

        No, Business Logic is not a 4GL.  Business Logic is declarative, providing automated ordering, re-use and optimization.  4GL languages are procedural languages extended with "power verbs", a dubious objective with the advent of extensible languages such as Java or C#.

        What problems are suitable for API Creator?

        Reactive logic is the processing you execute on save/submit: derivations, validations, and actions such as auditing, copying, messaging, business process initiation, etc. Architect such logic so that it is shared for multiple user interfaces and message-based transactions.

        Live API Creator provides save (transaction) processing. It is focused on SQL data. In some cases, you might consider it as part of a Polyglot DB approach, wherein an application might often employ both SQL and NoSQL technologies.

        Data Retrieval RESTful APIs - including multi-database and ERP integration

        Create RESTful APIs for SQL data that integrate multiple databases and ERP Systems.  You can create these in minutes, while providing Enterprise-class scalability.

        Basic Data Management RESTful APIs - create, read, update, delete

        Advanced Data Management - enterprise-class extensibility

        New Technology always brings issues

        Any new technology has implications. Some typical questions are answered below.

        What is the Learning Curve?

        Live API Creator fits into your existing architecture, using well-accepted principles of SOA, REST and JSON. There is a learning curve associated with logic:

        • Learn the rules - there are not many, but certainly you must learn them.  This should take no more than a morning.
        • Learn the Logic Patterns - we have provided an extensive tutorial, and the sample database is installed for your review.  This should not take more than 1 day or two
        • Learn the Extensibility Patterns - using custom Java and Javascript libraries.

        Can I use Business Logic on an Existing Project?

        Yes. The SOA architecture is particularly effective in dealing with multiple languages and architectures. As with any multi-tiered architecture, you will need to ensure consistency between applications that use the logic server, and those that do not.

        Is Business Logic a Wizard? Just for the Coding Phase?

        Business Logic is not a Wizard. In fact, there is no Design Time component - all of the processing occurs at runtime.

        It is relevant to far more of the Project Life Cycle than coding:

          • It provides some value at Analysis Time, by introducing high level abstractions such as allocation.
          • It provides considerable value during Design, by automating design issues such as re-use, ordering, optimizations, and partitioning.
          • It provides considerable value during Maintenance, automating re-ordering and re-optimization, and with Logicdoc provisions for transparency and Rules Traceability.

        I am a Developer - what's in it for me?

        Though we stress the value to the business of Agility and TCO, there are many benefits for developers:

        • Automated Maintenance - we're developers too, and we understand -- nobody likes maintaining old code. Automated Ordering eliminates the bulk of drudgery of maintenance, since you can just introduce the new logic without worries about dependency management. You'll also be able to find the business logic, without having to hunt through controllers, domain objects, services, and who knows what. So maintenance will be more like development, not archaeology.
        • Automated Documentation - logic is transparent to business users, so is executable documentation. So it's built as a by-product of development, and does not "drift" away like manual documentation
        • Quality - automated re-use means that your logic is always re-used. No more corner cases discovered during Final Test (or worse: later).
        • Creativity - why would you want to build code a machine can build? It is much more creative - and valuable - to identify new patterns, and build re-usable extensions to automate them.
        • Delivering - the "kick" of programming is to deliver new functionality that delights your users. Why not do it more quickly and more often?
        • Transparent - logs make the logic and SQL clear. Metrics enable you to detect APIs that are failing or running too slow.
        • Integrated - Live API Creator is an API-based implementation, so it integrates with your current technology.
        • Controlled Automation - you control how much automation you employ. You can start simple, using familiar JavaScript with basic Security and Validation services. You can use additional automation as you gain confidence.
        • Less Hassle - no need to compile/deploy/maintain code on an app server. No need to deal with SQL.
        • Latest Technology Exposure - with Live API Creator will quickly become familiar with technologies such as APIs, Micro Services, server-side JavaScript, Reactive Logic, etc.

        Does Business Logic benefit Package Development?

        Yes. Business Logic can make your Package Development more agile, can reduce customization costs, and can reduce merge costs for subsequent release cycles.

        Does Business Logic benefit Integrators with Frameworks?

        Yes, Integrators can enhance their business practice, provided they are focused on a value-based relationship with their clients.