1. Small Reusable Code Blocks

This may be a new concept to some people.  The debate of Large code blocks vs. Small code blocks.  In ServiceNow, Javascript is executed from top to bottom.  We've all seen that one developer (you may have been one at one point) that likes to write 500+ lines of code without breaking up into functions/methods.

Lets briefly touch on some pro's and cons of each. 

These are not all the pro's and cons of each!

Large Code Blocks.

Pros:

A lot of times these can be easier to read and to follow exactly what the code is doing in order of operations. 

It is in line from top to bottom. 

All in one place.

Cons:

Duplication of code.  We've all seen those scripts where someone has copied a GlideRecord query and just added an integer at the end of the variable.  So you have "var user"   and then "var user1" and then "var user2".  While this in itself is not necessarily an issue,  how the code is written could be duplicated.

May not be the most efficient

You cannot reuse the code.

It may be harder to troubleshoot issues.

extra time to re-write and test code.

so for example:

var user = new GlideRecord("sys_user");

user.addQuery('sys_id', ID);

user.query();

if(user.next()){

//Do something for user 1

}

var user2 = new GlideRecord("sys_user");

user2.addQuery('sys_id', ID);

user2.query();

if(user2.next()){

//Do something for user 2

}

var user3 = new GlideRecord("sys_user");

user3.addQuery('sys_id', ID);

user3.query();

if(user3.next()){

//Do something for user 1

}

Small Code Blocks:

Pros:

Write a function at a time (may only need to write it one time).

Write it in a re-usable format. 

Easy to test individual blocks.

Can use code from all over without having to copy paste

Save time by not re-writing code over and over.

Cons:

While larger blocks of code can be easy to follow top to bottom, Sometimes when written as smaller blocks of code, it can be harder to follow.  Take a script incudes for example. One function could have multiple call outs to smaller functions. 

While smaller may be better in a lot of ways, more senior devs will make calls out to multiple script includes.  This means all code is not in the same place.  Having to track down all the code could go out to 3, 4, 7 script includes. 

example:
Create a script includes called userInfo and create a function/method of return record.

returnRec: function(ID) {

var grUser = new GlideRecord("sys_user");

grUser.addQuery('sys_id', ID);

grUser.query();

if(grUser.next()){

return grUser;

}

return null;

}

Then you can call that  and reuse it.

var userInfoSI = new global.userInfo();

var user = userInfoSI.returnRec('sys_id for user 1');

var user2 = userInfoSI.returnRec('sys_id for user 2');

var user3 = userInfoSI.returnRec('sys_id for user 3');

The term "Cloud computing" has been around for years.  It's the idea that you can do something NOT on your local PC.  While you perform the action on your PC,  the actual computing is done within the cloud.  So the same thing can be done while you're at home on your home PC, or while you're at work on your work PC.

This is the concept of the Script Includes in ServiceNow.  If you put a small chuck of code into a script includes, you can call it from a client script, business rule, scheduled job, UI action, other script includes, fix scripts, etc.... As long as you pass in the required parameters the script requires.

Use as many small chucks of code in a script includes as possible.