CP317 | Week 6 | Implementation

Review of Week 5 Topics

• Object-oriented design includes association, aggregation, and composition.
• SOLID principles are: Single Responsibility, Open-Closed, Liskov Substitution, Interface Segregation, and Dependency Inversion.
• The Single Responsibility Principle states that a class should have one reason to change.
• The Open/Closed Principle states that software components should be open for extension but closed for modification.
• Liskov’s Substitution Principle states that derived types must be completely substitutable for their base types.
• The Interface Segregation Principle states that clients should not be forced to implement unnecessary methods.
• The Dependency Inversion Principle states to depend on abstractions, not concretions.

Introduction to Implementation

• Implementation is equal to coding.
• Becoming a great programmer involves clarifying requirements, being meticulous, problem-solving, debugging, reviewing code with SOLID principles, continuous learning, and proficient Googling.

Software Security Considerations

• Software security should be a consideration during implementation.
• Incorrect coding leads to vulnerabilities and system accidents.
• A buffer overflow is an example of a security vulnerability.
• Fail-safe default means that access to an object should be denied unless explicitly granted.

Coding Standard

• A coding standard is a set of guidelines and conventions for software developers.
• Benefits of using coding standards include improved software quality, quicker debugging, easier code review, conflict avoidance, and better collaboration.

Programming Tools

• Programming tools include compilers, linkers IDEs (Integrated Development Environments).
• Examples of IDEs includes Visual Studio, Visual Studio Code and Eclipse.

Software Code/Version Control

• Software code/version control involves managing changes to documents and computer programs.
• Benefits of version control includes automatic backup, multiple computer sharing, version control and version maintenance.
• Github and ClearCase are version control systems (VCS).

Understanding APIs

• Understand application programming interfaces (APIs) which requires knowledge of functionalities, inputs, and outputs, as well as computer language and operating system skills.
• Object-oriented programming APIs include C++, .NET C#, and Java.
• Knowledge of API theory and mechanism is essential.

Recommendations

• Writing good code can be difficult; strive for high cohesion, low coupling, and adherence to SOLID principles.
• Coding is a level of design.
• A good code designer should be a programmer.

Unexpected Situations

• Unexpected situations need to be handled.
• Questions you should about API failures is “should the process continue or stop?”.
• Creative thinking and attention to detail are crucial.

Comments

• Write sufficient comments.
• Comment outlines should adhere to coding standards, improving code understanding and maintenance.

Side Effects

• The goal is to avoid side effects.
• Side effects occur when a function modifies global variables or has interactions outside its scope.

Offensive and Defensive Programming

• Defensive programming involves designing software to continue functioning under attack by expecting erroneous input.
• Offensive programming departs from defensive principles by prioritizing the avoidance of errors stemming from software bugs.

Exception Handling

• An exception is an event that occurs during program execution and they can be inside or outside.
• Exception handling helps create reliable systems and separates error handling logic.

Memory Consumption

• A buffer is a physical memory region used for data.
• Buffer overflow happens, when a process writes more data into a buffer than it can hold.
• Stack based buffer overflow is equal to a stack overflow.
• Heap based buffer overflow is equal to a heap overflow.
• Stack overflow condition, may occur when computer program tries to use more memory space than the stack size.
• Memory leaks happen, when software fails to release required memory.
• Memory leaks cause impaired performance
• Avoiding repeating memory allocations without releases is suggested

Function Calls

• Minimizing local variables and function parameters can improve performance in C/C++, avoiding expensive frame pointer operations or excessive pushing onto the stack.
• It is best to avoid cascaded function calls, which can be hard for debugging in non-scripting languages

Safety Considerations

• Critical systems include medical devices, airplanes and automatic control train systems because failure in these systems may result in serious injury or even death.
• Real Time Operating Systems (RTOS) handle data in strict time frames.
• Redundancy: in software engineering, it is a design method in which a component is duplicated so if it fails there will be a backup.
• Employing system redundancy improves the reliability of computerized systems, as seen in online banking, control systems, and Hadoop applications.

Constructors/Destructors

• It is best to keep constructors lightweight (simple), and perform the necessary initialization including resource allocation within it.
• Destructors should prioritize releasing resources allocated in the heap.
• For initialization, the use of Color c(black) is faster than Color c; c = black;.
• It is best to keep destructors simple.
• Never allow exceptions to leave destructors.

Announcement

• The group project is to start.
• There is no class next week as it is reading week.