Looking ahead Your final-year project. In final year you do a project...  For these courses, it ’ s assumed you will build an “ artefact ”, and report.

Slides:



Advertisements
Similar presentations
INSE - Lecture 15  SE Project Management  This lecture is a brief overview –  mainly things to remember to do!
Advertisements

INSE - Lecture 16  Documentation  Configuration Management  Program Support Environments  Choice of Programming Language.
Verification and Validation
Annoucements  Next labs 9 and 10 are paired for everyone. So don’t miss the lab.  There is a review session for the quiz on Monday, November 4, at 8:00.
The “Lifecycle” of Software. Chapter 5. Alternatives to the Waterfall Model The “Waterfall” model can mislead: boundaries between phases are not always.
INSE - Lecture 11 Testing u Verification testing vs pursuit testing u Philosophy of testing u Stages of testing u Methods of testing u Design of test data.
1 CS 501 Spring 2003 CS 501: Software Engineering Lecture 2 Software Processes.
Chapter 15 Design, Coding, and Testing. Copyright © 2005 Pearson Addison-Wesley. All rights reserved Design Document The next step in the Software.
Software Evolution Managing the processes of software system change
System Design and Analysis
Business Intelligence Michael Gross Tina Larsell Chad Anderson.
SE 450 Software Processes & Product Metrics Reliability Engineering.
Modified from Sommerville’s originalsSoftware Engineering, 7th edition. Chapter 21 Slide 1 Software evolution.
CS 501: Software Engineering
Project Life Cycle Jon Ivins DMU. Introduction n Projects consist of many separate components n Constraints include: time, costs, staff, equipment n Assets.
16/27/2015 3:38 AM6/27/2015 3:38 AM6/27/2015 3:38 AMTesting and Debugging Testing The process of verifying the software performs to the specifications.
Software evolution.
1 CS 501 Spring 2005 CS 501: Software Engineering Lecture 26 Delivering the System.
Software maintenance Managing the processes of system change.
©Ian Sommerville 2000 Software Engineering, 6th edition. Chapter 27Slide 1 Chapter 27 Software Change.
Chapter 9 – Software Evolution and Maintenance
CASE Tools And Their Effect On Software Quality Peter Geddis – pxg07u.
Computer Programming and Basic Software Engineering 4. Basic Software Engineering 1 Writing a Good Program 4. Basic Software Engineering.
Introduction to Systems Analysis and Design Trisha Cummings.
CSC 395 – Software Engineering Lecture 34: Post-delivery Maintenance -or- What’s Worse than Being a Code Monkey?
Verification and Validation Yonsei University 2 nd Semester, 2014 Sanghyun Park.
1 Software Testing (Part-II) Lecture Software Testing Software Testing is the process of finding the bugs in a software. It helps in Verifying and.
Software evolution. Objectives l To explain why change is inevitable if software systems are to remain useful l To discuss software maintenance and maintenance.
Software change  Managing the processes of software system change.
ICAPRG301A Week 4Buggy Programming ICAPRG301A Apply introductory programming techniques Program Bugs US Navy Admiral Grace Hopper is often credited with.
Software Engineering CS3003 Lecture 3 Software maintenance and evolution.
Teaching material for a course in Software Project Management & Software Engineering – part II.
OHTO -99 SOFTWARE ENGINEERING “SOFTWARE PRODUCT QUALITY” Today: - Software quality - Quality Components - ”Good” software properties.
Chapter 2: Software Process Omar Meqdadi SE 2730 Lecture 2 Department of Computer Science and Software Engineering University of Wisconsin-Platteville.
©Ian Sommerville 2000 Software Engineering, 6th edition. Chapter 3 Slide 1 Software Processes l Coherent sets of activities for specifying, designing,
MBA essay topic analysis for the year Stanford University Another essay that involves quite a lot of work from the applicant. But the best part.
Chapter 11: Software Prototyping Omar Meqdadi SE 273 Lecture 11 Department of Computer Science and Software Engineering University of Wisconsin-Platteville.
©Ian Sommerville 2000 Software Engineering, 6th edition. Chapter 8 Slide 1 Software Prototyping l Rapid software development to validate requirements.
1 The Software Development Process  Systems analysis  Systems design  Implementation  Testing  Documentation  Evaluation  Maintenance.
©Ian Sommerville 2000 Software Engineering, 6th edition. Chapter 27Slide 1 Software change l Managing the processes of software system change.
Lecture 3 Software Engineering Models (Cont.)
OHTO -99 SOFTWARE ENGINEERING “SOFTWARE PRODUCT QUALITY” Today: - Software quality - Quality Components - ”Good” software properties.
Intermediate 2 Software Development Process. Software You should already know that any computer system is made up of hardware and software. The term hardware.
©Ian Sommerville 2004 Software Engineering. Chapter 21Slide 1 Chapter 21 Software Evolution.
This material is approved for public release. Distribution is limited by the Software Engineering Institute to attendees. Sponsored by the U.S. Department.
Difference between an “A” student and a “C” Student ► They are always prepared for class. They always respond when called on. Their attention to detail.
Chapter 12: Software Inspection Omar Meqdadi SE 3860 Lecture 12 Department of Computer Science and Software Engineering University of Wisconsin-Platteville.
1 CS 501 Spring 2004 CS 501: Software Engineering Lecture 2 Software Processes.
©Ian Sommerville 2004Software Engineering, 7th edition. Chapter 21 Slide 1 Software evolution 1.
Software Prototyping Rapid software development to validate requirements.
1 One Last Book, One Last Topic Code reviews / software inspections.
Software Engineering – University of Tampere, CS DepartmentJyrki Nummenmaa SOFTWARE PRODUCT QUALITY Today: - Software quality -
INSE - Lecture 8 Design Tactics (2) - Modular structure u Notations for design documents u Verification of design.
By Anthony W. Hill & Course Technology1 Troubleshooting Computer Problems.
CSC 480 Software Engineering Test Planning. Test Cases and Test Plans A test case is an explicit set of instructions designed to detect a particular class.
System Maintenance Modifications or corrections made to an information system after it has been released to its customers Changing an information system.
©Ian Sommerville 2004Software Engineering, 7th edition. Chapter 21 Slide 1 Software evolution.
Chapter 9 – Software Evolution 1Chapter 9 Software evolution.
AVCE ICT – Unit 7 - Programming Session 12 - Debugging.
© SERG Reverse Engineering (Software Maintenance & Reengineering) Software Maintenance Managing the processes of system change.
Chapter 18 Maintaining Information Systems
Chapter 8 – Software Testing
Software Processes (a)
Software Processes.
Introduction to Systems Analysis and Design
Chapter 9 – Software Evolution and Maintenance
Chapter 27 Software Change.
Business Intelligence
Chapter 8 Software Evolution.
Chapter 15 Debugging.
Presentation transcript:

Looking ahead Your final-year project

In final year you do a project...  For these courses, it ’ s assumed you will build an “ artefact ”, and report on the building of it.  It ’ s marked on the cleverness, innovation, problem-solving ability, insight etc. shown in the report.

Project topic  Ideally clever & small - you then have the time to deal with it properly.  You choose the topic, in consultation with possible supervisors.  ( “ Your ” topic => motivation => better projects.)  Staff may suggest project topics, or topic areas though.

Clearly, my suggestions are …  … mainly Software Engineering topics …  SE projects tend to need advance preparation …  … which is why I ’ m raising the issue now, so we can talk through possible projects over the rest of this year.

My special SE interests  Program tools to help design & code: –graphic editors for design; –prototypers; –programming-language oriented text editors; –program provers; –configuration management tools; –…–…  Programming languages

Other S.E. staff  No other SE specialists at the moment, but various staff I ’ d point you at for particular aspects – me for suggestions!

INSE - Lecture 12 Debugging; Maintenance

Debugging

A thought Glendower: I can call up spirits from the vasty deep Hotspur: Why, so can I, or so can any man, but will they come when you do call for them? Henry IV, part 1, Act 3 scene 1 u So when you know there ’ s a bug - finding it takes some mix of persistence, luck, skill and thought. u Skill and thought don ’ t “ just happen ”.

Debugging is... u time-consuming u reveals one ’ s own errors, so is … –often inefficiently done, so … »AVOID IT as much as possible u “ Short cuts ” in design & coding are false economy: –take extreme care in design –struggle for highest legibility of code u In maintenance: –if something works, don ’ t tamper.

Effective debugging (1) u Simplify it! –unit test any fragment that you feel might have a bug, no matter how small, & debug; –size modules so they probably have tiny numbers of bugs, and debug; –system test for small new combinations, and debug. u So then you only need to deal with a tiny number of bugs at a time.

Effective debugging (2) u Design every verification test to trap as many classes of bug as possible –avoids messy test-then-debug-then-test- then-debug … cycles

When there is a bug... u...you often need to improvise a “ pursuit test ” targeted on chasing the bug - –obvious, but often overlooked, especially by beginners. u … follow the logic of the bug back towards it ’ s origin ( “ back-deduction ” ) - –also obvious but often overlooked, especially by beginners.

Where is the bug? u Locate the region of the program that the bug is in - –e.g. in response to a mysteriously corrupted variable - what/where is corrupting it? –“ wolf fence ” tactic »(Also called “ divide and conquer ” ).

Having put in debugging code u It was expensive! keep it! u Comment it out: //... some debug code... u Eliminate it by conditional compilation: final boolean DEBUGGING = False; … if (DEBUGGING) { … some debug code … }

Dynamic debuggers... u … are now common extras for compilers and IDEs: –you can set “ break-points ”, then execute to the first break-point reached; –you can restart from a break-point till the next is reached; –you can “ single-step ” ; –you can monitor the values of variables; –you can change the values of variables; –...

Aptitudes for debugging u Ability to spot obscure patterns; u Ability to separate interleaved patterns; u Meticulousness; u Tenacity; u Judgement; u Intuition; u LUCK!!!

Maintenance  expense & risk  corrective, innovative & perfective maintenance  rate of discovery of bugs  aptitudes for maintenance

Maintenance is expensive  Most Industry reports say between 60% and 90% of total programming effort is maintenance;  quite where in that range seems to correlate to various sections of the industry;  high end => long life with regular need for functional change;  also varies with the effort that went into making the software maintainable and keeping it so!

Maintenance is risky  You are changing something beyond it ’ s original design …  … will the design stand up to the changes?  MORAL: designs should have flexibility build in.

Kinds of maintenance  Corrective - is really debugging, done late (the user reported the bug)  Innovative - adding new capabilities, perhaps updating old ones  Perfective - internal improvement to correct software not needing any innovation or update.

Corrective maintenance  Fixing errors (or other severe deficiencies) in a version of the software being used by customers;  therefore much more fraught than “ normal ” debugging.  Often –either not obvious where (in spec/design/ code) it originates; –or blatantly a result of wrong requirements or mis-specification!

Innovative maintenance  The requirements have changed...  … maybe new facilities are needed/ desired;  … maybe the real-world situation has changed;  … maybe there ’ s a perception that the real-world situation could be modelled better.

Perfective maintenance  Improving perceived quality, or...  Improving actual (internal) quality, or …  Increasing capacity, or …  Increasing speed, or...

Rate of discovery of bugs

Staffing of maintenance  … perhaps because their managers told them to repair the old one …  MORALS: –keep the team stable; –manage it thoughtfully.

After this lecture (1) u STRATEGIES FOR DEBUGGING: –avoid; –simplify. u TACTICS: –back-deduce (location by history); –wolf-fence (location by geography). u TOOLS: –dynamic debuggers. –(read the manual for others in the compiler or IDE).

After this lecture (2)  Build for maintainability;  Maintain thoughtfully;  Staff issues for maintainability – choose well!  This is another issue for long-term thought about your experience, and what you observe of other people ’ s experience.

u © C Lester

Revisiting “ risks of maintenance ”