Software Engineering

Recently, my friend started Freelancing (about content writing). The very first work was to write a blog about Software Engineering we both combinedly did some research and the outcome is

What is Software Engineering?

Software: Directly using it and driving force to deliver the product.

Engineering: It is the process to build things.

-> By observing both the definitions one can conclude that it is the systematic application of the engineering approach to the development of software. And engineering is the process to build things.

Technical definition: It is the logical thing and we cannot see the code of it.

To do a project?

One should identify the domain, problem statement; clarifying the objective of the project to make a plan; collecting requirements; Making a block diagram( rough structure); implementing- code and debugging; Testing product after completion Systematically doing all these things is nothing but Software Engineering.

Generally, Software Engineering has four phases:

1. Software Engineering

The things which come under this category are:

The nature of the software to be used, The Software process to be followed, Engineering practice which is to be implemented, Defining the framework activity, Identifying the task set, Extracting the patterns of the process, Assessing the process, and improving them to satisfy our need. There are main Process Models, some of them are Prescriptive process models, Specialized process models, The Unified process, Personal and Team Process models.

Agility: Highly dynamic software should also be handled properly.

There are some Agile Models also which can be implemented based on the requirements like Agility and cost of change, Agile process, Extreme programming, CMMI, Agile Manifesto, Pass on the secret session, Waterfall model session.

To do this perfectly, one should

a. Know about building software projects using different process models. b. Know how to implement an agile software process model.

1. Requirement Engineering:

All the groundwork should be done in this phase. Like gathering requirements they can be speaking with the client about his use cases and then identifying the required software to achieve the client's demand. To achieve them one should develop Use cases for the problem, Building the analysis model here the main aim is to analyze the problem statement, figuring out the goods and flaws in the statement, and again contacting the client to improve them. After analyzing the problem one should Negotiate and validate requirements. After gathering all the needs to fulfill the client's demands then we come to the main and very important phase that is Software Project Estimation. This the main important phase as this defines whether the client stays with you or leaves you. One should always reduce the cost of the project, because there are a lot more other factors contributing to the process like using resources of the factory, breakages during the process, etc.

Software project estimation comprises various things like project planning, gathering resources, checking decomposition techniques, Empirical estimation models, estimation for oo projects. After successful estimation of the Software project, one should identify Requirement Modeling. This is nothing but using the gathered resources to the utmost level for satisfying the client's requirements. Scenario-based methods, class-based methods, creating a behavioral model, identifying the events with use cases, state representations, are some methods used to satisfy requirements. Irrespective of them there are other concepts like Cause effect session, project inception, collaboration with the customer, speed boat session are also some of the important phases in Requirement Engineering.

To implement this perfectly, one should :

a. Know how to dramatize activities involved in the analysis of requirements. b. Correctly estimate LOC( lines of code) and FP( function points) based efforts in persons and months. c. Know how to design use case, data, class, and behavioral models of the software.

1. Design Engineering: Designing is the utmost important step in Software Engineering. This is the step where we design the already existing software or a developed software to our needs. Here Design with the context of software engineering is a very important task. One should keep in the mind design process, design concepts, and design model. Generally, design i.e, having a rough sketch of the work should be done more precisely than doing the work itself. Because, if there is a problem in the base of the project then the entire project will be a problem and that is very difficult to rectify as the time taken to complete the project and the budget increases rapidly. Architecture Design plays a key role in Design Engineering. It comprises software architecture, architectural genres, architectural styles, architectural considerations, architectural decisions, and a lot more. Other than them it also has a representing system in the context, defining the archetypes, refining the architecture into components, and also describing the instantiations of the system. Component Design which is an integral part of architecture design is like the heart of the entire software development model. One should take a lot of care in designing the components. This design can be done in many ways. Some of them are traditional, object-oriented, process-related views of the components, designing class-based components, conducting component level design, and component-based development. After designing the components next task is to design the user interface. It should be very minimalistic and also understandable by almost everyone on how to operate it. The user interface is the one that is seen by everyone. So, it should be clean without any errors.

To design a User Interface, one should keep the following in mind. They are the golden rules, analyzing the user interface, design how to analyze the interface, design steps, and the last and not least one is design evaluation.

For the perfect implementation of this, one should:

a. Correctly illustrating architectural and component models. b. Know how to create effective user interfaces.

1. Testing:

This is the place where the code is tested and debugged. This state should be handled very carefully as some small mistakes lead to huge errors. It can be a problem for the client or sometimes it can be the biggest problem for the company. Normally this state is performed by the highly intelligent people in the country. Though this is the least time spent state compared to all three it is also the most important state. So, to test a software there are many pre-defined methods and one should choose any one of them based on their requirements. Testing comprises testing the strategies, discussing the approach of the strategy, issues related to strategies, testing strategies for conventional and object-oriented software, checking the validation of testing, testing the system, and also checking the debugging state. As mentioned above Conventional Testing can be done by testing the white box, basis path testing, testing the control structure, model-based testing, and testing the real-time systems. Object-Oriented (OO) Testing can be done by testing OOA and OOD models, OO testing strategies, understanding OO testing methods, testing methods applicable at class level, identifying interclass test case design.

To implement testing of software correctly, one should:

a. Know how to test code based on functional and non-functional aspects of the software. b. Able to prepare test plans and strategies for conventional and Object-Oriented software.

To do all these above mentioned four things perfectly, The following things should be handled perfectly:

a. Select an appropriate process model for software product requests. b. Implement agile software process models for a given scenario. c. Identify the stakeholder's requirements and employ the models for analyzing their requirements. d. Estimate software cost and efforts in person and months. e. Construct use cases, activity, collaboration, and state transition diagrams that map software requirements. f. Design architecture for developing a project based on user requirements. g. Create test plans and employ testing strategies for verifying functional and non-functional requirements of the project.

By following the above-mentioned properties correctly one can successfully design software and can implement them effectively. So, One should go through all these things before entering into Software Engineering (tip for newbies).