Software engineering:-

Software is a program or set of programs containing instructions that provide desired functionality. And Engineering is the
process of designing and building something that serves a particular purpose and finds a cost-effective solution to
problems.
Software Engineering is the process of designing, developing, testing, and maintaining software. It is a systematic
and disciplined approach to software development that aims to create high-quality, reliable, and maintainable software.
Software engineering includes a variety of techniques, tools, and methodologies, including requirements analysis, design,
testing, and maintenance.
Software Engineering is mainly used for large projects based on software systems rather than
single programs or applications. The main goal of Software Engineering is to develop software applications for improving
quality, budget, and time efficiency. Software Engineering ensures that the software that has to be built should be
consistent, correct, also on budget, on time, and within the required requirements.

Objectives of Software Engineering

*Maintainability: It should be feasible for the software to evolve to meet changing requirements.
*Efficiency: The software should not make wasteful use of computing devices such as memory, processor cycles, etc.
*Correctness: A software product is correct if the different requirements specified in the SRS Document have been
correctly implemented.
*Reusability: A software product has good reusability if the different modules of the product can easily be reused to
develop new products.
*Testability: Here software facilitates both the establishment of test criteria and the evaluation of the software with
respect to those criteria.
*Reliability: It is an attribute of software quality. The extent to which a program can be expected to perform its desired
function, over an arbitrary time period.
*Portability: In this case, the software can be transferred from one computer system or environment to another.
*Adaptability: In this case, the software allows differing system constraints and the user needs to be satisfied by making
changes to the software.
*Interoperability: Capability of 2 or more functional units to process data cooperatively.

Software Product
Software Products are nothing but software systems delivered to the customer with the documentation that describes
how to install and use the system. In certain cases, software products may be part of system products where hardware, as
well as software, is delivered to a customer. Software products are produced with the help of the software process. The
software process is a way in which we produce software.
Types of software products:
Software products fall into two broad categories:
1.Generic products: Generic products are stand-alone systems that are developed by a production unit and sold on the
open market to any customer who is able to buy them.
2.Customized Products: Customized products are the systems that are commissioned by a particular customer. Some
contractor develops the software for that customer.

1
Essential characteristics of Well-Engineered Software Product:
*Efficiency: The software should not make wasteful use of system resources such as memory and processor cycles.
*Maintainability: It should be possible to evolve the software to meet the changing requirements of customers.
*Dependability: It is the flexibility of the software that ought to not cause any physical or economic injury within the
event of system failure. It includes a range of characteristics such as reliability, security, and safety.
*In time: Software should be developed well in time.
*Within Budget: The software development costs should not overrun and it should be within the budgetary limit.
*Functionality: The software system should exhibit the proper functionality, i.e. it should perform all the functions it is
supposed to perform.
*Adaptability: The software system should have the ability to get adapted to a reasonable extent with the changing
requirements.

Software paradigm
Software paradigm refers to method and steps, which are taken while designing the software. Programming paradigm is a
subset of software design paradigm which is future for other a subset of software development paradigm. Software is
considered to be a collection of executable programming code, associated libraries, and documentation. Software
development paradigm is also known as software engineering, all the engineering concepts pertaining to developments
software applied. It consists of the following parts as Requirement Gathering, Software design, Programming, etc. The
software design paradigm is a part of software development. It includes design, maintenance, programming.
Software paradigm is a theoretical framework that serves as a guide for the development and structure of a
software system.
There are several software paradigms, including:
*Imperative paradigm: This is the most common paradigm and is based on the idea that a program is a set of instructions
that tell a computer what to do. It is often used in languages such as C and C++.
*Object-oriented paradigm: This paradigm is based on the idea of objects, which are self-contained units that contain
both data and behavior. It is often used in languages such as Java, C#, and Python.
*Functional paradigm: This paradigm is based on the idea that a program is a set of mathematical functions that
transform inputs into outputs. It is often used in languages such as Haskell, Lisp, and ML.
*Logic paradigm: This paradigm is based on the idea that a program is a set of logical statements that can be used to infer
new information. It is often used in languages such as Prolog and Mercury.

Knowledge engineering:-
Knowledge engineering in software engineering is a discipline that focuses on capturing, organizing, and utilizing
knowledge and expertise to build intelligent systems, expert systems, or other software applications. It involves creating
computer-based systems that can reason and make decisions similar to a human expert in a specific domain.

Here are some key aspects of knowledge engineering in software engineering:

1.Knowledge Representation: Knowledge engineers need to represent human knowledge in a form that a computer can
understand and use. This often involves creating structured representations of information using languages like predicate
logic, frames, ontologies, or semantic networks.

2
2.Knowledge Acquisition: This is the process of gathering knowledge from human experts or other sources. Knowledge
engineers work closely with domain experts to extract their knowledge, rules, and heuristics, which are then encoded into
the software.
3.Knowledge Base Development: Knowledge engineers develop knowledge bases, which are repositories of structured
information and rules. These knowledge bases are used by the software to make decisions or provide expert advice.

4.Inference and Reasoning: The heart of many knowledge-based systems is their ability to perform reasoning and
inference. The software uses the knowledge base to answer questions, solve problems, or make decisions by applying
logical rules or heuristics.

5.Knowledge Validation and Maintenance: Knowledge engineers must ensure the accuracy and relevance of the
knowledge base. This includes validating the knowledge with experts, updating it as necessary, and ensuring it remains
consistent and up-to-date.
6.User Interfaces: Building user-friendly interfaces to interact with knowledge-based systems is crucial. Users should be
able to input queries or receive advice from the system in a manner that is understandable and useful to them.

7.Machine Learning Integration: In some cases, machine learning techniques are integrated with knowledge engineering
to enhance the system's capabilities. Machine learning can help systems adapt and improve their performance over time
based on data.
8.Expert Systems: Knowledge engineering is often associated with the development of expert systems. Expert systems are
computer programs that mimic the decision-making abilities of a human expert in a specific domain.

9.Applications: Knowledge engineering can be applied in various fields, including healthcare (medical diagnosis systems),
finance (investment advisors), engineering (design and analysis tools), and many others where expertise and decision-
making play a crucial role.
10.Challenges: Knowledge engineering projects can be complex and challenging. Gathering accurate knowledge, ensuring
the system's performance, and handling uncertainty and ambiguity in human expertise are some of the common
challenges.

End user development approaches:-

In information technology, the term end user is used to distinguish the person for whom a hardware or software product
is designed from the developers, installers, and servicers of the product. The "end" part of the term probably derives from
the fact that most information technologies involve a chain of interconnected product components at the end of which is
the "user."
In the Information Society, end-users keep increasing very fast in number, as well as in their demand with respect
to the activities they would like to perform with computer environments.
• End-user development (EUD) or end-user programming (EUP) refers to activities and tools that allow end-users - people
who are not professional software developers – to program computers.
•They include managers, accountants, engineers, home makers, teachers, scientists, health care workers, insurance
adjusters, salesmen, and administrative assistants.
• Many of these people work on tasks that rapidly vary on a yearly, monthly, or even daily basis.

3
•end users may be objects describing some automated behaviour or control sequence, such as database requests or
grammar rules, which can be described with programming paradigms such as programming by demonstration,
programming with examples, visual programming, or macro generation. They can also be parameters that choose
between alternative predefined behaviours of an application.
•end-user development may also refer to the creation of user-generated content such as annotations, which may be or
not computationally interpretable (i.e. can be processed by associated automated functions).

•Examples of end-user development include the creation and modification of:

■the spread sheeted computer users to write programs that represent complex data is the most popular EUD tool is
models.
■3D models created with end-user oriented tools and apps such as Sketchup.
■Game modifications to introduce users' own characters, environments, etc. many recent games are distributed with
modification in mind
■ Web Mashups in the form of visual languages such as Yahoo! Pipes.

Characteristics-
*end user as the developer and maintainer.
* the developer is client, therefore there are no communication issues.
*small budget and short time period for development.
Advatage-
*encourages active user participation.
*improve requirements determinations.
*strength user sense of ownership.
*Increases speed of system development.
Disadvatage-
*Inadequate expertise leads to underdeveloped systems
*Lack of organizational focus creates "privatized" system
*Insufficient analysis and design leads to subpar systems
*Lack of documentation of a system may lead to its being short lived

4
Abstraction:-
Abstraction is used to hide background details or any unnecessary implementation about the data so that users only see
the required information. It is one of the most important and essential features of object-oriented programming.
example - printing a document from your computer. You just open the document, click on the “print” command, and in a
short while, the printed document is ready. You are not really bothered about how the computer stores the document in
0s and 1s, nor about hoe it is transferred to the printer.

Partitioning and projection :-

Software partitioning is the process of mapping software functional requirements into a set of program modules for
implementation. This paper analyzes concurrent software design techniques that are based on structured analysis and
design (SA/SD) in order to highlight their potential and their shortcomings.
the program structure can easily be partitioned both horizontally and vertically.
In given figure (a), horizontal division defines the individual branches of the modular hierarchy for every major program
function. Control modular (shown by rectangles) are used to coordinate communication between tasks. The three
partitions are done in simple horizontal partitions i.e., input, data transformation (processing) and output.

The following benefits are provided by horizontal partitioning –

1.Software, that can easily be tested.
2.Software, that can easily be maintained.
3.Propagation of fewer side effects.
4.Software, that can easily be extended.
On the other hand, vertical segmentation, also known as “factoring”, states that control and function must be
distributed across the program structure, top to bottom. The top-level modules have to carry out control functions and
perform fewer modules in the structure are laborious, performing all input, processing and output tasks.
Figure (b), represents vertical partitioning. Due to the nature of changes in program structures, vertical
segmentation is required. Observing the figure (b), it can be said that a change in the control module would make its
subordinates more likely to cause the spread of side effects. Generally, changes are- changes to input, computation or
transformation, and output.

5
Projection:-
In software engineering, the term "projection" is not a commonly used or recognized concept. It's possible that there may
be some specific context or use of the term that I am not aware of, as my knowledge is based on information .
Software engineering primarily focuses on the principles, methods, and practices for designing, developing,
testing, and maintaining software systems. It involves various processes and activities such as requirements analysis,
design, coding, testing, and project management. If you have a specific question or topic related to software engineering
that you would like to know more about, please provide more details, and I'll do my best to provide you with relevant.

Software Requirement Specification (SRS) Format

In order to form a good SRS, here you will see some points that can be used and should be considered to form a structure
of good Software Requirements Specification (SRS). These are below mentioned in the table of contents and are well
explained below.
Table of Content
*Introduction
*General description
*Functional Requirements
*Interface Requirements
*Performance Requirements
*Design Constraints
*Non-Functional Attributes
*Preliminary Schedule and Budget
*Appendices
*Uses of SRS document
*FAQs on SRS Format
*Conclusion
Software Requirement Specification (SRS) Format as the name suggests, is a complete specification and description of
requirements of the software that need to be fulfilled for the successful development of the software system. These
requirements can be functional as well as non-functional depending upon the type of requirement. The interaction
between different customers and contractors is done because it is necessary to fully understand the needs of customers.
Software Requirement Specification Format Depending upon information gathered after interaction, SRS is developed
which describes requirements of software that may include changes and modifications that is needed to be done to
increase quality of product and to satisfy customer’s demand.

Introduction
Purpose of this Document – At first, main aim of why this document is necessary and what’s purpose of document is
explained and described.
Scope of this document – In this, overall working and main objective of document and what value it will provide to
customer is described and explained. It also includes a description of development cost and time required.
Overview – In this, description of product is explained. It’s simply summary or overall review of product.

6
General description
In this, general functions of product which includes objective of user, a user characteristic, features, benefits, about why
its importance is mentioned. It also describes features of user community.

Functional Requirements
In this, possible outcome of software system which includes effects due to operation of program is fully explained. All
functional requirements which may include calculations, data processing, etc. are placed in a ranked order. Functional
requirements specify the expected behavior of the system-which outputs should be produced from the given inputs. They
describe the relationship between the input and output of the system. For each functional requirement, detailed
description all the data inputs and their source, the units of measure, and the range of valid inputs must be specified.

Interface Requirements
In this, software interfaces which mean how software program communicates with each other or users either in form of
any language, code, or message are fully described and explained. Examples can be shared memory, data streams, etc.

Performance Requirements
In this, how a software system performs desired functions under specific condition is explained. It also explains required
time, required memory, maximum error rate, etc. The performance requirements part of an SRS specifies the
performance constraints on the software system. All the requirements relating to the performance characteristics of the
system must be clearly specified. There are two types of performance requirements: static and dynamic. Static
requirements are those that do not impose constraint on the execution characteristics of the system. Dynamic
requirements specify constraints on the execution behaviour of the system.

Design Constraints
In this, constraints which simply means limitation or restriction are specified and explained for design team. Examples
may include use of a particular algorithm, hardware and software limitations, etc. There are a number of factors in the
client’s environment that may restrict the choices of a designer leading to design constraints such factors include
standards that must be followed resource limits, operating environment, reliability and security requirements and policies
that may have an impact on the design of the system. An SRS should identify and specify all such constraints.

Non-Functional Attributes
In this, non-functional attributes are explained that are required by software system for better performance. An example
may include Security, Portability, Reliability, Reusability, Application compatibility, Data integrity, Scalability capacity, etc.

Preliminary Schedule and Budget

In this, initial version and budget of project plan are explained which include overall time duration required and overall
cost required for development of project.

Appendices
In this, additional information like references from where information is gathered, definitions of some specific terms,
acronyms, abbreviations, etc. are given and explained.

7
Uses of SRS document
*Development team require it for developing product according to the need.
*Test plans are generated by testing group based on the describe external behaviour.
*Maintenance and support staff need it to understand what the software product is supposed to do.
*Project manager base their plans and estimates of schedule, effort and resources on it.
*customer rely on it to know that product they can expect.
*As a contract between developer and customer.
*in documentation purpose.

FAQs on SRS Format

1. Why is it important to define the scope of an SRS document?
Defining the scope in an SRS document helps the customer understand the goals and worth of the software. It also has
details about how much it will cost to create and how long it will take, so that the project’s limits are clear.

2. What are functional requirements in an SRS document, and why are they important?
Functional requirements describe how the software system is supposed to work, including how it should react to inputs
and make outputs. They help you figure out what the software needs to do and give you a place to start building and
testing it.

Conclusion
Software development requires a well-structured Software Requirement Specification (SRS). It helps stakeholders
communicate, provides a roadmap for development teams, guides testers in creating effective test plans, guides
maintenance and support employees, informs project management decisions, and sets customer expectations. The SRS
document helps ensure that the software meets functional and non-functional requirements, resulting in a quality
product on time and within budget.

formal specification method

A formal specification method is a systematic and precise approach used in software engineering and other fields to
define and describe the behavior, structure, or properties of a system, component, or software application using formal
mathematical languages or techniques. The primary goal of formal specification is to eliminate ambiguity, reduce
misunderstandings, and facilitate rigorous analysis and verification of a system's properties. Formal specifications can be
used at various stages of the software development lifecycle, from requirements specification to design, implementation,
and verification.
Formal specification methods are systematic approaches used in software engineering and computer science to describe,
model, and analyze the behavior and properties of software systems, hardware systems, or other complex systems. These
methods provide a precise and unambiguous way to specify system requirements and design, helping to ensure
correctness, reliability, and maintainability of the system.

Here are some key aspects of formal specification methods:

8
 Mathematical Foundation: Formal specification methods are typically based on mathematical notations and formal
languages. These notations allow for rigorous and precise descriptions of system components, their interactions, and
desired properties.
 Abstraction: These methods often involve abstracting away unnecessary details while focusing on the essential aspects
of the system. This abstraction simplifies the specification and analysis process.
 Expressiveness: Formal specification languages are designed to be expressive, allowing the specification of various
aspects of a system, such as its structure, behavior, and constraints.

 Verification and Validation: Formal specifications enable rigorous verification and validation of system properties,
such as correctness, safety, security, and performance. This can involve formal proofs, model checking, and other
analysis techniques.
 Tool Support: Many formal specification methods come with specialized tools and software that allow for automated
analysis and verification of the specifications. These tools can help identify errors, inconsistencies, or potential issues in
the specifications.
 Documentation: Formal specifications serve as precise and comprehensive documentation of a system's requirements
and behavior, making it easier for stakeholders to understand and assess the system's characteristics.

Types of Formal Specification Methods:

 Model-Based: These methods involve creating abstract models of the system using formal notations like UML (Unified
Modeling Language) or SysML (Systems Modeling Language).
 Algebraic Specification: This approach uses algebraic equations and axioms to define system behavior.
 Temporal Logic: Temporal logic, such as Linear Temporal Logic (LTL) or Computational Tree Logic (CTL), is used to
specify temporal properties and behaviors of systems.
 Process Calculi: These are mathematical models used to describe concurrent and distributed systems. Examples
include the π-calculus and CSP (Communicating Sequential Processes).
 Formal Languages: Formal specification languages like Z, B, and VDM (Vienna Development Method) provide a
framework for specifying and reasoning about system properties.
 Automated Formal Methods: Tools like model checkers and theorem provers are used to automatically verify
properties of formal specifications.

Benefits:
 Improved system reliability and correctness.
 Better communication between stakeholders.
 Early detection of design flaws and defects.
 Support for code generation and documentation.
 Enhanced maintainability.

Challenges:
 Formal methods require specialized knowledge and expertise.
 Specification and verification can be time-consuming and expensive.
 Scaling formal methods to large, complex systems can be challenging.

9
  It may not always be feasible to use formal methods for every aspect of a project.

Overall, formal specification methods play a crucial role in ensuring the quality and reliability of complex systems,
especially in safety-critical domains like aerospace, automotive, and healthcare. They are an important tool in the
toolbox of software and system engineers to tackle complex design and verification challenges.

Specification tools
Specification tools in software engineering refer to various techniques, languages, and tools used to define, document,
and communicate the requirements and specifications of a software system. These tools are essential in the software
development process as they help bridge the gap between the client's or user's needs and the actual software
implementation. These tools help software engineers and stakeholders clearly communicate the desired functionality and
behavior of the software.
Three common types of specification tools are:

Data-Based Analysis:
 Data-based analysis focuses on defining the data structures and data flows within a software system. It involves
specifying the types of data that the system will handle, how the data will be stored, manipulated, and transmitted, and
the relationships between different data elements.
 Common tools and techniques used in data-based analysis include data flow diagrams (DFDs), entity-relationship
diagrams (ERDs), and data dictionaries. DFDs depict the flow of data through a system, while ERDs illustrate the
relationships between different data entities. Data dictionaries provide detailed descriptions of data elements.

Flow-Based Analysis:
 Flow-based analysis concentrates on defining the flow of control and functionality within a software system. It involves
specifying how the system will respond to different inputs and events, how it will process data, and how it will produce
outputs.
 Common tools and techniques used in flow-based analysis include flowcharts, state diagrams, and activity diagrams.
Flowcharts represent the flow of control and decision points in a system. State diagrams describe the different states a
system can be in and how it transitions between them. Activity diagrams show the flow of activities or processes within
the system.

Object-Oriented Analysis:
 Object-oriented analysis (OOA) is a methodology that focuses on modeling a software system using the principles of
object-oriented programming (OOP). It involves defining classes, objects, attributes, methods, and their relationships to
represent the system's structure and behavior.
 Common tools and techniques used in object-oriented analysis include Unified Modeling Language (UML) diagrams
such as class diagrams, object diagrams, sequence diagrams, and use case diagrams. Class diagrams show the classes
and their associations, while object diagrams depict instances of those classes. Sequence diagrams illustrate the
interactions between objects, and use case diagrams capture the system's functionality from the user's perspective.

10
These specification tools help software engineers and stakeholders to create a clear and unambiguous representation of
the software requirements. Depending on the project's nature and requirements, a combination of these tools may be
used to provide a comprehensive specification of the software system.

11