Language Evaluation Criteria PPL

1. Readability
2. Writability
3. Reliability
4. Cost
5. Generality
6. Extensibility
7. Standardability
8. Support for internationalization

1. Readability: Coding should be simple and clear to understand.
1. Simplicity: Should not involve complex syntax, many ways to perform a single task,overloading of methods and operator etc.
2. Orthogonality: This means relatively small set of primitive constructs can be combine.
• For ex., int  *count; Here pointer and integer is combined.
• Another ex., int count[ 5 ]; Here array and pointer is combine.
3. Control Statements: There should be adequate control statements.
• Use of  for loop, while loop, do while loop is adequate.
• Using of go to statements causes poor readability.
4. Data Types and Structures: Language should involve adequate facilities for defining data types and data structure.
• For ex., timeout = 1; is unclear as compare to timeout = true;.
5. Syntax Design: Syntax design affects the readability in the following way.
1. Identifier forms: Restriction to very short length of identifier is a barrier to readability.
2. Special words: Special words like while, for, class, int affects the readability of any language. If special words are allowed to be variable names than it will become confusing.
2. Writability: Writability is a measure of how easily language can be used to code.Most of the language characteristics that affect readability also affect writability. 
1. Simplicity: Should not involve complex syntax, many ways to perform a single task,overloading of methods and operator etc.
2. Orthogonality: This means relatively small set of primitive constructs can be combine.
• For ex., int  *count; Here pointer and integer is combined.
• Another ex., int count[ 5 ]; Here array and pointer is combine.
3. Support for Abstraction: Language should support process and data abstraction.
4. Expressivity: In less lines of code program should be writable. 
• For ex., for statements makes counting loops easier than while.
• Another ex., is i++ is more expressive than i=i+1.
3. Reliability: A program is said to be reliable if it performs to irs specifications under all conditions.
1. Type Checking: It is testing for type error, either at compile or run time.
• For ex., float percentage; is more desirable as compare to int percentage.
2. Exception Handling: It is the ability of program to handle run time error. Remember, handling runtime error are more expensive than compile errors.
3. Aliasing: It is same memory location (variable) having more than one name. Which is causes confusion.
4. Readability: Readability influences reliability.
5. Writability: Writability also influence reliability.
4. Cost: Total cost of programming should be minimum.
• For ex., cost of trainer.
• Cost of writing algorithm.
• Cost of compiling program in the language.
• Cost of hardware required for program.
• Cost of maintenance.
5. Generality: Language should not be limited to specific application only.
6. Extensibility: Should be flexible, must be able to add new constructs.
7. Standardability: Language should be platform independent.
8. Support for Internationalisation: Various formats like time, date, currency etc should be supportable.

• 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