What is software engineering? History and its Characteristics

Soft­ware engi­neer­ing is a branch of engi­neer­ing con­cerned with the cre­ation of soft­ware prod­ucts based on well-defined sci­en­tif­ic prin­ci­ples, meth­ods, and procedures. 

• Save

The end result of soft­ware engi­neer­ing is a reli­able and effi­cient soft­ware prod­uct. Basi­cal­ly, Soft­ware is a com­bi­na­tion of Pro­gram + Doc­u­men­ta­tion + Oper­at­ing Pro­ce­dure. A pro­gram is a set of instruc­tions that run simul­ta­ne­ous­ly. Doc­u­men­ta­tion helps to know all the aspects of a soft­ware mod­el. Oper­at­ing pro­ce­dure Con­sist User Man­u­als and Oper­a­tional man­u­als. The user man­u­als include a sys­tem overview, a begin­ner’s guide, a tuto­r­i­al, and a ref­er­ence guide.Installation Guide and Sys­tem Admin­is­tra­tor Guide are exam­ples of oper­a­tional manuals.

• 

  • Save
  Work­ing with the BIOS/CMOS
• 

  • Save
  Work­ing with Portable PCs
• 

  • Save
  Wire­less Com­mu­ni­ca­tion & Secu­ri­ty Threats : Def­i­n­i­tion, Types

Brief History

Begin­ning in the 1960s, soft­ware engi­neer­ing was regard­ed as a dis­tinct branch of engi­neer­ing. Fur­ther­more, the advance­ment of soft­ware engi­neer­ing was viewed as a chal­lenge. It was dif­fi­cult for soft­ware engi­neers to keep up with the hard­ware, which caused numer­ous prob­lems. Prob­lems includ­ed soft­ware that was over bud­get, missed dead­lines, neces­si­tat­ed exten­sive debug­ging and main­te­nance, failed to meet the needs of con­sumers, or was nev­er com­plet­ed at all. NATO held the first Soft­ware Engi­neer­ing con­fer­ence in 1968, where soft­ware issues were addressed and guide­lines and best prac­tices for soft­ware devel­op­ment were established.

Why is software engineering required ?

Soft­ware engi­neer­ing is required to get effi­cient work with less hard­ware and To man­age large amounts of software

For greater scal­a­bil­i­ty, Man­age­ment of Costs

For bet­ter qual­i­ty man­age­ment, man­age the dynam­ic nature of software.

14 Characteristics of a good software

There are numer­ous char­ac­ters in good soft­ware. Among them are the following.

1. Cor­rect­ness : The impor­tance of cor­rect­ness in soft­ware can­not be over­stat­ed. There must be no flaws in the spec­i­fi­ca­tion, design, or implementation.
2. Usabil­i­ty : A sys­tem should be sim­ple for users to learn and use.
3. Effi­cien­cy : The few­er resources that a piece of soft­ware con­sumes, the bet­ter. Proces­sor, mem­o­ry, and disc space usage should be kept to a minimum.
4. Reli­a­bil­i­ty : It is crit­i­cal to have a sys­tem that can per­form the required func­tions con­sis­tent­ly. Fail­ures should occur as infre­quent­ly as possible.
5. Integri­ty : Con­sid­er­a­tion should be giv­en to secu­ri­ty. Our soft­ware should allow attack­ers to gain unau­tho­rised access to resources. Data val­i­da­tion is also nec­es­sary to ensure that incor­rect data is not saved into the system.
6. Adapt­abil­i­ty : It’s prefer­able to have a sys­tem that can be used in a vari­ety of sit­u­a­tions with­out need­ing to be modified.
7. Accu­ra­cy : Its out­puts are fair­ly accu­rate. This deter­mines whether the soft­ware pro­duces the desired results for users.
8. Robust­ness : If a sys­tem con­tin­ues to func­tion despite invalid inputs and stress­ful envi­ron­men­tal con­di­tions, it is a good sign for our system.
9. Main­tain­abil­i­ty : The ease with which an exist­ing sys­tem can be mod­i­fied is crit­i­cal. The eas­i­er it is for us to make changes, the better.
10. Porta­bil­i­ty : It is a good sys­tem if it can oper­ate in envi­ron­ments oth­er than the one for which it was orig­i­nal­ly designed.
11. Reusabil­i­ty : The more reusable com­po­nents a piece of soft­ware con­tains, the bet­ter. We don’t have to start from scratch when we use reusable parts.
12. Read­abil­i­ty : It is sim­ple to change code that is easy to read. We can make changes faster and with few­er errors if we under­stand them better.
13. Testa­bil­i­ty : It is crit­i­cal that our soft­ware sys­tem be testable. If our code is sim­ple to unit test, that’s a good thing.
14. Under­stand­abil­i­ty : It is crit­i­cal for us to be able to under­stand our sys­tem from a glob­al per­spec­tive as well as at the detailed code level.