舉報 
會員
Hands-On Software Engineering with Python
SoftwareEngineeringisaboutmorethanjustwritingcode—itincludesahostofsoftskillsthatapplytoalmostanydevelopmenteffort,nomatterwhatthelanguage,developmentmethodology,orscopeoftheproject.Beingaseniordeveloperallbutrequiresawarenessofhowthoseskills,alongwiththeirexpectedtechnicalcounterparts,meshtogetherthroughaproject'slifecycle.Thisbookwalksyouthroughthatdiscoverybygoingovertheentirelifecycleofamulti-tiersystemanditsrelatedsoftwareprojects.You'llseewhathappensbeforeanydevelopmenttakesplace,andwhatimpactthedecisionsanddesignsmadeateachstephaveonthedevelopmentprocess.Thedevelopmentoftheentireproject,overthecourseofseveraliterationsbasedonreal-worldAgileiterations,willbeexecuted,sometimesstartingfromnothing,inoneofthefastestgrowinglanguagesintheworld—Python.ApplicationofpracticesinPythonwillbelaidout,alongwithanumberofPython-specificcapabilitiesthatareoftenoverlooked.Finally,thebookwillimplementahigh-performancecomputingsolution,fromfirstprinciplesthroughcompletefoundation.
最新章節
- Leave a review - let other readers know what you think
- Other Books You May Enjoy
- Summary
- Python Hadoop and Spark
- Integrating Python with large-scale cluster computing frameworks
- The Dispatcher
品牌：中圖公司
上架時間：2021-06-24 17:52:44
出版社：Packt Publishing
本書數字版權由中圖公司提供，并由其授權上海閱文信息技術有限公司制作發行
- Leave a review - let other readers know what you think 更新時間：2021-06-24 18:21:24
- Other Books You May Enjoy
- Summary
- Python Hadoop and Spark
- Integrating Python with large-scale cluster computing frameworks
- The Dispatcher
- The Orchestrator
- The Worker nodes
- Common functionality
- Parallelizing across multiple machines
- Threads
- Local parallel processing
- Some testing setup
- A simple but expensive algorithm
- Common factors to consider
- Multiprocessing and HPC in Python
- Summary
- Order fulfilment and shipping APIs
- Developing a UI
- Code review refactoring and cleanup
- Where hms_sys development could go from here
- Windows (NSSM) execution
- Linux (systemd) execution
- Common considerations across all operating systems
- Packaging and deploying the service
- Demonstrating the service
- Testing Artisan transactions
- Unit testing variations of note
- The overall testing strategy
- The challenges of testing services
- Testing and Deploying Services
- Summary
- When do messages get sent?
- Artisan – fulfilling an item in an order
- Customer – canceling an order
- Customer – relaying order items to artisans
- Order object transactions
- Artisan – updating Artisan data
- Central Office – deleting an artisan
- Central Office – updating artisan data
- Central Office – creating an artisan
- Artisan object transactions
- Artisan – deleting a product
- Artisan – updating product data
- Central Office – altering product data
- Central Office – approving/listing a product
- Artisan – creating a product
- Product object transactions
- Preparation for object transactions
- A bit of reorganization
- Remaining stories
- Handling Service Transactions
- Summary
- Impacts on testing and deployment
- Traffic to and from the service
- Requirements for a web-service-based daemon
- Queues and related Artisan properties
- Handling messages
- Message-queue implementation with RabbitMQ
- Deciding on a message-transmission mechanism
- Messages
- Iteration stories
- Overview and goal
- The Artisan Gateway Service
- Summary
- Managing services on other systems
- macOS launchd and launchctl
- Running a service using NSSM (Windows)
- Running a service using systemctl (Linux)
- Integrating a service with the OS
- The BaseRequestHandler and BaseResponseFormatter ABCs
- The BaseDaemon ABC
- A generic service design
- Request and response formats
- Other request types
- Message- queue-based
- HTTP- or web-based
- Filesystem – based
- Handling requests and generating responses
- Logging service activities
- YAML files
- JSON files
- Windows-style .ini files
- Configuration
- Service structure
- What is a service?
- Anatomy of a Service
- Summary
- Operations/use maintenance and decommissioning considerations
- Building/distribution demonstration and acceptance
- Unit tests and trust
- Unit testing hms_core.co_objects.py
- Unit testing hms_core.data_storage.py
- Testing the new hms_core Classes
- Testing hms_artisan.artisan_objects
- Testing hms_artisan.data_storage
- Writing the unit tests
- Testing Data Persistence
- Summary
- Accounting for the other CRUD operations
- Other hms_core.co_objects classes
- hms_core.co_objects.Product
- hms_core.co_objects.Artisan
- The concrete business objects of the Central Office projects
- RDBMS implementations
- Supporting objects for data persistence
- The data access strategy for the Central Office projects
- Picking out a backend datastore engine
- The Artisan Gateway and Central Office application objects
- Persisting Data to a Database
- Summary
- hms_artisan.Order
- hms_artisan.Product
- hms_artisan.Artisan
- Dealing with is_dirty and properties
- The concrete business objects of hms_artisan
- Implementing JSONFileDataObject
- Creating a local file system data store
- Setting up the hms_artisan project
- Persisting Object Data to Files
- Summary
- Unit testing BaseDataObject
- The BaseDataObject ABC
- Data Persistence and BaseDataObject
- Summary
- Why start from scratch?
- Data access decisions
- Data access design strategies
- Polymorphism (and programming to an interface)
- Selecting a data storage option
- Other data storage options
- Other NoSQL options
- MongoDB
- Advantages and drawbacks
- NoSQL databases
- PostgresQL
- MS-SQL
- MySQL/MariaDB
- Advantages and drawbacks
- Relational databases
- Data storage options
- Iterations are (somewhat) flexible
- Thinking About Business Object Data Persistence
- Summary
- Operation/use maintenance and decommissioning considerations
- Quality assurance and acceptance
- Distribution and installation considerations
- Unit testing patterns established so far
- Unit testing BaseArtisan
- Unit-testing BaseCustomer
- Unit testing BaseOrder
- Unit testing BaseProduct
- Unit testing HasProducts
- Unit testing the Address class
- Starting the unit testing process
- Testing Business Objects
- Summary
- Dealing with duplicated code – HasProducts
- BaseProduct
- BaseOrder
- BaseCustomer
- Implementing BaseArtisan's methods
- Implementing BaseArtisan's properties
- OO principles – composition over inheritance
- BaseArtisan
- Address
- Implementing the basic business objects in hms_sys
- A quick review of classes
- Assembly of stories and tasks
- Iteration goals
- Creating Business Objects
- Summary
- Integrating tests with the build process
- Creating unit test template files
- The property and method testing decorators
- Creating reusable module code coverage tests
- Identifying missing test methods
- Identifying missing test case classes
- Basic unit testing
- Python virtual environments
- Packaging and build process
- Component project setup
- Component project analysis
- Stubbing out component projects
- Setting Up SCM
- Assembly of stories and tasks
- Iteration goals
- Setting Up Projects and Processes
- Summary
- Using Python virtual environments
- Packages in a project's context
- Defining package structures for Python code
- Integrating unit tests and build processes
- Repeatable build processes
- Unit testing
- Process standards
- Function and method annotation (hinting)
- Structure and standards for classes
- Code organization in modules
- Internal standards
- PEP-8
- Standards for code
- Best practices
- Other SCM options
- Basic workflows for Git and SVN compared
- Subversion
- Git
- Typical SCM activities
- Source Code Management
- Others
- Eclipse variations + PyDev
- Geany
- IDLE
- Integrated Development Environment (IDE) options
- Development tools
- Development Tools and Best Practices
- Summary
- Post-development considerations and impact
- Writing and testing the code
- Iteration goals and stories
- What the iteration chapters will look like
- What's known/designed before development starts
- Goals for the system
- The hms_sys System Project
- Summary
- Continuous delivery or deployment
- Continuous integration
- Development practices
- Functional programming
- Object-oriented programming
- Development paradigms
- Test-driven design
- Feature-driven development
- Extreme programming
- Other Agile methodologies
- Kanban and the phases of the SDLC model
- Kanban
- Scrum and the phases of the SDLC model
- Scrum
- Agile (in general)
- Waterfall
- Process methodologies
- Methodologies Paradigms and Practices
- Summary
- System scope and scale
- Interprocess communication
- Data structure and flow
- Use cases (business processes and rules)
- Physical architecture
- Logical architecture
- Architecture both logical and physical
- System Modeling
- Summary
- Post-development phases of the SDLC
- System integration testing and acceptance
- Development and quality assurance
- System architecture and design
- Requirements analysis and definition
- Development – specific phases of the SDLC
- Project management planning
- Concept development
- Initial concept/vision
- Pre-development phases of the SDLC
- The Software Development Life Cycle
- Summary
- Asking questions
- The bigger picture
- Programming versus Software Engineering
- Reviews
- Get in touch
- Conventions used
- Download the color images
- Download the example code files
- To get the most out of this book
- What this book covers
- Who this book is for
- Preface
- Packt is searching for authors like you
- About the reviewers
- About the author
- Contributors
- Packt.com
- Why subscribe?
- Packt Upsell
- Humble Bundle
- Title Page
- coverpage
- coverpage
- Title Page
- Humble Bundle
- Packt Upsell
- Why subscribe?
- Packt.com
- Contributors
- About the author
- About the reviewers
- Packt is searching for authors like you
- Preface
- Who this book is for
- What this book covers
- To get the most out of this book
- Download the example code files
- Download the color images
- Conventions used
- Get in touch
- Reviews
- Programming versus Software Engineering
- The bigger picture
- Asking questions
- Summary
- The Software Development Life Cycle
- Pre-development phases of the SDLC
- Initial concept/vision
- Concept development
- Project management planning
- Development – specific phases of the SDLC
- Requirements analysis and definition
- System architecture and design
- Development and quality assurance
- System integration testing and acceptance
- Post-development phases of the SDLC
- Summary
- System Modeling
- Architecture both logical and physical
- Logical architecture
- Physical architecture
- Use cases (business processes and rules)
- Data structure and flow
- Interprocess communication
- System scope and scale
- Summary
- Methodologies Paradigms and Practices
- Process methodologies
- Waterfall
- Agile (in general)
- Scrum
- Scrum and the phases of the SDLC model
- Kanban
- Kanban and the phases of the SDLC model
- Other Agile methodologies
- Extreme programming
- Feature-driven development
- Test-driven design
- Development paradigms
- Object-oriented programming
- Functional programming
- Development practices
- Continuous integration
- Continuous delivery or deployment
- Summary
- The hms_sys System Project
- Goals for the system
- What's known/designed before development starts
- What the iteration chapters will look like
- Iteration goals and stories
- Writing and testing the code
- Post-development considerations and impact
- Summary
- Development Tools and Best Practices
- Development tools
- Integrated Development Environment (IDE) options
- IDLE
- Geany
- Eclipse variations + PyDev
- Others
- Source Code Management
- Typical SCM activities
- Git
- Subversion
- Basic workflows for Git and SVN compared
- Other SCM options
- Best practices
- Standards for code
- PEP-8
- Internal standards
- Code organization in modules
- Structure and standards for classes
- Function and method annotation (hinting)
- Process standards
- Unit testing
- Repeatable build processes
- Integrating unit tests and build processes
- Defining package structures for Python code
- Packages in a project's context
- Using Python virtual environments
- Summary
- Setting Up Projects and Processes
- Iteration goals
- Assembly of stories and tasks
- Setting Up SCM
- Stubbing out component projects
- Component project analysis
- Component project setup
- Packaging and build process
- Python virtual environments
- Basic unit testing
- Identifying missing test case classes
- Identifying missing test methods
- Creating reusable module code coverage tests
- The property and method testing decorators
- Creating unit test template files
- Integrating tests with the build process
- Summary
- Creating Business Objects
- Iteration goals
- Assembly of stories and tasks
- A quick review of classes
- Implementing the basic business objects in hms_sys
- Address
- BaseArtisan
- OO principles – composition over inheritance
- Implementing BaseArtisan's properties
- Implementing BaseArtisan's methods
- BaseCustomer
- BaseOrder
- BaseProduct
- Dealing with duplicated code – HasProducts
- Summary
- Testing Business Objects
- Starting the unit testing process
- Unit testing the Address class
- Unit testing HasProducts
- Unit testing BaseProduct
- Unit testing BaseOrder
- Unit-testing BaseCustomer
- Unit testing BaseArtisan
- Unit testing patterns established so far
- Distribution and installation considerations
- Quality assurance and acceptance
- Operation/use maintenance and decommissioning considerations
- Summary
- Thinking About Business Object Data Persistence
- Iterations are (somewhat) flexible
- Data storage options
- Relational databases
- Advantages and drawbacks
- MySQL/MariaDB
- MS-SQL
- PostgresQL
- NoSQL databases
- Advantages and drawbacks
- MongoDB
- Other NoSQL options
- Other data storage options
- Selecting a data storage option
- Polymorphism (and programming to an interface)
- Data access design strategies
- Data access decisions
- Why start from scratch?
- Summary
- Data Persistence and BaseDataObject
- The BaseDataObject ABC
- Unit testing BaseDataObject
- Summary
- Persisting Object Data to Files
- Setting up the hms_artisan project
- Creating a local file system data store
- Implementing JSONFileDataObject
- The concrete business objects of hms_artisan
- Dealing with is_dirty and properties
- hms_artisan.Artisan
- hms_artisan.Product
- hms_artisan.Order
- Summary
- Persisting Data to a Database
- The Artisan Gateway and Central Office application objects
- Picking out a backend datastore engine
- The data access strategy for the Central Office projects
- Supporting objects for data persistence
- RDBMS implementations
- The concrete business objects of the Central Office projects
- hms_core.co_objects.Artisan
- hms_core.co_objects.Product
- Other hms_core.co_objects classes
- Accounting for the other CRUD operations
- Summary
- Testing Data Persistence
- Writing the unit tests
- Testing hms_artisan.data_storage
- Testing hms_artisan.artisan_objects
- Testing the new hms_core Classes
- Unit testing hms_core.data_storage.py
- Unit testing hms_core.co_objects.py
- Unit tests and trust
- Building/distribution demonstration and acceptance
- Operations/use maintenance and decommissioning considerations
- Summary
- Anatomy of a Service
- What is a service?
- Service structure
- Configuration
- Windows-style .ini files
- JSON files
- YAML files
- Logging service activities
- Handling requests and generating responses
- Filesystem – based
- HTTP- or web-based
- Message- queue-based
- Other request types
- Request and response formats
- A generic service design
- The BaseDaemon ABC
- The BaseRequestHandler and BaseResponseFormatter ABCs
- Integrating a service with the OS
- Running a service using systemctl (Linux)
- Running a service using NSSM (Windows)
- macOS launchd and launchctl
- Managing services on other systems
- Summary
- The Artisan Gateway Service
- Overview and goal
- Iteration stories
- Messages
- Deciding on a message-transmission mechanism
- Message-queue implementation with RabbitMQ
- Handling messages
- Queues and related Artisan properties
- Requirements for a web-service-based daemon
- Traffic to and from the service
- Impacts on testing and deployment
- Summary
- Handling Service Transactions
- Remaining stories
- A bit of reorganization
- Preparation for object transactions
- Product object transactions
- Artisan – creating a product
- Central Office – approving/listing a product
- Central Office – altering product data
- Artisan – updating product data
- Artisan – deleting a product
- Artisan object transactions
- Central Office – creating an artisan
- Central Office – updating artisan data
- Central Office – deleting an artisan
- Artisan – updating Artisan data
- Order object transactions
- Customer – relaying order items to artisans
- Customer – canceling an order
- Artisan – fulfilling an item in an order
- When do messages get sent?
- Summary
- Testing and Deploying Services
- The challenges of testing services
- The overall testing strategy
- Unit testing variations of note
- Testing Artisan transactions
- Demonstrating the service
- Packaging and deploying the service
- Common considerations across all operating systems
- Linux (systemd) execution
- Windows (NSSM) execution
- Where hms_sys development could go from here
- Code review refactoring and cleanup
- Developing a UI
- Order fulfilment and shipping APIs
- Summary
- Multiprocessing and HPC in Python
- Common factors to consider
- A simple but expensive algorithm
- Some testing setup
- Local parallel processing
- Threads
- Parallelizing across multiple machines
- Common functionality
- The Worker nodes
- The Orchestrator
- The Dispatcher
- Integrating Python with large-scale cluster computing frameworks
- Python Hadoop and Spark
- Summary
- Other Books You May Enjoy
- Leave a review - let other readers know what you think 更新時間：2021-06-24 18:21:24
