Friday 22 March 2013

Identify at least two advantages of using high-level languages over assembly languages.


Q: Identify at least two advantages of using high-level languages over assembly languages.
Ans.: - Assembly language programs are limited to about a few hundreds of lines of assembly code, i.e. are very small in size. Every programmer develops programs in his own individual style - based on intuition. This type of programming is called Exploratory Programming.
But use of high-level programming language reduces development efforts and development time significantly. Languages like FORTRAN, ALGOL, and COBOL are the examples of high-level programming languages.

Emergence of Software Engineering?


5. Emergence of Software Engineering?

Ans:
  Early Computer Programming (1950s):
-        Programs were being written in assembly language.
-        Programs were limited to  about a few hundreds of lines of assembly code.
  • Every programmer developed his own style of writing programs:
-        according to his intuition  (exploratory programming).
High-Level Language Programming (Early 60s)
  • High-level languages such as FORTRAN, ALGOL, and COBOL were introduced:
-        This reduced software development efforts greatly.
  • Software development style was still exploratory.
-        Typical program sizes were limited to a few thousands of lines of source code.
Control Flow-Based Design (late 60s)
  • Size and complexity of programs increased further:
-        exploratory programming style proved to be insufficient. 
  • Programmers found: 
                  -        very difficult to write cost-effective and correct programs
-        programs written by others very difficult to understand and maintain.
  • To over come with this problem, experienced programmers advised: ``Pay particular attention to the   design of the program's control structure.'’               
  • A program's control structure indicates:
-         the sequence in which the program's instructions are executed.
  • To help design programs having good control structure:
-        flow charting technique was developed.
  • Using  flow charting technique:
-        one can represent and design a program's control structure.
-        Usually one understands a program:
·        by mentally simulating the program's execution sequence
  • A program having a difficult(messy) flow chart representation:
-        difficult to understand and debug.
  • It was found:
-        GO TO statements  makes control structure of a program messy(difficult, unorganized)
-        GO TO statements alter the flow of control arbitrarily.
-        The need to restrict use of GO TO statements was recognized.
  • Many programmers  had extensively used assembly languages.
-        JUMP instructions are frequently used for program branching in assembly languages,
-        programmers considered use of GO TO statements inevitable.
  • But, soon it was conclusively proved:
-        only three programming constructs are sufficient to express any programming logic:
·        sequence  (e.g. a=0;b=5;)
·        selection (e.g.if(c=true) k=5 else m=5;)
·        iteration   (e.g. while(k>0) k=j-k;)
  • Everyone accepted:
-        it is possible to solve any programming problem without using GO TO statements.
-        This formed the basis of  Structured Programming  methodology.

What is Computer Systems Engineering?


5. What is Computer Systems Engineering?
Ans:
  • Computer systems engineering:
-        encompasses software engineering.
  • Many products require development of software as well as specific hardware to run it:
-         a coffee vending machine,
-        a mobile communication product, etc.
  • The high-level problem:
-        deciding which tasks are to be solved by software
-        which ones by hardware.
  • Often, hardware and software are developed together:
-        Hardware simulator is used during software development.
  • Integration of  hardware and software.
  • Final system testing

Programs versus Software Products?


4. Programs versus Software Products?

PROGRAMS
S/W PRODUCT
  • Usually small in size
  • Author himself is sole user
  • Single developer
  • Lacks proper user interface
  • Lacks proper documentation
  • Ad hoc(Not Systematic or unplanned) development. 

  • Large
  • Large number of users
  • Team of developers
  • Well-designed interface
  • Well documented & user-manual prepared
  • Systematic development

What is Software Crisis


3. What is Software Crisis
Software Crisis

·Software products:
-fail to meet user requirements.
-frequently crash.
-expensive.
-difficult to alter, debug, and enhance.
-often delivered late.
-use resources non-optimally.


Factors contributing to the software crisis

·Larger problems,
·Lack of adequate training in software engineering,
·Increasing skill shortage,
·Low productivity improvements.

why do we learn software engineering?


(1)Why do we learn Software Engineering? 
ans:
To acquire skills to develop Applications(programs).

And to enhance  acquire skills to be a better programmer:
*Higher Productivity
*Better Quality Programs

Thursday 21 March 2013

Introduction of Software Engineering


Introduction

computer:
A computer is an electronic device which can perform arithmetic and lotgical operations with 100% accuracy is known as Computer.

  • Here Arithmetic operations means mathematical operations such as +-/*%.
  • The logical operations are those which uses the logical operations such as AND (&&), OR (||) AND negation (!) or NOT operator. These operators can be used to perform based on some conditions.
Whenever a problem happens in an engineering, that problem can be resolved in two ways
(i) By using Human 
(ii)By using Computer

(i) By using Human : If we want to solve any problem or issue we need a brain, bcoz the brain only thinks logically. By using Human solving a problem very easily . but sometimes we may not get 100% accuracy. Time complexity also takes place.

(ii) By using Computer:
If we want to solve any problem using Computer, computer should have the brain, we have to create an artificial brain of its own.
Here we observed one point that is ARTIFICIAL BRAIN, it is nothing but a Computer Program.

PROGRAM: it is nothing but a collection of instructions (statements) giving to the computer to perform a specific work.
(for learning programing language you can click this link http://improvec.blogspot.com)
                                            SOFTWARE:

It is nothing but a collection of program to do a specific problem.
so to create a software first of all we need to follow some of the topics, those concepts are covered in the Software Engineering.
We need to concentrate the following concepts to do a software or projects

  • algorithms
  • flow charts
  • programs.
Requirements:
  1. operating system
  2. Utility programs
  3. Language processors
  4. application programs
Let us first see out line of the software process
  • We will begin the nature of the software project

OUT LINE:
Ø      Nature of software projects:
Why they are challenging, why the projects are not successful,
            Then we will see how the engineering approaches can be helpful to the project
Ø      Engineering approaches
       we particularly look engineering projects are involved in other domains not only in software, in other side also,

After that we will talk about:

Ø      Software process:
   A process step: we will define a typical step software process to helping to us to developing large software

We will discuss what are the characteristics

Ø      Characteristics of a good process:
And we will look for a good process like below

Ø      Waterfall model for development: we will examine waterfall model for software development

We will also look for other models
Ø      Other models:
Finally we will briefly touch on project planning
Ø      Project planning:
Lets begin the nature of the software systems:

SOFTWARE SYSTEMS

Software comes in various forms. The following are the different categorites of software which continue to be challenges for software engineers:
(1) System Software (2) application software (3) engineering/Scientific software (4) embedded software (5) Product-Line software (6) web applications (7) Ubiquitous computing (8) Netsourcing (9)Open Source

  • All of us encountered the software systems and we see them in variety of applications you see them every where in day to day life:
  • If you go to any railway station for reservation
  • Railway reservation, online movie tickets , online library, online banking etc., we find all places
  • If some application you encountered may be in                                      (i.)business domain                                                                                           (ii.) in engineering domain or they may be                                              (iii)scientific applications

  • Basically the bottom line is computer software is touching all aspects of human life

  • These software applications may be different categories , they may be simple or they may be complex ex: system software, application software,embedded system
  • They may be made for internal used for organization or they may be made for public use such as the railway reservation system, we all are familiar with that.

  • Example of a very successful software system which is after public usage category or the software solutions could be very simple well defined task such as a payroll or it could be The Application which covers the all functions of a business organization that means it could be the ‘Enterprise wide software’

  • Then you can have a software which functions in one location or it may be a distributed software solution , software solution may be designed for batch operation or it may be a real time or it may be made only to give information to public or it may be a mission critical so you have a range of software solutions

  • And its very important area now software are all use in all applications

There are major challenges to develop a software

CHALLENGE IN LARGE PROJECTS

And why do have these challenging situations so developing a large software is challenging because firstly
  • It is effort intensive:  you have to organize the work very meticulously
  • High cost is involved: so in case the solution is not successful, entire investment goes waste. 
  • It also can take long development time
  • then we have to take into account the changing requirements of the user
  • and finally there is a high risk of failure, and this risk may be in terms of variety of aspects the users may not accept the software, it may not be a good performance, or the solutions is such not maintaining the software upto date . These are the challenging to developing the large software
  • we must realize the developing a software is quite different from developing one time program which we typically develop as a student or for ourself which has develop and try it out
  • it is useful results and through it away not talking about software solutions we are talking about software solutions which are of long duration it gives very important service to the people or organizations
  • this is what would be the focus of software in our codes
When do we call a software solutions can be successful
  •  basically the software projects have not always been successful, the success rate infact is much lower the success rate in other engineering domains
  • When do we consider a software application successful?
Ø       Development should be completed
Ø      It is useful
Ø      It is usable
Ø      Cost effectiveness, maintanablility
  •  
REASONS FOR FAILING:
  • The software is not ready in time
  • budget
  • No planning of development work(e.g. no milestones defined)
  • Deliverables to user not identified
  • Poor understanding of user requirements
  • No control or review.
  • Technical incompetence of developers
  • Poor understanding of cost and effort by both developer and user

The Computer Revolution
  • Design separated from physical representation ; design became a completely abstract concept.

  • Machines that were physically impossible or Impractical to build become feasible
  • Design can be changed without retooling or manufacturing.
  • Emphasis on steps to be achieved without worrying about how steps will be realized physically.