Orchestration Framework for JD Edwards

Add some maturity to your orchestrations.

Orchestrations are great, right?  Yes!  Everyone is using orchestrations all of the time.  They have the ability of sharing logic and data easily and securely.  It's a critical design ideal that we implement the logic in the end points, not the pipes - and that is exactly what orchestrations allow you to do.

They also form the building blocks of extensibility.  Being proficient in orchestrations allows you to take advantage of all of the additional functionality that is being built into User Defined Objects.  Honestly, if you are not calling orchestrations with form extensions - what are you doing?  If you are not calling orchestrations in workflow's - what are you doing?

We like to demonstrate a very mature approach to JD Edwards integrations.  We have accelerators for Azure, AWS and OIC to help get that JD Edwards data and logic outside the enterprise.

The above shows our Azure centric integration ideals.  Allowing you to plug in any of the power platform securely (yes using JWT) back to JDE.  No crazy password prompts, nice and native solution.  The blue ring is our orchestration framework that sits outside the orchestration functionality.  The orange ring in this design represents our Azure Integration Framework, which is a set of patterns to accelerate using Azure as your chosen middleware.

Fusion5 use orchestrations as the back bone of their mobility and integration solutions, but we found a couple of opportunities that we needed a solution for.

We needed a solution that would address some shortfalls of the standard orchestrations:

• Lack of visibility for logging, inputs and outputs in a central location
• No historical data for previous runs
• Inability to capture inputs and outputs (at certain tools releases)
• Difficult troubleshooting
• No centralized management console
• No enforcing of consistent approaches / development standards
• Native ability for asynchronous function calls

So the amazing team at Fusion5 have created the orchestration framework.  The name says it all, it is a standardization of integration methods and patterns as implemented as orchestrations in JD Edwards.  

We have developed a "plug and play" suite of enhancements to improve your orchestration developments.  Our patterns enforce standards that make logging easy and debugging easier.  We provide you with a one stop shop for controlling your orchestrations, defining your callbacks and overall management and monitoring of anything related to orchestrations.

Our centralized management console allows end users and/or developers to look at the payloads and work out why something has failed or not.  If the orchestration allows for resend, then this can also be triggered for outbound events.  This allows you to have the right people solving integration problems with all of the information that they need at their fingertips.

We ship the code and the samples to you, which show you how to code additional headers that provide unique identification throughout the JDE processes - but also identify the complete lifecycle of transactions through your middleware of choice.

Instead of learning all of this "on the fly", you can lay out mature orchestrations with all of the mandatory header information that you need to manage and monitor your integrations.  You can see from the above that we have mandatory headers which store GUIDs to track correlation and conversation IDs - to always have a complete picture of where an integration got to.

If you'd like to know more, please get in touch.  This is sold as a subscription - so that you can get all of the juicy updates - or as a one off.

Read more here:

https://www.fusion5.com.au/jd-edwards/jde-orchestration-integration-framework/

We also recommend if you want to add a heap of maturity to your orchestrations, then we could also write the first 2 or 3 in anger - making sure that you are using the framework effectively and allow you to solve all of your integration challenges consistently.

I'm going to try and do a series of blogs focused on integration and JD Edwards.  Also showing you how we lay down a bicep based Azure integration framework - preparing you for a proper internet facing middleware solution - where you only pay for what you need.  This allows you to take advantage of the Azure Service Bus, APIM and more to protect JD Edwards - whether you are on premise or in the cloud already.

I'll also talk about our native RTE to Azure Service Bus replication software, so you can capture those important outbound events in the cloud and act of them from there.   This was previously blogged here:  https://shannonscncjdeblog.blogspot.com/2020/05/rte-to-azure-great-escape.html 

Finally I hope to document what we are doing with event filtering, which is a more advanced way of controlling the events that are being fired out of JDE, as they can sometimes be a little overwhelming.

So - watch this space for integration education updates.

JDE and Java licensing

I know, I know - not enough blogging.

This might be a cracker for you!

Here is one that might be a little interesting.  What is big red doing with Java licensing and how this may affect you and your JDE.

Java SE Universal Subscription is what we are dealing with, an announcement earlier this year.  So in 2023 in Jan it was announced that if you are using java, then you need to pay for all employees in your company.  Not just the ones that are using Java - yay.

What licensing is currently offering the following licences:

See the current price list here: Oracle Java SE Universal Subscription Price List

There has been a significant change, if you have needed to download java from oracle, then you probably should be paying for it.  

The above has been stolen from a much better article -  https://redresscompliance.com/decoding-oracle-java-licensing-java-licensing-changes-2023/

Let's clarify exactly what Java SE is and why you need it...  Java SE is the product name for all of the below...  This diagram shows you the relationship between jdk, jre and jvm.

Java SE contains both the JRE (Java Runtime envrionment) and JDK (Java Development Kit).  In general a JDK contains a JRE.

So, if you have any of the above items on your machine, then there is a chance that you need to licence them.  If your company is writing code that ends with .java - this means there is a good chance that you might need a licence - but there are some exceptions...  

Remember, some bases to compile and run a java program - you will need a java environment, which includes an JDK.  javac is part of the jdk.

So the above uses the jdk to create a class file and the JRE to run the program.  And, I need a licence...  Or do I?

Take a look what my cheeky mac says:

shannonmoir@f5au367 ~ % which java

/usr/bin/java

shannonmoir@f5au367 ~ % java -version 

The operation couldn’t be completed. Unable to locate a Java Runtime.

Please visit http://www.java.com for information on installing Java.

So it's certainly not shipped by default in a new OS.  I need to google java download and see

This helps too - as it has the relevant links

Important Oracle Java License Information

The Oracle Java License changed for releases starting April 16, 2019.

The Oracle Technology Network License Agreement for Oracle Java SE is substantially different from prior Oracle Java licenses. This license permits certain uses, such as personal use and development use, at no cost -- but other uses authorized under prior Oracle Java licenses may no longer be available. Please review the terms carefully before downloading and using this product. An FAQ is available here.

Commercial license and support is available with a low cost Java SE Subscription.

So it seems that me as a developer is all good, but if I ship my magnificent code listed above to a customer...  They need java to run it...  So - they need to pay up!  The classic user pays.  

Back to JDE:

Let's think about where we use Java for JDE and then determine if Java SE license is required.

So...  

• weblogic uses Java
• a local web instance uses Java - which is weblogic
• BIP uses java on enterprise servers
• Server Manager (agents and console) use java
• kernels (metadata) use java

What version of Java do I need for JDE?  Everything at the moment point back to version 8.

Server version	JDK Version
Oracle WebLogic Server 12c (12.2.1.3)	Oracle JDK 1.8.0_131+ Refer to the Certify system for the exact versions
Oracle WebLogic Server 12c (12.2.1.4)	Oracle JDK 1.8.0_211+ Refer to the Certify system for the exact versions.
Oracle Weblogic Server 14c (14.1.1.0.0)	Oracle JDK 1.8.0_251+ Refer to the Certify system for the exact versions.

We are limited to version 8 at this stage, which has a supported roadmap until 2030...  as seen here: https://www.oracle.com/au/java/technologies/downloads/#java21

What you will also notice is that the java release roadmap is very confusing.  From a JDE perspective, we follow MTR's and that seems to be limited to version 8.  It's been going crazy over the last year, kinda fitting in with the oracle release numbers, 21 at the moment.

Above shows a little hint about Java SE available to run with other licensed oracle products...

It's actually easy to see what is using java, just go to your task manager in your operating system of choice.  You'll see java running and therefore you are using licences. 

As the screen shot above indicates, about using Java with oracle products os that there is a special way of inheriting your license.  I'm guessing that this applies to JDE and OTF (Oracle technology foundation)...  Let's look further. 

The table above says that Java 8 can only be licensed with:

My Oracle Support (Oracle Customers Only) and Oracle Technology Network License Agreement for Java SE for Personal, Development and other Users only.

MOS and OTN.  Well, we are MOS for JDE maintenance.

My.Oracle.Support Note 1557737.1 - Support Entitlement for Java SE When Used As Part of Another Oracle Product

Looks like we are nearly there... Wow, this is far more complex than I originally thought.  

I'm probably not allowed to copy everything verbatim, but the essence of the MOS support note 1557737.1 above states:

Oracle customers of Oracle products that use the Oracle JRE or Oracle JDK are entitled, without the need to separately purchase Oracle Java SE Subscriptions, to the following:

• Download and use Oracle Java SE updates, patches, and tools for use with the licensed Oracle product. Customers are only entitled to download such Java SE versions as are required by their Oracle product.
• Install and use such Java SE updates, patches, and tools to develop or deploy an Oracle product.
• Customers can file service requests for Java issues against an Oracle product, but not directly against Java SE.

In most cases, this means that Oracle customers are expected to download and install Oracle Java SE updates and patches only on those servers licensed to use an Oracle product and to configure the downloaded Java SE version to be used only with the Oracle product.

Some Oracle products are licensed as server products but also contain client applications or client-side libraries. For such Oracle products, Java SE updates and patches can be installed on the client side and either used to run only client applications provided by Oracle or used to run custom client applications built using client libraries provided as part of the Oracle product and accessed through a proprietary, product-specific protocol.

Examples:

• Customer is using WebLogic Server. Customer is entitled to download and use Java SE updates and patches to run WebLogic Server. This example is applicable for any server-side Oracle product based on Java and includes most Oracle middleware and applications products.
• Customer has built a custom client application that uses HTTP to talk to WebLogic Server. The customer is NOT entitled to download and install Java SE updates and patches on the client, since the client application is not using a product-specific protocol.
• Customer has built a client application that uses JDBC drivers to connect to a licensed instance of an Oracle database.  The customer is NOT entitled to download and install Java SE updates and patches on the client, because JDBC drivers do not use a product-specific protocol.

If the customer’s entitlement to the supported Oracle product ends, the customer’s entitlement to any Java SE product downloaded under this entitlement also is ended.

That last paragraph is a doozy, I read that to mean - if you are not paying maintenance then you cannot use Java SE anymore without a separate license.  Nice.

Summary:

My summary is that if you are paying maintenance to oracle for JDE, you can use Java 8 for your JDE products and also the oracle technology foundation products that have been included in your bundle and use oracle.  BUT - if your are writing code in java and connecting to these databases / services - then you might need a license.

Infocus 2023

Lucky me is going to be in Denver for Infocus 2023.

Glenn and I are going to present on generative AI and ERP insights, look out for us on the Thursday afternoon.

https://questoraclecommunity.org/events/conferences/infocus/

Look forward to seeing all of the community gather for this JD Edwards event.

Understanding Automation & AI use cases in JD Edwards

Presented by: Shannon Moir, Fusion5

Get beyond the hype and into real world scenarios on how you can find out where you can apply automation or AI to get the mos

t benefit for your business and end users. Fusion5 will show you how you can see exactly what your users are doing in JD Edwards via their ERP Insights tool. This unequivocal analysis of user patterns allows a business to hone in on their JDE hotspots and make the user experience better. We show you some of the cool ChatGPT inspired innovation that we have been implementing down under - we’re told the same code will work in the northern hemisphere too. If time allows, we’ll tell tales about throwing another shrimp on the “barbee” and also riding kangaroos to work. 

JD Edwards

2iC part 2 - JD Edwards AI assistant via ChatGPT and LangChain and more

I've had my team working on adding value to JD Edwards using ChatGPT, as blogged about previously.  My notes last time showed some basic interactions with ChatGPT - allowing it to create attachments to JD Edwards transactions based upon dynamic queries that are being sent to the generative AI platform.  This was good, but we wanted it to be better.

We've been working out how we can use our own data to help Generative AI benefit us.  The smarter people that I work with have been starting to dabble in LangChain.

Chain is critical in the definition of this framework - Chains allow us to combine multiple components together to create a single, coherent application. For example, we can create a chain that takes user input, formats it with a PromptTemplate, and then passes the formatted response to an LLM. We can build more complex chains by combining multiple chains together, or by combining chains with other components.

LangChain is a framework for developing applications powered by language models. It enables applications that are:

Data-aware: connect a language model to other sources of data

Agentic: allow a language model to interact with its environment

The main value props of LangChain are:

Components: abstractions for working with language models, along with a collection of implementations for each abstraction. Components are modular and easy-to-use, whether you are using the rest of the LangChain framework or not

Off-the-shelf chains: a structured assembly of components for accomplishing specific higher-level tasks

Off-the-shelf chains make it easy to get started. For more complex applications and nuanced use-cases, components make it easy to customize existing chains or build new ones.

It makes sense to use collaboration when trying to get advantage from AI and more specifically generative AI.

We did look at using either fine tuning vs embedding with native chatGPT, but this seemed to not provide us exactly what we needed.

What we decided to do is to use LangChain to assist us understand more about JDE data.  JDE data comes in many forms, and lucky for us - LangChain is able to use numerous consistent document types as input.  Such as SQL, CSV and PDF.

This means that we can produce a chain like the below - by creating a vectorStore of user specific JDE data which will allow an end user to securely query the data that they have access to, using or chaining the technologies or models of their choice.

So I imagine a time that I can basically use row & column security from JDE and being to load a users Vectorstore with all data that they have access to.  Then allow this data to augment is answer complex and adhoc queries that a user might have.  Remember that these queries could be structured via APIs or ad hoc via humans.

What we have done with WSJ and some pretty cool programming and UDOs:

You can see from the above that we are fairly basically programming some User Defined Objects to call orchestrations from WSJ.  What these do essentially mimic what could be done automatically or programmatically.   These buttons give the end user the ability to create their own VectorStore using LangChain APIs which then allows an end user to perform adhoc generative AI queries against the files. 

For example, I can select one of the PDF files and choose "load cache" button.  This uploads the PDF file to my personal location for additional queries.  This does this action securely.  My file is not training the ChatGPT model.

I can then query the contents (fairly basically once again - hey be nice... I'm doing all the JDE work here).

I have asked a simple question, but I could have made it quite complex - you can ask it anything.  this has been basically programmed to prompt for input before calling the orchestration to LangChain.

Okay, so wait...  Back the truck up... I've been able to engage LangChain and ChatGPT using orchestration studio to ask ad-hoc questions about either my PDF or CSV output from JDE?  This is amazing.  

I can therefore schedule these queries, or I can keep the [basic] interface adhoc.

Let's try a little more now.

This is getting cool.  I have a 2017 page report loaded and can ask any queries about this file.  For example I asked about the unique customers in the invoice print run.

I then asked is there consistent pricing amongst all of the invoices?

Oh wait, the final result is not great - given the above.  But good to know

I am super impressed that I can used UDOs and LangChain to get so much more value out of JD Edwards reports.  This is totally the NEXT LEVEL when is comes to extracting value from data.  You can literally ask for insights from your reports and they can be given to you.

This is the best result so far... This shows why you need to start asking questions and knowing about AI...

I asked for a 200 word summary of the report and asked for any anomalies that have been detected:

The report contains multiple invoices from the Worldwide Company to various customers. Each invoice includes details such as the invoice date, customer information, order number, item description, quantity, price, extended price, and tax. The items sold are primarily College Rule Paper.

The invoices are addressed to different customers, including Capital System and ABC Big Box Store, and are shipped to various locations. The invoice dates range from 2016 to 2023, and the prices for the College Rule Paper vary slightly across the invoices.

One anomaly in the data is the reprinting of invoices, which could indicate a correction or duplication. Another anomaly is the presence of unprocessed sales order lines mentioned at the end of the report. This could suggest incomplete transactions or issues in the order processing system.

The report also includes freight charges under the 'Invoice/Type' section, which are not consistently present in all invoices. This inconsistency could be due to different shipping methods or terms agreed with different customers.

Overall, the report provides a comprehensive view of the sales transactions of the Worldwide Company, but the anomalies suggest potential issues that may need further investigation.

You know you want this for your JDE, all you need to do is ask!

Double helix approach to JDE continuous improvement

We will eventually describe how each of the helix's above represent a continuous project, either reducing technical debt (or making updates easier) and the other enhancing how we use JD Edwards.

Why improve continuously?

I think it's well known that focus on iterative improvement (if you can) will reveal better results with small costs and impact of change.  We you are improving continuously, you can train people continuously (a smaller group), you can measure and quantify the improvements that you are seeing and you get better and better at implementing improvements.

When we talk of improvements, this is simply making end users jobs easier and more efficient.  We do this in 100's of different ways and the JDE toolset allows us to enable much of this efficiency with UDO's or their very flexible development environment - what I'd call a more traditional SDLC - Software Development Life Cycle.  At present, we see that man efficiencies are coming from automation, and the adoption of it's bigger brother - enterprise automation.   In it's essence, the foundation of automation is integration.  

Continuous improvement is also baked into the platform.  Though JDE is not SaaS, the ideals of customer paced "SaaS" is a JD Edwards release ideal.  If you have efficiencies in how you can apply the updates, then you can have all of the benefits of SaaS without the sting in the tail.

What's the SaaS sting?

The sting in the tail of SaaS is commitment…  You are committed, there are no more platform decisions…  If you adapt the solution for you, there is cost to maintain your customisations over an every changing platform - of which you have NO say in cadence of change or what is going to change.   Some might say that SaaS is great for standard businesses with standard approaches - but buyer beware - everything is subject to change.  The other factor of SaaS is pricing, when you are committed there are not many button and levers for reducing your pricing.  The perpetual license allowed you some flex in costs.  If your business was struggling you could choose not to pay maintenance and sweat your IT investments - ahhh - NO LONGER on SaaS.  You cannot sweat anything.

I quite often think that SaaS feels nice and new and shiny…  I need to be honest with you, I do not like looking after servers and internet connections - it's not good for my blood pressure.  But, my ideal place is JD Edwards in public cloud…  I can update continuously when I want.  I don't look after tin.  I'm secure and I can implement the most amazing cloud services to create native data lakes (eg. Our fast start JDE -> S3 data lake accelerator) - with minimal investments.

SaaS is not going away, because it’s great for large software vendors - talk about lock in… Easy to buy, easy to login…  hard to leave.

Why in integration so important to everything?

Integration is no longer an afterthought, it's a first class citizen in design ideals.  No new software platform is released without a complete integration solution.  These are generally API based when needed, perhaps push / pull when required and also batch.  

This is an important point, new SaaS subscriptions or any new software needs integration as a first class tenant.  You need to be able to report over the data and reconcile the data - you also need to make it part of your master data strategy and understand it's place in a transaction timeline.  You probably want to ensure that it can connect to your enterprise reporting suite natively too.

Guess what, JDE has a very mature approach to all these integration patterns.  We have RTE (Real Time Events) for pushing data.  We have orchestration's for implementing the VERY important "dumb pipes / smart end points" for integrations - APIs etc.  We have type 3 & 4 JDBC drivers and rest based (loose) connectivity to the tables.  Finally the good ol' UBE for batch.  Nice.  We also complement this with antiquated BSSV [please stop] and EDI.  Pretty neat.  Choose the right tool for the right job.

From <https://docs.oracle.com/en/applications/jd-edwards/interoperability/9.2.x/eotin/jd-edwards-enterpriseone-interoperability.html#u30175980> 

Integration is crucial because we are seeing the rise of the "best of breed" digital adoption.  Point solutions are deployed in seconds, finely tuned for their purpose and can integrate natively.  I'm seeing more of my clients choose point solutions, all cloud based, and making sure that when implemented they respect master data and security ideals.  Oh yes - this is a huge reason for a strategic approach to integration.  Remember that your enterprise security posture is generally only as strong as the weakest link.

Integration enables automation.  Integration reduces human error.  Integration speeds up business.  Simple.

Summary of above

Of course I'm a JDE guy, so you might consider the above with a grain of salt, but what I'm getting to is JDE is an amazing platform with a written guaranteed roadmap until 2034 and rolling year on year.  It's ready for all integration patterns, you can host it on any hyperscaler  and you can do process improvement at your pace. All good…

Now, finally, what do I mean by Double Helix approach to continuous improvement?

The two stands of the helix represent 2 concurrent ideals / projects for JDE.  Imagine that the blue line is modification reduction, or technical debt reduction and the second (red) is continuous improvement.

This is a duplicitous parallel stream that JD Edwards customers should dedicate resource to.  At times you may only focus on technical debt reduction and other times you might focus on process improvement, but they should work hand in hand.  For those of you who do not have a blue strand (you are without modification), then you can run a single helix.

Time is the X axis and effort is the Y axis, so you see that you can continually put effort into either stream, knowing that BOTH are contributing to lowering the TCO for JDE and also improving efficiencies in your enterprise.

Process Improvement

The types of projects that make up continuous improvement are:

• User productivity improvement

○ UI / UDO adoption

§ E1 Pages

§ UX One

§ Search Groups

§ Cafe1

§ Manage Queries

§ Oneview reporting

§ Form personalisation

§ Notifications

§ Form extensionsJDE maturity model

§ WatchLists

§ Workflow modeler

§ Form Extensions

§ Logic Extensions

○ Enterprise automation

○ Speed and efficiency

○ Maturity model assessments

○ Alert -> Analyse -> Act

○ ERP Insights & JDE usage analysis

○ Implementing AI / ML

• Integration

○ IoT

○ Process

○ Data

Process improvement is important, but more importantly is quantification of benefits.  You cannot quantify the improvements in productivity without a baseline, which is why we recommend our customers use ERP Insights to understand their JDE usage and use this data to baseline, measure and therefore quantify the productivity improvements in JDE.  All process improvement should make users jobs easier, reduce errors and processing time and allow users to do value add tasks.

The Alert -> Analyze ->Act paradigm helps us determine where the value add can occur.  We want to implement as much alerting as possible…  This means that the ERP is telling us about problems.  Instead of checking the bottom of 1000 page integrity every month, get notifications of exceptions…  The nice thing about simple alerts is that with enterprise automation we can covert these into workflows / integrations for self-healing…  Acting on an alert can be an easy automation…  Instead of the notification we just mentioned, we might add a journal automatically with an orchestration or an adjustment to balance our accounts due to rounding errors - all with thresholds and reporting.

The nice thing about doing the above is that it could be a citizen developer doing all of this.  There is not package build or deploy - all of that automation above is done by an power user.  Your user base can spend more time of the analyse part of their jobs, which is proactive - value add…  Doing things that algorithms and models cannot do. 

My recommendation is to use a service like the Fusion5 maturity model, which will put some laser focus on your usage of JD Edwards.  We probably want to you have ERP Insights installed first.  We'll look at your system usage under the microscope for that module and make recommendations for process improvement and enhance your use of Alert -> Analyse -> Act.  We'll find the best places for enterprise automation and recommend the lightest touch to implement the chance.  All of which is going to improve your usage of the module, improve your usage of JDE enhancements -> which assists you in all other modules.

Technical Debt Reduction

The types of projects that assist with technical debt reduction are:

• Removal of modifications

• Adoption of Mobile

• License analysis

• Automated testing

• Archive Data

I'll put a slightly different slant on this, I want you to read technical debt reduction as "how can I make upgrades faster"?  Everyone understands that the variable component of an upgrade is retrofit - nearly everything else is predictable.  So, we need to remove or reduce the impact of retrofit, which is done with technical debt reduction.

It's been said over and over that strategic modifications can stay - no problems.  Bolt on modules are pretty easy to upgrade too, the overhead is knowledge & testing - not too much technical retrofit of modifications.  Changes to core objects though, they need to be kept to a minimum.   

Here is a story that I have been told 50 times…  Let's to out upgrade "as is", we need to do it quickly and go live…  Okay, I say - we carry forward all of the technical debt at this point in time.  We hardly do analysis on the modification, whether it has been superseded by existing functionality.  Is there a smarter way of doing the code (with UDO) or is there a smarter way of implementing the process with deep functional knowledge?   It's too hard with the pressure of the upgrade project looming…  There is not enough time and it’s hard to estimate.

What if you did all of this work up front?  Whether it was module by module or object by object - have a continuous technical debt reduction project running.  Removing modifications, changing processing options… making upgrades (updates) easier…  Then, when you get to your update - you'll be surprised by the efficiency.  Remember that UDOs are not your only options for modifications.  You need to think about the improvements with orchestration and the ability to use modern mobile platforms to deploy your JDE functionality.  JD Edwards can be overwhelming for users that are not logging in all of the time.  Replacing this with a simple mobile app (insert favourite mobile app deployment software here) using SSO via JWT to ensure that your data and logic is safe.  The security model being enforced by JDE and therefore orchestration studio ensures that you are implementing least privilege principles over your valuable ERP data.  You also know that is just going to work after you take release 24 - because of your loose coupling implemented as part of your JDE SDLC.

You know that oracle tests their software extremely well before it gets shipped, so you know that the standard functionality is going to be working.  You need to test the standard code as it applies to your business.  You need to ensure that your loosely coupled UDOs continue to work and you can start being smug about keeping JDE up to date on a yearly basis - efficiently and predictably.

You might then start looking at automated regression testing and data archival to speed up some of your other painful go-live activities.

The tale of 4 large JDE customers performance, geography & functional footprint

 

Here is a unique view of 4 different JD Edwards customers and what we know about them, they will remain anonymous of course.

We are able to help our customers understand their JDE usage from many different perspectives:

• geographical, this is not just user counts, but looking into the modules and performance around the globe.  This is perfect when looking for process improvements and measuring global initiatives that you put in place.   Reporting like this helps you with internal billing too.
• license right size - you know who is using JDE, you know the modules and you know the locations and time being spent.  This allows you to ensure that you are always compliant.  Perhaps taking away access for users that use JDE 1 time a month - which could save you 1000s in compliance and license. 
• Module usage in terms of location, number of users and programs being used...  Which can turn into analysis of performance and engagement.

Looking at the above we have 1.1 million JDE page views in a month, we can see that this is generated by 1106 users in the same period.  A large functional footprint in JDE (409 unique application being loaded) is being used over many modules and is a global footprint too.    We can see that JDE usage is up a massive 10% as compared with the previous month, the customer must be busy.  This is an amazing executive snapshot to understand exactly what JDE is doing for the customer and comparing that with the previous month.

This is also really handy, when you know more information.  This is a cloud hosted client, so we are able to give complete costings for the platform on a user basis.

We are looking at about 60% usage of the previous sample data, with some limited international usage.  We can see that the average page load time is 45% slower for this customer than the one above and twice as slow as the example below - so there might be some opportunities to make the user experience a little quicker.  Note that this observation is only possible through the analysis of multiple data sets.  

When looking for process improvement, let's focus on the highly used apps and talk to the users that use those apps the most.  This is a simple task with all of the information above.

Okay, we are getting bigger, more complex and a lot faster!  But wait, I do not want to spoil the surprise.  We have more apps in use, more locations around the world and EVERY one of the 1.9 million pages in the last month being loaded in less than .8 of a second.  Usage is up a massive 22% of the previous month.  I can determine where this has come from, in terms of module and location - which is awesome for the business to see.  They can justify the spend and improvements in the platform based upon actual data.

Finally we have the big bopper!  6.4 million page loads in a month, 2400 users and a spread of 636 apps.  All being served up in .6 of a second on average.  I hope those end users know how lucky they are.

Also up 30% on the previous month!  WOW.

I also know the backend architecture of this site, so that is handy to justify the performance data.

As you can see a dashboard on it's own might not provide too much information to a business, but anonymous comparisons and also industry standards can allow us all to strive to be better.

Fusion5 are almost complete in implementing our very popular ERP Insights platform using GA4 and GTM.  This is going to provide BETTER insights to our customers and allow us to tailor the insights for more ERP platforms.  Watch this space.

ChatGPT and JDE - introducing 2iC

I've been in awe of the ChatGPT phenomenon.  It's not my first exposure to AI, I've been following along and implementing basic solutions in this area.  I've done some basic python programming involving training and implementation of iterative learning.  Conceptually I understand what is going on, but I find that ChatGPT has made this much more relevant and almost a commodity now.  Everyone has the ability to "chat" and start to understand the power of AI - even if in this basic use case of large language exchange.

I think that the really cool thing about this is that we are all learning how to ask better questions.  How we can use AI to assist us in our daily activities.  I've used it to summarise and generate data.  Awesome use cases there.  I've used it for programming, it's helped me with python and groovy.   I've asked it about the weather: using https://chat.openai.com/ of course.

If you have a good think about the response above, I think it explains a lot about what ChatGPT can do.  It talks about it's training is only until Sept 21 - so it's not a prediction method for random events (like weather), sure it can tell you the average temperature for the month of May in Melbourne Australia - but it cannot tell you accurately what tomorrows weather is going to be - because it needs super current context.

Yes, there are some advanced toggles that will include "google results" with the model for these types of queries - but this information is just not part of a model.  

Let's get JDE specific, so I'll try some other queries:

This is a pretty decent summary of the actions to perform.  Incredible that the model has crawled over the JDE manuals to be able to create a response like this.  Of course, we start to think that this is a good way of integrating help into JD Edwards - because all of the content it there.  What if I want a little more, include program names:

Fairly generic again, some additional and decent information.

Right - we are starting to get a feel for what we might be able to do in JD Edwards.  Let's get started.

We start nice a simple, a composite page that allows a user to ask ChatGPT questions.  This is a good idea to get your users starting the conversation with ChatGPT.  As we all know, we need to get better at finding the things that AI can do for us as individuals.  Help us with the mundane.  Probably good to note that you cannot just include https://openai.com - that will not work with all sorts of security problems.

We take this to the next level and create a composite page with the same chat interface.

Parametrized URL:

In this example I've preloaded the chat with context sensitive information from the native JD Edwards screen.  I'm passing in the item and the description and a few other details to get ChatGPT to create context sensitive and relevant information - generate a purchase agreement.

You can see that it's fairly easy to create the query with context from the webpage and have ChatGPT do all of the hard work.  Thanks - this is a really easy way of getting things done. 

Purchase Agreement

This Purchase Agreement (the “Agreement”) is made and entered into as of this ____ day of ___________, 20___ (the “Effective Date”), by and between ___________________ (the “Buyer”) and ___________________ (the “Seller”).

WHEREAS, the Buyer desires to purchase, and the Seller desires to sell, the following item (the “Item”):

Mountain Bike, Red, Item Number 210

NOW, THEREFORE, in consideration of the mutual promises and covenants set forth herein, the parties agree as follows:

1. Purchase. The Buyer agrees to purchase the Item from the Seller for the purchase price of ___________ (the “Purchase Price”). The Purchase Price shall be paid in full on or before the Effective Date.

2. Delivery. The Seller agrees to deliver the Item to the Buyer on or before the Effective Date. The Seller shall be responsible for all costs associated with the delivery of the Item, including any applicable taxes.

3. Specifications. The Item shall have the following estimated weight and volume: ___________.

4. Warranty. The Seller warrants that the Item shall be free from defects in material and workmanship for a period of ___________ from the date of delivery.

5. Limitation of Liability. The Seller shall not be liable for any damages, losses, or liabilities arising out of the Item’s use, other than those expressly provided for in this Agreement.

6. Governing Law. This Agreement shall be governed by and construed in accordance with the laws of the ___________.

7. Severability. If any provision of this Agreement is held to be invalid or unenforceable, such provision shall be struck and the remaining provisions shall be enforced.

8. Entire Agreement. This Agreement constitutes the entire agreement between the parties and supersedes all prior and contemporaneous agreements, representations, and understandings between the parties.

9. Modification. This Agreement may not be modified or amended except in a writing signed by both parties.

10. Waiver. No waiver of any provision of this Agreement shall be deemed or shall constitute a waiver of any other provision, whether or not similar, nor shall any waiver constitute a continuing waiver. No waiver shall be binding unless executed in writing by the party making the waiver.

IN WITNESS WHEREOF, the parties have executed this Agreement as of the date first set forth above.

BUYER: ___________________

SELLER: ___________________

Now, let's start to get more saucy!

I've created another layout above and added some buttons with form extensions.  Note that EVERYTHING you see here has been done without a package build or deploy.  We are only able to do all these enhancements to standard JDE due to the enhancements in the tooling. 

I created 3 buttons and associated orchestrations to the buttons, let me summarise what each of them can do.

create Packing instructions:

This is a cool little punch out to ChatGPT with the details of the item.  We ask chatGPT for weights and measures information for the item and then ask it to create some packing instructions.  We then attach this content back as a media object.  Pretty nice hey?  The cool thing is that the model often has accurate dimensions and of course it does help when you have accurate descriptions.

You can see from above that I have cached up the use of 3 different orchestrations on this form, for the 3 buttons of course!

We may have the most simple orchestration in the world.  I've created a connector and connection and then used this to call the chatGPT API's natively.  I did this by fighting the security layer a little bit and using postman to get it all working in the "lab".  I then created the MO functions, which now are very easy to use...  So - two steps and I'm interacting with Chat GPT.

Remember I could use chatGPT to do quality work on the attachments text.  I could use it to consistently fix the cAsE of my data (how good would that be?).  I simply head to https://api.openai.com/v1/chat/completions

and form my query, very simple./ go here for more information: https://platform.openai.com/docs/api-reference

Once again, with a small amount of work and clicks I can put very specific queries to ChatGPT and have the responses natively in JDE.

Here is a sample call:

Metric Cubic Volume: 
- iPhone 13 Pro Max Dimension: 160.8 mm x 78.1 mm x 7.65 mm 
- Volume = 160.8 x 78.1 x 7.65 = 93,346.908 cubic millimeters 
- Metric Cubic Volume = 93.35 cubic centimeters 

Average Weight: 
- iPhone 13 Pro Max Weight: 238 grams 

Packing Instructions: 
1. Secure the iPhone 13 Pro Max in its original packaging. 
2. Place it in a sturdy cardboard box that is slightly larger than the phone's packaging. 
3. Fill any empty spaces inside the box with bubble wrap or packing peanuts to prevent the phone from shifting. 
4. Seal the box with high-quality packing tape. 
5. Attach the shipping label to the box. 
6. Deliver to the courier service for shipping. 

Remember to handle the phone with care and make sure it is properly secured to prevent any damage during transit.

It's really quite impressive...  But - to continue our learning, here is the output from a VERY similar call:

Unfortunately, as an AI language model, I do not have access to the physical dimensions or weight of unreleased products such as the Samsung Galaxy S22 Ultra at this time. It is recommended to wait until official specifications are released by Samsung before attempting to determine the metric cubic volume or average weight, and appropriate packing instructions for this item.

Once again - shows us that the phone was probably released after the training date.

Button 2 - create image

This shows another strength of ChatGPT generating or finding images.  You can easily ask it to attach a photo of the item, based upon the description that you give it.

Note that this is a similar orchestration to last time.  We needed an additional URL launcher - as JDE cannot store URL's greater than 256 chars, which was a little annoying.  We create a copy of the object in Azure Blob Storage and serve it up through there.

The final button - attach anything

This is all about creative thinking.  IF you have an idea about the current transaction, want to write some notes... Then you can use this button (or a button like it), that has a query prompt.

When you  think if a good attachment to the current transaction in JDE, but cannot come up with all fo the words needed - then this is for you. 

What ever you type, gets attached as a media object.  Very nice.

The future -

patent pending, our JDE copilot (named 2iC) is going to be enhanced to allow you to interact with your JDE data and provide you with insights that you've not been able to generate before.  The interactions with 2iC will be grounded with your ERP data [role specific], augmented with your JDE usage information [from ERP Insights] and further enhanced with your training materials...  So interacting with 2iC will be your AI powered and organisation grounded insights machine.  

At Fusion5 we are working on developing 2iC in this fast paced environment.  Making sure that the grounding and associated security models can be respected so that AI's responses are secure and people can only receive insights from that that is available to them. We are looking to get access to the GPT3 APIs to further enhance the responses and size of payloads available to us.  

We all need to starting thinking about this quantum leap and bringing our users and communities along for the ride - injecting AI into our daily lives, which will hopefully enhance and improve some of the more mundane activities that we do.