Software Engineering Overview – Free Video Lesson
I am happy to announce my free video lesson on software engineering fundamentals, which I recently published in YouTube as part of my “Dev Concepts” series. In this lesson I make an overview of software engineering concepts like software development lifecycle, software quality assurance, unit testing, source control systems, and project trackers. Each concept is essential for your development as a software engineer. You should have a basic knowledge of each area because they are daily used in the software industry. Even if the technologies differ, the concept is still the same, only some details change over the time, like the tools we use.
Software Development Lifecycle (SDLC)
The software development lifecycle (SDLC) describes the activities that every software projects goes through, like gather requirements, design, develop, test, deploy and maintain the software.
As shown in the diagram, the software engineering activities are split into different stages:
- Requirement analysis – the senior members of the team or the project analysts gather information from the customer. This information is then used to plan the basic project approach and to conduct a product feasibility study in the economical, operational, and technical areas.
- Defining requirements – then the team should clearly define and document the product requirements and get them approved by the customer or the market analysts. The most important output from this step is the UI prototype: the app screens, which developers should implement.
- Designing architecture – a design approach clearly defines all the modules of the product along with its communication and data flow representation. The internal design should be clearly defined with even the minutest of the details.
- Building and developing – in this stage, the actual development starts, and the product is built. This is when programmers write and debug their code. If the design is performed in a detailed and organized manner, coding can be accomplished without much hassle.
- Testing the product – in this stage, developers and QA engineers test for defects and deficiencies. The issues found are fixed until the product meets the original specifications.
- Deployment – at this stage, the goal is to deploy the software (e.g. in a cloud environment / on a dedicated hosting / in the app store) so users can start using the product. However, many organizations choose to move the product through different deployment environments, such as a testing or staging environment.
- Maintenance – the final phase of the software development lifecycle occurs after the product is in full operation. Maintenance can include software upgrades, repairs, and fixes if it breaks. Customers often demand new features for the software application, which the developing team needs to add.
Software Quality Assurance (QA)
Software Quality Assurance (QA) is a term that covers all aspects of guaranteeing a high-quality software product or system. It includes creating processes for each stage of development to reduce bugs and flaws during the build. Companies need it to measure the quality of the software.
At the heart of the QA process is software testing. That is the process of checking whether the software conforms to the requirements and works as expected. Software testing aims to find the bugs (or defects) in the software and to report them for fixing. Software testing can be manual or automated.
- Manual testing also involves testing the user experience (UX), the user interface, and the visual look and feel of the software.
- Automated testing is done by scripts and programs, which perform robotic checks of the software.
In addition to testing, there are a few other approaches to software quality assurance, such as code reviews, quality inspections, and issue tracking.
Software Quality Assurance is a must in Software Development as it ensures your software is built efficiently and is finished with minimal flaws and bugs. Without it, Software Development could be quite unreliable, with products potentially requiring complete do-overs.
Unit testing is an important concept and practice in software development. As a term, unit tests are pieces of code that test specific functionality in a certain software component. Usually, they are not written by QA engineers but from the developers who wrote the code. Unit tests are part of the product source code and aim to improve the code quality, reliability, and maintainability.
Unit test developers usually follow the “AAA pattern“. It stands for:
- arrange the input data and entrance conditions
- act – execute the function for testing
- assert whether the results and the exit conditions are as expected
In the arrange section, you have the code required for setting up the specific test. Here is where we create objects and potentially set expectations. Then there is the act, which should be the invocation of the method being tested. In the assert, you would check whether the expectations are met.
By implementing unit testing, it’s easier to catch and fix issues early before they cost extra time and money. We should aim to write unit tests that focus solely on a single unit of code. With having more test reports, it will be easy to find the error in our code.
Source Control Systems
Source Control Systems (like SVN and Git) aim to keep the source code and other project assets in a shared repository. The information there is available through the Internet or in a local environment. The team that works on the specific repository can clone, pull, commit, and push the local changes. If there are conflicting changes, they can fix and merge them in the end. If the developers have a problem with a specific commit, they can compare different versions of the same file and restore previous versions.
Git is the most popular source control system in modern software development. It is a powerful tool for version control and team collaboration at the source code level. In the above video, I explain briefly Git and GitHub by showing a few examples. First, I clone the repository, edit a local file, commit the local changes, and then publish the commit.
Project Trackers are a simple tools designed to manage and track the project plan and schedule, to assign, arrange, track, and visualize project tasks. Trackers are an important concept in software project management in general. Each task may have a description, sub-tasks, assigned people, deadline, and other fields.
Most project trackers visualize and organize the work on the project with Kanban boards. A Kanban board is an agile project management tool designed to help visualize work limits, the work in progress, and maximize team efficiency. In general, it uses cards arranged in columns. Each card describes a task to be done or an issue to be handled. In general, it uses cards arranged in columns. Each card describes a task to be done or an issue to be handled.
Typically columns on the Kanban board are:
- Backlog – tasks waiting to be started. Usually, the tasks staying upper in the backlog have higher priority.
- In-Progress – this column holds the tasks that are currently taken by the team.
- Done – this is a collection of already completed tasks.
That process of work can be defined as “agile“. It means that tasks and their priorities change regularly, but everyone in the teams always knows the progress, and which task to do next. Teams that use project management apps typically track more than one project at a time. The software helps them figure out when to schedule work based on when things need to get done and the human resources available to do them.
All of these concepts are important for your future development as a software engineer. Each topic can be separated into a course and studied in detail. Even if you are indifferent to all the concepts, you should know at least the basics about each topic. In almost every interview for a software developer, you will be asked if you are familiar with these areas. Each software company uses different technologies, but the concepts behind them are similar.