40 STOP
100   LOCAL a$="Different Value"
110   PRINT a$
120 RETURN

This will print Different Value and Test on your screen as LOCAL creates in a sense two versions of a$. The second one exists only until the RETURN keyword is reached.

PRIVATE and PRIVATE CLEAR

PRIVATE is similar to LOCAL in the fact that's reserved only for subroutines (see above) and procedures (see next section). Its syntax is as follows:

PRIVATE var[=value]

where var is a numeric variable (Unlike LOCAL, only numeric variables are accepted by PRIVATE) and value is the optional initialisation value. The latter is important as you will see below. PRIVATE ensures that the variables that follow it, are both independent of the rest of the program and that they are retained every time the procedure is called. In order to reset the value of all private variables (to 0 or to the value initialised to by the PRIVATE statement) we can use PRIVATE CLEAR. When calleded from within banked code (See Chapter 23 – The Memory for information about banks and banked code) PRIVATE CLEAR initialises only the private variables for the procedures in that bank otherwise the private variables for the main program are reset. A small example on how PRIVATE and PRIVATE CLEAR work is the following:

100 PRIVATE CLEAR
110 FOR i=1 TO 10: PROC
    iterate():NEXT i:STOP
120 DEFPROC iterate()
130   PRIVATE callcount=0
140   callcount+=1
150   PRINT "I have been called
    ";callcount;"times"
160 ENDPROC

Procedures (DEFPROC / ENDPROC / PROC)

Procedures are a special form of subroutines. Imagine them as a combination of subroutines and functions (See Chapter 8 – Functions). Like subroutines and the GO TO keyword they branch execution to a different segment of the program to better organise and reuse code. Unlike subroutines but like functions, they can accept multiple variables as parameters, can be named and when called they do not require a line number or label.
Think of procedures as a way to extend NextBASIC commands much like user defined functions extend the inbuilt functions (See Chapter 8 for more details).

Procedure parameters can be regular numeric, integer and string variables as well as arrays which follow all the naming conventions of the former (As seen in Chapters 1 – Basic Programming Concepts , 7 – Expressions and 11 – Arrays).

Procedures can carry meaningful names following the naming conventions of numeric variables (See Chapter 7 – Expressions for valid numeric variable names), while they can also optionally be followed by a $ sign. The latter has no effect in functionality but can be used to identify what the procedure does (for example manage strings)

Procedures are defined by the keywords DEFPROC which takes the form:

DEFPROC name[$] ([parameter1[=def1][,...[, parameterN[=defN]]]])