Software engineering is a broad field of knowledge in the field of IT, covering not only programming, but also analytics, management, software package design, and much more. A software engineer differs from a programmer in the scale of tasks to be solved and the approaches that are used for this purpose.

Today it is one of the most promising areas of high-tech development. Without engineering it is impossible to create complex, expensive software products which solve not one but dozens of users’ problems. Learn more about what software engineering is and what problems it solves from our material.

What is software engineering?

The term “software engineering” or “programming technology”, as it sounded in the world, appeared quite a long time ago, back in the early 70’s of the XX century. At that time, the cost of software became comparable to the cost of computer hardware (or, as it was called, “iron”), so a new scientific direction was needed, which could reduce the time to develop programs and reduce their cost.

Software engineering and programming are like a professional and an amateur. Anyone can learn to write simple programs, soon the carriers of “artificial intelligence” will be able to do it. But such “products” cannot be compared in quality with proprietary software, especially when it comes to performance, reliability and economy of computing resources.

Programming is a list of commands controlling the inputs to a computer system. The result of the task will be a set of output indicators indicating that the complex system created for specific purposes is functioning properly.

Software engineers are professional programmers who have an understanding of the processes and constraints involved in developing solutions, how those solutions affect the stability and safety of complex systems, and who are able to create software products that qualitatively solve the tasks at hand.

The relationship of software engineering to other disciplines

Software engineering does not exist in a vacuum, but is closely related to disciplines such as computer science and systems engineering, and often appears after business engineering. Let us take a closer look at this area of software engineering.

Computer science is a scientific discipline that uses mathematical methods to define the formal foundations of computability. It includes mathematical logic, grammar theory, compiler construction methods, mathematical formal methods used in verification and model testing, etc. At first glance, computer science and software engineering are very similar, but the applications of each discipline are different.

Software engineering is more practical in nature and helps to solve production problems, computer science is a scientific development of mathematical approaches to programming.

System engineering is a set of engineering disciplines aimed at the development and creation of various artificial systems in power engineering, telecommunications, embedded real-time systems, etc. Software in this case often becomes part of the system, controlling the hardware directly. Such systems are hardware-software systems, so programmers who develop software for them must have a very good understanding of how the hardware itself works.

Business reengineering is the modernization of business in an individual company through the introduction of new methods of work on the basis of modern information systems. The process may concern the company’s internal reengineering or is aimed at creating a new customer service. Most often, these two processes are interrelated.

Business reengineering is usually performed prior to the implementation of an information system to streamline paperwork and then automate it.

Who is a software engineer?

Software engineering ensures that software products are safe, reliable, and of high quality, and that they retain these properties throughout their lifecycle. They are first designed, then written, tested, and maintained while solving user problems.

A true software engineer quickly grasps the problem at hand and understands what resources he can use to solve it. Sometimes this does not require compiling a new program, but rather applying an existing program or compiling it from several ready-made programs. In the future, most standard problems will be solved as early as the preliminary design stage of complex systems.

Basic components of software engineering:

• Getting to know the essence of the process and developing its mathematical or physical model, if necessary;
• Clarification of the goals and tasks for which the program methods should be used, the construction of the program algorithm;
• Searching of ready procedures and writing of missing blocks for the developed algorithm of the task solution in one of the programming languages;
• Running, debugging (error correction), testing and assembling the software product. 

During the introduction to the problem statement before starting work on the creation of software, the software engineer tries to find answers to the following questions:

• Is it possible to solve the problems of a complex system by using only one program;
• What specific problems will be solved by each of the written or ready-made programs;
• How can you speed up problem solving by using ready-made software packages, by writing new software blocks, or by combining them.

When it becomes clear whether it will be a new product from scratch, or the layout of existing procedures with the writing of the missing codes, the software engineer poses very different questions:

• Which software blocks need to be logically linked so that they work as a whole in the new product;
• What criteria will be used to select possibilities for further extensions of the product;
• How accessible the program code and comments to it should be, so that it is possible to understand the work of the created software product.

During software testing, completely different questions arise that need to be answered:

• Can the created product work in conditions of different computing equipment, initial time settings, in different operating environments and software environments;
• Whether the product under test has demonstrated its effectiveness in saving computing resources, whether it has demonstrated stability in operation, reliability, accuracy of execution, ease of installation, maintenance and support;
• Whether the created product is convenient for users;
• Whether the new product is able to work in case of incorrect initial data entry and in case of failures in the interaction of objects of a complex system;
• Whether the software product is capable of improving protection and security against external influences, and whether it does not contain features or defects not foreseen by the developer;
• Whether the new product accompanies all changes and/or errors with a message that can be understood by any user;
• Whether the system log is properly maintained, which records all errors that occur, so that they can be analyzed and corrected later by any guest programmer, not just the author of the software;
• Whether the most up-to-date programming language is best suited to optimize the software during the creation of a new software product is used.

Key Markers for Software Engineering

What kind of work can you do in software engineering? It won’t be the typical programmer limiting himself or herself to just writing programs. A software engineer’s horizons are much broader and include such categories as meeting needs and solving problems. After all, you don’t have to write a program every step of the way.

Many problems can be solved by using existing designs or combinations of them. And if you are proactive, some difficulties can be avoided at all. Therefore, designing good software complexes requires a plan drawn up in advance, so that no problems arise in the future.

Before you start programming, an engineer must answer a number of questions:

• What result should I achieve?
• What else can I do to solve the problem, besides write a program?
• How would getting a result be easier with a program?

Quality program codes are clear, easy to read, they can be supplemented with new elements, they work well with other programs, the maintenance of this software does not create headaches. Cumbersome workarounds, chosen for some personal reasons, are unacceptable in the creation of such codes.

One of the most important principles of software engineering is the ability to constantly update the product, which is laid down at the initial design stage. Applications are expanded because users need new features and want even more usability.

Every single piece of software is of little use. The usefulness of software comes at the moment when its components interact with each other, when they exchange data and produce the desired result.

All of this must be taken into account when designing software. What events will they track? What messages will they exchange with the user? How will the authorization be organized?

Another characteristic of quality programs is the cleanliness of the code, not the number of tests or the number of coverage reports. A simple check: can this code be read by another engineer? Or even simpler: will I, as the author of this code, be able to read it after some time has passed?

Readability of the code is very important. Unfortunately, there are no good metrics of code cleanliness yet. Templates and design methodologies sometimes help, but they are not enough. Literate software engineers rely on their experience and intuition, forming a flair for code cleanliness. One can compare it to the talent of a writer: a huge vocabulary is still no guarantee that you can write a coherent and understandable text.

Programs require debugging. Good software makes this easy and simple. When errors occur in programs, clear messages are generated and on the basis of these messages a single error log is kept for further analysis with assigning people responsible for fixing them. When the next error report comes, the specialist has to fix it and get the software working again.

To do this he must have access into the bowels of the system to catch the occurrence of this situation at any time, and be able to verify the results of any part of the system.

When software engineers develop their systems, they make sure to test them under the most incredible conditions – on computing hardware with different resources, anywhere in the world, on all types of screens. For example, if you develop a browser-based application, it must work in all browsers.

When developing software, engineers try to anticipate all eventualities and test them. First, the application is tested in normal mode, without any incidents (happy path), and then the testing of possible failures and errors is performed. Sometimes programmers write code to simulate these problematic situations, and then write basic code that successfully passes the test mode.

Software engineers understand that software requirements are often vague and incomplete. A talented engineer needs to know not how to write a solution, but what should go into it.

What is the difference between a software engineer and a programmer when creating a product?

Good software engineers work quickly and efficiently, but they demand a decent fee. Think a hundred times before you try to save money by hiring experienced programmers. The more competent specialists you hire, the faster you will get solutions to all problems, done accurately and reliably, stable and easy to maintain. And in the not too distant future your overall costs will be significantly reduced.

Each program uses computer resources that cost money. The efficiency of a software engineer is that the programs he writes will use these resources very sparingly. For example, one of the ways is to enable caching for frequently used data. Besides, there are thousands of various tools helping to accelerate the programs’ execution and improve their efficiency.

A novice programmer can solve the task, but his program will cost much more than the efficient software of an experienced programmer.

The matter is that good software products are initially designed in terms of user experience (UX). With the advent of modern computing technology a lot of studies and discoveries on the topic of human-computer interaction have been made. And the more information that can be obtained, the better applications can be created.

Let’s look at a few examples on the importance of usability:

• If an email address entry form is being developed, a good program will ignore letter cases and even spaces around the edges. The user should not have to watch for the CapsLock key, the program already knows that the email consists only of uppercase letters. New addresses should be checked to make sure they are correct, and if they are wrong the user is informed right away. This can be an obvious check for the “@” symbol, or a less obvious error, such as “gmail.cmo”.
• If the user has to click on a link in order to get the result, a good program will remember where he went from, and after the action is completed, it will return him back. Also, a good program will remember the data already entered and the actions performed, if the user needs them later. For example, you entered Expedia as a guest and looking for the necessary flight, but then decided to create an account. The program will save your previous search history in it so that you can view it when you login from different devices.
• A good program is designed with the user in mind. Put yourself in the user’s shoes rather than just throwing in extra features.

The most important features of applications that can distinguish the work of a professional from that of an amateur are software engineering processes such as reliability, security, and safety. Experienced programmers are well aware that all the solutions they write must first and foremost be safe and secure.

The application must also be resistant to incorrect data entry, bad interaction methods, and bad states. Achieving this is not just difficult, but very difficult.

Users have and will continue to enter bad or erroneous data, some inadvertently and some deliberately, trying to hack into the program and get at the resources it represents. The person blamed for Equifax’s recent failure has accused the company of failing to provide protection against erroneous and malicious data entry throughout its public software.

There is also a security problem with entering the correct data. Users often forget their passwords – how many attempts can they use? Does the program block users if they never remember their password?

And if someone else tries to block them? Does your program allow you to enter passwords on an unencrypted connection? What if the user is logging in from an IP address that is unusual for that user? What should the program do if it looks like a robot?

How do you protect your customers from cross-site scripting and fake requests, man-in-the-middle attacks and simple social phishing? Have you provided in the program what to do if DDoS attacks on your servers suddenly began? These are just a small part of the application security challenges you have to address.

Damaged or corrupted software must be recovered – it happens to the best systems too. If you don’t think about this and prepare for a bad scenario, then you are not working in software engineering, you are just making insecure programs.

Sometimes errors in a program remain invisible – our brain is just not able to foresee and correct all the possible defects. That is why experienced software engineers are well aware of the value of the tools that help them write stable and safe software.

Basic Standards in Software Engineering

Over time, the main areas of software engineering have been systematized and brought under a single international standard that covers and regulates almost all processes occurring in complex systems. For each project, taking into account its features and technical characteristics, it is always possible to select standard procedures that regulate the necessary processes.

On their basis, standard profiles for similar types of projects and/or enterprises are formed. The production of software products has long been put on an industrial basis due to the fact that the processes of standardization and certification are also firmly entrenched in software engineering.

The best known international software engineering standards are:

• ISO/IEC 12207 – Information Technology (Software Life Cycle Processes). Processes that occur during the operation of software tools. The standard includes definitions of basic concepts such as software product and software product life cycle.
• SEI CMM – Capability Maturity Model (for Software). A model of degree of professionalism in software development. The standard provides information about what the level of professionalism in software development should be.
• PMBOK – Project Management Body of Knowledge. A standard for project management.
• SWEBOK – Software Engineering Body of Knowledge. SWEBOK is a standard for software engineering. It consists of descriptions of directions by sections (fields of knowledge) of software engineering.
• ACM/IEEE CC2001 – Computing Curricula 2001. An academic educational standard for computer science. It includes four main sections: Computer science, Computer engineering, Software engineering and Information systems, each of which defines areas of knowledge, composition and plans of recommended courses.

Today, an expanded version of software engineering standards is being developed as part of the SWEBOK standard, with fifteen areas of focus:

• Software Requirements – software requirements.
• Software Design – Software design.
• Software Construction – Designing the software.
• Software Testing is the testing of the software.
• Software Maintenance is the maintenance of the software.
• Software Configuration Management – Software Configuration Management.
• Software Engineering Management – information technology project management.
• Software Engineering Process – software engineering process.
• Software Engineering Models and Methods – software development models and methods.
• Software Engineering Professional Practice – a description of the professionalism and competence criteria of a software developer.
• Software Quality – quality of software.
• Software Engineering Economics – economic issues of software development.
• Computing Foundations – Basics of computing technologies that are used in software development.
• Mathematical Foundations – Basic mathematical laws and concepts that are used in software development.
• Engineering Foundations – Basic concepts of engineering.

Software Engineering Tools

Software tools support software workflow processes. They automate simple, repetitive activities that remove routine work from the engineer and allow him or her to concentrate on the creative implementation of the processes. Often such tools are designed to support specific (private) software engineering technologies, reducing the administrative burden associated with their manual application.

CASE (Computer-Aided Software Engineering) is a set of software engineering tools and techniques for software design. Programs created with this set are of high quality, free of errors, very simple and easy to maintain.

Software Engineering Tools (CASE):

1. Software Requirements Tools – create and verify the software design.
2. Software Design Tools – create and verify software design. (SADT/IDEF, UML, BPMN/BPEL, Microsoft DSL, etc.)
3. Software Construction Tools fully correspond to SWEBOK’s concept of “construction”. They are needed in the process of producing and communicating a program text (e.g., source code) prepared for machine execution.
   • Program editors (program editors). These are needed to create and modify programs and their documentation.
   • Compilers and code generators. Non-interactive (command-line) translators of the source code. This class includes compilers and editors in integrated programming environments, as well as text processors, linkers/loaders and code generators that automatically create application source code.
   • Interpreters. They are often combined with compilers and code generators to prepare the source code for execution.
   • Debuggers. These tools are also involved in the software design process, their task is to catch errors.
4. Software Testing Tools.
   • Test generators (test generators). They help to develop test scenarios.
   • Test execution frameworks. With their help a controlled environment is created, which is necessary for test scenarios execution, where behavior of tested objects is tracked.
   • Test evaluation tools. They support test results evaluation – they help define to what extent and where exactly detected object behavior corresponds to expected behavior.
   • Test management tools.
   • Performance analysis tools.
5. Software Maintenance Tools. A very important set of tools that provide maintenance for modifiable software created.
   • Comprehension tools (comprehension tools). Working with them helps one understand how the program works. As an example, we can consider various visualization tools.
   • Reengineering tools. These tools help to perform reengineering described in the SWEBOK “Software Maintenance” standard.
6. Software Configuration Management Tools. They fall into three categories:
   • Tools for tracking bugs, extensions and problems.
   • Tools for managing different versions.
   • Build and release tools. These manage the tasks of building and releasing products and also include installation tools.Software Configuration Management Tools. They fall into three categories:

1. Software engineering and information technology management tools fall into three categories:
   • Tools for planning and tracking projects.
   • Tools to manage risks.
   • Quantitative assessment tools.
2. Software Engineering Process Tools:
   • Software modeling tools.
   • Software project management tools.
   • Configuration management tools that ensure the operation of actual versions of the whole set of project components.
   • Role-based software development platforms that cover all stages of the software life cycle and are the next stage in the development of integrated development tools and CASE tools in terms of supporting “related” activities – requirements management, configuration management activities with change management support, testing and quality assessment.
3. Software Quality Tools. The tools fall into two categories:
   • Inspection tools. Used to support software review and audit.
   • (Static) analysis tools. These tools are used to analyze software blocks, data, jobs performed and dependencies.