Software Engineering for Absolute Beginners: Your Guide to Creating Software Products

Table of Contents
About the Author
About the Technical Reviewer
Acknowledgments
Introduction
Chapter 1: Editors
	The Different Families of Programming Editors
		Shell-Based Editors
		Text Editors
		IDEs
	The Benefits of an IDE or an Editor like VS Code
	Installing Visual Studio Code
		Workspaces
		Built-In Features
		Features to Install
	Summary
Chapter 2: Containerizing Your Environment
	What Are Containers?
	The Main Components of Docker Explained
		The Dockerfile
		The Docker Image
			The Step-by-Step Way to Create a Docker Image
			The Dockerfile Method
		Docker Containers
	Setup and Usage
		Preparation
		How to Install Docker
			Important for Windows Users
		Creating the Dockerized Environments for Your Software’s Infrastructure
		Preparations Before You Start Cooking
		First Docker Image and Container
		Building the Image and Pushing It to the Repository
			Explanation
		Pushing the Image to a Docker Repository
		Docker Orchestration with Docker Compose
			Installing Docker Compose
			Docker Compose Explanation
		Final Docker Experiment
	Docker Checklist and Cheat Sheet
		Docker Commands
		Docker-compose Commands
Chapter 3: Repositories and Git
	A Word About Windows Git Usage and Hidden Files
	What Is Source Control?
		Additional Functionality
	Installing Git and Creating a GitLab Account
	Using GitLab
	Commits
	Branches
	A More Advanced Use Case
	Merging Conflicts
	Removing the Need to Type Your Password Every Time: SSH
	Gitignore
	git stash
	git reset and revert
	Cheat Sheet
Chapter 4: Programming in Python
	What Is Programming?
	Python
		Setup for This Chapter and How to Use It
		Basics
		Commenting Your Code
		Variables
			Integers
			Float
			Boolean
			Strings
			Last Word on Variables
			Constants
			Type Casting
			Shorthand Assignment Operators
	Sequences and Maps
		Lists and Strings
			Accessing Data Inside Lists
				Indexes
				Slicing
		Tuples
		When to Use a List and When to Use a Tuple
		Dictionaries
	Decision-Making Operators and Structures
		Operators
			Comparison Operators
			Logical Operators
				and
				or
				not
				Truth Tables
			Identity Operators
				is
				is not
			Membership Operators
				in
				not in
			Precedence of Operators in Expressions
			Bitwise Operators
		Scope and Structure of Python Code
			Local Scope
			Enclosing Scope
			Global Scope
			Built-in Scope
		Control Statements
			If Statements
			Loops
				While Loops
				For Loops
				List Comprehension (Shorthand Loops)
			Continue and Break
		Functions
		Custom Functions
			Principles of Function Design
			The Anatomy of a Function
			Should Functions Return or Print?
			Example Functions
			Parameter Type-Hinting
			Default Parameter Values
			Variable Parameters
			Named Keyword Arguments
	Classes and Objects
		The Anatomy of a Class
		Instantiating the Class
		Inheritance
		Polymorphism
		Composition
		Magic Methods
	Exceptions
		The Anatomy of an Exception
		Raising an Exception
		Catching an Exception
		Writing an Exception
	Imports
	Static Access to Classes
	Cheat Sheet
		Scope
		Variables
		Arrays
			Lists
			Tuples
			Dictionaries
		Control statements
			if
			while
			for
		Functions
		Classes
		Exceptions
			Catching an Exception
			Raising an Exception
			Creating an Exception
		Import
	Reference
Chapter 5: Object Calisthenics, Coding Styles, and Refactoring
	Object Calisthenics
		1. Do not exceed one level of indentation per method. (Or rather, limit the levels of indentation as much as you can.)
		2. Do not use the else keyword
		3. Wrap all primitives and strings
		4. Use only one dot per line
		5. Do not abbreviate
		6. Keep entities small
		7. Limit classes to use no more than two instance variables
		8. Use first-class collections
	Refactoring Code
	Coding Styles
		Linting
		Commenting Your Code
			Block Comments
			Inline Comments
			Docstrings: Commenting Your Classes
		Maximum Line Length
		Indentation
			Indenting Line Wraps
		Blank Lines
		Encoding
		Imports
		Whitespace
		Naming Conventions
			Package and Module Names in snake-case
			Class Names in PascalCase
			Method Names in snake-case
				Internal Methods
				Preventing Inheritance
			Variable Names in snake-case
				Internal Variables
				Preventing Variable Overwriting in Inheritance
			Constants in snake-case
	Chapter Summary
	References
Chapter 6: Databases and Database Design
	Three Things You Can Do with Data
	Overview of Database System Components
	Setting Up Your DBMS
		Ports
		Environment
		Volumes
		The Final Docker File
		Viewing Your Database Using Adminer
		Cleaning Up and Pushing to the Remote
	Preparing Your Database
	Primary Keys
		Indexes
		Index Caveats
	Data Types
	Creating a Database
		Creating the Table
			salutation
			firstname
			mobile
			city
			languages
		Filling the Database with Data
		Your First SQL Queries
			SELECT
			INSERT
			UPDATE
			DELETE
	Normalizing the Current Classes Table
		First Normal Form
		Second Normal Form
			One-to-Many Relationships, Joins, and Foreign Keys
			Querying on a Join
			Many-to-Many
		Third Normal Form
		Last Word on Joins
	Conclusion
	Cheatsheet and Checklist
	References
Chapter 7: Creating a RESTful API: Flask
	The Project
	What Is REST?
		JSON
		HTTP Verbs
		REST Query Routes
		HTTP Status Code
		HATEOAS
	The Technology You Will Use
	Setting Up the Environment
		Creating the GitLab Project
		Project Layout
		Creating the docker-compose and Docker Files
			File Changes to docker-compose.yml
			Docker File
			docker-compose.yml: DB Server and Adminer Sections
			Bringing Up the New System
			Testing the Application
			Testing the Application with Postman
			Migrations
			Migration Preparation Step
		The Final Steps: Coding
			Step 1
			Step 2
			Step 3, A Bit of Refactoring
			Step 4
			Step 5
				Anatomy of an Endpoint
				Anatomy of the Code Inside the Function
			Step 6
			Step 7
			Step 8
	The ORM Version
		GET Endpoint
		POST Endpoint
		PATCH Endpoint
		DELETE Endpoint
	Takeaway of This Chapter
	References
Chapter 8: Testing and Code Quality
	Overview of Code Quality Steps
	Automated Testing
		Unit Tests
			Writing a Unit Test
			Anatomy of the Unit Test
		How to Run the Unit Test
		Integration Tests
		How to Run the Integration Test
			Why Do We Need the Flask App Instance?
		A Last Issue and Some Refactoring
		Testing the New Code
	The Downside of Automated Testing
		The Validity of the Tests
		Time Pressure
	Peer Reviews
	Walk-Through
	Staging Environment and UAT
Chapter 9: Planning and Designing Your Code
	Software Development Lifecycle
		Why Use a Software Development Lifecycle?
			The Reality of Scope Creep and Not Pinning Down Requirements
		Steps in the SDLC
			Phase One: Planning
			Phase Two: Requirements
			Phase Three: Design
			Phase Four: Development
			Phase Five: Testing (But Not the Sole Testing Phase)
			Phase Six: Deployment
			Phase Seven: Support and Maintenance
	Modelling
		Where Does Modelling Fit In the SDLC?
		Why Create Diagrams and Models?
		Tools
		High-Level Models and Diagrams
			Activity Diagram
			Use Case Diagram
			Swimlanes
			Database Diagrams
			Modelling Relationships
		Low-Level Models
			Types of Objects
			Cohesion and Coupling
				Coupling
				Cohesion
			SOLID
				Single Responsibility
				Open/Close Principle
				Liskov Substitution Principle
				Interface Segregation Principle
				Dependency Inversion Principle
			DRY
			Composition
	Summary
Chapter 10: Security
	Securing Your Code
	Code-Level Security
		SQL Injection
		Cleaning Variables
		Keeping Errors a Secret
		XSS
		CSRF
		Session Management
	System-Level Security
		Keep Your Systems Up to Date
		Database Users
		Ports
		Docker Images
		HTTPS
		Password Policy
	Social Engineering
	Summary
Chapter 11: Hosting and CI/CD
	Types of Hosting
		Cloud and Serverless Technologies
		Shared Hosting
		Virtual Private Hosting
		Cloud Hosting
		Serverless
		Which Hosting Technology to Choose?
	Continuous Integration and Continuous Deployment (CI/CD)
		Creating the Pipeline
			Continuous Integration
			Continuous Deployment
	Summary
Index