PPL: Local referencing environments

A LECTURE VIDEO ON LOCAL REFERENCING ENVIRONMENTS

Click here to view on YouTube

LOCAL REFERENCING ENVIRONMENTS

Local Variables

• Vars that are defined inside subprograms are called local vars.
• Local vars can be either static or stack dynamic.
• By default an variable in stack dynamic.

Advantages of using stack dynamic variable:

a. Support for recursion.

b. Storage for locals is shared among some subprograms.

Disadvantages of using stack dynamic variable:

a. Allocation/deallocation time required.

b. Indirect addressing “only determined during execution.”

c. Subprograms cannot be history sensitive “can’t retain data values of local vars

between calls.”

Advantages of using static variable:

a. Static local vars can be accessed faster because there is no indirection.

b. No run-time overhead for allocation and deallocation.

c. Allow subprograms to be history sensitive.

Disadvantages of using static variable:

a. Inability to support recursion.

b. Their storage can’t be shared with the local vars of other inactive subprograms. 

Example for  stack dynamic variable:

int addition(int a, int b) {

int sum = 0;

sum = a+b;

return sum;

}

Example for  static variable:

//static variable uses static keyword

int addition(int a, int b) {

static int sum = 0;

sum = a+b;

return sum;

}

Nested Subprograms

• Residing of a subprogram under another subprogram is known as nested subprogram.
• When a subprogram is placed within another subprogram,it gets hide from the rest of the program.
• Algol 68, Pascal, Ada, JavaScript, Python, Ruby allows nesting of subprogram.
• C, do not allow subprogram nesting.

Principles of Programming Languages:

EasyExamNotes.com covered following topics in these notes.

• Language Evaluation Criteria
• Influences on Language Design 
• Language Categories
• Programming Paradigms
• Compilation
• Virtual Machines 
• Programming Environments
• Issues in Language Translation
• Parse Tree 
• Pointer and Reference type
• Concept of Binding
• Type Checking
• Strong typing 
• Sequence control with Expression
• Exception Handling 
• Subprograms
• Fundamentals of sub-programs
• Scope and lifetime of variable
• Static and dynamic scope
• Design issues of subprogram and operations
• Local referencing environments
• Parameter passing methods
• Overloaded sub-programs
• Generic sub-programs 
• Design issues for functions 
• Co routines 
• Abstract Data types
• Abstraction and encapsulation
• Static and Stack-Based Storage management
• Garbage Collection
• OOP in C++
• OOP in Java 
• OOP in C# 
• OOP in PHP
• Concurrency
• Semaphores 
• Monitors
• Message passing
• Java threads 
• C# threads 
• Exception handling 
• Exceptions
• Exception Propagation 
• Exception handler in C++ 
• Exception handler in Java
• Introduction and overview of Logic programming
• Basic elements of Prolog
• Application of Logic programming
• Functional programming languages
• Introduction to 4GL 

Practicals:

• Memory Implementation of 2D Array. 
• Memory Implementation of 3D Array. 
• Implementation of pointers in C++. 
• Write a program in Java to implement exception handling.
• Write a program in C++ to implement call by value parameter passing Method.
• Write a program in C++ to implement call by reference parameter passing Method. 
• Write a program in Java to implement concurrent execution of a job using threads.
• Implement Inheritance in C#.
• Implement Encapsulation in C#.
• Implement static/compiletime Polymorphism in C#.
• Implement dynamic/runtime Polymorphism in C#.

Previous years solved papers:

• PPL|RGPV|May 2018 
• PPL|RGPV|June 2017 

A list of Video lectures

• Click here

References:

1. Sebesta,”Concept of programming Language”, Pearson Edu 
2. Louden, “Programming Languages: Principles & Practices” , Cengage Learning 
3. Tucker, “Programming Languages: Principles and paradigms “, Tata McGraw –Hill. 
4. E Horowitz, "Programming Languages", 2nd Edition, Addison Wesley