Concepts to Code / Software Engineering Foundations
CtrlK
  • Front Matter
    • Preface
    • Syllabus Concept Map
    • Introduction
  • 100 Programming fundamentals
    • 110 Foundations of software development
      • 111 Introduction to software engineering
      • 112 Software development lifecycle
      • 113 Data flow diagrams
        • Tutorial / Interpreting data flow diagrams
          • Solutions
      • 114 Structure charts
        • Tutorial / Structure charts
          • Solutions
        • Lab / Develop a simple Python application from a structure chart
        • Quiz 1 / Subroutines (recognising key terms)
        • Quiz 2 / Subroutines (recognising key terms)
        • Quiz 3 / Subroutines (functions) in Python
    • 120 Algorithms and control structures
      • 121 Algorithm fundamentals
        • Tutorial / Algorithms
        • Lab 1 / Pseudocode to Python
        • Lab 2 / Flowcharts to Python
        • Lab 3 / Flowcharts to pseudocode
        • Quiz / Algorithm flowcharts
      • 122 Control structures
        • 1.61 Operations Manual
        • 1.62 Training
        • 1.63 Simulation
        • 1.64 Clearance
        • 1.65 Mission
      • 124 Algorithm design methods
        • 1.71 Operations Manual
        • 1.72 Training
        • 1.73 Simulation
        • 1.75 Mission
    • 130 Programming concepts
      • 131 Variables and data types
        • 131.1 Declaring and using variables
        • 131.2 Data types and type casting
        • 131.3 Constants and naming conventions
        • 131.4 Designing a data dictionary
      • 132 Data structures
        • 132.1 Lists
        • 132.2 Arrays
        • 131.3 Records
      • 133 File handling
      • 134 Number systems and binary
      • 135 Version control
        • 135.1 What is version control?
        • 135.2 Understanding Git and GitHub
        • 135.3 Using Git in an IDE and CLI
        • 135.4 Branching and merging
        • 135.5 Version control in a development workflow
  • 200 Object-Oriented Paradigm
    • 210 Introducing OOP
      • 211 Procedural comparison
      • 212 Classes and objects
      • 213 Creating classes
      • 214 Creating objects from a class
      • 215 Variable scope in OOP
      • 216 Calling methods
      • 217 Encapsulation
      • 218 Polymorphism
      • 219 Inheritance
    • 220 Building an OOP App
      • 221 Project brief and planning
        • 221.1 Project brief
        • 221.2 User stories and backlog
        • 221.3 Sprint overview
      • 222 System design and class modelling
        • 222.1 Class design / Task
        • 222.2 Class design / TaskManager
        • 222.3 Class diagram and CRC cards
        • 222.4 Notes on OOP design decisions
      • 223 Setting up your project environment
        • 223.1 File and folder structure
        • 223.2 Setting up the development environment
        • 223.3 Creating initial class files with stubs
      • 224 Implementing core features (Sprint 1)
      • 225 Extending functionality (Sprint 2)
    • 200 Suggested answers
      • 211 Procedural comparison
      • 212 Classes and objects
      • 213 Creating classes
      • 214 Creating objects from a class
      • 215 Variable scope in OOP
      • 216 Calling methods
  • 300 Programming mechatronics
    • 310 Understanding mechatronic systems
      • 311 Applications of mechatronics
      • 312 Microcontrollers and the CPU
    • 320 Designing control algorithms
    • 330 Programming and building mechatronic systems
  • 400 Secure Software Architecture
    • 410 Principles of secure software
      • 411 Goals of secure software development
        • 411.1 The CIA triad
        • 411.2 AAA Model
      • 412 Design principles
    • 420 Making software secure
      • 421 The secure development lifecycle
        • 421.1 Requirements and specifications
        • 421.2 System design
        • 421.3 Development
        • 421.4 Testing and debugging
        • 421.5 Installation and maintenance
      • 422 Secure development strategies
        • 422.1 Input validation and sanitisation
        • 422.2 Error and exception management
        • 422.3 Memory, session and file management
        • 422.4 Protecting against attacks
          • 422.41 XSS and CSRF
          • 422.42 Broken authentication
          • 422.43 Race conditions
          • 422.44 Invalid forwarding and redirecting
          • 422.45 Security hardening and fault tolerance
          • 422.46 File and hardware protection
        • 422.5 Code review and security testing
          • 422.51 Code review
          • 422.52 SAST and DAST
          • 422.53 Vulnerability assessment
          • 422.53 Penetration testing
      • 423 Security by design and user context
        • 423.1 Security and privacy by design
        • 423.2 Security design patterns
        • 423.3 Cryptography and isolation
          • 423.31 Cryptography basics
          • 423.32 Sandboxing and abstraction
        • 423.4 Secure APIs and authentication
        • 423.5 User-centred security
    • 430 Reasons for securing software
      • 431 Benefits of secure software
        • 431.1 The benefits to organisations of using secure software
        • 431.2 Benefits of developer collaboration
      • 432 Consequences of insecure software
        • 432.1 Impacts on people and society
        • 432.2 Legal and financial consequences
        • 432.3 Real-world case studies
  • 500 Programming for the web
    • 510 How web applications work
      • 511 Applications of web programming
      • 512 Client-server model
      • 513 Routing data across the Internet
      • 514 Web communication protocols
        • 514.1 HTTP and HTTPS
        • 514.2 TCP/IP, FTP, and SFTP
        • 514.3 SMTP, POP3, and IMAP
      • 515 Front-end developer tools
      • 516 Big data and web architecture
      • 517 Securing web applications
        • 517.1 Encryption and certificates
        • 517.2 Authentication and authorisation
        • 517.3 Hashing and digital signatures
    • 520 Frontend web programming
      • 521 Structuring webpages with HTML
      • 522 Styling webpages with CSS
      • 523 Responsive design and accessibility principles
      • 524 JavaScript in front-end web development
      • 525 Development tools and practices
        • 525.1 Version control and Git
        • 525.2 CMS and open source tools
        • 525.3 Performance and load time strategies
      • 526 Web standards and ethical development
    • 530 Back-end web programming
      • 531 Server-side web programming
        • 531.1 Handling requests (web server frameworks)
        • 531.2 Shell scripting in web dev (creating files, searching logs)
        • 531.3 APIs and JSON
      • 532 Database management
  • 700 Software Engineering Project
    • 710 Identifying and defining
      • 711 Project scoping requirements
      • 712 User requirements
      • 713 Project planning and management
    • 720 Research and planning
      • 721 Designing secure architecture
      • 722 Tool selection and justification
        • 722.1 Choosing a technology stack
        • 722.2 Version control and collaboration tools
        • 722.3 Evaluation criteria for tool selection
  • Exam-style questions
    • 400 Secure software architecture
      • Security vs Privacy by Design and SSDLC
        • Marking guideline and sample response
      • Sandboxing
        • Marking guideline and sample response
      • Applying cryptography in secure software design
        • Marking guideline and sample response
    • Python coding tasks
      • Task 1 Solution
      • Task 2 Solution
      • Task 3 Solution
Powered by GitBook
On this page

Was this helpful?

Edit
  1. Exam-style questions

400 Secure software architecture

Security vs Privacy by Design and SSDLCSandboxingApplying cryptography in secure software design
Previous722.3 Evaluation criteria for tool selectionNextSecurity vs Privacy by Design and SSDLC

Was this helpful?

LogoLogo

Jonathan Saurine licences this material under a Creative Commons CC BY-NC-SA license, which allows for the book to be freely shared, adapted and expanded upon for non-commercial purposes, provided that appropriate credit is given to the author.