Design, Testing and IDEs

Design, Testing and IDEs

1. defensive design

   • ensures program functions properly
     • if functioning properly code should never break/produce an error
       • doing this is difficult to achieve
   • done to protect programs
   • makes sure inputs can't be exploited
     • easiest way for a program to be exploited
     • can be prevented using to ways:
       • Input sanitation = removing unwanted characters
       • Input validation = checking if data meets a certain criteria
   • Authentication
     • confirm identity before allowing access
       • e.g using passwords and username
         • can be strengthened by forcing the use of strong passwords, limiting number of attempts and using random selection of characters
     • to much may be not very ergonomic
   • easy and well maintained
     • code should be easy to understand
       • code should be able to be edited without cause of problems
     • performed using:
       • comments
       • indentation
       • variables
       • only using global variables

2. testing

   • syntax error = when compiler / interpreter doesn't understand something
     • diagnosed by compiler / interpreter
       • unable to convert to machine code
   • logic error = when program does something unexpected
     • hard to identify and find
       • compiler / interpreter won't notice
   • functionality test should be tested through out development
     • other forms of testing:
       • performance test
       • usability test
       • security test
       • load/stress test
   • types of test:
     • final test (done once)
     • iterative test (done a few times)
   • test plan
     • made before implementation
     • outline what will be tested
       • should include:
         • normal data
         • extreme data
         • erroneous data (inputs that should not be accepted)

3. translators

   • convert high level language to low level language
   • used in programming languages such as python, C++ and Java script
   • high level language
     • one instruction represent many instructions
     • work on many different machines/processors
     • easy to understand
     • no control over CPU
     • must be translated to machine code
   • low level language
     • one instruction represent one instructions
     • usually written for one type of machine/processor
     • knowledge needed about internal structure of a CPU
     • machine code can be executed directly
     • more control of CPU
   • three types of translator:
     • assembler, compiler and interpreter
       • compiler
         • translates all source code at same time
         • only need once
         • returns list of errors
         • runs quickly
       • interpeter
         • slower
         • needed every time
         • returns first error it finds