Home - sammich/PegaStudioPro GitHub Wiki

A mildly curated list of ideas. Will be removed as they are built.

All ideas should be fundamentally possible without significant engineering effort. We aren't trying to rebuild Dev Studio, as that introduces far more regression risk than the component should take on. Ideas should be possible by editing rules closest to the UI layer.

Small ideas

Allow the Dev Studio search result stay open after clicking on a rule, as an optional behaviour
View what the changes are in the rule (indicated by the unsaved indicator, *) you've made. So you can see what you've changed before you save. For those times you can't remember what you did...
Clipboard (and anywhere else): show prominently (either at the top, or bolded, etc.) the IDs of a given object
- Naive implementation: hardcoded to pzInsKey, pyID, etc.
- Better: look up the keys to that class
The 'rule ID' of a new rule form
- When in 'Disable ID auto-update'-mode, change the read-only + 'Edit' popup to be a simple text input
- Add an option to have 'Disable ID auto-update' on by default
- Add a button to manually update the ID from the name
Add a 'Run Data transform' option to the Clipboard next to the 'Execute Activity' menu item
Record history view table filters
The header portions of the explorers (e.g. the tabs in the App explorer and class name input) need to be stickied to the top of their container
Sidebar rule lists (Recents, Branch, App Explorer) should indicate if a particular rule is already open in a tab
Logout button above the operator circicon
A way to see descendant classes for a class, and be able to go to it in App Explorer
Rule form: icon next to class name to one-click open in App Explorer
- Maybe even a little popup/menu to show that class's rules - like a mini-Explorer. Useful if you don't want to keep App Explorer as it is. Even with the new navigation functions, you'll lose your expanded class view state
Test case: show time of last run
Test case: indicator if rule was edited since last run
Test case: show which (if any) test suites this TC belongs to
Test case: see other TCs for the same RUT
Test suite: run summary also allows you to see and open the failed TC(s)
- You can click on the 'status' to open the test case result, but that's too many clicks
- Show status in the test suite screen? Or an overlay
Test suite: one-click to add all TCs from application, and remove deleted/non-existent
A way to open to the property browser landing page with inheritance and property types
Tracer: jump to/filter all messages
Report definition: show SQL (somehow) when RD is run
Rule form: Save button appears muted if the 'dirty' flag isn't set
Add to Data page rule form the 'pass parameter page' indicators like those added for in DTs and Activities
- Perhaps only do the most common source types: DT, Activity, RD, and their mapping DTs as there's just so many...
- Or even try embedding the whole parameter form (need a replacement for the parameter validation on the FA, though)
A portal control widget that can highlight details about the section as you hover over it. Very similar to LiveUI but more easily accessible and more readily available
- Activated by a keyboard shortcut or a key held down
- Hover over any section or control and see details about that element: e.g. source class, property path, control type (basically just metadata already in the data-attributes)
Action in branch landing page to set the owner of a branch (with quick action to set to self). May be useful if a branch is reused but metadata wasn't reset
Add to Dev Studio tracer menu a submenu of sessions to remote trace (save jumping to Admin Studio) (don't forget about privileges)
- is remarkably tricky to find the right rule to call to get the list of requestors on all nodes
A little indicator on an RF for relevant rules to show it's relevant
- Right-click menu to remove, manage relevant records for the class
Add a control/action/something to quickly view the 'code' in an expression field that's wider than the control
- UI on this might be a little tricky. Need a nice way to trigger the full view without it getting in the way, without being too repetitive for users
Add to the branch landing page an editable metadata section - e.g. notes, URLs
When checking in a rule, and you're using work items, present a list of recent work items you can click on to populate the field instead of typing or using the default work item in Dev Studio
- Would need a source for 'recent' work items for the user. Investigate if this exists, otherwise create it as concrete under the PSP class
- Would need to be opt-in as not sure how widespread Agile Studio usage is
Now we have Pulse in a branch, we can generate a Pulse comment of the rules merged. This may be useful if we reuse branches. Often asking myself 'what was merged earlier'.
- Perhaps there's another way we can solve this...a merge branch data class or some description. Better than formatted text in a Pulse message. Could evolve into a proper 'commit history' over the application's history. Also capture a 'commit' history for that merge. This is somewhat obviated by DM - idea needs a bit more development
- Would need to also work for Deployment Manager/Custom Task
Add optional view for the rule explorers (Recents, Favourites, Branch) to not show the label, and replace it with the rule ID. The OOTB display puts the class and rule ID in the same subtitle line which is often cut off. The rule ID is often a more succinct/shorter descriptor
- Needs a bit more thought: names do matter more than IDs in specific situations such as Test cases
- Overall goal is to make the rule display in these lists to be more compact/dense to fit more but not reduce the utility. Label/ID, class, rule type. Label/ID, class are all long text values, which are necessary to show

App Studio

Port over Studio quick switcher
Launch portals dropdown without needing to go into Preview first

Medium ideas

'Check out to branch' menu to be modified to below to remove the unnecessary popup:
- Private edit (existing)
- Separator
- Check out to ''
- Check out to branch... (change to nested menu)
  - Other branches in your app
Report definition: tool/screen to show:
1. which optimised columns aren't listed in the RD (useful for DataTableEditorReports)
2. which optimised columns which are also relevant properties on that class aren't listed
Left sidebar space/explorer to see your checked out rules
- It's easy to forget you have checked out rules because they're only revealed when you take an action
- Check outs should only be temporary, so having visibility of them means you keep good hygiene
- Check outs are also what you're working on, so being able to always refer to a list of them is vital

Big ideas

A helpful hints framework

It's if guardrails had a less annoying cousin. Like the Pega Peer Review's 'best practices', but like guardrails in that it runs against your configuration. It'll also have to be extensible like GRs. It would have a home in the PSP sidebar as a new tab.

Guardrails' informational tier is noisy. This feature would allow suggestions without it being forced on you, especially if they have no impact, can be intentional but can't removed for that rule instance.

They may even built on GRs, but only appear in the sidebar under the suggestions tab. They can be justified, and/or marked to ignore. They should be run on the same cadence as GRs. Suggestions should be entirely ignorable.

Note: look into Parapets implementation.

Examples:

Report definition
- detect if your RD uses filters that could benefit from a table index that doesn't exist, or even be run against ES
Many informational GRs

A 'command palette' popup with a terminal-like interface

Perform actions with just your keyboard...like a command prompt. Conceptually like the Jetbrain 'search everywhere' popup (shift-shift shortcut).

Such as:

any action you would normally perform on the current rule by clicking: e.g. copy, create new
open or create any rule in any class
open a landing page
open data designer for any class
replaces search
literally anything there's a JS API for on the form

What problem does it solve? Needing to constantly switch between typing and mousing just to navigate/use Dev Studio.

Implementation: need to investigate how the UI will work (avoid creating a custom control), it needs to be as fast in loading results as the native search/app explorer, etc. Will need to hook into the JS in Dev Studio to pull a lot of this off.

Better compare for rules and data instances

Rules that badly need proper compare:

Sections (not Views)

Technical notes:

explore how the OOTB compare function works and why it's insufficient for complex blobs such as for Sections.
option: convert the rule to XML, sort...?

Comprehensive review 'view' for rules (or, see next idea)

Rules need a simple 'one view' view that shows everything about the rule without need to click into other tabs, or to reveal popups that have more configurations. This would be very powerful for a) understanding (a.k.a. grokking) the rule quickly, b) reviewing changes to a rule you might already have familiarity with, which is also useful for comparing two rules

For example:

Activity: all loop/when/jump configurations visible, all step configurations open, parameters/local variables visible (like Preview, but complete)
Data transform: all steps expanded, with data transform mappings shown, parameters visible

All rules except those with complex editors (Section, Flow/Data flow, etc.) should be suitable for this. Even for sections/flows, we can possibly do a partial version by do a 'one view' of the config screens for the flow item, or the control, etc.

A 'source' view - a text, read-only simplified view

Each rule to get a text-only view of the rule/configuration.

This makes it easier to read and understand (aka 'grok'). Easier to compare. More information dense. It's as close to a 'source code' version of Pega's rules as possible. It will be read-only as a true source editing mode would require a lot of work.

It's a very 'power user' tool, but ultimately, I think given experienced Pega users are in short supply, reducing the overhead of them reviewing rule config will be a huge jump in their efficiency.

I can imagine a tool such as this can enable the following features:

comparing complex rules with nested configuration in one view
proper diff'ing of rules
reviewing an entire branch in a single view with diffs just like pull requests with text-based source

Side-by-side view

A new landing page/popup that allows us to show two rules side by side?

(Team) Rule Library

A new 'Library' feature that acts as a 'relevant rules' but for a development team. Relevant rules are targeted at specific use citizen use cases, but there's no equivalent for developers/SAs. Lack of namespacing, mean utility classes (@baseclass, Code-Pega-List, Work-, Data-, and Enterprise layer) end up being a dumping ground of rules with little discoverability. The idea is to have a team build up their own library/index of rules for easy referencing, and that utilities have more utility.

But why not use 'Favorites'? Because:

It's a flat list with little organisation and becomes unwieldy very quickly
No description on why it should be used
Can't use your own favourites and 'Access group' favourites side by side - clunky to switch between

How I see this feature:

Behaves like 'Favorites' but enhanced
- Can also think of it as a wiki page but integrated into Dev Studio
Add any rule to Library, with a description, category, tags
- Description can include expression snippets, for example
The Library landing page/popup
- can be used to organise the rules
- List all the rules, organised by category, or rule type
- Click on the rule to open it
Library can also be simple snippets
Accessed by clicking on a new menu in the Dev Studio toolbar
- Opens in a popover, where you can search for a rule or snippet
Can also be permanently opened into a popup window