ABSTRACT

A simplistic overview of the entire

software process, presented as
detailed as it is summarized. Its
purpose? To bring Software
Engineering at a glance to beginners
including most of the terms in a simple
and easy to understand way, removing
SOFTWARE all unnecessary complications in
presentation. Still a work in progress…
~ Isi Edeoghon

ENGINEERING
BASICS I
Compiled by Isi Edeoghon (PhD)
Chapter A – Introduction to the “very very” necessary basics of Software
Engineering.

What is a Software?

Software is a program or set of programs containing instructions that provide a desired

functionality. Engineering is the process of designing and building something that serves a
particular purpose and is a cost-effective solution to problems.

What is Software Engineering?

Software Engineering is the process of designing, developing, testing, and maintaining software.
It is a systematic and disciplined approach to software development that aims to create high-
quality, reliable, and maintainable software.

Software engineering includes a variety of techniques, tools, and methodologies, including

requirements analysis, design, testing, and maintenance. A rapidly evolving field, new tools and
technologies are constantly being developed to improve the software development process.

By following the principles of software engineering and using the appropriate tools and
methodologies, software developers can create high-quality, reliable, and maintainable software
that meets the needs of its users.

Software Engineering is mainly used for large projects based on software systems rather than
single programs or applications.

The main goal of Software Engineering is to develop software applications that are of quality,
reduce budget, and is time efficient.

Software Engineering ensures that the software that is built should be consistent, correct, also on
budget, on time, and within the required requirements.

Principles of Software Engineering

1. Modularity: Breaking the software into smaller, reusable components that can be developed
and tested independently.
2. Abstraction: Hiding the implementation details of a component and exposing only the
necessary functionality to other parts of the software.
 3. Encapsulation: Wrapping up the data and functions of an object into a single unit, and
protecting the internal state of an object from external modifications.
4. Reusability: Creating components that can be used in multiple projects, which can save
time and resources.
5. Maintenance: Regularly updating and improving the software to fix bugs, add new features,
and address security vulnerabilities.
6. Testing: Verifying that the software meets its requirements and is free of bugs.
7. Design Patterns: Solving recurring problems in software design by providing templates for
solving them.
8. Agile methodologies: Using iterative and incremental development processes that focus on
customer satisfaction, rapid delivery, and flexibility.
9. Continuous Integration & Deployment: Continuously integrating the code changes and
deploying them into the production environment.

Attributes of Good Software

There are four main Attributes of Software Engineering.

1. Efficiency: It must provide a measure of the resource requirement of a software product

efficiently.
2. Reliability: It must assure that the product will deliver the same results when used in similar
working environments.
3. Reusability: Its modules can be used in multiple applications.
4. Maintainability: It must be able to be modified, repaired, or enhanced easily with changing
requirements.

Objectives of Software Engineering

1. Maintainability: It should be feasible for the software to evolve to meet changing

requirements.
2. Efficiency: The software should not make wasteful use of computing devices such as
memory, processor cycles, etc.
3. Correctness: A software product is correct if the different requirements specified in the
(Software Requirements Specification) SRS Document have been correctly implemented.
 4. Reusability: A software product has good reusability if the different modules of the product
can easily be reused to develop new products.
5. Testability: Here software facilitates both the establishment of test criteria and the
evaluation of the software concerning those criteria.
6. Reliability: It is an attribute of software quality. The extent to which a program can be
expected to perform its desired function, over an arbitrary time period.
7. Portability: In this case, the software can be transferred from one computer system or
environment to another.
8. Adaptability: In this case, the software allows differing system constraints and the user
needs to be satisfied by making changes to the software.
9. Interoperability: Capability of 2 or more functional units to process data cooperatively.

What Careers Are There in Software Engineering?

A degree in software engineering and relevant experience can be utilized to explore several
computing job choices. Software engineers have the opportunity to seek well-paying careers and
professional progress, although their exact possibilities may vary depending on their particular
school, industry, and region.

Some job choices in software engineering:

1. SWE (Software Engineer)

2. SDE (Software Developer)
3. Web Developer
4. Quality Assurance Engineer
5. Web Designer
6. Software Test Engineer
7. Cloud Engineer ·
8. Front-End Developer
9. Back-End Developer
10. DevOps Engineer.
11. Security Engineer.
What Tasks do Software Engineers undertake?

The main responsibility of a software engineer is to develop useful computer programs and
applications. Working in teams, its possible to complete various projects and develop solutions to
satisfy certain customer or corporate demands.

Some of the key responsibilities of software engineers are:

1. Requirement Analysis: Collaborating with stakeholders to understand and gather the

requirements to design and develop software solutions.
2. Design and Development: Creating well-structured, maintainable code that meets the
functional requirements and adheres to software design principles.
3. Testing and Debugging: Writing and conducting unit tests, integration tests, and debugging
code to ensure software is reliable and bug-free.
4. Code Review: Participating in code reviews to improve code quality, ensure adherence to
standards, and facilitate knowledge sharing among team members.
5. Maintenance: Updating and maintaining existing software systems, fixing bugs, and
improving performance or adding new features.
6. Documentation: Writing clear documentation, including code comments, API
documentation, and design documents to help other engineers and future developers
understand the system.

Types of Software Engineering Practices

Software engineers can learn best practices from different areas of software development. Learning
best practices and then finding the right ways to apply them to a project matures software engineers
and helps them succeed.

When choosing the set of best practices to focus on, a programmer’s experience matters. So, while
junior engineers usually learn best practices for writing unit tests or avoiding code smells, seniors
or technical leaders should learn best practices that impact the entire project or development
process.
It is essential to follow software engineering conventions to keep the software maintainable.
Organizations need to invest in these software engineering practices by training, coaching, tools,
infrastructure, and time.

Software Engineering Practices

The following are software engineering practices, though not exhaustive:

1. Development Methodologies or also known as Software Development Life Cycle

A range of methodologies and frameworks can be adopted to develop Software, including

Waterfall, Agile, Scrum, Nexus, and Kanban. Transitioning to agile approaches requires
rethinking traditional project execution strategies.

1. Waterfall: This methodology emphasizes meticulous planning and comprehensive

requirements documentation (getting requirements). It often involves implementing these
requirements in a highly structured manner, which can be time-intensive and effort-
heavy.

Figure A - The Waterfall Model

2. Agile methodology: A dynamic approach to software development that prioritizes
collaboration, adaptability, and continuous improvement. It enables teams to efficiently
deliver high-quality software while accommodating evolving requirements. It entails key
principles such as:

• Iterative Development – Software is built incrementally, ensuring regular

feedback and refinements.
• Customer Collaboration – Ongoing stakeholder engagement ensures alignment
with user needs.

Popular Agile Frameworks

• Scrum – Uses short cycles (sprints) with well-defined roles and processes.
• Kanban – Focuses on continuous workflow management using a visual board.

Figure B – The Agile Methodology

3. Scrum: Scrum is a framework designed to enhance the quality, pace, and cost-
effectiveness of software delivery projects. Beyond software development, it also benefits
product design and lifecycle management. Work is divided into short cycles called
sprints, typically lasting two to four weeks.
 Figure C - The Scrum Model

4. Nexus: An extension of Scrum, Nexus addresses scaling challenges in large, long-term

projects. It facilitates incremental product releases across teams exceeding 100 developers
by adhering to established practices. Nexus scales Scrum for large and complex software
development projects. It extends Scrum principles to coordinate multiple teams working
on the same product, ensuring smooth collaboration and integration.

Figure D - The Nexus Model

5. Kanban: Kanban emphasizes visualizing workflow tasks to prioritize and manage

commitments efficiently. Its transparency enhances developer awareness and aids
organizational alignment in selecting suitable methodologies. It helps Software Engineers
visualize, manage, and optimize work processes.
 Figure E – Example of a kanban implementation

2. Coding Standards: Readability and Clean Code

Code readability is a hallmark of high-quality software. Organizations must prioritize team

collaboration, enforce quality code standards, and address poor readability, which can lead to
bugs, instability, and reduced team efficiency. Teams should be trained in clean coding
principles. Remember, well-structured and readable code improves collaboration, reduces bugs,
and simplifies maintenance.

3. Frequent Refactoring

Refactoring involves restructuring existing code to simplify maintenance and enable future
modifications. This practice entails understanding current requirements, improving code
structure, validating against specifications, and deploying adjustments to ensure flexibility and
efficiency.

4. Reducing Technical Debt

"Technical debt" refers to deficiencies such as bugs, legacy code, or lack of documentation, often
resulting from prioritizing rapid delivery over optimal code. Managing and reducing technical
debt is critical for maintainability, reliability, and user satisfaction.
5. Best Practices: KISS, YAGNI, DRY, and SOLID

• KISS (Keep It Simple, Stupid): Prioritize simplicity when designing solutions that meet
requirements.
• YAGNI (You Aren’t Gonna Need It): Avoid overgeneralizing designs to anticipate
nonessential future features.
• DRY (Don’t Repeat Yourself): Eliminate duplicate code to streamline maintenance.
• SOLID Principles: Emphasize modular design principles for robust, maintainable code.

6. Unit Testing

Unit testing is crucial for identifying potential issues early in development. Its automation
ensures efficiency, particularly in complex projects with frequent releases.

7. Behavior-Driven Development (BDD)

BDD bridges communication gaps between engineers and business stakeholders. In simple terms
it is a software development methodology that emphasizes collaboration and clarity by defining
application behavior in plain language using scenarios and examples.

8. Automated Acceptance Testing

Acceptance tests describe expected software behaviors as use cases. It validates if a system
meets predefined business requirements by executing automated test cases. Automating these
tests creates a continuous delivery strategy, ensuring seamless execution.

9. Performance Testing

Performance tests assess software efficiency under specific conditions, such as load or response
time, and are essential before user deployment.

10. Test-Driven Development (TDD)

TDD prioritizes quality by continuously running user-defined tests. This iterative approach
improves both software reliability and team efficiency.
11. Continuous Integration and Deployment (CI/CD)

Agile development requires frequent code integration and deployment, enabling rapid issue
resolution and quickening the overall lifecycle.

12. Microservices Architecture

Microservices split functionality into independent, adaptable modules, facilitating scalability and
flexibility. This is a software development approach in which an application is built as a
collection of small, independent services that communicate with each other. Each microservice is
designed to perform a specific function. This approach contrasts with monolithic architectures.

13. Monolithic Architecture

Monoliths are suitable for simpler projects that do not require modular scaling. However,
ensuring clear separation of concerns remains important. Over time, monoliths can transition into
microservices if necessary.

14. DevOps

DevOps represents a collection of development and operational practices that have emerged in
recent years to foster agile project delivery by integrating software development and operations.
Its primary objective is to accelerate the delivery of software applications through extensive
automation. Beyond being a methodology, DevOps constitutes a mindset, promoting a flexible
approach to product development that considers stakeholder requirements, associated risks, and
constraints while ensuring customer expectations are met.

Figure F – Illustration of the Dev-Ops cycle

15. Monitoring and Logging

In agile development, achieving continuous delivery is complex without robust monitoring and
logging systems. Effective monitoring ensures bugs are identified in controlled environments and
facilitates prompt corrective measures. Observability is integral to this process, necessitating
investment in centralized monitoring and logging solutions such as Elastic Stack, AWS
CloudWatch, or Azure Monitor.

16. Infrastructure as Code

Infrastructure as Code (IaC) enables the creation, management, and modification of cloud-based
infrastructure using code. Leading technologies like Terraform simplify this process, automating
infrastructure setup to achieve consistent and efficient environments. Storing infrastructure code
in version control systems ensures traceability and reliability.

Figure G – Example of Infrastructure as a Code

17. Configuration Management

Configuration management involves programming servers, applications, and infrastructure as

code. Tools such as Ansible, Puppet, and Chef facilitate the automation of tasks like database server
setup, application of security patches, and operating system upgrades. Since configurations are
stored as code, they remain testable and replicable, ensuring consistency.

18. Cloud Computing

Software developers must familiarize themselves with major cloud platforms like Amazon Web
Services (AWS), Microsoft Azure, and Google Cloud, as well as other solutions like Apache Cloud
Stack, OpenStack, and IBM Cloud Orchestrator. Adequate training equips teams to optimize
cloud-based development effectively.

19. DevSecOps

DevSecOps emphasizes the secure development, delivery, and continuous monitoring of software.
This practice prioritizes cybersecurity strategies based on risk assessments, enabling teams to adapt
swiftly to evolving requirements while delivering highly secure software.

20. Penetration Testing

Penetration testing (pen-testing) evaluates vulnerabilities in software and hardware that companies
rely on for service delivery. The goal is to simulate real-world challenges, ensuring systems remain
secure and reliable while integrating new features and functionalities.

Figure H – Example of penetration testing

21. Communication and Collaboration

Effective communication and collaboration are essential for implementing agile methodologies.
Cross-functional teams must employ clear communication strategies, including written
documentation, face-to-face meetings, video conferencing, and other media. These practices
ensure problem-solving, promote teamwork, and foster self-organizing groups that address
business needs. Ultimately, success relies not only on processes but also on the commitment and
engagement of business, technical, and management teams in applying these practices.
References

Introduction to Software Engineering, Geeks for Geeks, (2025)

https://www.geeksforgeeks.org/software-engineering-introduction-to-software-engineering/

21 Essential Software Engineering Practices, Øyvind Forsbak (2025)

https://www.orientsoftware.com/blog/software-engineering-practices/

What is Infrastructure as Code with Terraform? Terraform (2025)

https://developer.hashicorp.com/terraform/tutorials/aws-get-started/infrastructure-as-code

Embracing Simplicity: Why Nexus is the Best Scaling Framework for Scrum Teams, Mary Iqbal,
(2023)

https://www.rebelscrum.site/post/embracing-simplicity-why-nexus-is-the-best-scaling-
framework-for-scrum-teams

DevOps, Devopedia (2022)

https://devopedia.org/devops