20.1 Programming Paradigms (3)
Resources |
Revision Questions |
Computer Science
Login to see all questions
Click on a question to view the answer
1.
Compare and contrast the use of registers and memory in low-level programming. Explain how the programmer can directly interact with registers and the implications of doing so.
Registers and Memory:
Registers are small, high-speed storage locations within the CPU. Memory (RAM) is a larger, slower storage area used for storing data and instructions. Registers are directly accessible by the CPU, while accessing memory requires more time.
Comparison:
| Feature | Registers | Memory (RAM) | | Location | Inside the CPU | Outside the CPU (separate chips) | | Speed | Very Fast | Relatively Slow | | Size | Small (typically a few bytes) | Large (gigabytes) | | Cost | Expensive | Relatively Inexpensive |
|
Direct Interaction with Registers:
In low-level programming, programmers can directly manipulate registers using assembly language instructions. This allows for very fast operations, such as performing arithmetic calculations or accessing data. However, it requires a deep understanding of the CPU architecture and can lead to code that is difficult to read and maintain. Incorrect register manipulation can also cause program crashes or security vulnerabilities.
Implications:
- Performance Optimization: Direct register manipulation can significantly improve performance in critical sections of code.
- Hardware Control: Registers are often used to control hardware devices.
- Security Risks: Improper register handling can create security vulnerabilities, such as buffer overflows.
- Code Complexity: Code that directly manipulates registers is often more complex and harder to debug.
2.
Explain the benefits of using object-oriented programming over procedural programming. Consider aspects such as code reusability, maintainability, and scalability. Provide specific examples to illustrate your points.
To model a vehicle management system using OOP, I would create the following classes:
| Class Name | Attributes | Relationships |
| Vehicle | make, model, year, registration number, mileage | Abstract class - base for other vehicle types. |
| Car | fueltype, numberofdoors, enginesize | Inherits from Vehicle. |
| Truck | cargocapacity, numberof_axles | Inherits from Vehicle. |
| Motorcycle | enginecapacity, numberof_wheels | Inherits from Vehicle. |
Relationships:
- Inheritance: Car, Truck, and Motorcycle would inherit from the
Vehicle class. This allows them to share common attributes (like make, model, year) and methods (like start, stop). - Composition/Aggregation: A
Vehicle class might have a composition relationship with a Engine class. The Vehicle *contains* an Engine. This would allow for more complex vehicle models in the future.
This design demonstrates abstraction by hiding the specific details of each vehicle type within its respective class. Polymorphism is demonstrated by the ability to treat any Vehicle object as a Vehicle and call a common method like start() or accelerate(). Encapsulation is achieved by controlling access to the vehicle's attributes through getter and setter methods.
3.
Consider a simple task of calculating the area of a rectangle. Write pseudocode demonstrating how this task would be implemented using an imperative (procedural) approach. Then, briefly explain how the same task might be implemented using an object-oriented approach.
Imperative (Procedural) Pseudocode:
- Input: Get the length and width of the rectangle from the user.
- Process: Calculate the area by multiplying length and width (Area = length * width).
- Output: Display the calculated area to the user.
Object-Oriented Approach:
In an OOP approach, we would create a Rectangle class. This class would have:
- Attributes (Data):
length and width (these would be instance variables). - Methods (Functions): A method called
calculateArea() that would multiply the length and width attributes to return the area.
To use this, we would create an instance (object) of the Rectangle class, set its length and width attributes, and then call the calculateArea() method to get the area. This approach encapsulates the data (length and width) and the operation (calculating the area) within a single unit, making the code more organized and reusable.