book

Software Architecture with Python

Name: Software Architecture with Python
Author: Anand Balachandran Pillai
ISBN: 9781786468529

by Anand Balachandran Pillai

April 2017

Intermediate to advanced

556 pages

11h 5m

English

Packt Publishing

Read now

Unlock full access

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 codeDownloading the color images of this bookErrataPiracyQuestions
1. Principles of Software Architecture
Defining software architectureSoftware architecture versus designAspects of software architecture
Characteristics of software architecture
An architecture defines a structureAn architecture picks a core set of elementsAn architecture captures early design decisionsAn architecture manages stakeholder requirementsAn architecture influences the organizational structureAn architecture is influenced by its environmentAn architecture documents the systemAn architecture often conforms to a pattern
Importance of software architecture
System versus enterprise architecture
Architectural quality attributes
ModifiabilityTestabilityScalabilityPerformanceAvailabilitySecurityDeployability
Summary
2. Writing Modifiable and Readable Code
What is modifiability?
Aspects related to modifiability
Understanding readability
Python and readabilityReadability – antipatternsTechniques for readabilityDocument your codeFollow coding and style guidelinesReview and refactor codeCommenting the code
Fundamentals of modifiability – cohesion and coupling
Measuring cohesion and couplingMeasuring cohesion and coupling – string and text processing
Exploring strategies for modifiability
Providing explicit interfacesReducing two-way dependenciesAbstract common servicesUsing inheritance techniquesUsing late binding techniques
Metrics – tools for static analysis
What are code smells?Cyclomatic complexity – the McCabe metricTesting for metricsRunning static checkers
Refactoring code
Refactoring code – fixing complexityRefactoring code – fixing code smellsRefactoring code – fixing styling and coding issues
Summary
3. Testability – Writing Testable Code
Understanding testabilitySoftware testability and related attributesTestability – architectural aspectsTestability – strategiesReduce system complexityImproving predictabilityControl and isolate external dependencies
White-box testing principles
Unit testingUnit testing in actionExtending our unit test caseNosing around with nose2Testing with py.testCode coverageMeasuring coverage using coverage.pyMeasuring coverage using nose2Measuring coverage using pytestMocking things upTests inline in documentation – doctestsIntegration testsTest automationTest automation using Selenium WebDriverTest-driven developmentTDD 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 managerTiming code using the timeit moduleMeasuring the performance of our code using timeitFinding out time complexity – graphsMeasuring CPU time with timeit
Profiling
Deterministic profilingProfiling with cProfile and profilePrime number iterator class – performance tweaksProfiling – collecting and reporting statisticsThird-party profilersLine profilerMemory profilerSubstring (subsequence) problem
Other tools
objgraphPympler
Programming for performance – data structures
Mutable containers – lists, dictionaries, and setsListsDictionariesSetsImmutable containers – tuplesHigh performance containers – the collections moduledequedefaultdictOrderedDictDropping duplicates from a container without losing the orderImplementing a Least Recently Used (LRU) cache dictionaryCounterChainMapnamedtupleProbabilistic data structures – bloom filters
Summary
5. Writing Applications that Scale
Scalability and performance
Concurrency
Concurrency versus parallelismConcurrency in Python – multithreading
Thumbnail generator
Thumbnail generator – producer/consumer architectureThumbnail generator – resource constraint using locksThumbnail generator – resource constraint using semaphoresResource constraint – semaphore versus lockThumbnail generator – URL rate controller using conditions
Multithreading – Python and GIL
Concurrency in Python – multiprocessingA primality checkerSorting disk filesSorting disk files – using a counterSorting 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 generatorConcurrency options – how to choose?Parallel processing librariesJoblibPyMPFractals – the Mandelbrot setFractals – 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 CeleryServing with Python on the Web – WSGIuWSGI – WSGI middleware on steroidsGunicorn – unicorn for WSGIGunicorn versus uWSGIScalability architecturesVertical scalability architecturesHorizontal scalability architectures
Summary
6. Security – Writing Secure Code
Information security architecture
Secure coding
Common security vulnerabilities
Is Python secure?
Reading inputEvaluating arbitrary inputOverflow errorsSerializing objects
Security issues with web applications
Server Side Template InjectionServer-Side Template Injection – MitigationDenial of ServiceCross-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 algorithmsSumming up pluggable hashing algorithm
Patterns in Python – creational
The Singleton patternThe Singleton – do we need a Singleton?State sharing – Borg versus SingletonThe Factory patternThe Prototype patternPrototype – deep versus shallow copyPrototype using metaclassesCombining patterns using metaclassesThe Prototype factoryThe Builder pattern
Patterns in Python – structural
The Adapter patternThe Facade patternFacades in PythonThe proxy patternAn instance-counting proxy
Patterns in Python – behavioral
The Iterator patternThe Observer patternThe State pattern
Summary
8. Python – Architectural Patterns
Introducing MVCModel Template View (MTV) – DjangoDjango admin – automated model-centric viewsFlexible Microframework – Flask
Event-driven programming
Chat server and client using I/O multiplexing with the select moduleEvent-driven programming versus concurrent programmingTwistedTwisted – a simple web clientChat server using TwistedEventletGreenlets and Gevent
Microservice architecture
Microservice frameworks in PythonMicroservices example – restaurant reservationMicroservices – advantages
Pipe and Filter architectures
Pipe and filter in Python
Summary
9. Deploying Python Applications
DeployabilityFactors affecting deployability
Tiers of software deployment architecture
Software deployment in Python
Packaging Python codePIPVirtualenvVirtualenv and pipRelocatable virtual environmentsPyPIPackaging and submission of an applicationThe __init__.py filesThe setup.py fileInstalling the packageSubmitting the package to PyPIPyPARemote deployments using FabricRemote deployments using AnsibleManaging remote daemons using Supervisor
Deployment – patterns and best practices
Summary
10. Techniques for Debugging
Maximum subarray problemThe power of "print"Analysis and rewriteTiming and optimizing the code
Simple debugging tricks and techniques
Word searcher programWord searcher program – debugging step 1Word searcher program – debugging step 2Word searcher program – final codeSkipping blocks of codeStopping executionExternal dependencies – using wrappersReplacing functions with their return value/data (mocking)Saving to / loading data from files as cacheSaving to / loading data from memory as cacheReturning random/mock dataGenerating random patient data
Logging as a debugging technique
Simple application loggingAdvanced logging – logger objectsAdvanced logging – custom formatting and loggersAdvanced logging – writing to syslog
Debugging tools – using debuggers
A debugging session with pdbPdb – similar toolsiPdbPdb++
Advanced debugging – tracing
The trace moduleThe lptrace programSystem call tracing using strace
Summary
Index

Content preview from Software Architecture with Python

Summary

This chapter was all about performance. At the start of the chapter, we discussed performance and SPE. We looked at the two categories of performance testing and diagnostic tools—namely, stress-testing tools and profiling/instrumentation tools.

We then discussed what performance complexity really means in terms of the Big-O notation and discussed briefly the common time orders of functions. We looked at the time taken by functions to execute and learned the three classes of time usage—namely real, user, and sys in POSIX systems.

We moved on to measuring performance and time in the next section—starting with a simple context manager timer and moving on to more accurate measurements using the timeit module. We measured the time taken for certain ...

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Publisher Resources

ISBN: 9781786468529

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages