Load() and with() function difference

load() = load the locally declared variables one-time when the task is issued. To update a load variable, a save event must save into the local variable.

with() = load the locally declared variables each time there is a change in the form (such as field input).

"what if I use a rule which is declared inside load() function and again use it without load() function in a form , what will be the difference ? " = if the rule is setting a local variable then that'll happen once. Using the same rule in the form to update the same local variable will update that variable. This is important for minimizing form operations (reduced load, increased performance) and is used often as a design paradigm.

Load() function= a local variable's variable is only calculated the first time the expression is evaluated

With() function= a local variable's value is re-calculated when the expression is reevaluated 

Please see these links: https://docs.appian.com/suite/help/17.4/fnc_evaluation_load.html https://docs.appian.com/suite/help/17.4/fnc_evaluation_with.html

Hi,

variables declared inside load function - initiates once and value will be cached throughout the SAIL interface

variables declared inside with function - can be initiated first and reevaluates each time based on the dynamic logic(s) in the SAIL interface

Thanks!

Hi Souvik Das as per my understanding there are some differences between load and with and those are mention below:

1. You can define multiple local variable either Inside load() or with() but you can't perform save operation over the variables which are defined inside with() whereas we can save the data into a variable which is defined inside load()

2. Variables defined in load() instantiate for only once whereas variables defined in with() will be evaluated for each interaction on form, like sort, search, input a value in field etc. However forcefully you can dynamically change the value of the variables defined on load() as well.

3. Performance wise load() is faster than with() because of only once execution.

4. Any consistent values should be maintained in the variables defined in load() where as maintain those variables in with() which are expected to change its value based on given input.

Similarly we have few more differences, and I recommend you to go through the appian documentation to learn about it in detail.

Hope this will help you.

Load() calculates local variables value only first time when the expression is evaluated and With() re-calculates local variable's value when the expression is reevaluated

load() = Load Function

with() = With Function

 

Difference = load evaluate only once when form is loaded, and with evaluate for each user interaction with the components. 
Cascading dropdown is a very good example, the first dropdown is in load and evaluates only once when the form is loaded, but second dropdown in with evaluate every time when user change the value in first dropdown. 

variables defined under load() can be used in a!save() but variables defined with() cant be used in a!save().
load() variables are used for sorting or paging through a grid.

Load()-
1) Define local variables within an expression for a SAIL interface & evaluate the expression with local variables.
2) Retrieve data sets once & not have to get multiple times in an expression.
3) We can also used to create variables that capturing same data just like any other variable on a form. However, these variables only store data for a length the user is looking & interacting with a screen. When the user freshers or leaves screen the data in the local variables deleted.
With()-
1) Defines local variables within a function and evaluate the expression with the new variables.
2) It recalculates the local variable values each time the expression is re-evaluated.

Hi souvik das,

load evaluate only once when form is loaded, and with evaluate for each user interaction with the components.
Cascading dropdown is a very good example, the first dropdown is in load and evaluates only once when the form is loaded, but second
dropdown in with evaluate every time when user change the value in first dropdown.

Hi Souvik,

load() : It allows users to define multiple local variables inside the it. Local variable's value is evaluated the first time the expressions is executed.
with() : It also allows you to define multiple local variables but the value of these variables will be calculated each time there is any change n the form / each time the expression is re-evaluated.