Skip to content

Latest commit

 

History

History
392 lines (348 loc) · 11.4 KB

book-contents.md

File metadata and controls

392 lines (348 loc) · 11.4 KB

Why You Need Symphony

Introduction

Part 1: Get to Know Symphony

Chapter 1. Why You Need Symphony

  • 1.1 The Challenges of a Changing Web
    • 1.1.1 The Evolution of the Web
    • 1.1.2 The Evolution of Web Content
    • 1.1.3 The Changing Role of the CMS
    • 1.1.4 Content Management Challenges
  • 1.2 Functions Versus Features
    • 1.2.1 A Feature-focused Approach to Content Management
    • 1.2.2 Limitations of a Feature-focused Approach
    • 1.2.3 Prioritizing Functions Over Features
  • 1.3 The Symphony Way
    • 1.3.1 Make No Assumptions
    • 1.3.2 Provide the Tools, Trust the User
    • 1.3.3 Rely on Open Standards
  • 1.4 What Symphony Can Do For You
    • 1.4.1 Power Any Kind of Website
    • 1.4.2 Give you Back your Data
    • 1.4.3 Put you in the Driver's Seat
  • 1.5 Summary: Crafting the Future of the Web

Chapter 2. Symphony in Action

  • 2.1 Personal Website: The Interactive Manufactory of Jonas Downey
    • 2.1.1 Overview
    • 2.1.2 Points of Interest
    • 2.1.3 Developer’s Thoughts
  • 2.2 Web/Mobile App: Clorox MyStain
    • 2.1.1 Overview
    • 2.1.2 Points of Interest
    • 2.1.3 Developer’s Thoughts
  • 2.3 Publication Website: Public Culture
    • 2.1.1 Overview
    • 2.1.2 Points of Interest
    • 2.1.3 Developer’s Thoughts
  • 2.4 Business Website: Original Travel
    • 2.1.1 Overview
    • 2.1.2 Points of Interest
    • 2.1.3 Developer’s Thoughts
  • 2.5 Social Network: Whisky Connosr
    • 2.1.1 Overview
    • 2.1.2 Points of Interest
    • 2.1.3 Developer’s Thoughts
  • 2.6 Summary

Chapter 3. Getting Started

  • 3.1 Getting the Lay of the Land
    • 3.1.1 How Symphony Works
    • 3.1.2 Web Servers
    • 3.1.3 Server Environments
    • 3.1.4 Databases
    • 3.1.5 Summary
  • 3.2 Knowing What You Need
    • 3.2.1 Server Requirements
    • 3.2.2 Helpful PHP Extensions
    • 3.2.3 Requirements Summary
  • 3.3 Preparing the Installation
    • 3.3.1 Decisions, Decisions
    • 3.3.1 Getting Symphony Onto Your Server
    • 3.3.3 Creating a Database
  • 3.4 Running the Installer
  • 3.5 What To Do When You Need Help
    • 3.5.1 Reaching out to Community
    • 3.5.2 Reaching out to the Symphony Team
  • 3.6 Summary: Rolling up Your Sleeves

Part 2: Symphony Fundamentals

Chapter 4. Symphony Anatomy

  • 4.1 Dipping Your Toes In
  • 4.2 The Form of Symphony's Function
    • 4.1.1 The Content Layer
    • 4.1.2 The Interaction Layer
    • 4.1.3 The Presentation Layer
    • 4.1.4 Summary: Symphony’s Functional Anatomy
  • 4.2 The Admin Interface
    • 4.2.1 Composition and Layout
    • 4.2.2 Content
    • 4.2.3 Blueprints
    • 4.2.4 System
  • 4.3 Physical Footprint
    • 4.3.1 Folder Structure
  • 4.4 Differences Between Symphony 2 and Symphony 3
    • 4.4.1 Nomenclature
    • 4.4.2 File Structures
    • 4.4.3 Database
    • 4.4.4 Extensions
    • 4.4.5 Admin Interface
  • 4.5 Summary

Chapter 5. Content

  • 5.1 What is Content Modeling?
  • 5.2 Understanding Content in Symphony
    • 5.2.1 Sections
    • 5.2.2 Fields
    • 5.2.3 Field Types
    • 5.2.4 Relationships
    • 5.2.5 Planning Our Blog
  • 5.3 Working with Content in Symphony
    • 5.3.1 Creating and Editing Sections
    • 5.3.2 Working with Fields
    • 5.3.3 Adding and Configuring Fields
    • 5.3.4 Reordering and Removing Fields
    • 5.3.5 Designing Section Layouts
    • 5.3.6 Creating Relationships
    • 5.3.7 Managing Sections
    • 5.3.8 Managing Entries
  • 5.4 Summary

Chapter 6. Front-end

  • 6.1 What is Front-End Architecture?
  • 6.2 Understanding Symphony’s Front End
    • 6.2.1 Views
    • 6.2.2 View Types
    • 6.2.3 URL Parameters
    • 6.2.4 View Resources
    • 6.2.5 Planning Your Blog’s Front End
  • 6.3 Working with Symphony’s Front End
    • 6.3.1 Creating and Editing Views
    • 6.3.2 Crafting a URL Schema
    • 6.3.3 Organizing Views
  • 6.4 Summary

Chapter 7. Data Flow

  • 7.1 What is Data Flow?
  • 7.2 Understanding Data Flow in Symphony
    • 7.2.1 Data Sources
    • 7.2.2 Data Source Types
    • 7.2.3 Data Source Filters
    • 7.2.4 Events
    • 7.2.5 Event Options
    • 7.2.6 Planning Your Data Flow
  • 7.3 Working with Data Sources
    • 7.3.1 Creating and Editing Data Sources
    • 7.3.2 Filtering Data Sources
    • 7.3.3 Chaining Data Sources
  • 7.4 Working with Events
    • 7.4.1 Creating and Editing Events
    • 7.4.2 Entry-Saving Events and Form Submissions
  • 7.5 Summary

Chapter 8. Templating

  • 8.1 What is Templating?
  • 8.2 Understanding Templating in Symphony
  • 8.3 Understanding XSLT
    • 8.3.1 How Transformations Work
    • 8.3.2 Parsing XML
    • 8.3.3 Templates
    • 8.3.4 How Templates are Organized
    • 8.3.5 Anatomy of a Stylesheet
  • 8.4 Working with View Templates and XSLT Utilities
    • 8.4.1 Writing a View Template
    • 8.4.2 Writing an XSLT Utility
    • 8.4.3 Using XSLT Utilities
  • 8.5 Summary

Chapter 9. System Management

  • 9.1 Managing Settings
  • 9.2 Managing Users
    • 9.2.1 Creating and Editing Users
    • 9.2.2 User Roles
    • 9.2.3 Creating and Editing Roles
  • 9.3 Managing Extensions
    • 9.3.1 The Default Extensions
    • 9.3.2 Finding and Installing Extensions
    • 9.3.3
  • 9.4 Backups, Updates, and System Maintenance
  • 9.5 Summary

Part 3: Symphony Workflows

Chapter 10. Planning Symphony Projects

  • 10.1 Planning to Plan
    • 10.1.1 Be Open
    • 10.1.2 Lurk Around the Community
    • 10.1.3 Research Extensions
    • 10.1.4 Ask for Help
  • 10.2 Mapping Project Architectures
    • 10.2.1 Outline Your Content
    • 10.2.2 Wireframe
    • 10.2.3 Perform Task Analyses
    • 10.2.4 Plan Your Markup as a System
    • 10.2.5 Map Everything
  • 10.3 Workflows
    • 10.3.1 Plan to Test
    • 10.3.2 Be Flexible
    • 10.3.3 Use Version Control
    • 10.3.4 Be Ready to Deploy
  • 10.4 Summary

Chapter 11. Adaptive Techniques

  • 11.1 Rapid Prototyping
  • 11.2 Iterative Development
    • 11.2.1 Adjusting What You’ve Got
    • 11.2.2 Prototyping a Portfolio Addition
  • 11.3 Summary

Chapter 12. Setting Up a Master Layout Template

  • 12.1 One Stylesheet to Rule Them All
    • 12.1.1 What it Means to be DRY
    • 12.1.2 XSLT as a Templating System
  • 12.2 Creating a Master Layout Utility
    • 12.2.1 A Note on XSLT Output
    • 12.2.2 Having a Plan for your Markup
    • 12.2.3 Writing and Structuring your Master Layout Utility
  • 12.3 Setting up the View Templates
    • 12.3.1 Inclusion and Hierarchy in XSLT
    • 12.3.2 Creating View-specific Templates
  • 12.4 Summary

Chapter 13. Enabling Front-end Submission

  • 13.1 Symphony as a Two-Way Street
    • 13.1.1 The Importance of User-Generated Content
    • 13.1.2 Front-end Submission in Symphony
  • 13.2 Building Events
  • 13.3 Form Markup
    • 13.3.1 How Symphony Parses Forms
    • 13.3.2 Marking Up a Front-end Submission Form
    • 13.3.3 Advanced Options
  • 13.4 Validation and Feedback
    • 13.4.1 About Event Responses
    • 13.4.2 Validating Form Input
    • 13.4.3 Using Event Responses to Provide User Feedback
  • 13.5 Summary

Chapter 14. Abstracting Reusable XSLT

  • 14.1 Keeping Your Templating Layer DRY
    • 14.1.1 Consistency and Design
    • 14.1.2 Identifying Opportunities for Reuse
    • 14.1.3 Patterns of Template Organization
  • 14.2 Named Templates and Parameters in XSLT
    • 14.2.1 About Named Templates
    • 14.2.2 About XSLT Parameters
    • 14.2.3 How and When to Use Named Templates
  • 14.3 Rule Specificity, Modes, and Priorities
    • 14.3.1 Understanding Rule Specificity in XSLT
    • 14.3.2 How and When to Use Priorities
    • 14.3.3 How and When to Use Modes
  • 14.4 Summary

Chapter 15. Debugging, Testing, and Profiling

  • 15.1 Using Symphony's Devkit Interface
    • 15.1.1 About Devkits
    • 15.1.2 The Debug Devkit
    • 15.1.3 The Profile Devkit
  • 15.2 Debugging Content
    • 15.2.1 XML Basics
    • 15.2.2 Symphony and XML
    • 15.2.3 Common Problems and Mistakes
  • 15.3 Debugging XSLT and XPath
    • 15.3.1 Reviewing XSLT Stylesheets
    • 15.3.2 Using the XPath Search Function
  • 15.4 Inspecting the Front-end Environment
    • 15.4.1 Checking Parameters
    • 15.4.2 Reviewing Output
  • 15.5 Monitoring Performance
    • 15.5.1 Profiling a Front-end View
    • 15.5.2 Identifying Bottlenecks
  • 15.6 Summary

Part 4: More Symphony Projects

Chapter 16. The Lifestream

  • 16.1 A Study in Aggregation
    • 16.1.1 The Power of Communities
    • 16.1.2 XML: Language of the Semantic Web
    • 16.1.3 Achieving Web Fluency with Symphony
    • 16.1.4 Planning your Lifestream
  • 16.2 Identify the Sources
    • 16.2.1 Feeds and APIs
    • 16.2.2 Twitter
    • 16.2.3 Facebook
    • 16.2.4 Flickr
  • 16.3 Map Out the Interface
    • 16.3.1 The Front Page
    • 16.3.2 Advanced Browsing Options
  • 16.4 Configure the Data Sources - 16.4.1 Basic Setup - 16.4.2 Fine-tuning your Data Sources
  • 16.5 Build the Templates
    • 16.5.1 Working with External XML
    • 16.5.2 Write the Home Page Template
  • 16.6 Advanced Data Handling
    • 16.6.1 Caching
    • 16.6.2 Importing External XML
  • 16.7 Summary

Chapter 17. The Review Hub

  • 17.1 A Study in User-Generated Content
    • 17.1.1 Prioritizing User Input
    • 17.1.2 Capturing Data with Symphony
    • 17.1.3 Planning your Review Website
  • 17.2 Develop a Content Model
    • 17.2.1 Modeling with User Submissions in Mind
    • 17.2.2 Build your Sections
  • 17.3 Map Out the Interface
    • 17.3.1 The Front Page
    • 17.3.2 Submissions Pages
    • 17.3.3 Entry Pages
  • 17.4 Get the Data Moving
    • 17.4.1 Build the Events
    • 17.4.2 Configure the Data Sources
  • 17.5 Build the Templates
    • 17.5.1 Secure, Usable Forms
    • 17.5.2 A Sprinkle of AJAX
    • 17.5.3 Listings Pages
    • 17.5.4 Entry Pages
  • 17.6 Advanced Front-end Data Submission
    • 17.6.1 Editing Existing Entries
    • 17.6.2 Batch Edits
    • 17.6.3 Saving to Multiple Sections
  • 17.7 Basic Search
    • 17.7.1 Search Options in Symphony
    • 17.7.2 Implementing a Simple Search Function
  • 17.8 Summary

Chapter 18. The Shop

  • 18.1 A Study in User Experience
    • 18.1.1 Understanding How People Shop
    • 18.1.2 Crafting User Experiences with Symphony
    • 18.1.3 Planning your Shop
  • 18.2 Develop a Content Model
    • 18.2.1 Modeling Real-world Products on the Web
    • 18.2.2 Two Perspectives: Seller and Buyer
    • 18.2.3 Build your Product Sections
  • 18.3 Map Out the Interface
    • 18.3.1 What Kind of Experience Do We Want to Create?
    • 18.3.2 The Storefront
    • 18.3.4 The Shopping Cart
    • 18.3.5 The Checkout
  • 18.4 Configure the Data Sources
    • 18.4.1 Getting Only What We Need
    • 18.4.2 Dynamic Interfaces
  • 18.5 Build the Templates
    • 18.5.1 The Markup Plan
    • 18.5.2 Crafting your Storefront
    • 18.5.3 Creating Reusable Product Views
  • 18.6 Advanced Sessions and Security
    • 18.6.1 Symphony User Permissions
    • 18.6.2 Integrating Third-Party Tools
  • 18.7 Summary

Chapter 19. The API

  • 19.1 A Study in Data Portability
    • 19.1.1 Understanding APIs
    • 19.1.2 Symphony as Data Engine
    • 19.1.3 Planning your API
  • 19.2 Develop a Content Model
    • 19.2.1 Modeling with Meaning in Mind
    • 19.2.2 Crafting Usable Data
    • 19.2.3 Building your Sections
  • 19.3 Map Out the Interface
    • 19.3.1 Your API's Methods
    • 19.3.2 Using Subpages and Parameters
    • 19.3.3 Advanced Parameter Use
  • 19.4 Configure the Data Sources
    • 19.4.1 Getting the Most out of Data Sources
    • 19.4.2 Advanced Filtering and Chaining
  • 19.5 Build the Templates
    • 19.5.1 Outputting XML
    • 19.5.2 Templating for Structure and not Design
    • 19.5.3 Writing Modular XSLT
  • 19.6 Advanced Output Options
    • 19.6.1 JSON
    • 19.6.2 CSV
    • 19.6.3 Fun with Output
  • 19.7 Summary

Conclusion