Unit I: Introduction of Software Engineering - Software Engineering - BCA Notes (Pokhara University)

Breaking

Friday, August 30, 2019

Unit I: Introduction of Software Engineering - Software Engineering

History of Software Engineering:

The term software engineering first appeared in the late 1950’s and early 1960’s. Programs might have always known about civil, electrical and computer engineering and debated what engineering might mean for software. 
Introduction of software engineering, History of software engineering, Importance of Software Engineering, Role of software engineering Software Development, Software Development is a Layered Technology, Software Development Model, Waterfall Model,  RAD (Rapid Application Development) Model,  Spiral Model, V-Model, Incremental Model, Agile Model, Iterative Model, Big Bang Model, Prototype Model, Evolutionary Process Model, Attribute of good software, Different between software engineering and system Engineering, Some challenges of software Engineering, Software Engineering Ethics

The NATO science committee sponsored two conferences on software engineering in 1968 and 1969 and many believe these conferences marked the official start of the profession of software engineering. The term software engineering gets importance after the software crisis from 1965 to 1985.

Before the 1960s, different individual proposed different solutions to problems like some would suggest problems in the management team, some team organization while some would argue for better languages and tools. Based on these facts, it was required to apply the engineering approaches for management, team organization, tools, theories, methodology and techniques implemented which finally gave rise to software engineering.

Introduction of Software Engineering:

Software engineering encompasses a process, a collection of methods (practices) and an array of tools that allows professionals to build high-quality computer software. Software engineering is the application of a systematic, disciplined, quantifiable approach to the development, operation and maintenance of software and study of these applications of engineering to software. Software engineering is important because it enables us to build complex systems in a timely manner and with high quality. 
Introduction of software engineering, History of software engineering, Importance of Software Engineering, Role of software engineering Software Development, Software Development is a Layered Technology, Software Development Model, Waterfall Model,  RAD (Rapid Application Development) Model,  Spiral Model, V-Model, Incremental Model, Agile Model, Iterative Model, Big Bang Model, Prototype Model, Evolutionary Process Model, Attribute of good software, Different between software engineering and system Engineering, Some challenges of software Engineering, Software Engineering Ethics

Importance of Software Engineering:

Introduction of software engineering, History of software engineering, Importance of Software Engineering, Role of software engineering Software Development, Software Development is a Layered Technology, Software Development Model, Waterfall Model,  RAD (Rapid Application Development) Model,  Spiral Model, V-Model, Incremental Model, Agile Model, Iterative Model, Big Bang Model, Prototype Model, Evolutionary Process Model, Attribute of good software, Different between software engineering and system Engineering, Some challenges of software Engineering, Software Engineering Ethics

1. Reduces Complexity:

Big software is always complicated and challenging to progress. Software engineering has a great solution to reduce the complication of any project. Software engineering divides big problems into various small issues. And then start solving each small issue one by one. All these small problems are solved independently to each other.

2. Minimize Software Cost:

The software needs a lot of hard work and software engineers are highly paid experts. A lot of manpower is required to develop software with a large number of codes. But in software engineering, programmers project everything and decrease all those things that are not needed. In turn, the cost for software productions becomes less as compared to any software that does not use software engineering method.

3. Decrease Time:

Anything that is not made according to the project always wastes time. And if we are making great software, then we may need to run many codes to get the definitive running code. This is a very time-consuming procedure, and if it is not well handled, then this can take a lot of time. So if we are making our software according to the software engineering method, then it will decrease a lot of time.

4. Handling Big Projects:

Big projects are not done in a couple of days, and they need lots of patience, planning, and management. And to invest six and seven months of any company, it requires heaps of planning, direction, testing, and maintenance. No one can say that they have given four months of a company to the task, and the project is still in its first stage. Because the company has provided many resources to the plan and it should be completed. So to handle a big project without any problem, the company has to go for a software engineering method.

5. Reliable Software:

The software should be secure, means if we have delivered the software, then it should work for at least it’s given time or subscription. And if any bugs come in the software, the company is responsible for solving all these bugs. Because in software engineering, testing and maintenance are given, so there is no worry of its reliability.

6. Effectiveness:

Effectiveness comes if anything has made according to the standards. Software standards are the big target of companies to make it more effective. So Software becomes more effective in the act with the help of software engineering.

Role of Software Engineering:

Introduction of software engineering, History of software engineering, Importance of Software Engineering, Role of software engineering Software Development, Software Development is a Layered Technology, Software Development Model, Waterfall Model,  RAD (Rapid Application Development) Model,  Spiral Model, V-Model, Incremental Model, Agile Model, Iterative Model, Big Bang Model, Prototype Model, Evolutionary Process Model, Attribute of good software, Different between software engineering and system Engineering, Some challenges of software Engineering, Software Engineering Ethics

1. Confer with systems analysts, engineers, programmers and others to design system and to obtain information on project limitations and capabilities, performance requirements and interfaces.

2. Modify existing software to correct errors, allow it to adapt to new hardware, or to improve its performance.

3. Analyze user needs and software requirements to determine the feasibility of design within time and cost constraints.

4. Consult with customers about software system design and maintenance.

5. Coordinate software system installation and monitor equipment functioning to ensure specifications are met.

6. Design, develop and modify software systems, using scientific analysis and mathematical models to predict and measure outcome and consequences of design.

7. Develop and direct software system testing and validation procedures, programming, and documentation.

8. Analyze information to determine, recommend, and plan computer specifications and layouts, and peripheral equipment modifications.

Software Developments:

Software development is the process of developing software through successive phases in an orderly way. This process includes not only the actual writing of code but also the preparation of requirements and objectives the design of what is to be coded and confirmation that what is developed has met objectives.

The complexity of modern systems and computer programs made the need for a clear and orderly development process for the software. The orderly phases are:
Introduction of software engineering, History of software engineering, Importance of Software Engineering, Role of software engineering Software Development, Software Development is a Layered Technology, Software Development Model, Waterfall Model,  RAD (Rapid Application Development) Model,  Spiral Model, V-Model, Incremental Model, Agile Model, Iterative Model, Big Bang Model, Prototype Model, Evolutionary Process Model, Attribute of good software, Different between software engineering and system Engineering, Some challenges of software Engineering, Software Engineering Ethics

Software Development is a Layered Technology:

Software development is totally a layered technology. That means, to develop software one will have to go from one layer to another. The layers are related and each layer demands the fulfilment of the previous layer. The figure below is the upward flowchart of the layers of software development.
Introduction of software engineering, History of software engineering, Importance of Software Engineering, Role of software engineering Software Development, Software Development is a Layered Technology, Software Development Model, Waterfall Model,  RAD (Rapid Application Development) Model,  Spiral Model, V-Model, Incremental Model, Agile Model, Iterative Model, Big Bang Model, Prototype Model, Evolutionary Process Model, Attribute of good software, Different between software engineering and system Engineering, Some challenges of software Engineering, Software Engineering Ethics

1. A Quality Focus:

Software engineering must rest on an organizational commitment to quality. Total quality management and similar philosophies foster a continuous process improvement culture and this culture ultimately leads to the development of increasingly more mature approaches to software engineering. The bedrock that supports software engineering is a quality focus.

2. Process:

The foundation for software engineering is the process layer. The process defines a framework for a set of Key Process Areas (KPAs) that must be established for the effective delivery of software engineering technology. This establishes the context in which technical methods are applied, work products such as models, documents, data, reports, forms, etc. are produced, milestones are established, quality is ensured, and change is properly managed.

3. Methods:

Software engineering methods provide the technical how-to for building software. Methods will include requirements analysis, design, program construction, testing, and support. This relies on a set of basic principles that govern each area of the technology and include modelling activities and other descriptive techniques.

4. Tools:

Software engineering tools provide automated or semi-automated support for the process and the methods. When tools are integrated so that information created by one tool can be used by another, a system for the support of software development called computer-aided software engineering is established.

Software Development Model:

1. Waterfall Model:

Winston Royce introduced the Waterfall Model in 1970. This model has five phases: Requirements analysis and specification, design, implementation, and unit testing, integration and system testing, and operation and maintenance. The steps always follow in this order and do not overlap. The developer must complete every phase before the next phase begins. This model is named the Waterfall Model because its diagrammatic representation resembles a cascade of waterfalls.
Introduction of software engineering, History of software engineering, Importance of Software Engineering, Role of software engineering Software Development, Software Development is a Layered Technology, Software Development Model, Waterfall Model,  RAD (Rapid Application Development) Model,  Spiral Model, V-Model, Incremental Model, Agile Model, Iterative Model, Big Bang Model, Prototype Model, Evolutionary Process Model, Attribute of good software, Different between software engineering and system Engineering, Some challenges of software Engineering, Software Engineering Ethics

Various Phases Of Waterfall Model Are As Follows:

1. Requirements Analysis And Specification Phase:
The aim of this phase is to understand the exact requirements of the customer and to document them properly. Both the customer and the software developer work together so as to document all the functions, performance, and interfacing requirement of the software. It describes the "what" of the system to be produced and not "how." In this phase, a large document called Software Requirement Specification (SRS) document is created which contained a detailed description of what the system will do in the common language.

2. Design Phase:
This phase aims to transform the requirements gathered in the SRS into a suitable form which permits further coding in a programming language. It defines the overall software architecture together with high level and detailed design. All this work is documented as a Software Design Document (SDD).

3. Implementation And Unit Testing:
During this phase, the design is implemented. If the SDD is complete, the implementation or coding phase proceeds smoothly, because all the information needed by software developers is contained in the SDD.

During testing, the code is thoroughly examined and modified. Small modules are tested in isolation initially. After that, these modules are tested by writing some overhead code to check the interaction between these modules and the flow of intermediate output.

4. Integration and System Testing:
This phase is highly crucial as the quality of the end product is determined by the effectiveness of the testing carried out. The better output will lead to satisfied customers, lower maintenance costs, and accurate results. Unit testing determines the efficiency of individual modules. However, in this phase, the modules are tested for their interactions with each other and with the system.

5. Operation And Maintenance Phase:
Maintenance is the task performed by every user once the software has been delivered to the customer, installed, and operational.

When to use SDLC Waterfall Model?

Some Circumstances where the use of the Waterfall model is most suited are:
a) When the requirements are constant and not changed regularly.
b) A project is short.
c) The situation is calm.
d) Where the tools and technology used is consistent and is not changing.
e) When resources are well prepared and are available to use.

Advantages of Waterfall Model:

a) This model is simple to implement also the number of resources that are required for it is minimal.
b) The requirements are simple and explicitly declared; they remain unchanged during the entire project development.
c)  The start and endpoints for each phase are fixed, which makes it easy to cover progress.
d) The release date for the complete product, as well as its final cost, can be determined before development.
e) It gives easy to control and clarity for the customer due to a strict reporting system.

Disadvantages of Waterfall Model:

a) In this model, the risk factor is higher, so this model is not suitable for more significant and complex projects.
b) This model cannot accept the changes in requirements during development.
c) It becomes tough to go back to the phase. For example, if the application has now shifted to the coding phase, and there is a change in requirement, it becomes tough to go back and change it.
d) Since the testing done at a later stage, it does not allow identifying the challenges and risks in the earlier phase, so the risk reduction strategy is difficult to prepare.

2. RAD (Rapid Application Development) Model:

RAD is a linear sequential software development a process model that emphasizes a concise development cycle using an element based construction approach. If the requirements are well understood and described, and the project scope is a constraint, the RAD process enables a development team to create a fully functional system within a concise time period.

RAD (Rapid Application Development) is a concept that products can be developed faster and of higher quality through:
a) Gathering requirements using workshops or focus groups.
b) Prototyping and early, reiterative user testing of designs.
c) The re-use of software components.
d) A rigidly paced schedule that refers to design improvements to the next product version.
e) Less formality in reviews and other team communication.

Introduction of software engineering, History of software engineering, Importance of Software Engineering, Role of software engineering Software Development, Software Development is a Layered Technology, Software Development Model, Waterfall Model,  RAD (Rapid Application Development) Model,  Spiral Model, V-Model, Incremental Model, Agile Model, Iterative Model, Big Bang Model, Prototype Model, Evolutionary Process Model, Attribute of good software, Different between software engineering and system Engineering, Some challenges of software Engineering, Software Engineering Ethics

Various Phases Of RAD Are As Follows:

1. Business Modelling:
The information flow among business functions is defined by answering questions like what data drives the business process, what data is generated, who generates it, where does the information go, who process it and so on.

2. Data Modelling:
The data collected from business modelling is refined into a set of data objects (entities) that are needed to support the business. The attributes (character of each entity) are identified, and the relation between these data objects (entities) is defined.

3. Process Modelling:
The information object defined in the data modelling phase are transformed to achieve the data flow necessary to implement a business function. Processing descriptions are created for adding, modifying, deleting, or retrieving a data object.

4. Application Generation:
Automated tools are used to facilitate the construction of the software; even they use the 4th GL techniques.

5. Testing & Turnover:
Many of the programming components have already been tested since RAD emphasis reuse. This reduces the overall testing time. But the new part must be tested, and all interfaces must be fully exercised.

When to use RAD Model?

a) When the system should need to create the project that modularizes in a short span time (2-3 months).
b) When the requirements are well-known.
c) When the technical risk is limited.
d) When there's a necessity to make a system, which modularized in 2-3 months of period.
e) It should be used only if the budget allows the use of automatic code generating tools.

Advantage of RAD Model:

a) This model is flexible for change.
b) In this model, changes are adaptable.
c) Each phase in RAD brings highest priority functionality to the customer.
d) It reduced development time.
e) It increases the reusability of features.

Disadvantage of RAD Model:

a) It required highly skilled designers.
b) All application is not compatible with RAD.
c) For smaller projects, we cannot use the RAD model.
d) On the high technical risk, it's not suitable.
e) Required user involvement.

3. Spiral Model:

The spiral model, initially proposed by Boehm, is an evolutionary software process model that couples the iterative feature of prototyping with the controlled and systematic aspects of the linear sequential model. It implements the potential for rapid development of new versions of the software. Using the spiral model, the software is developed in a series of incremental releases. During the early iterations, the additional release may be a paper model or prototype. During later iterations, more and more complete versions of the engineered system are produced.
Introduction of software engineering, History of software engineering, Importance of Software Engineering, Role of software engineering Software Development, Software Development is a Layered Technology, Software Development Model, Waterfall Model,  RAD (Rapid Application Development) Model,  Spiral Model, V-Model, Incremental Model, Agile Model, Iterative Model, Big Bang Model, Prototype Model, Evolutionary Process Model, Attribute of good software, Different between software engineering and system Engineering, Some challenges of software Engineering, Software Engineering Ethics

Each Cycle In The Spiral Is Divided Into Four Parts:

1. Objective Setting:
Each cycle in the spiral starts with the identification of purpose for that cycle, the various alternatives that are possible for achieving the targets, and the constraints that exist.

2. Risk Assessment And Reduction:
The next phase in the cycle is to calculate these various alternatives based on the goals and constraints. The focus of evaluation in this stage is located on the risk perception for the project.

3. Development And Validation:
The next phase is to develop strategies that resolve uncertainties and risks. This process may include activities such as benchmarking, simulation, and prototyping.

4. Planning:
Finally, the next step is planned. The project is reviewed, and a choice made whether to continue with a further period of the spiral. If it is determined to keep, plans are drawn up for the next step of the project.

The development phase depends on the remaining risks. For example, if performance or user-interface risks are treated more essential than the program development risks, the next phase may be an evolutionary development that includes developing a more detailed prototype for solving the risks.

The risk-driven feature of the spiral model allows it to accommodate any mixture of a specification-oriented, prototype-oriented, simulation-oriented, or another type of approach. An essential element of the model is that each period of the spiral is completed by a review that includes all the products developed during that cycle, including plans for the next cycle. The spiral model works for development as well as enhancement projects.

When To Use Spiral Model?

a) When deliverance is required to be frequent.
b) When the project is large
c) When requirements are unclear and complex
d) When changes may require at any time
e) Large and high budget projects

Advantages:

a) The high amount of risk analysis.
b) Useful for large and mission-critical projects.

Disadvantages:

a) Can be a costly model to use.
b) Risk analysis needed highly particular expertise.
c) Doesn't work well for smaller projects.

4. V-Model:

V-Model also referred to as the Verification and Validation Model. In this, each phase of SDLC must complete before the next phase starts. It follows a sequential design process same as the waterfall model. Testing of the device is planned in parallel with a corresponding stage of development.
Introduction of software engineering, History of software engineering, Importance of Software Engineering, Role of software engineering Software Development, Software Development is a Layered Technology, Software Development Model, Waterfall Model,  RAD (Rapid Application Development) Model,  Spiral Model, V-Model, Incremental Model, Agile Model, Iterative Model, Big Bang Model, Prototype Model, Evolutionary Process Model, Attribute of good software, Different between software engineering and system Engineering, Some challenges of software Engineering, Software Engineering Ethics

Verification:

It involves a static analysis method (review) done without executing code. It is the process of evaluation of the product development process to find whether specified requirements meet.

Validation:

It involves dynamic analysis method (functional, non-functional), testing is done by executing code. Validation is the process to classify the software after the completion of the development process to determine whether the software meets the customer expectations and requirements.

So V-Model contains Verification phases on one side of the Validation phases on the other side. Verification and Validation process is joined by coding phase in V-shape. Thus it is known as V-Model.

There Are The Various Phases Of Verification Phase Of V-Model:

1. Business Requirement Analysis:
This is the first step where product requirements understood from the customer's side. This phase contains detailed communication to understand customer's expectations and exact requirements.

2. System Design:
In this stage, system engineers analyse and interpret the business of the proposed system by studying the user requirements document.

3. Architecture Design:
The baseline in selecting the architecture is that it should understand all which typically consists of the list of modules, brief the functionality of each module, their interface relationships, dependencies, database tables, architecture diagrams, technology detail, etc. The integration testing model is carried out in a particular phase.

4. Module Design:
In the module design phase, the system breaks down into small modules. The detailed design of the modules is specified, which is known as Low-Level Design.

5. Coding Phase:
After designing, the coding phase is started. Based on the requirements, a suitable programming language is decided. There are some guidelines and standards for coding. Before checking in the repository, the final build is optimized for better performance, and the code goes through many code reviews to check the performance.

There Are The Various Phases Of Validation Phase Of V-Model:

1. Unit Testing:
In the V-Model, Unit Test Plans (UTPs) is developed during the module design phase. These UTPs are executed to eliminate errors at the code level or unit level. A unit is the smallest entity which can independently exist, e.g., a program module. Unit testing verifies that the smallest entity can function correctly when isolated from the rest of the codes/ units.

2. Integration Testing:
Integration Test Plans are developed during the Architectural Design Phase. These tests verify that groups created and tested independently can coexist and communicate among themselves.

3. System Testing:
System Tests Plans are developed during System Design Phase. Unlike Unit and Integration Test Plans, System Tests Plans are composed by the client's business team. System Test ensures that expectations from an application developer are met.

4. Acceptance Testing:
Acceptance testing is related to the business requirement analysis part. It includes testing the software product in user atmosphere. Acceptance tests reveal the compatibility problems with the different systems, which is available within the user atmosphere. It conjointly discovers the non-functional problems like load and performance defects within the real user atmosphere.

When To Use V-Model?

a) When the requirement is well defined and not ambiguous.
b) The V-shaped model should be used for small to medium-sized projects where requirements are clearly defined and fixed.
c) The V-shaped model should be chosen when sample technical resources are available with essential technical expertise.

Advantage (Pros) of V-Model:

a) Easy to Understand.
b) Testing Methods like planning, test designing happens well before coding.
c) This saves a lot of time. Hence a higher chance of success over the waterfall model.
d) Avoids the downward flow of the defects.
e) Works well for small plans where requirements are easily understood.

Disadvantage (Cons) of V-Model:

a) Very rigid and least flexible.
b) Not a good for a complex project.
c) Software is developed during the implementation stage, so no early prototypes of the software are produced.
d) If any changes happen in the midway, then the test documents along with the required documents have to be updated.

5. Incremental Model:

Incremental Model is a process of software development where requirements divided into multiple standalone modules of the software development cycle. In this model, each module goes through the requirements, design, implementation and testing phases. Every subsequent release of the module adds function to the previous release. The process continues until the complete system achieved.
Introduction of software engineering, History of software engineering, Importance of Software Engineering, Role of software engineering Software Development, Software Development is a Layered Technology, Software Development Model, Waterfall Model,  RAD (Rapid Application Development) Model,  Spiral Model, V-Model, Incremental Model, Agile Model, Iterative Model, Big Bang Model, Prototype Model, Evolutionary Process Model, Attribute of good software, Different between software engineering and system Engineering, Some challenges of software Engineering, Software Engineering Ethics

Various Phases Of Incremental Model Are As Follows:

1. Requirement Analysis:
In the first phase of the incremental model, the product analysis expertise identifies the requirements. And the system functional requirements are understood by the requirement analysis team. To develop the software under the incremental model, this phase performs a crucial role.

2. Design & Development:
In this phase of the Incremental model of SDLC, the design of the system functionality and the development method are finished with success. When software develops new practicality, the incremental model uses style and development phase.

3. Testing:
In the incremental model, the testing phase checks the performance of each existing function as well as additional functionality. In the testing phase, the various methods are used to test the behaviour of each task.

4. Implementation:
Implementation phase enables the coding phase of the development system. It involves the final coding that design in the designing and development phase and tests the functionality in the testing phase. After completion of this phase, the number of the product working is enhanced and upgraded up to the final system product.

When To Use The Incremental Model?

a) When the requirements are superior.
b) A project has a lengthy development schedule.
c) When Software team are not very well skilled or trained.
d) When the customer demands a quick release of the product.
e) We can develop prioritized requirements first.

Advantage of Incremental Model:

a) Errors are easy to be recognized.
b) Easier to test and debug.
c) More flexible.
d) Simple to manage risk because it handled during its iteration.
e) The Client gets important functionality early.

Disadvantage of Incremental Model:

a) Need for good planning.
b) Total Cost is high.
c) Well defined module interfaces are needed.

6. Agile Model:

The meaning of Agile is swift or versatile. "Agile process model" refers to a software development approach based on iterative development. Agile methods break tasks into smaller iterations, or parts do not directly involve long term planning. The project scope and requirements are laid down at the beginning of the development process. Plans regarding the number of iterations, the duration and the scope of each iteration is clearly defined in advance.

Each iteration is considered as a short time "frame" in the Agile process model, which typically lasts from one to four weeks. The division of the entire project into smaller parts help to minimize the project risk and to reduce the overall project delivery time requirements. Each iteration involves a team working through a full software development life cycle including planning, requirements analysis, design, coding, and testing before a working product is demonstrated to the client.
Introduction of software engineering, History of software engineering, Importance of Software Engineering, Role of software engineering Software Development, Software Development is a Layered Technology, Software Development Model, Waterfall Model,  RAD (Rapid Application Development) Model,  Spiral Model, V-Model, Incremental Model, Agile Model, Iterative Model, Big Bang Model, Prototype Model, Evolutionary Process Model, Attribute of good software, Different between software engineering and system Engineering, Some challenges of software Engineering, Software Engineering Ethics

Phases of Agile Model:

1. Requirements Gathering:
In this phase, we must define the requirements. We should explain business opportunities and plan the time and effort needed to build the project. Based on this information, we can evaluate technical and economic feasibility.

2. Design The Requirements:
When we have identified the project, work with stakeholders to define requirements. We can use the user flow diagram or the high-level UML diagram to show the work of new features and show how it will apply to our existing system.

3. Construction/ Iteration:
When the team defines the requirements, the work begins. Designers and developers start working on their project, which aims to deploy a working product. The product will undergo various stages of improvement, so it includes simple, minimal functionality.

4. Testing:
In this phase, the Quality Assurance team examines the product's performance and looks for the bug.

5. Deployment:
In this phase, the team issues a product for the user's work environment.

6. Feedback:
After releasing the product, the last step is feedback. In this, the team receives feedback about the product and works through the feedback.

When To Use The Agile Model?

a) When frequent changes are required.
b) When a highly qualified and experienced team is available.
c) When a customer is ready to have a meeting with a software team all the time.
d) When project size is small.

Advantage (Pros) of Agile Method:

a) Frequent Delivery
b) Face-to-Face Communication with clients.
c) Efficient design and fulfils the business requirement.
d) Anytime changes are acceptable.
e) It reduces total development time.

Disadvantages (Cons) of Agile Model:

a) Due to the shortage of formal documents, it creates confusion and crucial decisions taken throughout various phases can be misinterpreted at any time by different team members.
b) Due to the lack of proper documentation, once the project completes and the developers allotted to another project, maintenance of the finished project can become a difficulty.

7. Iterative Model:

In this Model, we can start with some of the software specifications and develop the first version of the software. After the first version if there is a need to change the software, then a new version of the software is created with a new iteration. Every release of the Iterative Model finishes in an exact and fixed period that is called iteration.

The Iterative Model allows the accessing earlier phases, in which the variations made respectively. The final output of the project renewed at the end of the Software Development Life Cycle (SDLC) process.
Introduction of software engineering, History of software engineering, Importance of Software Engineering, Role of software engineering Software Development, Software Development is a Layered Technology, Software Development Model, Waterfall Model,  RAD (Rapid Application Development) Model,  Spiral Model, V-Model, Incremental Model, Agile Model, Iterative Model, Big Bang Model, Prototype Model, Evolutionary Process Model, Attribute of good software, Different between software engineering and system Engineering, Some challenges of software Engineering, Software Engineering Ethics

Various Phases Of Iterative Model Are As Follows:

1. Requirement Gathering & Analysis:
In this phase, requirements are gathered from customers and check by an analyst whether requirements will fulfil or not. Analyst checks that need will achieve within budget or not. After all of this, the software team skips to the next phase.

2. Design:
In the design phase, team design the software by the different diagrams like Data Flow diagram, activity diagram, class diagram, state transition diagram, etc.

3. Implementation:
In the implementation, requirements are written in the coding language and transformed into computer programmes which are called Software.

4. Testing:
After completing the coding phase, software testing starts using different test methods. There are many test methods, but the most common are white box, black box, and grey box test methods.

5. Deployment:
After completing all the phases, the software is deployed to its work environment.

6. Review:
In this phase, after the product deployment, review phase is performed to check the behaviour and validity of the developed product. And if there is any error found then the process starts again from the requirement gathering.

7. Maintenance:
In the maintenance phase, after deployment of the software in the working environment there may be some bugs, some errors or new updates are required. Maintenance involves debugging and new additional options.

When To Use The Iterative Model?

a) When requirements are defined clearly and easy to understand.
b) When the software application is large.
c) When there is a requirement of changes in future.

Advantage (Pros) of Iterative Model:

a) Testing and debugging during smaller iteration is easy.
b) Parallel development can plan.
c) It is easily acceptable to ever-changing needs of the project.
d) Risks are identified and resolved during iteration.
e) Limited time spent on documentation and extra time on designing.

Disadvantage (Cons) of Iterative Model:

a) It is not suitable for smaller projects.
b) More Resources may be required.
c) Design can be changed again and again because of imperfect requirements.
d) Requirement changes can cause over budget.
e) Project completion date not confirmed because of changing requirements.

8. Big Bang Model:

In this model, developers do not follow any specific process. Development begins with the necessary funds and efforts in the form of inputs. And the result may or may not be as per the customer's requirement, because in this model, even the customer requirements are not defined.

This model is ideal for small projects like academic projects or practical projects. One or two developers can work together on this model.
Introduction of software engineering, History of software engineering, Importance of Software Engineering, Role of software engineering Software Development, Software Development is a Layered Technology, Software Development Model, Waterfall Model,  RAD (Rapid Application Development) Model,  Spiral Model, V-Model, Incremental Model, Agile Model, Iterative Model, Big Bang Model, Prototype Model, Evolutionary Process Model, Attribute of good software, Different between software engineering and system Engineering, Some challenges of software Engineering, Software Engineering Ethics

When To Use Big Bang Model?

As we discussed above, this model is required when this project is small like an academic project or a practical project. This method is also used when the size of the developer team is small and when requirements are not defined, and the release date is not confirmed or given by the customer.

Advantage (Pros) of Big Bang Model:

a) There is no planning required.
b) Simple Model.
c) Few resources required.
d) Easy to manage.
e) Flexible for developers.

Disadvantage (Cons) of Big Bang Model:

a) There are high risk and uncertainty.
b) Not acceptable for a large project.
c) If requirements are not clear that can cause very expensive.

9. Prototype Model:

The prototype model requires that before carrying out the development of actual software, a working prototype of the system should be built. A prototype is a toy implementation of the system. A prototype usually turns out to be a very crude version of the actual system, possible exhibiting limited functional capabilities, low reliability, and inefficient performance as compared to actual software. In many instances, the client only has a general view of what is expected from the software product. In such a scenario where there is an absence of detailed information regarding the input to the system, the processing needs, and the output requirement, the prototyping model maybe employed.
Introduction of software engineering, History of software engineering, Importance of Software Engineering, Role of software engineering Software Development, Software Development is a Layered Technology, Software Development Model, Waterfall Model,  RAD (Rapid Application Development) Model,  Spiral Model, V-Model, Incremental Model, Agile Model, Iterative Model, Big Bang Model, Prototype Model, Evolutionary Process Model, Attribute of good software, Different between software engineering and system Engineering, Some challenges of software Engineering, Software Engineering Ethics

Steps of Prototype Model:

1. Requirement Gathering and Analyst
2. Quick Decision
3. Build a Prototype
4. Assessment or User Evaluation
5. Prototype Refinement
6. Engineer Product

Advantage of Prototype Model:

a) Reduce the risk of incorrect user requirement
b) Good where requirement is changing/uncommitted
c) Regularly visible process aids management
d) Support early product marketing
e) Reduce Maintenance cost.
f) Errors can be detected much earlier as the system is made side by side.

Disadvantage of Prototype Model:

a) An unstable/badly implemented prototype often becomes the final product.
b) Require extensive customer collaboration:
        i.   Costs customer money
       ii.   Needs committed customer
      iii.   Difficult to finish if the customer withdraws
       iv.   Maybe too customer-specific, no broad market
c) Difficult to know how long the project will last.
d) Easy to fall back into the code and fix without proper requirement analysis, design, customer evaluation, and feedback.
e) Prototyping tools are expensive.
f) Special tools & techniques are required to build a prototype.
g) It is a time-consuming process.

10. Evolutionary Process Model:

Evolutionary process model resembles the iterative enhancement model. The same phases are defined for the waterfall model occurs here in a cyclical fashion. This model differs from the iterative enhancement model in the sense that this does not require a useful product at the end of each cycle. In evolutionary development, requirements are implemented by category rather than by priority.

For example, in a simple database application, one cycle might implement the graphical user interface (GUI), another file manipulation, other queries and other updates. All four cycles must complete before there is a working product available. GUI allows the users to interact with the system, file manipulation allow the data to be saved and retrieved, queries allow the user to get out of the system, and updates allow users to put data into the system.
Introduction of software engineering, History of software engineering, Importance of Software Engineering, Role of software engineering Software Development, Software Development is a Layered Technology, Software Development Model, Waterfall Model,  RAD (Rapid Application Development) Model,  Spiral Model, V-Model, Incremental Model, Agile Model, Iterative Model, Big Bang Model, Prototype Model, Evolutionary Process Model, Attribute of good software, Different between software engineering and system Engineering, Some challenges of software Engineering, Software Engineering Ethics

Benefits of Evolutionary Process Model:

1. Use of EVO brings a significant reduction in risk for software projects.
2. EVO can reduce costs by providing a structured, disciplined avenue for experimentation.
3. EVO allows the marketing department access to early deliveries, facilitating the development of documentation and demonstration.
4. Better fit the product to user needs and market requirements.
5. Manage project risk with the definition of early cycle content.
6. Uncover key issues early and focus attention appropriately.
7. Increase the opportunity to hit market windows.
8. Accelerate sales cycles with early customer exposure.
9. Increase management visibility of project progress.
10. Increase product team productivity and motivations.

The Attribute Of Good Software:

As we are all aware that software systems are an abstract and intangible quantity that includes computer programs and associated documentation. Software products may be developed for a particular customer (as application software) or may be developed for a general market (as system software). To gain an understanding of software products (and ultimately an understanding of software engineering), it is important to examine the characteristics of software that make it different from other things that human beings build. 

As we know that software is a logical rather than a physical system element (like computer hardware). Therefore, the software has characteristics that are considerably different than those of hardware. Hence as a software examiner when we focus on the quality of the professional software, we have to take into account the environment at where the software is used and behaviour of software changed by people apart from its developers.

Quality of software products is therefore not just concerned with what the software does. Rather, it has to include the software’s behaviour while it is executing and the structure and organization of the system programs and associated documentation. This is reflected in so-called quality or non-functional software attributes. For example to examine the quality of software products includes the response time of software to a user query, the understandability of the program code, running time and space occupied by the software product.

There are three specific factors set of attributes that easily must be included for a quality software product. These set of factors can be easily explained by software quality triangle as follows:
Introduction of software engineering, History of software engineering, Importance of Software Engineering, Role of software engineering Software Development, Software Development is a Layered Technology, Software Development Model, Waterfall Model,  RAD (Rapid Application Development) Model,  Spiral Model, V-Model, Incremental Model, Agile Model, Iterative Model, Big Bang Model, Prototype Model, Evolutionary Process Model, Attribute of good software, Different between software engineering and system Engineering, Some challenges of software Engineering, Software Engineering Ethics

Operational Characteristics of a Good Quality Software Product:

Operational characteristics of a good quality software product are based on the functionality and related to ‘exterior quality’ of a software product. Various operational characteristics of a quality software product are as follows:

1. Correctness:

The developed software product makes sure should meet all the customer specification.

2. Usability/Learnability:

The software product must be user-friendly and easy to understand even for IT-illiterate end-users. To learn and understand the operational behaviour and how to use the software product should be less.

3. Integrity:

Quality software should be side effects free product. For example, like each medicine have side-effects (either direct or indirect), in the same way, the software may have side-effects i.e. it may affect the working of another application, so for good quality software, it should have no side effect.

4. Reliability:

For a good quality software product reliability factor is highly important i.e. software should not have any defects. Not only this, it shouldn’t run time failed.

5. Efficiency:

The efficiency factor of a quality software relates to the effective uses the available resources by the software product. For example, developed software should be effectively used the available memory (like permanent memory-ROM and/or temporary memory- RAM) and execute a command as per the desired timing requirement.

6. Security:

To keep data secure from external threats good software product have high-security factors.

7. Safety:

The software should not be hazardous to the environment and/or end-user life.

Revision Characteristics of a Good Quality Software Product:

Review characteristics of a good quality software product based on the engineering factors that relate to the ‘Interior quality’ of the developed software. This factor of software quality deals with the efficiency, documentation and the structure of the software product. Various revision characteristics of software are as follows:

1. Maintainability:

After delivering the software product at the end-user, maintenance should be easy for any kind of end-user.

2. Flexibility:

As per the end-users requirements, software product changes should be easy to make.

3. Extensibility:

For the future functionality enhancement software product should be easy to increase the functions performed by it.

4. Scalability:

The developed software product should be very easy to upgrade for more work and/or a number of users.

5. Testability:

Testing the software should be easy.

6. Modularity:

Every software is a collection of separate programs, unites and modules which are dependent and/or independent of each other. These programs, units and modules are then integrated to make the final software. If the software is divided into separate independent parts that can be modified, tested separately, it has high modularity.

Transition Characteristics of Good Quality Software Product:

Transition characteristics of a good quality software product based on the data intervention behaviour factor that relates to the software end-user environment and platform, modules reusability and interoperability of the software. Various transition characteristics of software are as follows:

1. Interoperability:

Interoperability is the ability of software to exchange information/data with other applications and make use of information transparently.

2. Reusability:

If we are able to use the software code with some modifications for a different purpose then we call software to be reusable.

3. Portability:

The factor of software refers to how well the software can adapt to changes in its environment and/or platform or with its requirements. The sub-factor of this characteristic includes adaptability, conformance and replaceability.

Difference Between Software Engineering And System Engineering:

As we all aware that engineering is the obedience that deals with the application of science, mathematics and other types of data to design and build-up products and services that perk up the eminence of human livelihood. Engineering is broken down into many sub-disciplines on behalf of specialization in particular domains using various technologies. Software Engineering and Systems Engineering are two sub-specialized disciplines that are not purely interconnected disciplines but they are intimately intertwined. Although these two disciplines are interconnected to each other but at some phases, they create a marginal difference that are as follows:

1. System engineering concerns on the overall management of engineering projects throughout their life cycle. It deals with logistics, team coordination, automatic machinery control, work processes and similar tools whereas Software engineering concern about the designing and developments engineering specified software of the highest quality and should have broad information systems experience.

2. System Engineers focus more on users and domains, while Software Engineering focus more on implementing quality software.

3. System Engineer may deal with a substantial amount of hardware, software, people, database and other elements involved with that system which is going to be developed but typically software engineers will focus solely on software components.

4. System Engineers may have a broader education (including Engineering, Mathematics and Computer science), while Software Engineers will come from a Computer Science or Computer engineering background.

5. Software engineering is a part of system engineering.

Challenges of Software Engineering:

Building a high quality product is the end goal for any organization, but the software developers often run into a myriad of challenges on the way, while staying on top of new technologies and trends. The software development process is going through some unusual changes – development tactics are evolving, automation is becoming rampant, and new tools and libraries are emerging daily.

If we want to create value, products must evolve, adapt, improve, and be a source of innovation almost every day to sustain market pressures, technological advances, changing customer needs, and changing an industry dynamics. A process as complex as software development comes with its own set of challenges. Challenges that we might encounter every day; challenges that need to be addressed almost immediately to reduce the impact they have on our end product.
Introduction of software engineering, History of software engineering, Importance of Software Engineering, Role of software engineering Software Development, Software Development is a Layered Technology, Software Development Model, Waterfall Model,  RAD (Rapid Application Development) Model,  Spiral Model, V-Model, Incremental Model, Agile Model, Iterative Model, Big Bang Model, Prototype Model, Evolutionary Process Model, Attribute of good software, Different between software engineering and system Engineering, Some challenges of software Engineering, Software Engineering Ethics

Top 10 Software Product Development Challenges:

1. Project Infrastructure Issues:

An unestablished project environment is always a common challenge in terms of its impact on project delivery. To ensure efficient project development, test and pre-production environments should be made available during the development, testing, and user acceptance testing (UAT) phases. If the environment is not available, then there is no way we can proceed with our project on time and under budget.

2. Requirements Volatility:

A major reason for the complexity of software projects is the constant changing of requirements. Not surprisingly, 33% of the respondents of the 2016 Stack Overflow Developer Survey consider building products with unspecific requirements, as their biggest challenge. Requirements gathering is a lot more than a handful of business consultants coming up with their ideal product, it is understanding fully what a project will deliver.
a) Define and agree on the scope of the project.
b) Don’t assume end-user needs and requirements, make sure the project team fully understands the needs and it’s been communicated in between teams clearly.
c) While refurbishing a product, involve users from the start, and in the case of new product development, consider UX from the start.
d) Create a clear, concise and thorough requirements document and confirm our understanding of the requirements.
e) And if necessary, create a prototype to confirm and/or refine final agreed-upon requirements.

3. Ignoring Best Code Development Practices:

Not reviewing code, or suppressing errors are just a means that developers use to save time and meet deadlines. Following a formal quality assurance process is imperative for a successful launch. If we witness developers trying to cut corners in the development process, discourage it immediately. Encourage them to use best code development practices to meet the requirements sooner and in a more efficient manner.

4. Undefined Quality Standards:

Defect identification is inevitable during functionality testing, even if the product has been through thorough unit testing during the development phase. When we come out with the test approach, scenarios, conditions, cases, and scripts to complete the functional testing of our project, make sure our test plan covers all the requirements that are to be delivered by planning several cycles of testing.

5. Adapting the Latest Market Trends:

Catering to the latest technology requirements such as mobile-first or mobile-only or desktop-first is often challenging. If we don’t have resources with hands-on experience in the latest and trending technologies, it is sure to impact our time to market. Make sure our resources constantly polish their skills to remain relevant.

6. Managing Design Influences:

Product designs are under constant influence from stakeholders, the development organization, and other developmental factors. Managing these influences is essential for maximizing the quality of systems and their related influence on future business opportunities. The increase of easily accessible, simple applications has resulted in user expectations growing exponentially. Make sure we streamline our design and offer a consistent experience across devices, operating systems, and form factors.

7. The Integration Challenge:

There are thousands of different technologies, systems, and applications available for businesses. Integrating third-party or other custom applications, such as our ERP, website, or inventory management database adds substantial complexity to our project. And the bigger challenge with integration is that they remain hidden throughout the development process, and surface only at the end leading to extra costs, delays, lowered quality, and sometimes even failure of the project. If we want our software solution to conform to the external constraints of other systems, we should:
a) Get a clear understanding of end-user requirements.
b) Implement an enterprise-wide framework which works as a platform of structuring the application.
c) Discover and research new technologies, design and develop new solutions, and then test and evaluate them to ensure optimum integration.
d) Pay extra attention to research and development, testing, and prototyping.
e) Test, test, and test again before deploying the solution.

8. Juggling Projects and Tasks:

Very often multi-tasking might give us more trouble than expected. Resources cannot focus on a single task or module if their manager bombards them with tasks.

“To be successful in project management we absolutely have to be an excellent planner,” says Ryan Chan, founder and CEO of UpKeep Maintenance Management.

And, one obvious way to be an excellent planner is to leverage project management tools like Project Pro in O365 and keep projects, resources, and teams organized and on track. Stay on track, meet all deadlines, work seamlessly across applications, and efficiently and effortlessly manage our projects. Always keep task allocation sequential rather than parallel, and encourage resources to give their best in whatever they do.

9. Test Environment Duplication:

Testing a software system in a controlled environment is difficult since the user is not immersed in a completely realistic working situation. It’s impractical to gauge how a user will really use the application in different situations on a regular basis until it’s deployed. However, with software applications for both B2B and B2C segments becoming more and more diversified than in the past, controlled testing is not sufficient. Therefore, testing the software or app or product in a separate real-life test environment is critical to our software’s success.

10. The Security Challenge:

Security breaches are on the rise; a recent study estimates that 96% of all web applications contain at least one serious vulnerability. How do we cope with evolving security threats? How do we keep each layer of our software or application secure?
a) Look beyond technology to improve the security of our software.
b) Develop our software using high-level programming languages with built-in security features.
c) Make security assurance activities such as penetration testing, code review, and architecture analysis an integral part of the development effort.
d) Perform all the essential core activities to produce secure applications and systems including conceptual definition, control specification, design and code review, system test review, and maintenance and change management.
e) Make sure security is not just the responsibility of the software engineer but also the responsibility of all the stakeholders involved including the management, project managers, business analysts, quality assurance managers, technical architects, and application and developers.

Software Engineering Ethics:

Software engineers shall commit themselves to make the analysis, specification, design, development, testing and maintenance of software a beneficial and respected profession. In accordance with their commitment to health, safety and the welfare of the public software engineers shall adhere (follow) to the following principles:
Introduction of software engineering, History of software engineering, Importance of Software Engineering, Role of software engineering Software Development, Software Development is a Layered Technology, Software Development Model, Waterfall Model,  RAD (Rapid Application Development) Model,  Spiral Model, V-Model, Incremental Model, Agile Model, Iterative Model, Big Bang Model, Prototype Model, Evolutionary Process Model, Attribute of good software, Different between software engineering and system Engineering, Some challenges of software Engineering, Software Engineering Ethics

Principle 1 – Public:

Software engineers shall act consistently with the public interest. In particular, software engineers shall, as appropriate:

1. Accept-full responsibility for their own work.

2. Moderate the interests of the software engineer, the employer, the client and the users with the public good.

3. Approve software only if they have a well-founded belief that it is safe, meets specifications pass appropriate tests and do not diminish the quality of life, diminish privacy or harm the environment. The ultimate effect of the work should be to the public good.

4. Disclose to appropriate persons or authorities any actual or potential danger to the user, the public, or the environment, that they reasonably believe to be associated with software or related documents.

5. Cooperate in efforts to address matters of grave public concern caused by software, its installation, maintenance, support or documentation.

6. Be fair and avoid deception in all statements, particularly public ones, concerning software or related documents, methods and tools.

7. Consider issues of physical disabilities, allocation of resources, economic disadvantage and other factors that can diminish access to the benefits of the software.

8. Be encouraged to volunteer professional skills to good causes and contribute to public education concerning the discipline.

Principle 2 – Client and Employer:

Software engineers shall act in a manner that is in the best interests of their client and employer, consistent with the public interest. In particular, software engineers shall, as appropriate:

1. Provide service in their areas of competence, being honest and forthright about any limitations of their experience and education.

2. Not knowingly use software that is obtained or retained either illegally or unethically.

3. Use the property of a client or employer only in ways properly authorized, and with the clients or employer’s knowledge and consent.

4. Ensure that any document upon which they rely has been approved, when required, by someone authorized to approve it.

5. Keep private any confidential information gained in their professional work, where such confidentiality is consistent with the public interest and consistent with the law.

6. Identify, the document, collect evidence and report to the client or the employer promptly if, in their opinion, a project is likely to fail, to prove too expensive, to violate intellectual property law, or otherwise to be problematic.

7. Identify, document, and report significant issues of social concern, of which they are aware, in software or related documents, to the employer or the client.

8.  Accept no outside work detrimental to the work they perform for their primary employer.

9. Promote no interest adverse to their employer or client, unless a higher ethical the concern is being compromised; in that case, inform the employer or another appropriate authority of the ethical concern.

Principle 3 – Product:

Software engineers shall ensure that their products and related modifications meet the highest professional standards possible. In particular, software engineers shall, as appropriate:

1. Strive for high quality, acceptable cost and a reasonable schedule, ensuring significant tradeoffs are clear to and accepted by the employer and the client, and are available for consideration by the user and the public.

2. Ensure proper and achievable goals and objectives for any project on which they work or propose.

3. Identify, define and address ethical, economic, cultural, legal and environmental issues related to work projects.

4. Ensure that they are qualified for any project on which they work or propose to work by an appropriate combination of education and training and experience.

5. Ensure an appropriate method is used for any project on which they work or propose to work.

6. Work to follow professional standards, when available, that are most appropriate for the task at hand, departing from these only when ethically or technically justified.

7. Strive to fully understand the specifications for software on which they work.

8. Ensure that specifications for software on which they work have been well documented, satisfy the user’s requirements and have the appropriate approvals.

9. Ensure realistic quantitative estimates of cost, scheduling, personnel, quality and outcomes on any project on which they work or propose to work and provide an uncertainty assessment of these estimates.

10. Ensure adequate testing, debugging, and review of software and related documents on which they work.

11. Ensure adequate documentation, including significant problems discovered and solutions, adopted, for any project on which they work.

12. Work to develop software and related documents that respect the privacy of those who will be affected by that software.

13. Be careful to use only accurate data derived by ethical and lawful means, and use it only in ways properly authorized.

14. Maintain the integrity of data, being sensitive to outdated or flawed occurrences.

15. Treat all forms of software maintenance with the same professionalism as new development.

Principle 4 – Judgment:

Software engineers shall maintain integrity and independence in their professional judgment. In particular, software engineers shall, as appropriate:

1. Temper all technical judgments by the need to support and maintain human values.

2. Only endorse documents either prepared under their supervision or within their areas of competence and with which they are in agreement.

3. Maintain professional objectivity with respect to any software or related documents they are asked to evaluate.

4. Not engage in deceptive financial practices such as bribery, double billing, or other improper financial practices.

5. Disclose to all concerned parties those conflicts of interest that cannot reasonably be avoided or escaped.

6. Refuse to participate, as members or advisors, in a private, governmental or the professional body concerned with software related issues, in which they, their employers or their clients have undisclosed potential conflicts of interest.

Principle 5 – Management:

Software engineering managers and leaders shall subscribe to and promote an ethical approach to the management of software development and maintenance. In particular, those managing or leading software engineers shall, as appropriate:

1. Ensure good management for any project on which they work, including effective procedures for the promotion of quality and reduction of risk.

2. Ensure that software engineers are informed of standards before being held to them.

3. Ensure that software engineers know the employer’s policies and procedures for protecting passwords, files and information that is confidential to the employer or confidential to others.

4. Assign work only after taking into account appropriate contributions of education and experience tempered with a desire to further that education and experience.

5. Ensure realistic quantitative estimates of cost, scheduling, personnel, quality and outcomes on any project on which they work or propose to work, and provide an uncertainty assessment of these estimates.

6. Attract potential software engineers only by a full and accurate description of the conditions of employment.

7. Offer fair and just remuneration.

8. Not unjustly prevent someone from taking a position for which that person is suitably qualified.

9. Ensure that there is a fair agreement concerning ownership of any software, processes, research, writing, or other intellectual property to which a software engineer has contributed.

10. Provide for due process in hearing charges of violation of an employer’s policy or of this Code.

11. Not ask a software engineer to do anything inconsistent with this Code.

12. Not punish anyone for expressing ethical concerns about a project.

Principle 6 – Profession:

Software engineers shall advance the integrity and reputation of the profession consistent with the public interest. In particular, software engineers shall, as appropriate:

1. Help develop an organizational environment favourable to acting ethically.

2. Promote public knowledge of software engineering.

3. Extend software engineering knowledge by appropriate participation in professional organizations, meetings and publications.

4. Support, as members of a profession, other software engineers striving to follow this Code.

5. Not promote their own interest at the expense of the profession, client or employer.

6. Obey all laws governing their work, unless, in exceptional circumstances, such compliance is inconsistent with the public interest.

7. Be accurate in stating the characteristics of software on which they work, avoiding not only false claims but also claims that might reasonably be supposed to be speculative, vacuous, deceptive, misleading, or doubtful.

8. Take responsibility for detecting, correcting, and reporting errors in software and associated documents on which they work.

9. Ensure that clients, employers, and supervisors know of the software engineer’s commitment to this Code of ethics and the subsequent ramifications of such commitment.

10. Avoid associations with businesses and organizations which are in conflict with this code.

11. Recognize that violations of this Code are inconsistent with being a professional software engineer.

12. Express concerns to the people involved when significant violations of this Code are detected unless this is impossible, counter-productive, or dangerous.

13. Report significant violations of this Code to appropriate authorities when it is clear that consultation with people involved in these significant violations is impossible, counter-productive or dangerous.

Principle 7 – Colleagues:

Software engineers shall be fair to and supportive of their colleagues. In particular, software engineers shall, as appropriate:

1. Encourage colleagues to adhere to this Code.

2. Assist colleagues in professional development.

3. Credit fully the work of others and refrain from taking undue credit.

4. Review the work of others in an objective, candid, and properly- documented way.

5. Give a fair hearing to the opinions, concerns, or complaints of a colleague.

6. Assist colleagues in being fully aware of current standard work practices including policies and procedures for protecting passwords, files and other confidential information, and security measures in general.

7. Not unfairly intervene in the career of any colleague; however, concern for the employer, the client or public interest may compel software engineers, in good faith, to question the competence of a colleague.

8. In situations outside of their own areas of competence, call upon the opinions of other professionals who have competence in that area.

Principle 8 – Self:

Software engineers shall participate in lifelong learning regarding the practice of their profession and shall promote an ethical approach to the practice of the profession. In particular, software engineers shall continually endeavour to:

1. Further their knowledge of developments in the analysis, specification, design, development, maintenance and testing of software and related documents, together with the management of the development process.

2. Improve their ability to create safe, reliable, and useful quality software at a reasonable cost and within a reasonable time.

3. Improve their ability to produce accurate, informative, and well-written documentation.

4. Improve their understanding of the software and related documents on which they work and of the environment in which they will be used.

5. Improve their knowledge of relevant standards and the law governing the software and related documents on which they work.

6. Improve their knowledge of this Code, its interpretation, and its application to their work.

7. Not give unfair treatment to anyone because of any irrelevant prejudices.

8. Not influence others to undertake any action that involves a breach of this Code.

9. Recognize that personal violations of this Code are inconsistent with being a professional software engineer.

No comments:

Post a Comment

If you have any doubt, then don't hesitate to drop comments.