Category: Intelligent Advisor

Intelligent Advisor New Feature : Hub Authoring

Join us today as we investigate a new feature (much-signposted and much-heralded in the previous 12 months) that crept into Intelligent Advisor 20C monthly release 2. The Intelligent Advisor New Feature we are talking about, and that we expect everyone else will be talking about, is Hub Authoring. it’s been on the horizon for a long time.

The concept is simple – let’s see what the official definition of this Intelligent Advisor New Feature is, taken from the documentation:

Hub authoring provides a business-user friendly authoring interface through a web browser for rapid creation and deployment of decision web services, without requiring a desktop installation. It is a suitable for:

  • calculation services (shipping, tax, permit, insurance premiums)
  • risk assessments
  • invoice validation
  • batch update of case or incident data
  • triage
  • action recommendations

Aside from the rather vague business scenarios, this means three things

  • Rule Authors can write rules in the Hub interface
  • Managers manage the input and output contract
  • The rule auto-documents in standard JSON

Clearly the integration with Oracle Visual Builder Service or a similar platform is targeted. As many of you will remember, our recent survey showed that existing Intelligent Advisor Professionals are definitely not overwhelmingly in favor of web-based rule engines:

The results of our 2020 Rule Design Survey can be viewed here.

Most of us have been around long enough to see how poor a lot of web-based user interfaces are, how often they change and how they rarely achieve what they set out to. In addition, many shared with me the belief that once the web-based UI is upon us, it’s a matter of when rather than if the Intelligent Advisor / Policy Modeling Windows platform will disappear. So it is a great relief to see that the team has really worked hard to get this to a point where it is both useful and easy to use. I would say that for the moment it is not exactly business-user friendly despite the remarks in the help documentation, but overall it is a good effort!

Those provisos aside, let’s look at this Intelligent Advisor New Feature in three broad areas:

  1. Rule Design

Assuming you have Author role, you can go into the Intelligent Advisor Hub and write a rule in the rule block shown. You can also rename the project from the default.

Once you start writing, if this is a new Project, then expect to see red lines and warnings. This is to tell you that your rules do not have any underlying public names or “input” or “output” information that would be consumed by the integration service. So that needs to happen as we will see in a moment. An interesting titbit in the documentation, no doubt opening the door for future enhancements :

“Also, content from an Oracle Policy Modeling rule document can be pasted into the rule editor in a decision service project. Most syntax will be preserved, although some functions are not supported.”

2. Contract Management

To stop the authors from accidentally destroying the details of any integration, and to allow the technical team to connect the rules we have written to a service definition, we need to define the interface contract – which is only modifiable by Manager role users. They can (and must) add Input and Output “public names” to map to the rule attributes, thus building the “contract”.

Note in the example above how the red wavy line has gone, now that I have begun defining my contract and the boolean text is marked as an input called b_agreement. Once the mapping is done, we are ready to test our service. Since this is entirely REST driven, we can use a typical Swagger-style web interface to test the rule right away. That’s what the blue Run button (you can see it in the first image) is for.

3. Intelligent Advisor New Feature – Live Testing

Intelligent Advisor New Feature - Live Test

Note how the “Try it” section lets me immediately test out my rule, based on the contract elements defined as input and output. I can also download a definition and do all the usual things associated with REST calls like get authentication and so on.

4. Version Control

Once my project is committed using the big blue Commit button on the blue background, I have defined version one of my service.

Intelligent Advisor New Feature - Web Contract

Working on the next version, as shown above, repeats the process of defining contract items, testing and committing. And when I commit again, I will create version 2, as you can see below in the corner near the Commit button.

Intelligent Advisor New Feature - Web Authoring

It means that I can access any version using the drop-down, as shown here:

Should you open an earlier version, then you are offered a variety of choices such as Revert to this Version.

Note the possibility to export the project. There is also (obviously) an Import option on the main Project screen. I didn’t dig very hard but even if it is not yet present, given that the format is pure JSON, one would expect this feature to be in the administration REST API soon. Of course if all you want to do is share your work with others, then they can log in to the Hub and have a look / edit the project. The import and export will be useful when delivering to a test environment for example.

And so, the most awaited (for some) Intelligent Advisor New Feature has finally broken cover. Tell us what you think about this in the comments – we’re always eager to hear your views!

Video : Input Extensions for Interviews in Intelligent Advisor

In the second of our ongoing series (this was the first part) , the video at the end of this article tries to give a good overview of what an Input Extension is used for in an Intelligent Advisor Interview. More specifically, it looks at the following topics :

  1. The basic layout of the Input Extension code and how to quickly generate a sample using the Code Generator.
  2. The difference between an Input Extension and a Full Input.
  3. The basic mechanics of the Input Extension, in terms of the code that needs to be always present and the code that can be adjusted to meet your exact requirements.
  4. We look at the Validate and Update event keys and how you might use them with a simple example of each to illustrate the ideas.
  5. We then look at how you can leverage the concepts behind these extensions – starting with a simple HTML Input tag, moving to using algorithms for validation, external libraries for visual content – such as Google Maps – and finally combining all of these elements and leveraging Intelligent Advisor content – such as entity instances or complex data – into your Inputs.

Extensions like these, when used wisely, can propel an Intelligent Advisor Interview to the next level and encourage users to engage more with whatever process you are showing them. Although the default Intelligent Advisor controls are fantastic – they render quickly, they are responsive and the binding with attributes is really easy to understand and manage – it is always a fact that Internet-facing interviews will need to have styling and code extensions either because of corporate insistence or data-management needs.

In the video which is 28 minutes long, as well as looking at how to build them, you can see some simple examples of how to use them for practical and visual effect in Interviews.

video

The video is also available on our Youtube Channel if you prefer to watch it there in full screen. Just click on the image below:

Input Extensions Video
https://youtu.be/Xq5t6aXtvAc : Input Extensions Introduction

Mythbuster : Temporal Reasoning in Intelligent Advisor

Mythbuster : Temporal Reasoning in Intelligent Advisor

This post started life in an elevator, as a conversation with someone who has been working with Intelligent Advisor for about a year now, and who struggled a bit with Entities and Relationships, but who generally speaking was quite comfortable with building rules and calculations. The business had presented a new requirement, and upon seeking advice from a colleague, it became clear that Temporal Reasoning was needed.

The individual was, to put it simply, quite stressed. Temporal reasoning had been presented as some sort of magical, dangerous thing. “You probably won’t need this for much, so let’s just leave it for now” was how it had been mentioned originally. And this mystery had grown over time. It’s complicated!!! It’s weird!!!

So I wanted to spend 20 minutes or so chatting about it. And this is the conversation I had, reproduced in WordPress Post format. I hope it helps others who are perhaps wondering about temporal reasoning or are struggling with the concept.

In Intelligent Advisor, everything is temporal, if you want it to be. Consider the following simple rule:

the benefit amount = the number of children * the rate

So, if you have two children and the rate is 300, then the benefit amount is 600. Check it in the Debugger!

Great. But you have two children today, maybe tomorrow you will have three. And didn’t the rate change a few times over the years?. Both of these changes illustrate the fact that your rule, as it currently stands, works fine for static values – but these values change over time. So what does it take to change your rule into a magic, wonderful temporal rule?

Nothing.

Your rule remains as it is. The input data and the output data change. So let’s do it. Change the input information for the number of children (feel free to change the dates or number of children).

Temporal Reasoning Input Image

In the above example, I’ve added three children (who are now most definitely adults!) according to their dates of birth. The number of children starts at 0, and continues from there. So now our benefit amount looks like this, assuming that the rate does not change :

Temporal Reasoning Output Image

The benefit amount has become (tada!) a temporal attribute. Not really. It’s the attribute value that is now temporal. Your attribute could always handle it, you just didn’t use it before. Now let’s go and change the rate as well. Edit the rate input value in the Debugger:

Temporal Reasoning Final Image

Obviously feel free to change the dates and the rate values. Now your rule is 100% temporal – two sets of input values, and a set of output values. No rule modification required. And that’s the beauty of Intelligent Advisor reasoning – whether you need temporal reasoning or not, it’s right there ready to go.

Replacing Captcha with hCaptcha in Intelligent Advisor

Replacing Captcha with hCaptcha in Intelligent Advisor

I don’t know about you, but I find the built-in Intelligent Advisor captcha control is a bit, well, old-fashioned. Here it is, in all it’s monochrome splendour:

It certainly feels to me as if it has been forgotten in the many User Experience updates and extensions that have been given to us in the last few years. This thing has not changed since the first release, I think. Maybe I’m exaggerating but it is pretty drab as captchas go.

The other thing that disturbs me about it is the lack (at least, the visible, or verifiable lack) of any server-side verification. Modern captchas rely not only on the user selecting the correct images, but also on a server-side check to make sure that it is really OK.

For example, in more modern captcha scenarios you might be shown an image like this one:

When you select the images correctly, that’s the first level of control. But usually some sort of coded string is generated, using a public site key that identifies yourdomain.com, and it is passed back to the server for checking and decoding. Just in case someone tries to programmatically hack the captcha itself, or tries to leverage it on another site.

Google reCaptcha takes it even further, in version 3 there is no image in many cases – the server simply responds to a request from the website, and using all manner of impressive bells and whistles Google simply responds with a number between 0 and 1, where 1 is completely confident that you are a human and 0 means you are a bot or similar.

So how could we implement these captcha in Intelligent Advisor? Well, we certainly could implement a captcha system to replace the current one. Based on the two choices I mentioned above (hCaptcha and Google reCaptcha) the implementation is remarkably similar. Your own decision can be based on the approach (frictionless with Google, where there is no user interaction, or traditional with hCaptcha) or on the constraints of your organization (Google reCaptcha is often mentioned as being less interested in security than other solutions, make of that what you will, hCaptcha is actually not only free but can earn you credits).

Down to the mechanics of a Captcha. In Intelligent Advisor we will need several items – probably something simple for the display of the image – like a Label extension – and a bit of code for the button click when you leave the Screen, so that we can send a server-side request when you try and navigate. More sophisticated versions could use Input extensions if needed. For the purposes of this article, let us assume we will implement the hCaptcha variant. This assumes you have created an account on their website and registered the website where your Intelligent Advisor interviews are hosted (public cloud or private cloud but visible on the internet (otherwise how will people get to your Interviews?).

The label control in this demonstration would be primarily used to load the captcha library and to insert the <div> that will hold the content.

Note that the div has a number of properties that need to be set correctly, most notably the site key (specific to your website) and the class. The Submit button will need to handle the delivery of the captcha code to the server.

The important things here are the sending of the response from the client side – an encoded string held in the data-hcaptcha-response attribute – to the server for verification. If there is no data available, the Next button does nothing, so the bot is stuck. Let’s assume that the captcha is completed and sent to the server – is it some sort of impersonation attempt coming from a different server?

So we push it to a PHP file on our server, which will then send it on to the hcaptcha server for checking. Notice that this is an asynchronous call. In real life therefore, you will need a strategy to handle when this value is returned to Intelligent Advisor – perhaps through an update key somewhere, or by maintaining everything as not visible until the verification has succeeded, or to redirect the user to a dead-end bot-trap.

In this simple version, an attribute is updated to either true or false depending on the server-side validation. In this simplified version, the PHP simply returns either 1 or 0 for success or failure. And that’s what the Submit button above is checking for. If a 1 is supplied, then all is well and the flag is set to true in the interview.

Of course you don’t have to trigger the validation on the Next button at all – you could do it on any suitable update key, and then handle it before making the Next button available. There are many ways to manage it. This is just for demonstration.

Here is a bit of PHP:

Our intermediary file collects the data attribute and sends it to the hcaptcha server. The result (0 or 1) is sent back to the JavaScript extension.

This means that the value of the attribute is updated thanks to a server-side call and the interview can continue (or not).

Here is a demonstration of the basic concept. There are three scenarios – a valid captcha with a good server response, and a valid captcha with a bad server response. The third scenario does not even require any server-side commitment – the bot simply does not respond to the captcha, so there is not client-side data attribute, so nothing is sent and the Next button does nothing.

You can see just how similar the concepts are between hCaptcha and reCaptcha, even though they look very different.

The example hCaptcha project is in the OPA Hub Shop.

Execution Statistics : 20C New Feature in Intelligent Advisor

Whilst some have already upgraded, many are still (at least in their production site) using 20B. I wanted to look at a 20C New Feature in a little more detail in this post. For some of my clients these Execution Statistics features have been very high on their wishlist for a long time. So what are we talking about?

Have you ever needed to identify which parts of the execution process are consuming the most time? Have you longed for some instrumentation? Users of complex platforms like Siebel CRM are familiar with the Application Response Measurement platform and the ability to drill down into domain and subdomain data to find out why something is not performing well.

Intelligent Advisor is not Siebel CRM nor is it trying to be, however this 20C New Feature is the start of more visibility of execution data. So let’s look at what the Execution Statistics functionality introduced in 20C means for rule authors and developers.

Firstly, consider the following : I’ve got a heavy set of rules, and I want to find out what is consuming execution time – is it a particular element – a specific attribute or something else.

There are three things to mention. Firstly, you need a project, and you need some Test Cases. The first pieces of functionality are based around the obvious principle that since test cases are executed on the client PC, and statistics of execution are available in the engine, why not make them available to the rule designer?

Execution Statistics - 20C1

So in the above example this is a project that calculates the journey between two station in the Paris underground network. It’s a pretty heavy set of rules with thousands of interconnected entity instances.

And there are some test cases in a Test Case file.

Execution Statistics - 20C2

We’re going to investigate the three bullet points shown. The first two are based on the Test Cases in your project. If you use the Run button, then the links should appear (assuming you have never done this before). CSV Files are generated. The first file, testPerformance.csv, is generated in the root directory of the project. It is a CSV and once you have cleaned it up, it looks like this:

Execution Statistics - Performance Analysis

So this is a pretty good start for performance analysis – we can see the time is recorded as a very highly precise number. We can see which main components are taking time – in this case the child station amount which is a big loop over thousands of combinations.

The second link is more oriented towards understanding which of the test cases you gave the engine to run are taking longer than others. So clicking the second link provided you with a detailed set of statistics for the test cases. This file is stored in a new folder TestLogs under the root of your project with a name like TestCaseLog_20200827144055.csv. The history of your runs is kept for you since the file is timestamped.

Performance Analysis Test Cases

So in my case I can investigate further by loading the most time-consuming test case into the debugger and looking at it in more detail.

The third button is used in a similar way, but requires external content, specifically a JSON file from one of your REST Batch runs. When you click the Analyse Batch Request button and provide a file (for example, a batch JSON file looks a bit like this in my case (this is just one case, the file probably has 500 cases) :

JSON File Execution Statistics

When the file is selected using the button, after a few seconds (or longer, depending on your project) then a new link appears next to the button (you get to choose the filename and location for this one) :

Access JSON Statistics

Opening this file gives the following output, which is the same performance information, only this time for your JSON files. This is useful if you are using Batch Assess. JSON files like this can also be loaded int the Debugger.

Execution Statistics JSON Output

So you can see that the 20C release has made excellent strides in the direction of execution analysis – rule designers now have something to work with!

Our Survey Results – The Future of Rule Design in Intelligent Advisor

A few weeks ago we began collecting results for our latest survey – the subject of course (I’m sure you have been aware of this – apologies if you have received too much communication about it, but we consider it to be one of the most important subjects on the horizon at the moment) is the future of rule design. If you have not voted yet please do!

Many customers have leveraged Word and Excel as an adoption vector – after all, it is easy to “sell” Intelligent Advisor to people who use Excel every day, or who are used to working with Word. Irrespective of your opinion of Oracle Policy Modeling, and where you think the future of rule design is heading, it is hard to deny that these tools are omnipresent in every organization.

So, as we look to the future and imagine what tools might be used in the future – not basing ourselves on any concrete information, not talking about anything that might be used as a future purchasing decision criteria – just wondering about where things might go. It’s probably safe to say that a web editor is on the horizon – a fully Cloud product would need a fully Cloud editing tool.

But there are other possibilities (some which represent missed opportunities – like OpenOffice) and of course there might be no change – we could all be using Word and Excel in the Cloud. So if you are interested in the perspective of the other people who read this article / this site, here are the preferences that people have expressed so far.

The data can of course evolve as more people take the survey, but it is already fascinating reading. Of course it does not answer all of our questions, and to drill-down into the results will take further surveys and questions. But at least we can begin to see what people expect for the future of rule design.

Intelligent Advisor Video Training : Free Modules

As many of you know, the OPA Hub Website offers many video training modules. For our first offerings, we concentrated on the basics – helping new starters get an overview of the product, without drowning them in too much detail. So most of the modules are sort of 30 minutes long, maximum. We recently added a second set of video training to the list, so we currently have 22 or so Intelligent Advisor Video Training modules.

At the same time, we have decided to release a series of introductory videos about more technical subjects, with the first being the Label Control Extension which was released about a week ago. The next one will be coming soon. These modules will remain free – and probably on YouTube.

In light of the difficulties that a lot of people are facing right now, we have taken the decision to make some of the modules available free of charge – so if you are unable to attend training right now – virtually or physically – then you can at least get started and see a bit of what Intelligent Advisor is all about.

The free Intelligent Advisor Video Training modules are :

Module 1 – The Platform
Module 2 – Before You Start
Module 3 – Projects
Module 4 – Attributes and Rules
Module 5 – Functions
Module 6 – Entities

Customers who purchased these modules will soon be provided with access to other modules to the same value. Hopefully this initiative will enable more people to get into Intelligent Advisor in spite of the challenges that exist at the moment. We will be in touch as soon as the next technical Intelligent Advisor Video Training modules are available.

If you or your colleagues have any suggestions or requests for training modules that would help speed up the adoption of Intelligent Advisor, then please just leave a note in the comments, or alternatively use the Contact Us option in the menu.

Intelligent Advisor Video Training
Book now available worldwide

SIRET / Credit Card Checking in Intelligent Advisor with Luhn

This post was originally going to be called SIRET checking in Intelligent Advisor but the notion of a SIRET number is an acronym famous I think only in France. What we are really talking about is validating anything that uses the Luhn Algorithm (aka Modulus 10 algorithm). There are so many uses, most of them well known and some surprising (customer survey codes at McDonalds, who knew!).

This algorithm is, according to a very well-known site:

From Wikipedia

“used to validate a variety of identification numbers, such as credit card numbers, IMEI numbers, National Provider Identifier numbers in the United States, Canadian Social Insurance Numbers, Israeli ID Numbers, South African ID Numbers, Greek Social Security Numbers (ΑΜΚΑ), and survey codes appearing on McDonald’s, Taco Bell, and Tractor Supply Co. receipts. It is described in U.S. Patent No. 2,950,048, filed on January 6, 1954, and granted on August 23, 1960.

The algorithm is in the public domain and is in wide use today. It is specified in ISO/IEC 7812-1.[1] It is not intended to be a cryptographically secure hash function; it was designed to protect against accidental errors, not malicious attacks. Most credit cards and many government identification numbers use the algorithm as a simple method of distinguishing valid numbers from mistyped or otherwise incorrect numbers.”

So it’s not surprising that Luhn Validation came up sooner rather than later in an Intelligent Advisor project. The implementation is possible in two ways I suppose : firstly, if you are already using RuleScript in the project (which you should not be doing for new projects, but maybe it is an existing one) then it is a really simple task to find a decent implementation of the algorithm in JavaScript and adapt it for your Project. Other algorithms that are more complex can be quite easily implemented that way (sigh, such a pity that RuleScript is no longer part of the future of OPA).

The second way to do it is to use a JavaScript extension for your Input Control and let the Validate key do the work. I suppose there may be a third approach, to try and implement the algorithm in natural language but I doubt it is possible or practical.

Anyway how could it be done. Simple, first get a decent implementation of the Luhn algorithm : for example this one is super fast. Then build out a standard Input Control Extension. Here is a very simple example with some comments below the code:

/*  Generated by the OPA Hub Website 15/09/2020 13:47
Generated Example of Custom Input Extension for Oracle Policy Automation
 I will remember this is for demonstration purposes only. 
*/
OraclePolicyAutomation.AddExtension({
    customInput: function(control, interview) {
        if (control.getProperty("name") == "xSIRET") {
            return {
                mount: function(el) {
                    var div = document.createElement("input");
                    div.id = "xSIRET";
                    div.value = interview.getValue("siret", "record", control.instance);
                    el.appendChild(div);
                },
                update: function(el) {},
                validate: function(el) {
                    if (luhnChk(document.getElementById("xSIRET").value) == true) {
						interview.setInputValue("siret",document.getElementById("xSIRET").value, "record", control.instance);
                        return true;
                    } else {
                        return 'The string fails the Mod 10 Test'
                    }
                },
                unmount: function(el) {
                    if (control.getProperty("name") == "xSIRET") {
                        var xSIRET = document.getElementById("xSIRET");
                        xSIRET.parentNode.removeChild(xSIRET);
                    }
                }
            }
        }
    }
})

var luhnChk = (function (arr) {
    return function (ccNum) {
        var 
            len = ccNum.length,
            bit = 1,
            sum = 0,
            val;

        while (len) {
            val = parseInt(ccNum.charAt(--len), 10);
            sum += (bit ^= 1) ? arr[val] : val;
        }

        return sum && sum % 10 === 0;
    };
}([0, 2, 4, 6, 8, 1, 3, 5, 7, 9]));

As you can probably tell, what matters above is the luhnChk functiion (from the resource linked above) and the validate key. In Input Controls, the Validate needs to either return a boolean (true means the validation has succeeded and the test is passed, false means the validation has failed) or as a simpler alternative, return a string – this is considered to be a failure (false) and the string is used to display the error message. If you choose the pure boolean option then it is up to you to signal to the user that the validation failed.

This version works on instances of an entity, so the entity name and instance are used to retrieve and populate the value of the attribute. So it looks like this when the validation fails:

Luhn Test Example

It is important to note that this example is string based, so if you are planning on testing something different, you will need to strip out spaces, and convert the content to text.

If you are interested the demo 20C Zip File (free of charge) is in the shop, search for Luhn.

Video : Label Extension Overview in Intelligent Advisor

Video : Label Extension Overview in Intelligent Advisor

Here at the OPA Hub Website we always like to think that we are able to listen to our readers. Recently, one of the growing population of developers being asked to implement extensions came to us with a series of questions about a Label Extension.

And it became clear that a video was probably the most efficient way to address these queries. To be honest the OPA Hub Website finds that Video is over-used today in learning. I’ve nearly 30 years as an educator and consultant, I find it frustrating that education is constantly the target of cost-cutting and it means that even really large software providers think they can get away with selling poorly recorded slides with a soundtrack and call this a “learning program”. It’s definitely not a program, it’s an excuse.

Living in Europe and having worked in the States and elsewhere, I know how difficult it is to solve the equation of large distances, different languages and multiple timezones. But I still believe that face to face training is the best answer.

And I feel that although many other benefits exist for video training – immediacy, repeatability and accessibility – sometimes I find that companies push video or recorded training as another way to save money, while still expecting the same level of recall and interest from the students.

In a way, I see it also in the Covid phenomenon – how much video we have been consuming and how many of my colleagues have reached saturation point but are expected to be watching and doing video 7 or 8 hours a day. Of course I get that this is a necessity – but no allowance is made for just how hard it is to watch or deliver. Employers love the productivity it generates.

So this is why, the OPA Hub Website tries to keep the videos, where possible, to a maximum of 45 minutes at a time. Our Online Learning Program is based on that concept.

Anyway, enough mindless chatter : Here is a video introducing the concept of a Label Extension for Interviews, using the Intelligent Advisor Extensions API. The video talks about the basics, and shows lots of examples. We’ve got a few more videos in the pipeline, so watch this space.

video

If you want to watch the video in a new window on Youtube (yes, for once this is on Youtube) then just click the image below:

https://youtu.be/dbCfOWjktJ8

About Intelligent Advisor Certification #4

About Intelligent Advisor Certification #4

Now we move to the final part in this set of posts. For reference, the previous parts are linked here : one, two, three. I appreciate that some people may be approaching the certification exam for the first time, and like all examinations in those circumstances, fear of the unknown is your worst enemy.

I’ve taken lots of certification examinations over the (many) years I’ve been in this business, whether it be Oracle, Siebel, Salesforce or non-IT things like First Aid. And the Intelligent Advisor / Oracle Policy Modeling certification exam is certainly unique in the sense that it has so many different kinds of question, and so many different kinds of audience. I’ve seen Subject Matter Experts turn into Intelligent Advisor wizards, and I’ve seen technical people jump in a prosper with Intelligent Advisor too. It’s part of the unique strength of the product in fact – how accessible it is, and much closer to true mixed teams you can get, merging strengths from the business for conception and testing, and strengths from the IT side for the delivery of the specifications. Part of that is because it uses Word and Excel – and if you have not already taken part in our Future of Rule Authoring Survey please do so (one question!) .

Back to business – trying to remove the fear of the unknown was part of the reason for creating this series of posts (and to a certain extent, this entire blog is about demystifying IA). So here are some more kinds of question that you probably will come up against. Remember that in the exam – if you choose to take the exam in a test center – you will be provided with a whiteboard and a marker pen, so that you can write out ideas, sketch data models and so on. The whiteboard is not part of the exam, and nobody cares about your drawing ability – it is just a helping hand.

The Debugging Questions

I’ve come across these a few times, so I’m adding one here. These questions are testing your knowledge not just of the product (where is the debugger, how does it work and so on) but also your ability to understand Intelligent Advisor vocabulary (intermediate attributes versus base attributes etc.).

Certification Question Example

The above diagram represents a policy model. D and E are linked by a disjunction. E and F by a conjunction. B and C are linked by a disjunction to A. The rule author wishes to debug the behaviour of the attribute B. What should they do

  1. Run the Debugger and enter a value for A,B and C, then right-click B and select Show Decision
  2. Run the Debugger and enter a value for D and E then right-click B and select Show Decision
  3. Run the Debugger and enter a value for D then right-click B and select Investigate
  4. Run the Debugger and enter a value for D then right-click B and select Show Decision

And so on and so on…(answers in the comments please).

The OPA Hub Role Questions

The OPA Hub forms a section of the examination, and whilst I have already mentioned the kind of question you might get that involves the Hub (see the Memory Question) there will of course be questions that specifically target Hub functionality. Here’s a variation on one I’ve seen before.

Bob works on a Project on his laptop. Janet wants to collaborate on the same project. What steps must occur on the Hub for this to happen

  1. Bob must upload his project to the Hub.
  2. Bob must share a Zip copy of the project
  3. Janet must be created as a Hub User with the Author role
  4. Janet must change her password
  5. Bob must approve Janet’s share request
  6. Janet must download the latest version from the Hub
  7. Janel must have access to the Collection
  8. Bob must store the project in a Collection that he has access to.
  9. Janet must email Bob to ask for the project.

You will notice that it is a variation on some of the other questions that rely on remembering all the steps of a given process. I do these things all day every day but I still find it hard to remember exactly every step. Practice makes perfect.

The Service Cloud Question (type A)

Obviously, since Intelligent Advisor has historically been marketed as part of Service Cloud (amongst other dubious decisions), you can expect a few certification exam questions that specifically target Service Cloud knowledge. Here are two that you will come across.

How many objects can the Global object be mapped to in a Service Cloud data mapping

  1. One
  2. Two
  3. More than Two

Answers in the comments please. The trick here is to understand the unique nature of Service Cloud mapping and the types of Interview that can be delivered.

The Service Cloud Question (type B)

The commonest form of certification question that I have seen has been those that focus on the different options available to Service Cloud connections. For example:

Bob wants to create an Interview accessible to customer service agents. He wants to load and update an Incident if one exists already, and create one if it does not. What settings should he choose in the Service Cloud Mapping Settings Dialog?

  1. Select Customer Service Agent
  2. Select Contact Center Agent
  3. Select Load at Start Incident
  4. Select At End of Interview Update Incident
  5. Select At End of Interview Create Incident
  6. Check the Or Create Interview if none is loaded checkbox
  7. Check the loading data is optional checkbox
  8. Embed the Interview in the Incident Workspace
  9. Embed the Interview in the User Workspace

Answers in the comments if you know the answers. More details here.

The Service Cloud Question (type C)

Service Cloud provides Value List integration for a number of built-in lists and menus from Service Cloud. How can a rule designer use a custom Value List in Intelligent Advisor for data mapping?

  1. They cannot.
  2. They can only map in an out. No Value List is created.
  3. They can refresh the data model and use the Value List that will be automatically added
  4. They can only be used with Anonymous interviews.

Answers in the comments if you know.

So that just about wraps it up for our little certification series – if there are any question types that you remember and would like us to add, then just write them in the comments and we will be happy to oblige.

Worldwide
Logo by Southpaw Projects LLC