SDD

    avatar
    Created by
    Eva

    Cards (31)

    • Iterative Vs agile software development - Client interaction 

      Iterative

      Client is involved in the initial analysis stage and at the end of development to see if the software meets their needs

      Agile

      Client is involved throughout, giving constant feedback. |
      Feedback is quickly acted upon, changing goals during the process can be positive in terms of final client satisfaction
    • Iterative Vs Agile software development - Teamwork 

      Iterative
      Team of programmers work independently on each phase of development, mainly work in isolation with some communication required between phases
      Agile
      Team of programmers collaborate rather than teams working independently, face to face communication between people with different skills is important in progressing the project quickly
    • Iterative Vs Agile software development - Documentation 

      Iterative
      A detailed project specification is created at the start of the development process, time is spend during the project on design, program commentary and test plans
      Agile
      Focuses on reducing documentation, spends time on small cycles of coding, testing and adapting to change, any documentation produced should focus purely on progressing the project
    • Iterative Vs Agile software development - Measurement of progress

      Iterative
      Follows a strict plan with progress measured against timescales set at the beginning of the progress

      Agile
      Breaks a project into a series of short development goals. This involves cross-functional teams working on: planning, analysis, design, coding, unit testing and acceptance testing
      Agile focuses on delivering software as quickly as possible
    • Predictive Vs Adaptive 

      Predictive
      Rely on effective early phase analysis and if this goes wrong, the project may have difficulty changing direction. 
      Institute a change control board to ensure they consider only the most valuable changes. 
      Adaptive
      An adaptive team has difficulty describing exactly what they will do next week but could report on which features they plan for next month. 
      The further away a date is, the vaguer an adaptive method is about what will happen on that date.
    • Iterative Vs Agile software development - Testing 

      Iterative
      Testing is carried out when the implementation phases has been completed
      Agile
      There is no recognised testing stage, testing is carried out throughout the development
    • Analysis
      • Purpose: a general description of the purpose of the software. 
      • Scope: a list of the deliverables that the project will hand over to the client and/or end- user, e.g., design or completed program. It can also include any time limits for the project. 
      • Boundaries: the limits that help to define what is in the project and what is not. It can also clarify any assumptions made by the software developers regarding the client’s requirements. 
      • Functional requirements: the features and functions that must be delivered by the system in terms of inputs, processes and outputs. 
       
    • Design
      PSUEDOCODE
      • Top level design — the major steps of the design.
      • Data flow — shows the information that must flow In or Out from the sub-programs.
      • Refinements — break down the design from the top level when required.
      You can also use a flowchart or structure diagram to implement these steps
    • 1-D Array 

      1-D Arrays allow programmers to store data in a list (provided that the data is of the same data type). 
      For example, to store a list of Scottish cities you could create a 1-D array. 
      A programmer can define the number of variables held in a list when they create a 1-D array. 
    • Index

      An index is created to identify each variable in the list . The index will start at 0
      It is the same as a counter
    • Number of elements
      it is common to identify the number of elements that need to be stored in the array when you use software development langugages. 
      E.g. a 1-D array for Scottish cities held in Visual Basic could be represented as: 
      Dim scottish_cities (7) as String 
       
      The value shown in brackets determines the number of elements that are held within the 1-D array. 
    • Records

      1-D arrays can only store data of the same data type. It is not possible to use a 1-D array to store multiple data types at the same time. 
      If you want to hold related data of different data types it is practical to use a record type. 
      This is known as using parallel arrays. 
      Alternatively, a record structure could be used.
      A record type to store information on each city would look like this when created using reference language: 
      RECORD cityData IS {STRING cityName, INTEGER population, INTEGER area km, BOOLEAN capital} 
    • Array of records 

      Instead of using four arrays with four data types (name, population, area, capital): 
      • Use of a record could allow the program to store all of the desired information for each city within an array called scottish_cities 
      • The data type for the array of records would be the name of the record type, in this case cityData 
      DECLARE scottish_cities AS ARRAY OF cityData  
       
    • Local Variables

      A local variable is declared within one specific sub-program of a larger main program. 
      During the execution of this sub-program, the values of local variables will be held in RAM. 
      Upon completion of the execution of this sub-program the variable is no longer retained in RAM. This is more efficient in terms of demands on system resources. 
      The scope of a local variable is the sub-program where it has been declared.
    • Global Variables 

      A global variable places greater demand on system resources - it needs to be retained in memory (RAM) throughout the entire execution of a program. 
      This ensures that the value of the global variable is accessible to each part of the program at all times.
      Errors in code can leave the value itself susceptible to accidental or unintentional change that can have a knock on effect elsewhere in the program.
      The scope of a global variable is the entire program.
    • Parameter Passing
      Parameter passing allows the values of local variables within a main program to be accessed, updated and used within multiple sub-programs without the need to create or use global variables. 
      • a main program is set up with local variables 
      • either the address of the local variable in RAM, or a copy of the value of the local variable can be passed to subprograms and functions when needed 
    • Data Flow 

      The term data flow  is used to describe how data moves between sub-programs in a software development language. Data flow is often identified during design and implemented using parameter passing. 
      Data either flows out of a sub-program or into a sub-program. 
      IN - Data is passed into a sub-program 
      OUT - Data is passed out of a sub-program 
    • Input Validation
      DO 
      RECEIVE numStudents FROM KEYBOARD 
      IF (numStudents < 1) OR (numStudents > 5) THEN 
      SEND “Invalid Input -Try Again” TO DISPLAY 
      END IF 
      REPEAT UNTIL (numStudents >= 1) AND (numStudents <= 5)       ‘validating input in range 1 to 5 inclusive 
    • Finding Maximum
      SET maximum TO testscore [0] 
      FOR counter FROM 1 TO 9 DO 
      IF testscore[counter] > maximum THEN 
      SET maximum TO testscore[counter] 
      END IF 
      END FOR  
      SEND "The maximum value was " & maximum TO DISPLAY 
    • Finding Minimum
      SET minimum TO testscore [0] 
      FOR counter FROM 1 TO 9 DO 
      IF testscore[counter] < minimum THEN 
      SET minimum TO testscore[counter] 
      END IF 
      END FOR  
      SEND "The minimum value was " & minimum TO DISPLAY 
       
    • Count Occurences
      SET occurrence TO 0  
      RECEIVE desired_value FROM (INTEGER) KEYBOARD 
      FOR counter FROM 0 TO 9 DO 
      IF age [counter] = desired_value THEN 
      SET occurrence TO occurrence + 1 
      END IF 
      END FOR 
      SEND "There were " & occurrence & " occurrences of " & desired_value TO DISPLAY 
       
       
    • Linear Search 

      SET item_found TO FALSE 
      SET counter TO 0 
      RECEIVE desired_item FROM (STRING) KEYBOARD 
      REPEAT 
      IF desired item = nation[counter] THEN 
      SET item found TO TRUE  
      SEND "The program found " & desired item & " at position " & counter & “ of the nation array.” TO DISPLAY 
      ELSE 
      SET counter TO counter + 1 
      END IF 
      UNTIL counter = 10 OR item found = TRUE 
      IF item_found = FALSE THEN 
      SEND “The program did not find a match for “ & desired_item & “ within the nation array.” TO DISPLAY 
      END IF 
       
       
    • Comprehensive Testing 

      Your comprehensive plan could include: 
      • Test every process that is listed in the functional requirements (with various inputs) 
      • That the output of the process  is correct 
      • That data is passed into the process correctly 
      • That data is passed out (if applicable) of the process correctly 
      • The program produces the overall output you expected 
      • The program reads from/writes to files correctly 
      • The program runs in a reasonable period of time 
      • The program has a reasonable user interface 
    • Syntax Errors
      Syntax errors are (essentially) things like spelling mistakes, words in the wrong order, symbols in the wrong place, or any other time that your code breaks the rules of the language 
    • Logic Errors 

      Logic errors are flaws in the designer’s or programmer’s logic, not in the program code itself. A logic error doesn’t produce an error message; this makes them hard to track down. Common logic errors would be mixing up > and <, or confusing AND and OR.
    • Execution Errors

      Execution errors happen when the program is running; the program “crashes” because of some input from the user. As an example, the program asks for a number. The user types “three” (in words), and the program crashes. A robust program (see evaluation) is more likely to cope with/avoid execution errors. 
      One type of execution error is the end-of-file (EOF). This happens if you are reading, say, 100 lines from a file. If you loop 101 times, and try to read the 101st line, your program will experience an end-of-file execution error.
    • Evaluation
      This reflects whether the software carries out all the tasks required of the software specification. 
       
      Your evaluation should identify any discrepancies between the software specification and the completed software. 
    • Coding constructs 

      This reflects whether the software writers have used their knowledge of constructs to help them create efficient code. For example, using: 
       
      • suitable data types or structures 
      • conditional or fixed loops 
      • arrays 
      • nested selection 
      • procedures or functions with parameter passing 
       
      Your evaluation should identify where your coding has been efficient. 
    • Usability

      This reflects how intuitive the software is from a user’s perspective and should include: 
       
      • the general user interface 
      • the user prompts 
      • the screen layout 
      • any help screens 
       
      Your evaluation should identify features of the software that have enhanced usability for the user. 
       
    • Maintainability

      This reflects how easy it is to alter the software. The factors affecting maintainability include: 
       
      • readability of the code — made easier by using meaningful variable names, comments, indentation and whitespace 
      • amount of modularity — using functions and procedures effectively 
       
      Your evaluation should identify how your code helps with the maintainability of the software. 
       
    • Robustness

      This reflects how well the software copes with errors during execution including: 
       
      • exceptional data, e.g. the computer crashing if “out of range” 
      • incorrect data entered 
       
      Your evaluation should reflect the testing that has been undertaken to meet the specification, as well as to demonstrate some degree of robustness. 
       
    See similar decks