Scribd
Upload
2 views4 pages

PPL Chapter 3

Uploaded by

uckoojoyeeta24
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
2 views4 pages

PPL Chapter 3

Uploaded by

uckoojoyeeta24
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 4

1.

Evolution of the Concept of Data Type


Early Programming
 Machine Code & Assembly Language:

o No explicit concept of data types; everything was represented as raw bits.


o The interpretation of data (e.g., integer, float, character) was determined by the instructions
used.
 First-Generation High-Level Languages:
o FORTRAN (1950s): Introduced basic data types such as integers, floats, and arrays. Data
types were closely tied to hardware representations.
Second Generation (1960s–1970s)
 Structured Programming:

o Languages like ALGOL, C, and Pascal introduced explicit data types and structured data types
like arrays, records, and pointers.

o Enhanced readability and reusability.


o Stronger type checking reduced runtime errors.
Third Generation (1980s–1990s)
 Object-Oriented Programming (OOP):
o C++, Java, and Smalltalk allowed user-defined data types through classes and objects.

o Introduced the concepts of abstraction and encapsulation, supporting more complex and
reusable data models.

Modern Programming (2000s–Present):


 Dynamic and Functional Paradigms:
o Python, JavaScript, and functional languages like Haskell focus on dynamic and flexible data
types.
o Introduced dynamic typing (types determined at runtime) and type inference (automatic
determination of variable types).
 Type Systems and Safety:
o Modern languages like Rust and TypeScript emphasize type safety to prevent common bugs.

o Hybrid approaches combine static and dynamic typing.

2. Abstraction, Encapsulation, and Information Binding


Abstraction
 Definition: Hiding the details of implementation and exposing only the essential features.

 Purpose: Simplifies complex systems by focusing on high-level functionality.


 Examples:
o Functions: Users call a function without knowing its internal code.
o Abstract classes/interfaces: Define behavior without implementation.

Encapsulation
 Definition: Bundling data (variables) and methods (functions) together and restricting access to the
internals of an object.
 Purpose: Protects data from unauthorized access and modification.
 Implementation:
o Access modifiers (e.g., private, protected, public in Java).
o Use of getter and setter methods.

Information Binding
 Definition: The association of operations with the data they operate on.
 Purpose: Strengthens the integrity of data by ensuring it's manipulated only through defined
methods.
 Examples:
o Methods in a class can manipulate only their own class's fields.

o Binding in lambda expressions (e.g., capturing variables in C++).

3. Subprograms
Definition
 A block of code designed to perform a specific task, which can be invoked from various points in a
program.
Types:

1. Functions: Return a value (e.g., int sum(int a, int b)).


2. Procedures: Do not return a value (e.g., void printMessage()).
3. Methods: Functions defined within a class (e.g., public int getArea()).
Key Features:
 Parameter Passing:

o By Value: Copies the actual value.


o By Reference: Passes the address, allowing modification.
o Default Parameters: Allow optional arguments (e.g., C++).
 Recursion: Subprograms calling themselves (e.g., factorial computation).
Advantages:
 Code reusability.
 Improved readability and maintainability.

4. Type Definition
Definition
 The process of defining new data types or aliases for existing ones.
Examples:

Benefits:
 Increases clarity.
 Helps manage complexity by creating meaningful names.

5. Abstract Data Types (ADTs)


Definition
 A mathematical model for data types where the behavior (operations and properties) is defined
independently of implementation.
Key Characteristics:

 Encapsulation: Hides the implementation details.


 Operations: Exposes only the operations that can be performed (e.g., push, pop for stacks).
 Independence: Users interact with the interface, not the implementation.
Examples:
1. Stack:
o Interface: push(x), pop(), peek().
o Implementation: Array or linked list.
2. Queue:
o Interface: enqueue(x), dequeue().
o Implementation: Circular array or linked list.

Benefits:
 Flexibility: Implementation can change without affecting users.
 Reliability: Only valid operations are permitted.

Summary of Key Relationships

 Abstraction: Focus on "what" a system does.


 Encapsulation: Control "how" the data and methods are bundled.
 Information Binding: Ensure data is operated on in a controlled manner.
 Subprograms: Reusable blocks of functionality.
 Type Definition: Create meaningful and flexible data types.

 ADTs: Combine abstraction and encapsulation for data-centric programming.

You might also like