Subprograms

Fundamentals of Subprograms

A subprogram is a program inside a larger program that can be used multiple times in multiple places. Each subprogram can have only one entry point and execute one at a time. All calling programs will be suspended during subprogram execution. 

A subprogram header contains:

• name of the subprogram

• type of the subprogram

• a list of parameters (optional)

Parameters

There are two types of parameters, the formal parameter and the actual parameter.

Procedures are a category of subprograms that contain blocks of codes that perform a task or calculate a value.  There are two methods to produce results in calling program unit:

1. If there are variables that aren't formal parameters but are still visible in both the procedure and the calling program unit, the procedure can change them

2. The procedure has formal parameters that allow the transfer of data to the caller, those parameters can be changed.

Functions that do not return a value can be considered as a procedure.  

Similar to a procedure, a function is more semantically modeled on mathematical functions. It is executed once invoked. A function consists of:

1. 'function' keyword

2. the function name

3. a list of parameters

4. statements enclosed in curly braces

(Concepts of Programming Language, n.d.) 

- Anis Syifaa'

Local Referencing Environments

Subprograms have a complex structure, hence a lot of design issues arise, especially on deciding the multiple choice of parameter passing methods. Variables declared in the subprograms are called local variables, meaning they can only be called within the same subprogram.

Can local variable be stack-dynamic?

JavaScript has a stack-based memory management system, therefore local variables stored in the memory can be stack-dynamic. 

Stack-dynamic local variables are bound to storage when the subprogram begins to run and are unbound when execution stops. 

Advantages:

1. Promotes flexibility, especially for recursive subprograms

2. Storage for local variables in the current subprogram can be shared with other variables in an inactive subprogram. 

Disadvantages:

1. Time-consuming, because each call needs to allocate, initialize, and deallocate memory to and from a variable.

2. Access to static-dynamic variables is indirect because the memory location of a local variable can only be determined during execution. This requires the CPU to calculate the memory address beforehand, requiring an extra process.

3. It is not history-sensitive as it quickly discards the variable from a memory location as soon as execution ends.

Can local variables be static?

JavaScript does not have 'static' keyword for local variables like Java. However, it does have 'static' keyword for method and property of a class. 

However, we can still simulate similar static-like behavior to local variables by using nested subprograms, static methods and closures.

(Concepts of Programming Language, n.d.) 

- Anis Syifaa' 

Calling Subprograms Indirectly

Indirectly called subprograms often occur in situations when the specific subprograms to be called are not known until run time (Sebesta, 2012). In JavaScript, subprograms can be invoked indirectly using call(), apply(), bind(), or callbacks.

1. call()

The call() method is a pre-defined JavaScript method. It can be used to invoke a method or subprogram with an owner object as an argument (parameter) (GeeksforGeeks, 2024).

2. apply()

The apply() method is used to write methods that can be used on different objects, which takes arguments as an array (GeeksforGeeks, 2023).

3. bind()

The bind() method creates a new function, and when that new function is called, it sets this keyword to the first argument, which is passed to the bind() method. If any other sequences of arguments preceding the first argument are passed to the bind() method, then they are passed as an argument to the new function when the new function is called (GeeksforGeeks, 2024).

4. Callbacks

A callback is a function passed as argument to another function, which allows the latter to execute the callback function at a specific time, often after completing an operation. Callbacks are a fundamental concept in JavaScript to allow asynchronous programming and modular code design (GeeksforGeeks, 2024).

-  Sofia Batrisyia

Overloaded Subprograms

Function Overloading is a feature in many object-oriented programming languages that allows multiple functions or methods to share the same name but different signatures, where the implementations of the parameter, such as the number or type of arguments passed. 

Unlike other programming languages, JavaScript does not support subprogram overloading. This is because JavaScript functions are dynamically typed and do not strictly enforce parameter types or counts which means that variable types are checked during runtime instead of during compilation.  As JavaScript treats functions as objects, redefining a function with the same name simply reassigns its reference, so the last defined function will overwrite the previous ones.  

However, function overloading in JavaScript can be simulated by checking the number or types of arguments using tools like the arguments object, rest parameters, or type checks. JavaScript supports function overriding, where the most recently defined function with a given name takes precedence and will be executed whenever the function is called.

(www.naukri.com, n.d.-b) (GeeksforGeeks, 2024c) 

(GeeksforGeeks, 2024b)

The example below shows how function overloading is simulated using conditionals to check the number and type of arguments passed to the functions. The function behaves differently based on how it is called. 

(GeeksforGeeks, 2024b)

Sample Application

All functions (summarizeWithHuggingFace, summarizeDocs, promptUserForQuestions, main) have unique names, and there are no instances of multiple functions with the same name but different parameter lists.

- Kueh Pang Teng