Category Archives: app dev

Application development platforms, tools and methodologies

Getting started with OpenText case management

I had a demo from Simon English at the OpenText Enterprise World expo earlier this week, and now he and Kelli Smith are giving a session on their dynamic case management offering. English started by defining case management:

  • Management of dynamic, unstructured processes
  • Processes are driven by events or human interactions to support faster, more accurate decisions
  • Decisions are tied to content and the case directs that content to the right conclusion

In their terms, a case is a transaction that is “opened” and “closed” over a period of time: resolve a problem, settle a claim, or fulfill a request. There may be many different types of participants required to complete the case, and a variety of content and data involved.

Similar to the approach of other vendors, OpenText equates “case management” with “vertical application development” to a certain extent, and getting to case handling quickly needs a blueprint to quick-start solution development. To that end, they provide an accelerator as part of Process Suite that includes a pre-defined case model and entities to provide a starting point for developing a case management application, particularly incident management or service requests. Essentially, it’s a sample app/template, albeit a well-structured one that can easily be modified for actual solutions; they have no illusions that this is going to be an out-of-the-box solution for anyone, but rather a guide for people creating new case management applications so that they don’t need to start from scratch.

If you refer back to the more complete description of AppWorks Low Code that I gave in the previous post, they have defined entities, forms, layouts and a case lifecycle that fit a wide variety of request-style case management applications.

Smith then gave us a demonstration of People Center — similar to what we saw her do on the main stage on Tuesday — and discussed how they used the case management accelerator as a starting point for developing the People Center application. They used some parts of the template pretty much as is — such as the request creation form — but made it specific to HR management and extended the capabilities to suit, including a dashboard specific to each role. Checklists and options are specific to the HR application, but as discussed in previous posts, those will persist through an upgrade of the underlying People Center application.

She also walked us through the case management accelerator in the development environment, showing the fairly complete set of entities, forms, layouts, action bars, lists, relationships, rules, email templates, BPM processes, roles and other objects, as well as how easy it is to modify them for your own use. For any partners in the audience, or even customer developers, this will resonate as a method of quickly creating a fully-customized application based on the template that addresses a specific vertical functionality.

OpenText Process Suite becomes AppWorks Low Code

“What was formerly known as Process Suite is AppWorks Low Code, since it has always been an application development environment and we don’t want the focus to be on a single technology within in.”  – Dana Khoyi, architect of OpenText’s Process Suite

That pretty much sums up the biggest BPM positioning/branding announcement at OpenText Enterprise World 2017 this week. BPM is dead, long live low-code application development? Note that AppWorks is the name used for all OpenText developer tools; the technical developer APIs and access points, plus this low code product which is really a separate product.

Khoyi and Kelli Smith (who did the main stage People Center demo on Tuesday) led a session on the last day of Enterprise World to show how Process Suite AppWorks is used to create applications, starting with defining composite entities (business objects made up of multiple pieces of data), then UI constructs including forms, dashboards and lists. Because process and content are built into the environment, there are easy building blocks for content lifecycle, activity flow and history. Declarative rules are supported — triggered on conditions, events or user actions — and dropping out to a full process model for more complex flows and events. They also have a development framework for building customizable applications that persists customizations separately from the application and merges them at runtime, allowing a new version of the core application to be installed without discarding the previous customizations, although obviously you’d want to test and might require some minor retrofits.

Application development starts by defining the core entity for the application (think process or case instance class) then add properties (data fields) and building blocks: forms to edit and display those properties (as well as built-in properties such as state); lists that can be worklists or reporting artifacts; and layouts, which are essentially the application UI screens and can include the previously-created forms plus actions, breadcrumbs, and related content. Data/content security and access/update conflicts are handled automatically on the forms/layouts based on underlying security definitions. Apps that are created can be published immediately to run; these can be moved as packages between testing and production environments although it’s not clear that there’s any versioning or automation around that, so likely some manual governance is required.

Other building blocks that can be added to an application include:

  • A history log that maintains a complete audit trail of everything done during the instance including field-level data changes
  • A discussion for collaborative chat/comments on an instance
  • Content, which can be files/folders that are attached to the case instance using a local document store or other content store via a connector or CMIS, or a businses workspace within Content Server (using Extended ECM) which stores the content in CS and allows access from either environment while syncing properties between them.
  • Email templates that provide a form letter email capability for inbound/outbound email associated with the case
  • Three ways of managing work:
    • Lifecycle, which is a state machine-oriented view (i.e., milestones and the actions required to move between states) for a simple case workflow
    • BPM, for a full drop to the BPMN editor for complex process flows
    • Action flow, which is a simple sequence flow
  • Mobile app creation
  • Entity relationships

There’s a lot of stuff in here, and we didn’t see it all in this short session, but looks like a pretty robust environment for low-code development. Khoyi stated explicitly that this is becoming the development for all OpenText products, replacing the workflow capabilities in Content Server and Documentum.

Bridging the bimodal IT divide

Bimodal ITI wrote a paper a few months back on bimodal IT: a somewhat controversial subject, since many feel that IT should not be bimodal. My position is that it already is – with a division between “heavy” IT development and lighter-weight citizen development – and we need to deal with what’s there with a range of development environments including low-code BPMS. From the opening section of the paper:

The concept of bimodal IT – having two different application development streams with different techniques and goals – isn’t new. Many organizations have development groups that are not part of the standard IT development structure, including developers embedded within business units creating applications that IT couldn’t deliver quickly enough, and skunkworks development groups prototyping new ideas.

In many cases, this split didn’t occur by design, but out of situational necessity when mainstream IT development groups were unable to service the needs of the business, especially transformational business units created specifically to drive innovation. However, in the past few years, analysts are positioning this split as a strategic action to boost innovation. By 2013, McKinsey & Company was proposing “greenfield IT” – technology managed independently of the legacy application development and infrastructure projects that typically consume most of the CIO’s attention and budget – as a way to innovate more effectively. They found a correlation between innovation and corporate growth, and greenfield IT as a way to achieve that innovation. By the end of 2014, the term “bimodal IT” was becoming popular, with Mode 1 being the traditional application development cycle focused on stability, well suited to infrastructure and legacy maintenance and Mode 2, focused on agility and innovation, similar to McKinsey’s greenfield IT.

Read on by downloading the paper from Software AG’s site; right now, it looks like registration isn’t required.

American Express digital transformation at Pegaworld 2016

Howard Johnson and Keith Weber from American Express talked about their digital transformation to accommodate their expanding market of corporate card services for global accounts, middle market and small businesses. Digital servicing using their @work portal was designed with customer engagement in mind, and developed using Agile methodologies for improved flexibility and time to market. They developed a set of guiding principles: it needed to be easy to use, scalable to be able to manage any size of servicing customer, and proactive in providing assistance on managing cash flow and other non-transactional interactions. They also wanted consistency across channels, rather than their previous hodge-podge of processes and teams depending on which channels.

wp-1465337619564.jpg

AmEx used to be a waterfall development shop — which enabled them to offshore a lot of the development work but meant 10-16 months delivery time — but have moved to small, agile teams with continuous delivery. Interesting when I think back to this morning’s keynote, where Gerald Chertavian of Year Up said that they were contacted by AmEx about providing trained Java/Pega developers to help them with re-onshoring their development teams; the AmEx presenter said that he had four of the Year Up people on his team and they were great. This is a pretty negative commentary on the effectiveness of outsourced, offshore development teams for agile and continuous delivery, which is considered essential for today’s market. AmEx is now hiring technical people for onshore development that is co-located with their business process experts, greatly reducing delivery times and improving quality.

wp-1465337686253.jpg

Technology-wise, they have moved to an omni-channel platform that uses Pega case management, standardizing 65% of their processes while providing a single source of the truth. This has resulted in faster development (lower cost per market and integration time, with improved configurability) while enabling future capabilities including availability, analytics and a process API. On the business side, they’re looking at a lot of interesting capabilities for the future: big data-enabled insights, natural language search, pluggable widgets to extend the portal, and frequent releases to keep rolling this out to customers.

It sounds like they’re starting to use best practices from a technology design and development standpoint, and that’s really starting to pay off in customer experience. It will be interesting to see if other large organizations — with large, slow-moving offshore development shops — can learn the same lessons.

Camunda BPM 7.5: CMMN, BPMN element templates, and more

I attended an analyst briefing earlier today with Jakob Freund, CEO of Camunda, on the latest release of their product, Camunda BPM 7.5. This includes both the open source version available for free download, and the commercial version with the same code base plus a few additional features and professional support. Camunda won the “Best in Show” award at the recent bpmNEXT conference, where they demonstrated combining DMN with BPMN and CMMN; the addition of the DMN decision modeling standard to BPMN and CMMN modeling environments is starting to catch on, and Camunda has been at the front edge of the wave to push that beyond modeling into implementation.

They are managing to keep their semi-annual release schedule since they forked from Activiti in 2013: version 7.0 (September 2013) reworked the engine for scalability, redid the REST API and integrated their Cockpit administration module; 7.1 (March 2014) focused on completing the stack with performance improvements and more BPMN 2.0 support; 7.2 (November 2014) added CMMN execution support and a new tasklist; 7.3 (May 2015) added process instance modification, improved authorization models and tasklist plugins; and 7.4 (November 2015) debuted the free downloadable Camunda Modeler based on the bpmn.io web application, and added DMN modeling and execution. Pretty impressive progression of features for a small company with only 18 core developers, and they maintain their focus on providing developer-friendly BPM rather than a user-oriented low-code environment. They support their enterprise editions for 18 months; of their 85-90 enterprise customers, 25-30% are on 7.4 with most of the rest on 7.3. I suspect that a customer base of mostly developers means that customers are accustomed to the cycle of regression testing and upgrades, and far fewer lag behind on old versions than would be common with products aimed at a less technical market.

Today’s 7.5 release marches forward with improvements in CMMN and BPMN modeling, migration of process instances, performance and user interface.

Oddly (to some), Camunda has included Case Management Model & Notation (CMMN) execution in their engine since version 7.2, but has only just added CMMN modeling in 7.5: previously, you would have used another CMMN-compliant modeler such as Trisotech’s then imported the model into Camunda. Of course, that’s how modeling standards are supposed to work, but a bit awkward. Their implementation of the CMMN modeler isn’t fully complete; they are still missing certain connector types and some of the properties required to link to the execution engine, so you might want to wait for the next version if you’re modeling executable CMMN. They’re seeing a pretty modest adoption rate for CMMN amongst their customers; the messaging from BPMS vendors in general is causing a lot of confusion, since some claim that CMMN isn’t necessary (“just use ad hoc tasks in BPMN”), others claim it’s required but have incomplete implementations, and some think that CMMN and BPMN should just be merged.

Camunda 7.5 element templatesOn the BPMN modeling side, Camunda BPM 7.5 includes “element templates”, which are configurable BPMN elements to create additional functionality such as a “send email” activity. Although it looks like Camunda will only create a few of these as samples, this is really a framework for their customers who want to enable low-code development or encapsulate certain process-based functionality: a more technical developer creates a JSON file that acts as an extension to the modeler, plus a Java class to be invoked when it is executed; a less technical developer/analyst can then add an element of that type in the modeler and configure it using the properties without writing code. The examples I saw were for sending email and tweets from an activity; the JSON hooked the modeler so that if a standard BPMN Send Task was created, there was an option to make it an Email Task or Tweet Task, then specify the payload in the additional properties that appeared in the modeler (including passed variables). Although many vendors provide a similar functionality by offering things such as Send Email tasks directly in their modeling palettes, this appears to be a more standards-based approach that also allows developers to create their own extensions to standard activities. A telco customer is using Camunda BPM to create their own customized environments for in-house citizen developers, and element templates can significantly add to that functionality.

Camunda 7.5 instance migration 4 - manual mapping of unrecognized steps between modelsThe process instance migration feature, which is a plugin to the enterprise Cockpit administration module but also available to open source customers via the underlying RESET and Java APIs, helps to solve the problem of what to do with long-running processes when the process model changes. A number of vendors have solutions for this, some semi-automated and some completely manual. Camunda’s take on it is to compare the existing process model (with live instances) against the new model, attempt to match current steps to new steps automatically, then allow any step to be manually remapped onto a different step in the new model. Once that migration plan is defined, all running instances can be migrated at once, or only a filtered (or hand-selected) subset. Assuming that the models are fairly similar, such as the addition or deletion of a few steps, this should work well; if there are a lot of topology changes, it might be more of a challenge since there could need to roll back instance property values if instances are migrated to an earlier step in the process.

They have also improved multi-tenancy capabilities for customers who use Camunda BPM as a component within a SaaS platform, primarily by adding tenant identifier fields to their database tables. If those customers’ customers – the SaaS users – log in to Cockpit or a similar admin UI, they will only see their own instances and related objects, without the developers having to create a custom restricted view of the database.

Camunda 7.5 process duration reportThey’ve released a simple process instance duration report that provides a visual interface as well a downloadable data. There’s not a lot here, but I assume this means that they are starting to build out a more robust and accessible reporting platform to play catch-up with other vendors.

Lastly, I saw their implementation of external task handling, another improvement based on customer requests. You can see more of the technical details here and here: instead of a system task calling an Camunda 7.5 external-task-patternexternal task asynchronously then wait for a response, this creates a queue that an external service can poll for work. There are some advantages to this method of external task handling, including easier support for different environments: for example, it’s easier to call a Camunda REST API from a .NET client than to put a REST API on top of .NET; or to call a cloud-based Camunda server from behind a firewall than to let Camunda call through your firewall. It also provides isolation from any scaling issues of the external task handlers, and avoids service call timeouts.

<a href="https://flic.kr/s/aHskxvvNsX" target="_blank">Click to View</a>

There’s a public webinar tomorrow (June 1) covering this release, you can register for the English one here (11am Eastern time) and the German one here (10am Central European time).

bpmNEXT 2016 demos: Appian, Bonitasoft, Camunda and Capital BPM

Last day of bpmNEXT 2016 already, and we have a full morning of demos in two sessions, the first of which has a focus on more technical development.

Intent-Driven, Future-Proof User Experience – Malcolm Ross and Suvajit Gupta, Appian

Appian’s SAIL UI development environment. Build interfaces with smart components that detect the capabilities of the runtime device (e.g., camera, Bluetooth) and enable/disable/configure components on the fly. Supports a variety of UI rendering architectures/frameworks for desktop, and generates native mobile apps for Android and iOS. Directly supports their underlying constructs such as Records and process models when building forms. Dynamic content based on selections and data on form. Fast rebranding of forms with color and logos. Full functionality on mobile devices, and offline support via caching data down to device, and saving any offline transactions to automatically synchronize when reconnected. Switch between design (tree/graphical) view and code view in IDE to support different technical capabilities of UI designers. Not a focus on BPM per se, since Appian is repositioning as more of a process-centric application development tool than BPMS, although used as the UI development environment for their process applications.

Continuous Integration: Tools to Empower DevOps in Process-Based Application Development – Charles Souillard, Bonitasoft

Embodying continuous integration for live updates of applications, enabling easier development and automated testing supported by Docker images. Demo of simple shopping cart application created using BonitaBPM, with a combination of forms, pages, layouts, custom widgets and fragments that can be rendered on desktop and mobile devices. Underlying BPMN process model with human activities connected to UI artifacts. Versioned using Subversion. The continuous integration functionality monitors checked-in changes to the application and integrates them into the dev/test repository to allow immediate testing; in the demo, a new input parameter was added to a process step; the updated code was detected and tested, with testing errors raised due to the unknown parameter. Potential to accelerate the dev-test cycle, since code can be checked in by developers several times each day, with the results automatically tested and fed back to them.

Combining DMN with BPMN and CMMN: The Open Source Way – Jakob Freund, Camunda

wp-1461259584764.pngCamunda’s “developer-friendly” BPM for developers to add process, case and decision capabilities to their applications. Their DMN decision tables allows changing decision tables at runtime for increased agility, depending on binding specified by process designer. Decisions executed as decision tasks from a process are logged as part of process history, and visible in their admin Cockpit interface to trace through decisions for a specific process instance. DMN engine also available outside decision tasks in a process, such as a REST API call from a form to dynamically update values as parameters change; when deploying a table, both a public ID for executing the table and a private ID for editing the table are generated for the REST access. Nice traceability directly into the decision table, and fast changes to production decision tables. Open source, with a free (non-production) DMN cloud version. Extra points for creating an online dungeon game using BPMN, and playing a round during the demo.

Appian Around The World – Toronto

Appian was recently doing a round of road-show conferences, and when they landed in my backyard, I decided to stop in for the day and see what was new. I missed Appian World this year and was looking forward to a bit of a product update as well as some of the local customer stories.

The day started with Edward Hughes, SVP of sales, giving us a high-level overview of Appian and their BPM platform-as-a-service and case management products (for the non-customers in the audience), as well as their shift to becoming more of a broad application development platform rather than just a BPMS. I’ve been seeing this trend with many BPM vendors over the past few years, and Appian has been repositioning this way for a year or two already. Using Appian as an application development platform allows applications to be developed independently of the deployment platform, both on server side (e.g., develop on the cloud version, deploy on premise) and for client interfaces on desktops or mobile devices. The messaging is that you can use their platform to create customer service applications “beyond CRM” to handle the entire customer journey, with a unified interface plus a consolidated view onto enterprise data using their Records function. He also talked about the Appian App Market, which is an expanded version of their Appian Forum, containing add-in components and complete applications from Appian and third parties.

Since it was a small room, the local customers introduced themselves and talked about their Appian experience and applications: 407 ETR with 10 apps integrated with their customer portals so that online actions (e.g., acquiring a new transponder) become Appian processes assigned to the 125 internal users; Manulife, the first Appian cloud customer back in 2008, now migrating their “legacy” Appian apps to the Tempo UI and serving 900 users for work/time tracking and records management in Marketing; and IESO with apps to register and manage information about energy companies participating in electricity markets. We also heard from some of the partners attending: TCS, Princeton Blue, and boutique contender Bits In Glass with 15+ Appian-trained people in Canada and the US. Bits In Glass used to do mostly code-level (Java) bespoke development, and have reduced their efforts and timelines to 1/3 of that using Appian’s model-driven development.

Next up was Michael Beckley, describing his new role as Chief Customer Officer (as well as CTO) as well as giving us a product update on the 7.11 quarterly release. Appian is seeing corporate IT budgets as 20% innovation and 80% maintenance, but they want to flip that ratio so that maintenance is much less expensive than the original build, freeing up time and energy for innovation. Most large enterprises aren’t going to get rid of custom applications, but they do need to make them faster to build and maintain, while enforcing strict security and providing a user-friendly interface for internal and external users. In theory, an integrated application development such as Appian provides all the pieces:user interface, reports, rules, collaboration, process, on-premise cloud, mobile, social, data, content, security, identity, and integration; in practice, most organizations end up doing something outside the model-driven development environment, although it can definitely improve their custom development efforts. Appian’s focus, as with many of the other BPMS vendors pivoting to become app dev vendors, is on providing a platform to build process-centric applications that get things done via automation, with people injected into the process where required.

Beckley gave us a hint of their growth strategy: they tend to build rather than buy in order to keep their technology pure, and since growth by acquisition inevitably requires a large (and underestimated) effort to integrate the new technology.

Here’s a quick list of the Appian 7.11 updates (some of these likely came before 7.11, but I haven’t had an update for a while):

  • Three UI styles for Appian apps: the Tempo social interface, Sites limited-function workspace/worklist for heads-down workers, and Embedded SAIL to embed Appian functionality within an existing portal for internal or external users. Sites have Action Forms for fit-for-purpose apps when a social feed UI isn’t appropriate, and Embedded SAIL has Action Forms for customer-facing apps within a third-party web portal. These latter two are critical for real-world enterprise applications: although I like the Tempo interface, many of my enterprise clients need a different sort of view for heads-down workers, which can be provided by Sites or using Embedded SAIL.
  • A number of improvements to the Tempo news feed and UI, including the Tempo Kudos view to promote collaboration and provide awareness of accomplishments, dynamically-updating filters to better link and manage record data and underlying data sources
  • Improvements to SAIL, including positioning it as a device-independent UI that provides shared model experience (rather than an HTML5 gateway into an existing app as seen in some other mobile-enablement technology) that is natively rendered on each device. The rendering engine can be updated independently of the applications, making it easier to adapt to new OS versions and devices. Appian uses SAIL to build their own components and apps that become part of the product. From a developer functionality standpoint, SAIL has added placeholder text and tooltips on forms, auto first field focus to reduce clicks and improve efficiency, additional image sizes that are auto-scaled to the device, initially-collapsed form sections, “submit” links that can be placed on a graphic element instead of standard buttons, links in milestones and pickers, grid enhancements, and continuing speed improvements. There’s also a new barcode component, although on iOS only and requiring a Verifone device for capture.
  • Mobile offline actions use native encrypted data containers rather than HTML5 storage (some of this is iOS only although Android is planned for later this quarter), with the developer deciding which actions and data are available offline. Changes to the definition of a form while a user is offline will prompt the user to review and resubmit the form with the new/updated form field definitions, so application changes can continue even if there are active offline users. This does not (yet) allow existing records to be locked for offline updates, although tasks can be locked to user before going offline.
  • For designers, the developer portal is being migrated to SAIL and enhanced with build processes; there’s a UI designer navigation tree to allow view/select/edit within a hierarchical tree view of an action form; the expression rule designer (“for those of you who are still writing expressions”, namely power developers) auto-suggests rule inputs and there is some level of expression rule testing; a process report designer can be used to create performance reports; impact analysis reports show where rules are invoked and other object relationships; bulk security updates can be made across objects.
  • For administrators, a big new thing is LDAP/SAML authentication with multiple LDAP servers and complex configurations.

They have frequent product update webinars , free introductory courses and tips & tricks sessions online; in fact, there is a product update webinar tomorrow if you want to hear more about what I’ve listed above.

We heard from Rew Dickinson, a solutions consultant, on what makes a great app — complete with a live demo to show us how it’s done. There were a lot of best practices here that I won’t repeat, better for you to check out one of their webinars, but a few key pointers:

  • Design applications to be omni-channel and easily adaptable.
  • Use Records to organize and model corporate data, regardless of source, for use in an application; bidirectional links between Records and process instances allow for a full view whether you’re coming from the process or data side of things.
  • Use Sites for fit-for-purpose applications, e.g., a worklist for heads-down task execution, as an alternative to full Tempo environment. Effectively, this is a report that can be sorted and filtered, with links to tasks that takes the user to the task form; it can include work management analytics for a manager/dispatcher user to monitor and reallocate task assignments. This made me think that Appian has just reinvented their per-application portal mode with Sites, albeit with better underlying technology, but that’s a discussion for another day.
  • Use Embedded SAIL for customer-facing portal environments, e.g., create service request from a customer order page.

Michael Beckley came back to talk to us about Appian Cloud, that is, their public cloud offering. It uses Amazon AWS/EC2/S3 in a single-tenant architecture, which allows each environment to be upgraded independently — more of a managed hosting model. The web tier is shared and handled by Appian, who also manages servers, load balancing, high availability and upgrades. There can be a VPN tunnel to on-premise data, and in fact the AWS instance does not have to be available on the public internet, but can be restricted to access only through the VPN from a corporate location. This configuration provides the elasticity and availability of the Amazon cloud, but allows private data to remain on premise — something that goes a long ways to resolving geographic data location issues. They’ve obviously been working on the optics of US-owned data centers by listing their privacy chops, but it would have been even more reassuring to see a mention of any Canadian standards such as PIPEDA for this purely Canadian audience. There are tiers for development, medium, large and extra-large deployments, with a redeployment to move between tiers (so not that elastic…) but it supposedly only takes a few minutes if planned. Uptime this year is mostly 5 9’s, with customer credits for missed uptime SLAs. You can also self-host Appian in other environments, e.g., Azure, although the Appian Cloud SaaS offering is currently Amazon only.

We finished up with Mike Cichy, an Appian consultant, discussing their center of excellence offerings and how customers can plug into the vast wealth of information, from checklists to migration guides to training in order to embody best practices. There are a number of tools available such as the Appian Health Check and Deployment Automation in addition to these practices, with an overall goal to help achieve a large improvement in developer speed and quality within customer/partner organizations.

Altogether an informative day, and great catch up with some old friends.

Pega 7 Express at PegaWORLD 2015

img-pega-7-express-ui-snippetAdam Kenney and Dennis Grady of Pega gave us the first look at Pega 7 Express: a new tool for building apps on top of the Pega infrastructure to allow Pega to push into the low-code end of the BPM/ACM market. In part, this is likely driven by the somewhat high degree of technical skill that has traditionally been required to create applications using Pega, but also by the fact that customer experience is becoming a key differentiator, creating the need to create good customer-facing applications faster. Customer experience, of course, is much more than just the type of apps that you’re going to create using Pega 7 Express: it’s new devices and methods of interaction, but all of these are setting the bar high and changing customer expectations for how they should be able to deal with vendors of goods and services. Pega 7 Express is part of the Pega 7 platform, using the same underlying infrastructure: it’s (just) a simpler authoring experience that requires little or no advance training.

We saw an introductory video, then a live demo. It includes graphical data modeling, form building and case configuration, all with multi-device support.

IMG_7234Call it end-user computer (EUC), citizen computing or low-code model-driven development, Express is addressing the problem area of applications that were traditionally built using email, spreadsheets and local desktop databases (I’m looking at you, Excel and Access). I’m not going to enumerate the problems with building apps like these; suffice it to say that Express allows you to leverage your existing Pega infrastructure while allowing non-Java developers to build applications. They even include some badges for gamifying achievements – when you build your first app, or personalize your dashboard. Just-in-time learning is integrated so that you can see an instructional video or read the help as you need it, plus in-context guidance while you’re working.

IMG_7236In the demo, we created a new case-based app by specifying the following:

  • Application name, description and logo
  • Case type
  • Major phases (a straight-through process view)
  • Steps in each phase
  • Form design for specific steps – the data model is created behind the scenes from the form fields
  • Routing/assignment to reviewers and approvers
  • Milestones and deadlines
  • Device support

In part, this looks a lot like their Directly Capturing Objectives tools, but with more tools to create an actual executable app rather than just as input to the more technical Designer Studio development environment. We also saw customizing the dashboard, which was a pretty standard portal configuration.

IMG_7237As with any good Pega demo, however, Kenney went off-screen to “create a little data table” while Grady showed us the graphical form/case builder; they are definitely the masters of “pay no attention to the man behind the curtain” during demos, where one person does the user-friendly stuff on-screen, while a couple of others do a bit of heavy lifting in the background. Lucky for us (unlikely for Kenney), he couldn’t connect to the wifi so we did get to see the data table definition, which was straightforward.

IMG_7239This does look like a pretty usable low-code application development environment. Like any other low-code model driven development, however, it’s not really for complete non-techies: you need to understand data types, how to design a form, the concept of linking case types and separately-defined data types, and how to decompose a case into phases and steps. It wasn’t clear from the brief demo how this would interact with any sort of expected case automation or other parts of the underlying Pega infrastructure: predictions, automated steps/service calls, more complex process flow or temporal dependencies, access control, etc. It’s also unclear any sort of migration path from Express to the full Designer Studio, so that this could be used as an operational prototyping tool for more complex development. They did respond to a question about reporting; there is some out of the box, and they will be adding more as well as adding ad hoc

Pega 7 Express was announced today, with the cloud version available starting today, with a 30-day free trial followed by subscription pricing; when Pega 7.19 rolls out to on-premise installations, it will also offer Express. They’re not really pushing it yet, but will start to roll out the marketing around it in Q3.

bpmNEXT 2015 Day 2 Demos: Omny.link, BP-3, Oracle

We’re finishing up this full day of demos with a mixed bag of BPM application development topics, from integration and customization that aims to have no code, to embracing and measuring code complexity, to cloud BPM services.

Omny.link: Towards Zero Coding

Tim Stephenson discussed how extremely low-code solutions could be used to automate marketing processes, in place of using more costly marketing automation solutions. Their Omny.link solution integrates workflow and decisioning with WordPress using JavaScript libraries, with detailed tracking and attribution, by providing forms, tasks, decision tables, business processes and customer management. He demonstrated an actual client solution, with custom forms created in WordPress, then referenced in a WordPress page (or post) that is used as the launch page for an email campaign. Customer information can be captured directly in their solution, or interfaced to another CRM such as Sugar or Salesforce. Marketers interact with a custom dashboard that allows them to define tasks, workflows, decisions and customer information that drive the campaigns; Tim sees the decision tables as a key interface for marketers to create the decision points in a campaign based on business terms, using a format that is similar to an Excel spreadsheet that they might now be using to track campaign rules.

BP-3: Sleep at Night Again: Automated Code Analysis

Scott Francis and Ivan Kornienko presented their new code analysis tool, Neches, that applies a set of rules based on best practices and anti-patterns based on their years of development experience to identify code and configuration issues in IBM BPM implementations that could adversely impact performance and maintainability. They propose that proper code reviews — including Neches reviews — at the end of each iteration of development can find design flaws as well as implementation flaws. Neches is a SaaS cloud tool that analyzes uploads of snapshots exported from the IBM BPM design environment; it scores each application based on complexity, which is compared to the aggregate of other applications analyzed, and can visualize the complexity score over time compared to found, resolved and fixed issues. The findings are organized by category, and you can drill into the categories to see the specific rules that have been triggered, such as UI page complexity or JavaScript block length, which can indicate potential problems with the code. The specific rules are categorized by severity, so that the most critical violations can be addressed immediately, while less critical ones are considered for future refactoring. Specific unused services, such as test harnesses, can be excluded from the complexity score calculation. Interesting tool for training new IBM BPM developers as well as review code quality and maintainability of existing projects, leveraging the experience of BP-3 and Lombardi/IBM developers as well as general best coding practices.

Oracle: Rapid Process Excellence with BPM in the Public Cloud

Linus Chow presented Oracle’s public cloud BPM service for developing both processes and rules, deployable in a web workspace or via mobile apps. He demonstrated an approval workflow, showing the portal interface, a monitoring view overlaid on the process model, and a mobile view that can include offline mode. The process designer is fully web-based, including forms and rules design; there are also web-based administration and deployment capabilities. This is Oracle’s first cloud BPM release and looks pretty full-featured in terms of human workflow; it’s a lightweight, public cloud refactoring of their existing Oracle BPM on-premise solution, but doesn’t include the business architecture or SOA functionality at this time.

Great day of demos, and lots of amazing conversations at the breaks. We’re all off to enjoy a free night in Santa Barbara before returning for a final morning of five more demos tomorrow.

Smarter Processes With Kapow Integration

I’m in a Kofax Transform breakout session on Kapow Integration together with KTA; I missed documenting the first part of the session when my Bluetooth keyboard stopped talking to my Android tablet, until I figured out how to pair it with my iPhone (which is not supposed to be possible), so I’m blogging on that. I feel like Macgyver.

Kapow provides a method to create “robots” for a sophisticated sort of automated control and screen scraping of web pages, so that you can create robots to interact with a web page for the purpose of integrating it with other applications (such as those built on Kofax TotalAgility) instead of a user having to interact with the page directly. In the demonstration that we saw, a robot was created to enter data to generate pay stubs on a site, then scroll between the full set of stubs created to take a screen snapshot or PDF of each. This allows any web application to use the robots to harvest information from a web site without user interaction, for example, to go to a series of bank web sites and enter the provided credentials to gather bank statements as input to a mortgage process. The use case shown had a web application that was presented to the customer, gathered their credentials for a number of banking sites, then went to each of those behind the scenes to grab the bank statements using the robot’s knowledge of how to navigate to each of those sites. Although the web sites being remotely controlled are hidden from the user, the robot can show a clip of the underlying site to, for example, display an error message such as incorrect credentials.

The design is all pretty much drag-and-drop, meaning that a semi-technical data or business analyst could work through the creation of a robot: they just need to know how to navigate through the web site to be controlled, and be able to understand how to handle all of the possible error cases. There are more technical implementations for complex scenarios that would require developer skills, but a lot can be done without that.

In my past life as a systems integrator, we did a lot of screen scraping, mostly of green-screen systems that could not be easily integrated with; funny that we have exactly the same problem even though we have leapfrogged a few generations of technologies from terminal emulators to browsers. Plus ça change.