Software Project Management
Thread Rating:
  • 0 Vote(s) - 0 Average
  • 1
  • 2
  • 3
  • 4
  • 5
seminar presentation
Active In SP
**

Posts: 582
Joined: Apr 2010
#1
19-05-2010, 04:01 PM


Abstract:
In software industry, the major problem is meeting the clients requirements with specific to a software project and implimentation development is the deliverables that should be promised to the client. The client standardizes himself to a contract and fixes a specific time onto the systems, when the project and implimentation has to be delivered. Once the software development contract is signed, the actual task on scheduling the manpower and machine requirements arises. In scheduling the manpower and machine requirements arise. In a software development process, if the manpower is not organized properly then it can cause a great lot of have in reaching the targets. The major goal of any software development firm is to meet the targets as fast as possible with the least manpower, to get targeted profits. The other area where the software developments firm are interested are with respect to the management of library with specific to the previous project and implimentation development processes. The application training the bugs and their associated tescases that were developed previously also plays a vital role. The software project and implimentation management solutions, is an application that kinds itself with the overall standards of managing a project and implimentation at all levels of its development processes. The application is project and implimentationed towards the maintenance of data, that is utmost necessary to know the state and status of a project and implimentation that is undergoing through the process of development. The major intension its to maintain the history of all the components that have been developed for a specific project and implimentations along with the associated information about the software engineer who has been involved in the process of development of that component. This type of standard always helps the industry not only in managing the Human Resources properly but also help to keep down the maintenance upon the system. The history of information also helps in keeping the standards of bug tracking and bug management much easier, flexible and faster.
The project and implimentation has been planned to be having the view of distributed architecture, with centralized storage of the database. The application for the storage of the data has been planned. Using the constructs of MS-SQLServer2000 and all the user interfaces have been designed using the ASP.Net technologies. The database connectivity is planned using the
Use Search at http://topicideas.net/search.php wisely To Get Information About Project Topic and Seminar ideas with report/source code along pdf and ppt presenaion
Reply
seminar class
Active In SP
**

Posts: 5,361
Joined: Feb 2011
#2
02-03-2011, 11:07 AM

presented by:
Mohd Zeeshan Ali


.ppt   Software Project Management.ppt (Size: 682.5 KB / Downloads: 160)
Abstract
Under the topic SOFTWARE PROJECT MANAGEMENT ,we discuss how the project and implimentation and product processes fit together to define a unique project and implimentation instance. The basic things meant for a project and implimentation management are why, what , how, do it, and did it .which in turn relates to initiating, planning, executing, controlling and closing , regardless of the nature of the project and implimentation.
There are mainly four main things to be kept in mind about software project and implimentation management, they are four p’s people, product, process and project and implimentation.
Key concepts to be observed here are Agile teams, co-ordination, critical practices, software scope, software team, stake holders, team leaders.
The following are the questions raised while preparing a software project and implimentation management
How can software metrics be use to manage project and implimentations ?
How do we estimate effort, cost and project and implimentation duration ?
Techniques to be used to formally assess the risks ?
How does a software project and implimentation manager select tasks ?
How is a project and implimentation schedule created ?
What is quality management
Why are formal technical reviews so important ?
How changes are to be made to the software after delivery to the customer ?
Now we shall see in brief the answers to above questions and the requirements to define the goal and scope of a unique software project and implimentation management.
INTRODUCTION
SOFTWARE PROJECT MANAGEMENT

Is concerned with activities
software is delivered on time and on schedule
Meets the requirements of the organisations that develop and procure the software.
KEY ELEMENTS
Project Management
Estimation
Project Scheduling
Risk Management
Quality Management
Change Management
PROJECT MANAGEMENT
The People
people must be organized into effective teams such as PM-CMM.
The Product
Product objectives and scope are defined here.
The Process
Process provides the framework from which a comprehensive plan is designed.
The Project
Project is used to manage complexity.
ESTIMATION
The software project and implimentation planner must estimate these basic things before a project and implimentation begins,
Scope of the project and implimentation and feasibility.
Analyze risks.
Define required resources.
Estimate cost and effort.
Develop a project and implimentation schedule.
PROJECT SCHEDULING
Software project and implimentation scheduling is an activity that shows the total effort of individual activities done inside a planned project and implimentation. Basic principles for Product scheduling
Compartmentalization
Breaking the project and implimentation into manageable actions, activities and tasks.
Interdependency
Interdependency of each compartmentalized activity , action , or task must be determined.
Time allocation
Each task must be allocated some number of work units.
Effort Validation
The number of people on the software team for a project and implimentation must be defined.
Defined Responsibilities
Every task that is scheduled should be assigned to a specific team member.
Defined Outcomes
Every task that is scheduled should have a defined outcome.
Defined Milestones
Every task or a group of tasks should be associated with a project and implimentation milestone
RISK MANAGEMENT
The Risk Management is to assist a project and implimentation team in defining risks, assessing their impact and probability, and tracking risks through a software project and implimentation.
Risk Identification
It is a systematic attempt to specify threats to the project and implimentation plan
Risk Estimation
Establish a scale that reflects the perceived likelihood of a Risk.
Delineate the consequences of the Risk.
Estimate the impact of the risk on the project and implimentation and the product.
Note the overall accuracy of the risk project and implimentationion.
Risk Mitigation, Monitoring, And Management
Risk avoidance.
Risk monitoring.
Risk management and contingency planning.
QUALITY MANAGEMENT (SQA)
Software quality management is an umbrella activity that is applied at each step in the software process.
Consists the following steps:
SQA process
Specific quality assurance and quality control tasks
Effective software engineering practice
Control of all software work products
CHANGE MANAGEMENT(SCM)
The main objective here is to manage changes in effective way of software project and implimentation.
SCM Activities
Identify and Control Change.
Audits and Reports modifications.
conclusion
Finally a project and implimentation management activity encompasses the below things.
Measurement and metrics
Estimation and scheduling
Risk analysis, tracking and control
All these comprises to form a software project and implimentation management





Reply
rickytorson
Active In SP
**

Posts: 4
Joined: Mar 2011
#3
02-03-2011, 01:23 PM

There are mainly four main things to be kept in mind about software project and implimentation management, they are four p’s people, product, process and project and implimentation. Key concepts to be observed here are Agile teams, co-ordination, critical practices, software scope, software team, stake holders, team leaders. It is really very important.
These are really very important in this. KEY ELEMENTS Project Management Estimation Project scheduling Risk Management. It is really very important to study more about it because it is very necessary for it.
Reply
seminar class
Active In SP
**

Posts: 5,361
Joined: Feb 2011
#4
12-05-2011, 12:43 PM


.ppt   08 software testing.ppt (Size: 305 KB / Downloads: 83)
Applied Software Project Management
Software Testing
Quality

Quality means “conformance to requirements”
The best testers can only catch defects that are contrary to specification.
Testing does not make the software perfect.
If an organization does not have good requirements engineering practices then it will be very hard to deliver software that fills the users’ needs, because the product team does not really know what those needs are.
Test Plans
The goal of test planning is to establish the list of tasks which, if performed, will identify all of the requirements that have not been met in the software. The main work product is the test plan.
The test plan documents the overall approach to the test. In many ways, the test plan serves as a summary of the test activities that will be performed.
It shows how the tests will be organized, and outlines all of the testers’ needs which must be met in order to properly carry out the test.
The test plan should be inspected by members of the engineering team and senior managers.
Test Cases
A test case is a description of a specific interaction that a tester will have in order to test a single behavior of the software. Test cases are very similar to use cases, in that they are step-by-step narratives which define a specific interaction between the user and the software.
A typical test case is laid out in a table, and includes:
A unique name and number

A requirement which this test case is exercising
Preconditions which describe the state of the software before the test case (which is often a previous test case that must always be run before the current test case)
Steps that describe the specific steps which make up the interaction
Expected Results which describe the expected state of the software after the test case is executed
Test cases must be repeatable.
Good test cases are data-specific, and describe each interaction necessary to repeat the test exactly.
Test Execution
The software testers begin executing the test plan after the programmers deliver the alpha build, or a build that they feel is feature complete.
The alpha should be of high quality—the programmers should feel that it is ready for release, and as good as they can get it.
There are typically several iterations of test execution.
The first iteration focuses on new functionality that has been added since the last round of testing.
A regression test is a test designed to make sure that a change to one area of the software has not caused any other part of the software which had previously passed its tests to stop working.
Regression testing usually involves executing all test cases which have previously been executed.
There are typically at least two regression tests for any software project and implimentation.
Defect Tracking
The defect tracking system is a program that testers use to record and track defects. It routes each defect between testers, developers, the project and implimentation manager and others, following a workflow designed to ensure that the defect is verified and repaired.
Every defect encountered in the test run is recorded and entered into a defect tracking system so that it can be prioritized.
The defect workflow should track the interaction between the testers who find the defect and the programmers who fix it. It should ensure that every defect can be properly prioritized and reviewed by all of the stakeholders to determine whether or not it should be repaired. This process of review and prioritization referred to as triage.
Smoke Tests
A smoke test is a subset of the test cases that is typically representative of the overall test plan.
Smoke tests are good for verifying proper deployment or other non invasive changes.
They are also useful for verifying a build is ready to send to test.
Smoke tests are not substitute for actual functional testing.
Test Automation
Test automation is a practice in which testers employ a software tool to reduce or eliminate repetitive tasks.
Testers either write scripts or use record-and-playback to capture user interactions with the software being tested.
This can save the testers a lot of time if many iterations of testing will be required.
It costs a lot to develop and maintain automated test suites, so it is generally not worth developing them for tests that will executed only a few times.
Postmortem Reports
The postmortem report is an overall account of the team’s experience in building the software, and of the experience of the users and stakeholders in working with the team.
The report should contain an honest assessment of how the team members, users, and stakeholders perceived the end product, and assessed the decisions made throughout the project and implimentation.
The purpose of the post-mortem report is to highlight the team’s successes and identify any problems which should be fixed in future releases.
Reply
smart paper boy
Active In SP
**

Posts: 2,053
Joined: Jun 2011
#5
19-07-2011, 09:48 AM


.ppt   Software Project Management.ppt (Size: 3.42 MB / Downloads: 65)
Software Project Management Rational Unified Framework
Part 1 Software Management Renaissance Introduction
In the past ten years, typical goals in the software process improvement of several companies are to achieve a 2x, 3x, or 10x increase in productivity, quality, time to market, or some combination of all three, where x corresponds to how well the company does now.
The funny thing is that many of these organizations have no idea what x is, in objective terms.
Part 1 Software Management Renaissance
Part 1 Software Management Renaissance Table of Contents (1)
The Old Way (Conventional SPM)
The Waterfall Model
Conventional Software Management Performance
Evolution of Software Economics
Software Economics
Pragmatic Software Cost Estimation
Part 1 Software Management Renaissance Table of Contents (2)
Improving Software Economics
Reducing Software Product Size
Improving Software Processes
Improving Team Effectiveness
Improving Automation through Software Environments
Achieving Required Quality
Peer Inspections: A Pragmatic View
The Old Way and the New
The Principles of Conventional Software Engineering
The Principles of Modern Software Management
Transitioning to an Iterative Process
The Old Way
Part 1 The Old Way
Software crisis
“The best thing about software is its flexibility”
It can be programmed to do almost anything.
“The worst thing about software is also its flexibility”
The “almost anything ” characteristic has made it difficult to plan, monitor, and control software development.
Part 1 The Old Way The Waterfall Model
Drawbacks
Protracted integration
and late design breakage
Late risk resolution
Requirements - driven
functional decomposition
Adversarial stakeholder relationships
Focus on document
and review meetings
Part 1 The Old Way Conventional Software Management Performance
Finding and fixing a software problem after delivery costs 100 times more than finding and fixing the problem in early design phases.
You can compress software development schedules 25% of nominal, but no more.
For every $1 you spend on development, you will spend $2 on maintenance.
Software development and maintenance costs are primarily a function of the number of source lines of code.
Variations among people account for the biggest differences in software productivity.
The overall ratio of software to hardware costs is still growing. In 1955 it was 15:85; in 1985, 85:15.
Only about 15% of software development effort is devoted to programming.
Walkthroughs catch 60% of the errors.
80% of the contribution comes from 20% of contributors.
Part 1 Evolution of Software Economics
Part 1 Evolution of Software Economics
Most software cost models can be abstracted into a function of five basic parameters:
Size (typically, number of source instructions)
Process (the ability of the process to avoid non-value-adding activities)
Personnel (their experience with the computer science issues and the applications domain issues of the project and implimentation)
Environment (tools and techniques available to support efficient software development and to automate process)
Quality (performance, reliability, adaptability…)
Part 1 Evolution of Software Economics Three generations of software economics
Part 1 Evolution of Software Economics The predominant cost estimation process
Part 1 Evolution of Software Economics Pragmatic software cost estimation
A good estimate has the following attributes:
It is conceived and supported by the project and implimentation manager, architecture team, development team, and test team accountable for performing the work.
It is accepted by all stakeholders as ambitious but realizable.
It is based on a well defined software cost model with a credible basis.
It is based on a database of relevant project and implimentation experience that includes similar processes, technologies, environments, quality requirements, and people.
It is defined in enough detail so that its key risk areas are understood and the probability of success is objectively assessed.

Part 1 Improving Software Economics
Five basic parameters of the software cost model:
Reducing the size or complexity of what needs to be developed
Improving the development process
Using more-skilled personnel and better teams (not necessarily the same thing)
Using better environments (tools to automate the process)
Trading off or backing off on quality thresholds
Part 1 Improving Software Economics Important trends in improving software economics
Cost model parameters Trends
Part 1 Improving Software Economics Reducing Software Product Size
“The most significant way
to improve affordability and return on investment is usually to produce a product that achieves the design goals with the minimum amount of human-generated source material.”
Part 1 Improving Software Economics Reducing Software Product Size - Languages
Part 1 Improving Software Economics Reducing Software Product Size – Object-Oriented Methods
“An object-oriented model of the problem and its solution encourages a common vocabulary between the end users of a system and its developers, thus creating a shared understanding of the problem being solved.”
Here is an example of how object-oriented technology permits corresponding improvements in teamwork and interpersonal communications.
“The use of continuous integration creates opportunities to recognize risk early and make incremental corrections without destabilizing the entire development effort.”
This aspect of object-oriented technology enables an architecture-first process, in which integration is an early and continuous life-cycle activity.
An object-oriented architecture provides a clear separation of concerns among disparate elements of a system, creating firewalls that prevent a change in one part of the system from rending the fabric of the entire architecture.”
This feature of object-oriented technology is crucial to the supporting languages and environments available to implement object-oriented architectures.
Part 1 Improving Software Economics Reducing Software Product Size – Reuse
Number of Projects Using Reusable Components
Part 1 Improving Software Economics Reducing Software Product Size – Commercial Components
Part 1 Improving Software Economics Improving Software Processes

Part 1 Improving Software Economics Improving Team Effectiveness (1)
The principle of top talent: Use better and fewer people.
The principle of job matching: Fit the task to the skills an motivation of the people available.
The principle of career progression: An organization does best in the long run by helping its people to self-actualize.
The principle of team balance: Select people who will complement and harmonize with one another.
The principle of phase-out: Keeping a misfit on the team doesn’t benefit anyone.
Part 1 Improving Software Economics Improving Team Effectiveness (2)
Important Project Manager Skills:
Hiring skills. Few decisions are as important as hiring decisions. Placing the right person in the right job seems obvious but is surprisingly hard to achieve.
Customer-interface skill. Avoiding adversarial relationships among stake-holders is a prerequisite for success.
Decision-making skill. The jillion books written about management have failed to provide a clear definition of this attribute. We all know a good leader when we run into one, and decision-making skill seems obvious despite its intangible definition.
Team-building skill. Teamwork requires that a manager establish trust, motivate progress, exploit eccentric prima donnas, transition average people into top performers, eliminate misfits, and consolidate diverse opinions into a team direction.
Selling skill. Successful project and implimentation managers must sell all stakeholders (including themselves) on decisions and priorities, sell candidates on job positions, sell changes to the status quo in the face of resistance, and sell achievements against objectives. In practice, selling requires continuous negotiation, compromise, and empathy.
Part 1 Improving Software Economics Achieving Required Quality
Key practices that improve overall software quality:
Focusing on driving requirements and critical use cases early in the life cycle, focusing on requirements completeness and traceability late in the life cycle, and focusing throughout the life cycle on a balance between requirements evolution, design evolution, and plan evolution
Using metrics and indicators to measure the progress and quality of an architecture as it evolves from a high-level prototype into a fully compliant product
Providing integrated life-cycle environments that support early and continuous configuration control, change management, rigorous design methods, document automation, and regression test automation
Using visual modeling and higher level language that support architectural control, abstraction, reliable programming, reuse, and self-documentation
Early and continuous insight into performance issues through demonstration-based evaluations
Part 1 The Old Way and the New
Part 1 The Old Way and the New The Principles of Conventional Software Engineering
Make quality #1. Quality must be quantified and mechanism put into place to motivate its achievement.
High-quality software is possible. Techniques that have been demonstrated to increase quality include involving the customer, prototyping, simplifying design, conducting inspections, and hiring the best people.
Give products to customers early. No matter how hard you try to learn users’ needs during the requirements phase, the most effective way to determine real needs is to give users a product and let them play with it.
Determine the problem before writing the requirements. When faced with what they believe is a problem, most engineers rush to offer a solution. Before you try to solve a problem, be sure to explore all the alternatives and don’t be blinded by the obvious solution.
Evaluate design alternatives. After the requirements are agreed upon, you must examine a variety of architectures and algorithms. You certainly do not want to use an “architecture” simply because it was used in the requirements specification.
Use an appropriate process model. Each project and implimentation must select a process that makes the most sense for that project and implimentation on the basis of corporate culture, willingness to take risks, application area, volatility of requirements, and the extent to which requirements are well understood.
Use different languages for different phases. Our industry’s eternal thirst for simple solutions to complex problems has driven many to declare that the best development method is one that uses the same notation through-out the life cycle. Why should software engineers use Ada for requirements, design, and code unless Ada were optimal for all these phases?
Minimize intellectual distance. To minimize intellectual distance, the software’s structure should be as close as possible to the real-world structure.
Put techniques before tools. An undisciplined software engineer with a tool becomes a dangerous, undisciplined software engineer.
Get it right before you make it faster. It is far easier to make a working program run than it is to make a fast program work. Don’t worry about optimization during initial coding.
Part 1 The Old Way and the New The Principles of Conventional Software Engineering
Inspect code. Inspecting the detailed design and code is a much better way to find errors than testing.
Good management is more important than good technology. The best technology will not compensate for poor management, and a good manager can produce great results even with meager resources. Good management motivates people to do their best, but there are no universal “right” styles of management.
People are the key to success. Highly skilled people with appropriate experience, talent, and training are key. The right people with insufficient tools, languages, and process will succeed. The wrong people with appropriate tools, languages, and process will probably fail.
Follow with care. Just because everybody is doing something does not make it right for you. It may be right, but you must carefully assess its applicability to your environment. Object orientation, measurement, reuse, process improvement, CASE, prototyping-all these might increase quality, decrease cost, and increase user satisfaction. The potential of such techniques is often oversold, and benefits are by no means guaranteed or universal.
Take responsibility. When a bridge collapses we ask, “what did the engineers do wrong?” Even when software fails, we rarely ask this. The fact is that in any engineering discipline, the best methods can be used to produce awful designs, and the most antiquated methods to produce elegant design.
Understand the customer’s priorities. It is possible the customer would tolerate 90% of the functionality delivered late if they could have 10% of it on time.
The more they see, the more they need. The more functionality (or performance) you provide a user, the more functionality (or performance) the user wants.
Plan to throw one away .One of the most important critical success factors is whether or not a product is entirely new. Such brand-new applications, architectures, interfaces, or algorithms rarely work the first time.
Design for change. The architectures, components, and specification techniques you use must accommodate change.
Design without documentation is not design. I have often heard software engineers say, “I have finished the design. All that is left is the documentation.”
Part 1 The Old Way and the New The Principles of Conventional Software Engineering
21.Use tools, but be realistic. Software tools make
Part 1 The Old Way and the New The Principles of Modern Software Management
The central design element
Part 2 A Software Management Process Framework
Part 2 A Software Management Process Framework Table of Contents (1)
Life-Cycle Phases
Engineering and Production Stages
Inception Phase
Elaboration Phase
Construction Phase
Transition Phase
Artifacts of the Process
The Artifact Sets
Management Artifacts
Engineering Artifacts
Pragmatic Artifacts
Part 2 A Software Management Process Framework Table of Contents (2)
Model-based software Architectures
Architecture: A Management Perspective
Architecture: A Technical Perspective
Workflows of the Process
Software Process Workflows
Iteration Workflows
Checkpoints of the Process
Major Milestones
Minor Milestones
Periodic Status Assessments
Part 2 Life-Cycle Phases Engineering and Production Stages
Part 2 Life-Cycle Phases Engineering and Production Stages
Part 2 Life-Cycle Phases Inception Phase
Part 2 Life-Cycle Phases Elaboration Phase
Part 2 Life-Cycle Phases Construction Phase
Part 2 Life-Cycle Phases Transition Phase
Part 2 Life-Cycle Phases
Part 2 Artifacts of the Process
Part 2 Artifacts of the Process Management Artifacts
Part 2 Artifacts of the Process Management Artifacts
Part 2 Artifacts of the Process Management Artifacts
Part 2 Artifacts of the Process Engineering Artifacts
Part 2 Artifacts of the Process Engineering Artifacts
Part 2 Artifacts of the Process Pragmatic Artifacts
Part 2 Model-Based Software Architectures A Management Perspective
Part 2 Model-Based Software Architectures A Management Perspective
Part 2 Model-Based Software Architectures A Technical Perspective
Part 2 Model-Based Software Architectures A Technical Perspective
Part 2 Workflows of the Process Software Process Workflows
Part 2 Workflows of the Process Software Process Workflows
Part 2 Workflows of the Process Iteration Workflows
Part 2 Workflows of the Process Iteration Workflows
Part 2 Checkpoints of the Process
Part 2 Checkpoints of the Process
Part 3 Software Management Disciplines






Part 3 Software Management Disciplines Table of Contents (1)
Iterative Process Planning
Work Breakdown Structures
Planning Guidelines
The Cost and Schedule Estimating Process
The Iteration Planning Process
Pragmatic Planning
Project Organizations and Responsibilities
Line-of-Business organizations
Project Organizations
Evolution Organizations
Process Automation
Tools: Automation Building Blocks
The Project Environment
Part 3 Software Management Disciplines Table of Contents (2)
Project Control and Process Instrumentation
The Seven Core Metrics
Management Indicators
Quality Indicators
Life-Cycle Expectations
Pragmatic Software Metrics
Metrics Automation
Tailoring the Process
Process Discriminants
Example: Small-Scale Project Versus Large-scale Project
Part 3 Iterative Process Planning Work Breakdown Structures
Part 3 Iterative Process Planning Planning Guidelines
Part 3 Iterative Process Planning The Cost and Schedule Estimating Process
Part 3 Iterative Process Planning The Cost and Schedule Estimating Process
Part 3 Iterative Process Planning The Iteration Planning Process
Part 3 Project Organizations and Responsibilities Line-of-Business Organizations
Default roles in a software line-of-business organizations
Part 3 Project Organizations and Responsibilities Project Organizations
Software Management Team
Part 3 Project Organizations and Responsibilities Project Organizations
Software Architecture Team
Part 3 Project Organizations and Responsibilities Project Organizations
Software Development Team
Part 3 Project Organizations and Responsibilities Project Organizations
Software Assessment Team
Part 3 Project Organizations and Responsibilities Evolution of Organizations
Part 3 Process Automation Computer-aided software engineering
Computer-aided software engineering (CASE) is software to support software development and evolution processes.
Activity automation
Graphical editors for system model development;
Data dictionary to manage design entities;
Graphical UI builder for user interface construction;
Debuggers to support program fault finding;
Automated translators to generate new versions of a program.
Part 3 Process Automation Computer-aided software engineering (CASE) Technology
Case technology has led to significant improvements in the software process. However, these are not the order of magnitude improvements that were once predicted
Software engineering requires creative thought - this is not readily automated;
Software engineering is a team activity and, for large project and implimentations, much time is spent in team interactions. CASE technology does not really support these.
Part 3 Process Automation CASE Classification
Classification helps us understand the different types of CASE tools and their support for process activities.
Functional perspective
Tools are classified according to their specific function.
Process perspective
Tools are classified according to process activities that are supported.
Integration perspective
Tools are classified according to their organisation into integrated units.
Part 3 Process Automation Functional Tool Classification
Part 3 Process Automation CASE Integration
Tools
Support individual process tasks such as design consistency checking, text editing, etc.
Workbenches
Support a process phase such as specification or design, Normally include a number of integrated tools.
Environments
Support all or a substantial part of an entire software process. Normally include several integrated workbenches.
Part 3 Process Automation Tools, Workbenches, Environments
Part 3 Project Control and Process Instrumentation The Core Metrics
Part 3 Tailoring the Process Process Discriminants
The two primary dimensions of process variability
Part 3 Tailoring the Process Example: Small-Scale Project vs. Large-Scale Project
Differences in workflow priorities between small and large project and implimentations
Part 4 Looking Forward
Part 4 Looking Forward Table of Contents
Modern Project Profiles
Continuous Integration
Early Risk Resolution
Evolutionary Requirements
Teamwork Among Stakeholders
Top 10 Software Management Principles
Software Management Best Practices
Next-Generation Software Economics
Next-Generation Cost Models
Modern Software Economics
Modern Process Transitions
Culture Shifts
Denouement
Part 4 Modern Project Profiles Continuous Integration
Part 4 Modern Project Profiles Continuous Integration
Part 4 Modern Project Profiles Early Risk Resolution
Part 4 Modern Project Profiles Evolutionary Requirements
Part 4 Modern Project Profiles Teamwork among stakeholders
Part 4 Modern Project Profiles Top 10 Software Management Principles
Part 4 Modern Project Profiles Top 10 Software Management Principles
Part 4 Modern Project Profiles Software Management Best Practices
Part 4 Next-Generation Software Economics Next-Generation Cost Models
Part 4 Next-Generation Software Economics Next-Generation Cost Models
Part 4 Next-Generation Software Economics Modern Software Economics
Part 4 Next-Generation Software Economics Modern Software Economics
Part 4 Modern Process Transitions Culture Shifts
Part 4 Modern Process Transitions Denouement
Appendix
Appendix Use Case Analysis
What is a Use Case?
A sequence of actions a system performs that yields a valuable result for a particular actor.
What is an Actor?
A user or outside system that interacts with the system being designed in order to obtain some value from that interaction
Use Cases describe scenarios that describe the interaction between users of the system and the system itself.
Use Cases describe WHAT the system will do, but never HOW it will be done.
Appendix What’s in a Use Case?
Define the start state and any preconditions that accompany it
Define when the Use Case starts
Define the order of activity in the Main Flow of Events
Define any Alternative Flows of Events
Define any Exceptional Flows of Events
Define any Post Conditions and the end state
Mention any design issues as an appendix
Accompanying diagrams: State, Activity, Sequence Diagrams
View of Participating Objects (relevant Analysis Model Classes)
Logical View: A View of the Actors involved with this Use Case, and any Use Cases used or extended by this Use Case
Appendix Use Cases Describe Function not Form
Use Cases describe WHAT the system will do, but never HOW it will be done.
Use Cases are Analysis Products, not Design Products.
Appendix Use Cases Describe Function not Form
Use Cases describe WHAT the system should do, but never HOW it will be done
Use cases are Analysis products, not design products
Appendix Benefits of Use Cases
Use cases are the primary vehicle for requirements capture in RUP
Use cases are described using the language of the customer (language of the domain which is defined in the glossary)
Use cases provide a contractual delivery process (RUP is Use Case Driven)
Use cases provide an easily-understood communication mechanism
When requirements are traced, they make it difficult for requirements to fall through the cracks
Use cases provide a concise summary of what the system should do at an abstract (low modification cost) level.
Appendix Difficulties with Use Cases
As functional decompositions, it is often difficult to make the transition from functional description to object description to class design
Reuse at the class level can be hindered by each developer “taking a Use Case and running with it”. Since UCs do not talk about classes, developers often wind up in a vacuum during object analysis, and can often wind up doing things their own way, making reuse difficult
Use Cases make stating non-functional requirements difficult (where do you say that X must execute at Y/sec?)
Testing functionality is straightforward, but unit testing the particular implementations and non-functional requirements is not obvious
Appendix Use Case Model Survey
The Use Case Model Survey is to illustrate, in graphical form, the universe of Use Cases that the system is contracted to deliver.
Each Use Case in the system appears in the Survey with a short description of its main function.
Participants:
Domain Expert
Architect
Analyst/Designer (Use Case author)
Testing Engineer

Appendix Sample Use Case Model Survey
Appendix Analysis Model
In Analysis, we analyze and refine the requirements described in the Use Cases in order to achieve a more precise view of the requirements, without being overwhelmed with the details
Again, the Analysis Model is still focusing on WHAT we’re going to do, not HOW we’re going to do it (Design Model). But what we’re going to do is drawn from the point of view of the developer, not from the point of view of the customer
Whereas Use Cases are described in the language of the customer, the Analysis Model is described in the language of the developer:
Boundary Classes
Entity Classes
Control Classes
Appendix Why spend time on the Analysis Model, why not just “face the cliff”?
By performing analysis, designers can inexpensively come to a better understanding of the requirements of the system
By providing such an abstract overview, newcomers can understand the overall architecture of the system efficiently, from a ‘bird’s eye view’, without having to get bogged down with implementation details.
The Analysis Model is a simple abstraction of what the system is going to do from the point of view of the developers. By “speaking the developer’s language”, comprehension is improved and by abstracting, simplicity is achieved
Nevertheless, the cost of maintaining the AM through construction is weighed against the value of having it all along.
Appendix Boundary Classes
Boundary classes are used in the Analysis Model to model interactions between the system and its actors (users or external systems)
Boundary classes are often implemented in some GUI format (dialogs, widgets, beans, etc.)
Boundary classes can often be abstractions of external APIs (in the case of an external system actor)
Every boundary class must be associated with at least one actor:
Appendix Entity Classes
Entity classes are used within the Analysis Model to model persistent information
Often, entity classes are created from objects within the business object model or domain model
Appendix Control Classes
The Great Et Cetera
Control classes model abstractions that coordinate, sequence, transact, and otherwise control other objects
In Smalltalk MVC mechanism, these are controllers
Control classes are often encapsulated interactions between other objects, as they handle and coordinate actions and control flows.
Literature
Software Project Management
A Unified Framework
Walker Royce
Software Processes
©Ian Sommerville 2004
Process and Method:
An Introduction to the Rational Unified Process
Reply
seminar ideas
Super Moderator
******

Posts: 10,003
Joined: Apr 2012
#6
27-07-2012, 02:54 PM

Software Project Management


.doc   Software Project Management.doc (Size: 586 KB / Downloads: 20)


Introduction

A stereotype is one of three types of extensibility mechanisms in the Unified Modeling Language (UML). They allow designers to extend the vocabulary of UML in order to create new model elements derived from existing ones but that have specific properties that are suitable for a particular problem domain or otherwise specialized usage. The nomenclature is derived from the original meaning of stereotype used in printing. For example when modeling a network you might need to have symbols for representing routers and hubs. By using stereotyped nodes you can make these things appear as primitive building blocks.
Graphically a stereotype is rendered as a name enclosed by guillemets « » or if guillemets proper are unavailable << >> and placed above the name of another element. In addition or alternatively it may be indicated by a specific icon. The icon image may even replace the entire UML symbol. For instance in a class diagram stereotypes can be used to classify method behavior such as «constructor» and «getter». Despite its appearance «interface» is not a stereotype but a classifier.
One alternative to stereotypes suggested by Peter Coad in his book Java Modeling in Color with UML. Enterprise Components and Process is the use of colored archetypes. The archetypes indicated by different colored UML boxes can be used in combination with stereotypes. This added definition of meaning indicates the role that the UML object plays within the larger software system.




Stereotypes

Stereotypes are the core extension mechanism of the UML. If you find that you need a modeling construct that isn't in the UML but it is similar to something that is you treat your construct as a stereotype of the UML construct.
An example of this is the interface. A UML interface is a class that has only public operations with no method bodies or attributes. This corresponds to interfaces in java, com and cobra. Since it's a special kind of class it is defined as a stereotype of class.
Stereotypes are usually shown in text between guillemets for example interface but you can also show them by defining an icon for the stereotype.
Many extensions to the core UML can be described as a collection of stereotypes. Within class diagrams these might be stereotypes of classes, associations or generalizations. You can think of the stereotypes as subtypes of the met model types class, association and generalization.
I've noticed that people using the UML tend to confuse constraints and stereotypes. If you mark a class as abstract is that a constraint or a stereotype?
The current official documents call it a constraint but you should be aware that there is a blurred usage between the two. This is not surprising as subtypes are often more constrained than super types. An effort is under way at the OMG to create UML profiles. A profile takes a part of the UML and extends it with stereotypes for a particular purpose. The OMG has started with such things as a real time profile and a cobra Interface Definition Language (IDL) profile. I'm sure that more will follow.



Profile Servers

One profile might reuse some or all parts of another profile, to extend already existing profiles. Multiple profiles could be applied to the same model.
The constraints that are part of the profile are evaluated when the profile has been applied to a package. These constraints need to be satisfied in order for the model to be well formed.
Package since UML 2.4 has optional URI attribute which serves as unique identifier of the package. Profile is a package and the URI attribute was introduced mostly to support exchange of profiles using XMI.


Stereotype Application
Profile diagram is used to show definition of stereotype. Stereotype is applied when it is used on use case diagrams, class diagrams, deployment diagrams etc.
When a stereotype is applied to a model element an instance of the stereotype is linked to an instance of the metaclass. The name of the applied stereotype is shown within a pair of guillemets above or before the name of the model element.
UML versions before 2.4 required the first letter of the name of the applied stereotype to be in lower case e.g. «servlet». Starting from UML 2.4 the first letter should normally be in upper case. Naming stereotype applications with lower case letters where the stereotypes themselves are defined using upper-case first letter is still valid but is considered obsolete.


Reply
seminar flower
Super Moderator
******

Posts: 10,120
Joined: Apr 2012
#7
08-08-2012, 10:03 AM

Software Project Management


.ppt   module1 - Chapter_1.ppt (Size: 959 KB / Downloads: 16)

Introduction

What is software project and implimentation management? Is it really different from ‘ordinary’ project and implimentation management?
Need to look at planning, monitoring & control of s/w project and implimentations
How do you know when a project and implimentation has been successful? For example, do the expectations of the customer/client match those of the developers?
Meet its objectives
Accurate information

Why is SPM important?

Lot of money involved in ICT project and implimentations
Govt spend more on ICT project and implimentations than on other project and implimentations
Mismgmt would mean less money for good things like pensions
Unsuccessful Projects
Report published in 2003, the Standish group in US
Out of 13,522 project and implimentations, only 1/3rd of project and implimentations were successful
82% were late and 43% exceeded their budget

Project – planned activity

Planned – we can determine how we are going to carry out a task before we start.
Exploratory project and implimentations - Planning is difficult
Uncertain project and implimentations – planning may lead to provisional and speculative plans
Routine maintenance - every one involved knows exactly what needs to be done.
Planning hardly seems necessary

Project - Definition

Unique process, consisting of a set of coordinated and controlled activities with start and finish dates, undertaken to achieve an objective conforming to specific requirements, including constraints of time, cost and resources

Characteristics of project and implimentations

A task is more ‘project and implimentation-like’ if it is:
Non-routine
Planned
Aiming at a specific target
Work carried out for a customer
Involving several specialisms
Made up of several different phases
Constrained by time and resources
Large and/or complex

Reply
seminar flower
Super Moderator
******

Posts: 10,120
Joined: Apr 2012
#8
29-10-2012, 10:39 AM

SOFTWARE PROJECT MANAGEMENT


.doc   SOFTWARE PROJECT.doc (Size: 329.5 KB / Downloads: 20)

What Is a COTS Product?

• A product that is
– sold, leased, or licensed to the general public
– offered by a vendor trying to profit from it
– supported and evolved by the vendor, who retains the intellectual property rights
– available in multiple, identical copies
– used without modification of the internals
Almost-COTS Products
• Freeware/Shareware
– Vendor “profit” may not be dollars but some sort of brand recognition.
• Open source
– The “vendor” is the community.
• Restricted distribution products
– “General public” may have restricted meaning.
Ex: In the U.S., products with strong encryption can only be sold to U.S. companies.

What Is a COTS-Based System?

• Any system partially or completely constructed using COTS software products as integral components.
– not measured in percentages
• Examples include
– enterprise resource planning (ERP) systems
– Army C3/C4 systems constructed using a combination of custom and COTS software.

A Spectrum of COTS-Based Systems

COTS-Solution Systems One substantial product (suite) used (and sometimes tailored) to provide significant system functionality:
• integration focus
• vendor maintained

Software Architecture and COTS Softwares:

Choosing or designing an appropriate architecture to fulfill the requirements of a large software system is hard enough. The problem becomes acute when an architect is forced (or chooses) to utilize COTS-based components to provide some functionality of a system.
In a traditional engineering approach a software architect would make architectural decisions based on system requirements, constraints, and business objectives alone. After system architecture plans are stabilized a set of COTS components would be evaluated. According to Lisa Brownsword (SEI) this traditional engineering approach is not suitable for COTS based systems. There may be no suitable COTS components available to suit the specific needs of the envisioned system.
By choosing to use COTS an architect takes on additional risk that he or she cannot control. Vendors may go out of business, choose not to support the existing components, etc. In foreseeable future the time to market pressure will only rise, and customers will continue to expect software intensive systems to be delivered at a faster pace. Sooner or later architects will have to assemble some parts of a system from pre-built blocks, as building those elements from scratch will be cost prohibitive.
Extreme Programming

A gentle introduction:

The first Extreme Programming project and implimentation was started March 6, 1996. Extreme Programming is one of several popular Agile Processes. It has already been proven to be very successful at many companies of all different sizes and industries,worldwide.
Extreme Programming is successful because it stresses customer satisfaction. Instead of delivering everything you could possibly want on some date far in the future this process delivers the software you need as you need it. Extreme Programming empowers your developers to confidently respond to changing customer requirements, even late inthe,lifecycle.
Extreme Programming emphasizes teamwork. Managers, customers, and developers are all equal partners in a collaborative team. Extreme Programming implements a simple, yet effective environment enabling teams to become highly productive. The team self-organizes around the problem to solve it as efficiently as possible.
Extreme Programming improves a software project and implimentation in five essential ways; communication, simplicity, feedback, respect, and courage. Extreme Programmers constantly communicate with their customers and fellow programmers. They keep their design simple and clean. They get feedback by testing their software starting on day one. They deliver the system to the customers as early as possible and implement changes as suggested. Every small success deepens their respect for the unique contributions of each and every team member. With this foundation Extreme Programmers are able to courageously respond to changing requirements and,technology.

What is Extreme Programming?

Extreme Programming is a discipline of software development based on values of simplicity, communication, feedback, and courage. It works by bringing the whole team together in the presence of simple practices, with enough feedback to enable the team to see where they are and to tune the practices to their unique situation.
• Core Practices: Whole Team
Extreme Programming teams use a simple form of planning and tracking to decide what should be done next and to predict when the project and implimentation will be done. Focused on business value, the team produces the software in a series of small fully-integrated releases that pass all the tests the Customer has defined.
• Core Practices: Planning Game, Small Releases, Customer Tests
Extreme Programmers work together in pairs and as a group, with simple design and obsessively tested code, improving the design continually to keep it always just right for the current needs.
Core Practices
All the contributors to an XP project and implimentation sit together, members of one team. This team must include a business representative — the “Customer” — who provides the requirements, sets the priorities, and steers the project and implimentation. It’s best if the Customer or one of her aides is a real end user who knows the domain and what is needed. The team will of course have programmers. The team may include testers, who help the Customer define the customer acceptance tests. Analysts may serve as helpers to the Customer, helping to define the requirements. There is commonly a coach, who helps the team keep on track, and facilitates the process. There may be a manager, providing resources, handling external communication, coordinating activities. None of these roles is necessarily the exclusive property of just one individual: Everyone on an XP team contributes in any way that they can. The best teams have no specialists, only general contributors with special skills.

Why "Extreme"?

"Extreme" means these practices get "turned up" to a much higher "volume" than on traditional project and implimentations. XP ignores any other practice (like BigDesignUpFront) that does not appear on the list. The result is stable, productive, and very rapid because the practices support each other the more they are used together without interference. An Extreme project and implimentation is typically so stable and sedate it can lead to FortyHourWeeks without any schedule slips.

Conclusion

Extreme Programming is a discipline of software development based on values of simplicity, communication, feedback, and courage. It works by bringing the whole team together in the presence of simple practices, with enough feedback to enable the team to see where they are and to tune the practices to their unique situation.
Reply
seminar tips
Super Moderator
******

Posts: 8,857
Joined: Oct 2012
#9
08-01-2013, 12:49 PM

to get information about the topic "Software Project Management" full report ppt and related topic refer the link bellow

topicideashow-to-software-project and implimentation-management

topicideashow-to-software-project and implimentation-management-and-monitoring-system

topicideashow-to-software-project and implimentation-management-system

topicideashow-to-software-project and implimentation-management-concepts

topicideashow-to-introduction-to-software-project and implimentation-management-report?pid=131298#pid131298
Reply

Important Note..!

If you are not satisfied with above reply ,..Please

ASK HERE

So that we will collect data for you and will made reply to the request....OR try below "QUICK REPLY" box to add a reply to this page

Quick Reply
Message
Type your reply to this message here.


Image Verification
Please enter the text contained within the image into the text box below it. This process is used to prevent automated spam bots.
Image Verification
(case insensitive)

Possibly Related Threads...
Thread Author Replies Views Last Post
  ONLINE EL-CHICO RESTAURANT MANAGEMENT SYSTEM seminar flower 1 620 08-04-2016, 11:10 AM
Last Post: mkaasees
  PROJECT ON HOSPITAL MANAGEMENT SYSTEM seminar flower 1 930 01-04-2016, 11:54 AM
Last Post: mkaasees
  ABSTRACT ON REPORT HOSPITAL MANAGEMENT SYSTEM study tips 1 578 01-04-2016, 11:53 AM
Last Post: mkaasees
  ms dos linker in system software ppt jaseelati 0 410 18-12-2014, 04:51 PM
Last Post: jaseelati
  HOSTEL MANAGEMENT SYSTEM pdf seminar tips 3 7,587 09-12-2014, 03:42 PM
Last Post: mkaasees
  scholarship MANAGEMENT SYSTEM seminar tips 6 5,098 12-08-2014, 07:56 AM
Last Post: donsilver
  Color Lab Management System seminar ideas 9 5,312 11-06-2014, 10:04 AM
Last Post: seminar project topic
  Project Ideas- Hostel Management System Using Oracle mvaravinda 0 2,070 29-10-2013, 05:34 PM
Last Post: mvaravinda
  Project Ideas- Hostel Management System mvaravinda 0 874 29-10-2013, 05:30 PM
Last Post: mvaravinda
Wink Jewellery Management System mvaravinda 0 812 29-10-2013, 05:27 PM
Last Post: mvaravinda