![]()
Software Architecture with Python
![]()
Table of Contents
Software Architecture with Python
Credits
About the Author
About the Reviewer
www.PacktPub.com
Customer Feedback
Preface
What this book covers
What you need for this book
Who this book is for
Conventions
Reader feedback
Customer support
Downloading the example code
Downloading the color images of this book
Errata
Piracy
Questions
1. Principles of Software Architecture
Defining Software Architecture
Software Architecture versus design
Aspects of Software Architecture
Characteristics of Software Architecture
An architecture defines a structure
An architecture picks a core set of elements
An architecture captures early design decisions
An architecture manages stakeholder requirements
An architecture influences the organizational structure
An architecture is influenced by its environment
An architecture documents the system
An architecture often conforms to a pattern
Importance of Software Architecture
System versus enterprise architecture
Architectural quality attributes
Modifiability
Testability
Scalability
Performance
Availability
Security
Deployability
Summary
2. Writing Modifiable and Readable Code
What is modifiability?
Aspects related to Modifiability
Understanding readability
Python and readability
Readability - antipatterns
Techniques for readability
Document your code
Follow coding and style guidelines
Review and refactor code
Commenting the code
Fundamentals of Modifiability – Cohesion & Coupling
Measuring cohesion and coupling
Measuring cohesion and coupling – string and text processing
Exploring strategies for modifiability
Providing explicit interfaces
Reducing two-way dependencies
Abstract common services
Using inheritance techniques
Using late binding techniques
Metrics – tools for static analysis
What are code smells?
Cyclomatic complexity – the McCabe metric
Testing for metrics
Running Static Checkers
Refactoring Code
Refactoring code – fixing complexity
Refactoring code - fixing code smells
Refactoring code - fixing styling and coding issues
Summary
3. Testability – Writing Testable Code
Understanding testability
Software testability and related attributes
Testability – architectural aspects
Testability – strategies
Reduce system complexity
Improving predictability
Control and isolate external dependencies
White-box testing principles
Unit testing
Unit testing in action
Extending our unit test case
Nosing around with nose2
Testing with py.test
Code coverage
Measuring coverage using coverage.py
Measuring coverage using nose2
Measuring coverage using py.test
Mocking things up
Tests inline in documentation – doctests
Integration tests
Test automation
Test automation using Selenium Web Driver
Test-Driven Development
TDD with palindromes
Summary
4. Good Performance is Rewarding!
What is performance?
Software performance engineering
Performance testing and measurement tools
Performance complexity
Measuring performance
Measuring time using a context manager
Timing code using the timeit module
Measuring the performance of our code using timeit
Finding out time complexity – graphs
Measuring CPU time with timeit
Profiling
Deterministic profiling
Profiling with cProfile and profile
Prime number iterator class – performance tweaks
Profiling – collecting and reporting statistics
Third-party profilers
Line profiler
Memory profiler
Substring (subsequence) problem
Other tools
Objgraph
Pympler
Programming for performance – data structures
Mutable containers – lists, dictionaries, and sets
Lists
Dictionaries
Sets
Immutable containers – tuples
High performance containers – the collections module
deque
defaultdict
OrderedDict
Dropping duplicates from a container without losing the order
Implementing a Least Recently Used (LRU) cache dictionary
Counter
ChainMap
namedtuple
Probabilistic data structures – bloom filters
Summary
5. Writing Applications That Scale
Scalability and performance
Concurrency
Concurrency versus parallelism
Concurrency in Python – multithreading
Thumbnail generator
Thumbnail generator – producer/consumer architecture
Thumbnail generator – resource constraint using locks
Thumbnail generator – resource constraint using semaphores
Resource constraint – semaphore versus lock
Thumbnail generator – URL rate controller using conditions
Multithreading – Python and GIL
Concurrency in Python – multiprocessing
A primality checker
Sorting disk files
Sorting disk files – using a counter
Sorting disk files – using multiprocessing
Multithreading versus multiprocessing
Concurrecy in Python - Asynchronous Execution
Pre-emptive versus cooperative multitasking
The asyncio module in Python
Waiting for a future – async and await
Concurrent futures – high-level concurrent processing
Disk thumbnail generator
Concurrency options – how to choose?
Parallel processing libraries
Joblib
PyMP
Fractals – the Mandelbrot set
Fractals – Scaling the Mandelbrot set implementation
Scaling for the Web
Scaling workflows – message queues and task queues
Celery – a distributed task queue
The Mandelbrot set using Celery
Serving with Python on the Web—WSGI
uWSGI – WSGI middleware on steroids
Gunicorn – unicorn for WSGI
Gunicorn versus uWSGI
Scalability architectures
Vertical scalability architectures
Horizontal scalability architectures
Summary
6. Security – Writing Secure Code
Information Security architecture
Secure coding
Common security vulnerabilities
Is Python secure?
Reading input
Evaluating arbitrary input
Overflow errors
Serializing objects
Security issues with web applications
Server Side Template Injection
Server-Side Template Injection – mitigation
Denial of Service
Cross-Site Scripting(XSS)
Mitigation – DoS and XSS
Strategies for security – Python
Secure coding strategies
Summary
7. Design Patterns in Python
Design patterns - Elements
Categories of design patterns
Pluggable hashing algorithms
Summing up pluggable hashing algorithm
Patterns in Python – Creational
The Singleton pattern
The Singleton – do we need a Singleton?
State sharing – Borg versus Singleton
The Factory pattern
The Prototype pattern
Prototype – deep versus shallow copy
Prototype using metaclasses
Combining patterns using metaclasses
The Prototype factory
The Builder pattern
Patterns in Python – Structural
The Adapter pattern
The Facade pattern
Facades in Python
The Proxy pattern
An instance-counting proxy
Patterns in Python – Behavioral
The Iterator pattern
The Observer pattern
The State pattern
Summary
8. Python – Architectural Patterns
Introducing MVC
Model Template View (MTV) – Django
Django admin – automated model-centric views
Flexible Microframework – Flask
Event-driven programming
Chat server and client using I/O multiplexing with the select module
Event-drive...
