Full Stack JavaScript Strategies. The Hidden Parts Every Mid-Level Developer Needs to Know Milecia McGregor

Dostępność produktu

Produkt nie został jeszcze oceniony pod kątem ułatwień dostępu lub nie podano żadnych informacji o ułatwieniach dostępu lub są one niewystarczające. Prawdopodobnie Wydawca/Dostawca jeszcze nie umożliwił dokonania walidacji produktu lub nie przekazał odpowiednich informacji na temat jego dostępności.

Spis treści książki

• Preface
  • Who This Book Is For
  • What You Will Learn
  • What This Book Is Not
  • How This Book Is Organized
  • Conventions Used in This Book
  • Using Code Examples
  • OReilly Online Learning
  • How to Contact Us
  • Acknowledgments
• I. Starting Your New Project
• 1. Kicking Off the Project
  • The Project Youll Build
  • Project Kickoff Meeting
  • Design Considerations
  • Data-Driven Design
    • Breaking Down Designs into Tasks
    • Refining Tasks from Feature Requirements
  • Discussing Timelines with Product and Other Teams
    • Talking to Other Development Teams
    • Coordinating with DevOps
    • Working with QA
    • Planning with Support
  • Conclusion
• II. Building the Backend
• 2. Setting Up the Backend
  • Why NestJS?
  • Choosing a Project Approach
  • Setting Up NestJS
    • Testing the Backend Locally
    • Updating the README
    • Adding a CHANGELOG
  • Monolith and Microservice Architectures
  • Alternative Architectures to Consider
  • Selecting an API Design Pattern: REST and GraphQL
  • Conclusion
• 3. Building the Data Schema
  • Initial Considerations
  • Diagramming the Data Schema
  • Setting Up Postgres
  • Deciding What ORM to Use
  • Writing Migrations
  • Seeding the Database
  • Conclusion
• 4. REST APIs
  • Making Sure the Frontend and Backend Agree
  • Creating a Document for Conventions
  • Making the API and First Endpoint
    • Creating the Orders Endpoints
    • Working on the Orders Service
    • Checking the Database Connection
  • Conclusion
• 5. Third-Party Services
  • Choosing a Third-Party Service
  • List of Potential Services
  • Integrating Stripe
    • Writing the Controller
    • Writing the Service
  • Conclusion
• 6. Background Jobs
  • Updating the Backend Architecture
  • Using Cron Jobs
    • Alerts and Monitoring
    • Logging
    • Issues with Data Sync and Task Execution
    • Future Considerations
  • Conclusion
• 7. Backend Testing
  • Why Spend the Time on Tests
  • How to Approach Test Writing
  • Mock Data
  • Conclusion
• 8. Backend Security Considerations
  • Authentication
  • Authorization
  • OWASP Top 10
  • Other Noteworthy Practices
  • Conclusion
• 9. Backend Debugging
  • Detailed Log Messages
  • Environment Configurations
  • Strategies for Tracing Bugs
  • Helping Other Devs Debug
  • Debugging Checklist
  • Conclusion
• 10. Backend Performance
  • Metrics
  • Alerts and Monitoring
  • Caching
    • Cache Strategies
    • Types of Caching
    • Cache Implementation with Redis
  • Product Considerations
  • Conclusion
• 11. Scalability Considerations
  • Types of Scaling
    • Vertical Scaling
    • Horizontal Scaling
  • Hybrid Scaling
    • Resource Scaling
  • Scaling Best Practices
    • Make a Plan
    • Document the Plan
    • Run Tests
    • Communicate Progress
    • Start Shifting Traffic
  • Conclusion
• 12. Monitoring, Logging, and Incident Handling
  • Uses for Logs and Monitoring
    • Use Logs for Debugging
    • Use Monitoring to Inform Your Actions
    • Monitoring and Logging Tools
  • Incident Playbooks
    • Playbook Stages
      • Stage 1: Detect an incident
      • Stage 2: Set up incident communication
      • Stage 3: Determine the impact and severity
      • Stage 4: Notify users
      • Stage 5: Notify the right teams
      • Stage 6: Delegate incident responsibilities
      • Stage 7: Resolve the incident
    • Incident Response Template
    • Blameless Postmortems
  • Conclusion
• III. Building the Frontend
• 13. Setting Up the Frontend
  • Frontend Architecture Decisions
  • Choosing a Frontend Framework
    • App Setup Options
    • Common Components
    • Choosing Packages
  • Working with Other Teams
  • Conclusion
• 14. Building the React App
  • Set Up the Initial React App
    • Set Up Linters and Formatters
    • Set Up the Build Configs
    • Set Up Styles
    • Set Up Testing
    • Set Up CHANGELOG and README
    • Run the App Locally
  • Build the First Feature
    • Project Structure
    • Set Up Routing
    • Update the Root of the App
  • Conclusion
• 15. State Management
  • How Component State Works
    • useState
    • useReducer
    • useContext
    • Knowing What App Level to Manage State In
  • Different Approaches to State Management
  • Setting Up the State Manager
  • Conclusion
• 16. Data Management
  • Potential Tools for Fetching Data
  • Handling API Calls with Axios and TanStack Query
    • The .env File
    • Handling Loading States
    • Handling Error States
    • Configuring Request Headers
  • When to Check on Backend Functionality
  • Conclusion
• 17. Custom Styles
  • Accessibility
    • Making an Accessible Form
    • Checking Your Accessibility Implementations
    • More Accessibility Considerations
  • Consistent Designs
  • Custom Themes
  • Responsive Design
  • Conclusion
• 18. Frontend Error Handling
  • Error Boundary Approaches
    • Error Components
    • Logging Errors
  • User Validation Errors
  • API Errors
  • Conclusion
• 19. Frontend Security Considerations
  • Common Vulnerabilities
    • Business Logic Validation
    • Session Management
    • Package Version Maintenance
    • Input Validation
  • Other Principles
  • How to Check Your Own App
  • Conclusion
• 20. Frontend Performance
  • Benchmark Metrics
    • Lighthouse Tools
    • Sitespeed.io
  • Areas for Improvement
    • Bundle Size Analysis
    • Build Configurations
    • Caching Configuration
    • Lazy Loading
    • Prefetching
    • CSS, Images, and Fonts
  • Conclusion
• 21. Frontend Testing
  • Determining Test Scenarios
  • Unit Tests
    • Jest and React Testing Libraries
    • Vitest
    • Mock Service Worker
  • E2E Testing with Cypress
  • Conclusion
• 22. Frontend Debugging
  • The Debugging Process
  • Looking Through Logs
  • Checking the Code
    • Using console.log Messages
    • Using Breakpoints
    • Using Unit Tests
    • Using Git
  • Using the Browser Devtools
    • The Elements Tab
    • The Sources Tab
    • The Network Tab
    • The Application Tab
  • Debugging in Other Environments
  • Unexpected Places
  • Conclusion
• IV. Deploying the Full Stack App
• 23. Full Stack Deployment Setup
  • Teams Involved in Deploys
  • Backend and Frontend Connection Steps
    • Backend Steps
    • Frontend Steps
    • Cleanup Steps
    • Documentation and Maintenance Steps
  • Conclusion
• 24. Integration Testing
  • The Test Cases
  • End-to-End Tests with Cypress
  • End-to-End Tests with Playwright
  • End-to-End Tests with Nightwatch
  • Comparison Between Packages
  • Conclusion
• 25. Making Deployments
  • Deploying Frontend-Only or Backend-Only Updates
  • Deploy Strategies
    • Release Dates
    • Version Releases
    • Blue-Green Deploys
    • Canary Deploys
  • Strategies for Doing Rollbacks
    • Deploying Older Versions
    • Reverting or Resetting PRs
    • Deploying a Hotfix
  • Conclusion
• 26. Integration Concerns
  • Frontend and Backend Concerns
  • Third-Party Service Concerns
  • Data and Security in Production
  • Containerization of Your App
  • Conclusion
• 27. Building a CI/CD Pipeline
  • Creating Your Own Pipeline
    • Speed Considerations
    • Git Hooks
    • GitHub Configs
    • CircleCI Configs
  • Environment Pipelines
    • Feature Environment
    • Development Environment
    • Staging Environment
    • Production Environment
    • Environment Variables
  • Conclusion
• 28. Git Management
  • Branching Strategies
    • Common Branches and Merge Flow
    • PR Reviews
    • Branches for Smaller Functionality
    • Feature Branches for Larger Implementations
    • Squashing Commits
    • Rebasing and Merging Branches
  • Handling Merge Conflicts
    • Discuss with the Dev Who Made Changes
    • Use git bisect to Find the Affected Files
    • Manually Compare File Changes
  • Conclusion
• 29. Project Management
  • Sprint Discussions
    • Estimates
    • Dev Capacity
    • Feature Requirements
    • Dev Team Ticket Review
    • Roadmaps
  • Defining and Managing Tasks
    • Maintain Team Awareness
    • Write and Clarify Tickets
    • Consider Overhead Tasks
    • Pace Yourself
    • Manage Context Shifting
    • Keep Communication Open
  • Conclusion
• 30. Understanding the Business Domain
  • Domain-Specific Knowledge
    • Learn from People Working Directly in the Domain
    • Take Courses
    • Work in the Domain
  • Architectural and System Design Decisions
    • Domain-Driven Design
    • C4 Design
  • Learning from Other Teams
    • Get on Sales Calls
    • Join User Research Studies
    • Talk to Marketing
    • Listen in on Customer Support Calls
    • Learn About Legal
  • Documentation Considerations
    • Define Jargon
    • Only Keep Relevant Info
    • Share Your Knowledge
    • Show How the Product Affects the Organization
  • Conclusion
• 31. Working on Different Types of Projects over Your Career
  • Considerations for Brand-New Apps
    • Understand the Problem Youre Trying to Solve
    • Build the Data Schema
    • Decide on an Architecture
    • Pick Your Cloud Provider
    • Build the Backend
    • Build the Frontend
    • Integrate the Backend and Frontend
    • Set Up Your CI/CD Pipeline
    • Perform QA Testing
    • Check Your App in Production
  • Considerations for Existing Apps
    • Get Access to the Services You Need
    • Get a Dev Instance Running
    • Look at the App in Production
    • Look at the App in Nonproduction
    • Read Through the Code
    • Take Notes About Potential Refactors
    • Ask Questions and Document the Answers
    • Improve the Code Quality
    • Add Tests
    • Learn What Different Alerts Mean
  • Your Career
    • The Technical Path
    • The Management Path
    • Professional Journal
    • Moving to Other Areas
  • Conclusion
• Index

pokaż cały spis treści

ukryj recenzje