CSE3310 Synthesized

Good communications also strengthen group cohesion as it promotes understanding.

- Status of group members - Personalities in groups - Sexual composition of group - Communication channels

Cost Drivers Micro Conditions in Cocomo.

17

Algorithmic code modelling

A formulaic approach based on historical cost information, and which is generally based on the size of the software. Most commonly used product attribute for cost estimation is code size.

Thin client model Disadvantage

A major disadvantage is that it places a heavy processing load on both the server and the network

Plan-driven development (Heavy Weight approach)

A plan-driven approach to software engineering is based around separate development stages with the outputs to be produced at each of these stages planned.

Control

A protective measure that reduces a system's vulnerability. Encryption is an example of a control that reduces a vulnerability of a weak access control system

Attack

An exploitation of a system's vulnerability. Generally, this is from outside the system and is a deliberate attempt to cause some damage.

Motivation

An important role of a manager is to motivate the people working on a project. Motivation is a complex issue, but it appears that there are different types of motivation based on

Function Points

Based on a combination of program characteristics -external inputs and outputs - user interactions -external interfaces -files used by the system A weight is associated with each of these. The function point count is computed by multiplying each raw count by the weight and summing all values. Function point count modified by complexity of the project.

Threat

Circumstances that have potential to cause loss or harm. You can think of these as a system vulnerability that is subjected to an attack

Measurement Problems

Estimating: -size of the measure -total number of programmer months which have elapsed. -contractor productivity and incorporating this estimate in overall estimate

Estimation by analogy Disadvantages:

Impossible if no comparable project has been tackled. Needs systematically maintained cost database.

Applicability of Lehman's laws

Lehman's laws seem to be generally applicable to large, tailored systems developed by large organizations. It is not clear how they should be modified for - Shrink-wrapped software products. - Systems that incorporate a significant number of COTS components. -Small organizations. - Medium sized systems

Productivity is based on

Line of code and function point.

Scale drivers in Cocomo

Macro conditions:

conditions in economics.

Micro and Macro

Exposure

Possible loss or harm to a computing system. This can be loss or damage to data or can be a loss of time and effort if recovery is necessary after a security breach.

What are the types of scale drivers in Cocomo

Precedents Development Flexibility Architecture/Risk Resolution Team Cohesion Process Maturity

Software cost estimation

Predicting the resources required for a software development process.

Complexity Metrics

Predictions of maintainability can be made by assessing the complexity of system components.

Layered application architecture

Presentation layer Application processing layer Data management layer

Personality types

The needs hierarchy is almost certainly an over-simplification. Motivation should also take into account different personality types: - Task-oriented -Self-oriented -Interaction-oriented

Scaling out

is concerned with how agile methods can be introduced across a large organization with many years of software development experience.

Scaling up

is concerned with using agile methods for developing large software systems that cannot be developed by a small team. Scaling up agile methods involves changing these to cope with larger, longer projects where there are multiple development teams, perhaps working in different locations.

CORBA part 2

middleware to manage communications between distributed objects.

Program evolution dynamics

study of the processes of system change.

Extreme Programming (XP)

takes an 'extreme' approach to iterative development.

Interception

that allow an attacker to gain access to an asset.

Fabrication

that allow an attacker to insert false information into a system.

Interruption

that allow an attacker to make part of the system unavailable.

Modification

that allow an attacker to tamper with a system asset.

Scaling agile methods

-Agile methods have proved to be successful for small and medium sized projects that can be developed by a small co-located team. -It is sometimes argued that the success of these methods comes because of improved communications which is possible when everyone is working together.

Staff selection factors

-Application domain experience -Platform experience -Programming Language experience -Educational background -Communicational ability -Adaptability -Attitude -Personality

Factors affecting productivity

-Application domain experience - Process quality -Project size -Technology support -Working environment

Motivation Needs

-Basic needs (e.g. food, sleep, etc.) - Personal needs (e.g. respect, self-esteem) -Social needs (e.g. to be accepted as part of a group)

Agile method Principles

-Customer involvement -Incremental delivery -People not process -Embrace change -Maintain simplicity

Refactoring

-Programming team look for possible software improvements and make these improvements even where there is no immediate need for them. - This improves the understandability of the software and so reduces the need for documentation. -Changes are easier to make because the code is well-structured and clear. -However, some changes require architecture refactoring, and this is much more expensive.

Equation we need to know

-Effort is when there's one person, Duration is for multiple. -EFFORT = 2.94 * EAF * (KSLOC)^E • EAF=Cost drivers. E= Scale driver. K is 100,000 lines of code but remove ,000= 100K. EX: a project with all Nominal Cost Drivers and Scale Drivers would have an EAF of 1.00 and exponent, E, of 1.0997. Assuming that the project is projected to consist of 8,000 source lines of code, COCOMO II estimates that 28.9 Person-Months of effort is required to complete it: -Effort = 2.94 * (1.0) * (8)1.0997 = 28.9 Person-Months For example, if your project is rated Very High for Complexity (effort multiplier of 1.34), and Low for Language & Tools Experience (effort multiplier of 1.09), and all of the other cost drivers are rated to be Nominal (effort multiplier of 1.00), the EAF is the product of 1.34 and 1.09. -Effort Adjustment Factor = EAF = 1.34 * 1.09 = 1.46 -Effort = 2.94 * (1.46) * (8)1.0997 = 42.3 Person-Months 9. -Duration = 3.67 * (Effort)SE -Effort is the effort from the -COCOMO II effort equation. -SE is the schedule equation exponent derived from the five Scale Drivers. -Continuing the example, and substituting the exponent of 0.3179 that is calculated from the scale drivers, yields an estimate of just over a year, and an average staffing of between 3 and 4 people: -Duration = 3.67 * (42.3)0.3179 = 12.1 months -Average staffing = (42.3 Person-Months) / (12.1 Months) = 3.5 people.

Group communications

-Good communications are essential for effective group working. -Information must be exchanged on the status of work, design decisions and changes to previous decisions.

Group cohesiveness Advantages:

-Group quality standards can be developed. -Group members work closely together so inhibitions caused by ignorance are reduced. -Team members learn from each other and get to know each other's work. -Egoless programming where members strive to improve each other's programs can be practiced.

Software cost components

-Hardware and software costs -Travel and training costs -Effort costs (the dominant factor in most projects) -Effort costs must take overheads into account.

Fundamental estimation questions

-How much effort is required to complete an activity? -How much calendar time is needed to complete an activity? -What is the total cost of an activity? -Project estimation and scheduling and interleaved management activities

Pair programming

-In XP, programmers work in pairs, sitting together to develop code. -It serves as an informal review process as each line of code is looked at by more than 1 person. -It encourages refactoring as the whole team can benefit from this. - In pair programming, programmers sit together at the same workstation to develop the software. -Pairs are created dynamically so that all team members work with each other during the development process.

Five stage model (IRDMO)

-Initial. -Repeatable. -Defined. -Managed. -Optimizing

Advantages of distributed object architecture

-It allows the system designer to delay decisions on where and how services should be provided. -It is a very open system architecture that allows new resources to be added to it as required. -The system is flexible and scalable. -It is possible to reconfigure the system dynamically with objects migrating across the network as required.

Group leadership

-Leadership depends on respect not title or status. -There should be both a technical and a managerial leader. -A career path based on technical competence should be supported.

Software Maintenance

-Modifying a program after it has been put into use. -Maintenance does not normally involve major changes to the system's architecture. -Changes are implemented by modifying existing components and adding new components to the system. -The system requirements are likely to change while the system is being developed because the environment is changing

Fat client model

-More processing is delegated to the client as the application processing is locally executed. -Most suitable for new C/S systems where the capabilities of the client system are known in advance. -More complex than a thin client model especially for management. New versions of the application have to be installed on all clients.

Importance of evolution

-Organizations have huge investments in their software systems , they are critical business assets. -To maintain the value of these assets to the business, they must be changed and updated. -The majority of the software budget in large companies is devoted to evolving existing software rather than developing new software.

Management Activities

-Problem solving: using available people -Motivating: people who work on a project -Planning: what people are going to do -Estimating: how fast people will work -Controlling: people's activities -Organizing: the way in which people work.

Services and distributed objects

-Provider independence. -Public advertising of service availability. -Potentially, run-time service binding. -Pay for use of services. -Smaller, more compact. -applications. Reactive and adaptive applications.

Expert judgement Advantages:

-Relatively cheap estimation method. -Can be accurate if experts have direct experience of similar systems.

Group organization

-Software engineering group sizes should be relatively small (< 8 members). -Break big projects down into multiple smaller projects. -Small teams may be organized in an informal, democratic way. -Chief programmer teams try to make the most effective use of skills and experience.

What does Cocomo use for measurements? What is source line of code?

-Source line of code is what is delivered to your customer. -Source line of code (SLOC) created by the project staff. -One source line of code is a logical line of code. -Declarations are counted as SLOC. -Comments are not counted as SLOC.

The Sprint cycle

-Sprints are fixed length, normally 2-4 weeks. They correspond to the development of a release of the system in XP. -The starting point for planning is the product backlog, which is the list of work to be done on the project. -The selection phase involves all of the project team who work with the customer to select the features and functionality to be developed during the sprint.

Maintenance cost factors

-Team stability -Contractual responsibility -Staff skills -Program age and structure

Types of Maintenance

-To repair software faults. -To adapt software to a different operating environment. -To add to or modify the system's functionality.

Thin client model

-Used when legacy systems are migrated to client server architectures.

Test-first development

-Writing tests before code clarifies the requirements to be implemented. -Tests are written as programs rather than data so that they can be executed automatically. -All previous and new tests are run automatically when new functionality is added, thus checking that the new functionality has not introduced errors. -The customer who is part of the team helps write tests as development proceeds.

Complexity depends on

-control structures -data structures -object -method (procedure) -module size.

The Scrum approach is a general agile method, but its focus is on managing iterative development rather than specific agile practices.

...

Vulnerability

A weakness in a computer-based system that may be exploited to cause loss or harm.

Estimation by analogy Advantages:

Accurate if project data available.

Estimation techniques

Algorithmic cost modelling -Expert judgement -Estimation by analogy -Pricing to win

Distributed systems disadvantages

Complexity Security Manageability Unpredictability

Cocomo stand for

Constructive Cost Model

Client-server architectures

Distributed services which are called on by clients. Servers that provide services are treated differently from clients that use services.

Group cohesiveness

In a cohesive group, members consider the group to be more important than any individual in it

Extreme Programming (XP) Practices A:

Incremental planning Small releases Simple design Test-first development Refactoring.

FPs can be used to estimate LOC depending on the average number of LOC per FP for a given language.

LOC = AVC * number of function points

Group working

Most software engineering is a group activity. -The development schedule for most non-trivial software projects is such that they cannot be completed by one person working alone. Group interaction is a key determinant of group performance. Flexibility in group composition is limited. -Managers must do the best they can with available people.

Object points are

NOT the same as object classes. The number of: -object points in a program is a weighted estimate of. -separate screens that are displayed. -reports that are produced by the system. -3GL modules that must be developed to supplement the 4GL code.

CORBA services

Naming and trading services, Notification services Transaction services.

Human needs hierarchy

Needs: -Self-realization -Esteem -Social -Safety -Physiological

Distributed object architectures

No distinction between clients and servers. Any object on the system may provide and use services from other objects.

CORBA

Object Request Broker

Object Points

Object points are an alternative function-related measure to function points when 4Gls or similar languages are used for development.

Expert judgement

One or more experts in both software development and the application domain use their experience to predict software costs. Process iterates until some consensus is reached.

Extreme Programming (XP) Practices B:

Pair programming Collective ownership Continuous integration Sustainable pace On-site customer.

Peer-to-Peer architectures

Peer to peer (p2p) systems are decentralized systems where computations may be carried out by any node in the network

System types

Personal systems. Embedded systems. Distributed systems

Distributed systems characteristics

Resource sharing Openness Concurrency Scalability Fault tolerance

Security is essential

Security is essential as most systems are networked so that external access to the system through the Internet is possible

Services standards

Services are based on agreed, XML-based standards so can be provided on any platform and written in any programming language.

SOAP

Simple Object Access Protocol.

Middleware

Software that manages and supports the different components of a distributed system. In essence, it sits in the middle of the system. Examples: Transaction processing monitors, Data converters, Communication controllers.

Asset

Something of value which has to be protected. The asset may be the software system itself or data used by that system.

Agile development (Light Weight approach)

Specification, design, implementation and testing are inter-leaved and the outputs from the development process are decided through a process of negotiation during the software development process.

Group composed of members who share the same motivation can be problematic.

Task-oriented - everyone wants to do their own thing. -Self-oriented - everyone wants to be the boss. -Interaction-oriented - too much chatting, not enough work. An effective group has a balance of all types. Can be difficult to achieve because most engineers are task oriented. Need for all members to be involved in decisions which affect the group.

Agile methods

The aim of agile methods is to reduce overheads in the software process (e.g. by limiting documentation). -Focus on the code rather than the design. -Are based on an iterative approach to software development. -Are intended to deliver working software quickly.

Estimation by analogy

The cost of a project is computed by comparing the project to a similar project in the same application domain.

Peer-to-Peer architectures Models

The logical network architecture, Application architecture, and Focus here on network architectures

Pricing to win Disadvantages:

The probability that the customer gets the system he or she wants is small. Costs do not accurately reflect the work required

Pricing to win

The project costs whatever the customer has to spend on it

Security definition

The security of a system is a system property that reflects the system's ability to protect itself from accidental or deliberate external attack.

Threat Types

Threats: Interception Interruption Modification Fabrication

UDDI

Universal Description, Discovery and Integration.

Urgent change requests

Urgent changes may have to be implemented without going through all stages of the software engineering process. -If a serious system fault must be repaired. -If changes to the system's environment (e.g. an OS upgrade) have unexpected effects. -If there are business changes that require a very rapid response (e.g. the release of a competing product).

Expert judgement Disadvantages:

Very inaccurate if there's no experts!

WSDL

Web Services Description Language.

Pricing to win Advantages:

You get the contract.

Security is an essential pre-requisite for

availability, reliability and safety.

What does cocomo do

uses line of code. Cocomo uses source Line of code for productivity measure.

Managing people

working as individuals and in groups. People are an organization's most important assets.