O'Reilly logo

Stay ahead with the world's most comprehensive technology and business learning platform.

With Safari, you learn the way you learn best. Get unlimited access to videos, live online training, learning paths, books, tutorials, and more.

Start Free Trial

No credit card required

Building Social Web Applications

Book Description

Building a web application that attracts and retains regular visitors is tricky enough, but creating a social application that encourages visitors to interact with one another requires careful planning. This book provides practical solutions to the tough questions you'll face when building an effective community site -- one that makes visitors feel like they've found a new home on the Web.

If your company is ready to take part in the social web, this book will help you get started. Whether you're creating a new site from scratch or reworking an existing site, Building Social Web Applications helps you choose the tools appropriate for your audience so you can build an infrastructure that will promote interaction and help the community coalesce. You'll also learn about business models for various social web applications, with examples of member-driven, customer-service-driven, and contributor-driven sites.

  • Determine who will be drawn to your site, why they'll stay, and who they'll interact with
  • Create visual design that clearly communicates how your site works
  • Build the software you need versus plugging in one-size-fits-all, off-the-shelf apps
  • Manage the identities of your visitors and determine how to support their interaction
  • Monitor demand from the community to guide your choice of new functions
  • Plan the launch of your site and get the message out

Table of Contents

  1. Building Social Web Applications
  2. Dedication
  3. Preface
    1. Design As the Primary Approach
    2. Who This Book Is For
    3. Who This Book Is Not For
    4. What You’ll Learn
    5. How This Book Is Organized
    6. Typographical Conventions Used in This Book
    7. Safari® Books Online
    8. We’d Like to Hear from You
    9. How This Book Came About
    10. Acknowledgments
  4. 1. Building a Social Application
    1. Building Applications
    2. The Distributed Nature of Seemingly Everything
      1. Real-Time Services
      2. APIs and Their Importance
      3. Collective Intelligence: The New Artificial Intelligence
    3. Summary
  5. 2. Analyzing, Creating, and Managing Community Relationships
    1. Analyzing Your Users’ Relationships
      1. Relationships with Baby Boomers to Gen-C’ers
      2. Behavior and Interaction-Based Relationships
        1. Customer-service-driven
        2. Publisher-driven
        3. Member-driven
        4. Contributor-driven
      3. Pros and Cons of Different Relationship Types
    2. Analyzing the Essence of Your Community’s Needs
      1. Apple and Its Many Communities
      2. Determining Your Site’s Purpose
      3. Creating and Nurturing Relationships
    3. Summary
  6. 3. Planning Your Initial Site
    1. Deciding What You Need
    2. Building a Web Application
    3. Choosing Who You Need
    4. Planning the Life Cycle
      1. Expecting to Evolve with the Community
        1. Twitter
        2. Flickr
      2. Keeping Your Application Simple
      3. Avoiding the Line Item Approach
      4. Getting to the Core Quickly
      5. Taking Time to Plan
        1. Iterating
        2. Showing it off
        3. Figuring out the verbs
    5. Communicating During Development
    6. Managing the Development Cycle
      1. Feature Prioritization and the Release Cycle
      2. Choosing a Development Methodology
    7. Collecting Audience Feedback
      1. Why Would People Continue to Visit Your Site?
    8. Summary
  7. 4. Creating a Visual Impact
    1. Dynamic Interactions
      1. The Power of Partial Page Reloads
      2. Designing Around Community-Generated Internal Pages
      3. Visual Design and Navigation
    2. Design First
      1. Page Types
      2. Designer Roles and Team Approaches
        1. Visual design approach
        2. Software design approach
        3. Wireframes approach
        4. Sketching approach
    3. Copywriting
    4. Summary
  8. 5. Working with and Consuming Media
    1. Media Types Affect Consumption Styles
      1. Analyzing Consumption Patterns
      2. Collecting Consumption Data
    2. Media Evolves and Consumption Styles Change
      1. “comment is free”
      2. Amazon: Reader Reviews Encourage Purchases
    3. New Services Respond to Evolving Needs
      1. Music
      2. Photos
      3. Video
    4. Summary
  9. 6. Managing Change
    1. Resistance
      1. Schema Theory
        1. Congruence
        2. Adaptation
        3. Rate of change
      2. Web Communities and Change
    2. Internal Workflow
    3. Community Managers
    4. Summary
  10. 7. Designing for People
    1. Making Software for People
      1. Waterfalls Are Pretty to Look At
    2. Interaction Design
    3. Identify Needs with Personas and User-Centered Design
      1. Talking with Potential Users
      2. Naming Influences Perspectives
    4. Common Techniques for UCD
    5. Running Interaction Design Projects
    6. Using Agile and UCD Methods
    7. Beyond UCD
      1. HCI and Information Architecture
      2. The Craftsman Approach
    8. Learning to Love Constraints
      1. Keeping Experiments Quick
      2. Figuring Out the Social Aspect
      3. Subjects, Verbs, and Objects
    9. Including You, Me, and Her Over There, Plus Him, Too
    10. Moving Quickly from Idea to Implementation
      1. Explaining to Others What You Are Doing
      2. Creating Service Functionality Documents
      3. Calculating Content Size
    11. Don’t Let Your Users Drown in Activity
    12. Implementing Search
      1. Member-Specific Search
      2. Advanced Search
    13. Understanding Activity and Viewpoints
      1. Recipe Books: An Example
      2. Remembering the Fun
    14. Twelve Ideas to Take Away
    15. Summary
  11. 8. Relationships, Responsibilities, and Privacy
    1. We Are in a Relationship?
    2. Personal Identity and Reputation
    3. Handling Public, Private, and Gray Information
    4. Privacy and Aggregate Views
    5. See But Don’t Touch: Rules for Admins
    6. Private by Default?
    7. Setting Exposure Levels
    8. Managing Access for Content Reuse, Applications, and Other Developers
      1. Content Reuse
      2. Don’t Give Away Too Much Power
      3. Licensing Content
    9. Summary
  12. 9. Community Structures, Software, and Behavior
    1. Community Structures
      1. Publisher-Led
      2. Interest-Led
      3. Product-Led
    2. Supporting Social Interactions
      1. Non-Text-Based Social Interaction
      2. Competition: Making Games Social
      3. Content Creation and Collectives
      4. Social Microblogging
    3. Who Is Sharing, and Why?
      1. Competition Between Peers Skews Interaction
      2. Talking About Things That Are Easy to Discuss
    4. How Are They Sharing?
      1. Being Semiprivate
      2. Lifestreaming and Social Aggregation
      3. Overfeeding on Lifestreams
      4. A Simple Core for Rapid Growth
    5. Social Software Menagerie
      1. Blogging
        1. Community blogging
        2. Creating a blogging system
      2. Commenting Is Not the Same As Blogging
    6. Groups
      1. Group Formation
      2. Group Conversation
        1. Conversing on message boards
        2. Making message boards
      3. Group Aggregation Tools
      4. Collaboration Tools for Groups
      5. Social Platforms As a Foundation
      6. Ning and White Label Social Software
      7. Growing Social Networks
    7. Summary
  13. 10. Social Network Patterns
    1. Sharing Social Objects
      1. Relationships and Social Objects
      2. Determining the Right Social Object
    2. Published Sites Expect Audiences
    3. Deep and Broad Sharing
    4. Capturing Intentionality
    5. Cohesion
    6. Filtering Lists by Popularity
      1. Filtering Lists to Show Recent Content
      2. Calculating Popularity Across a Site
    7. Commenting, Faving, and Rating
      1. Commenting
      2. Faving or Marking As Favorite
      3. Rating
    8. Internal Messaging Systems
    9. Friending Considered Harmful
    10. Sharing Events
    11. Summary
  14. 11. Modeling Data and Relationships
    1. Designing URLs
    2. Getting to the Right URL
    3. Permalinks
    4. Putting Objects on the Internet
      1. Issuing Identifiers
      2. Identifying People
      3. Using Data-Driven Site Design
      4. Handling Containment
      5. Changing Identities and Linking Content
      6. Identity and Context-Dependent Views
      7. Exploring a Video Example
    5. Aggregating Data to Create New Content
    6. Exploring Groups
      1. Handling Groups and Privacy
      2. Handling Privacy and Scaling Issues
    7. Making the Most of Metadata
    8. Connecting the Relationship to the Content
      1. Modeling Relationships
      2. Entering the Geoworld
      3. Becoming “Brokers of the World”
    9. Considering Time Implications
    10. Looking Beyond the Web
    11. Summary
  15. 12. Managing Identities
    1. Existing Identities
    2. Forms of Identification
      1. Email
      2. Real Names Versus Aliases and Screen Names
      3. OpenID
      4. Tips for Account Registration and Verification
    3. The Need for Profile Pages
      1. Profile Page Anatomy
      2. Real-World Profile Pages
        1. Pownce
        2. Twitter
        3. LinkedIn and Nature Network
        4. Personal network member maximums
    4. Activity Pages
    5. Invisibility and Privacy
    6. Summary
  16. 13. Organizing Your Site for Navigation, Search, and Activity
    1. Understanding In-Page Navigation
      1. Tagging Content
      2. Searching for People
    2. Connecting People Through Content
    3. Providing Activity Pages
      1. Determining Activity Page Content
    4. Filtering Activity Lists and the Past
      1. Using Replies to Create Conversations
      2. Allowing for Content Initiation Versus Content Follow-Up
      3. Providing for Email Updates
      4. Creating RSS Feeds
    5. Who Stole My Home Page?
    6. Providing for Site Navigation
      1. Creating Page Titles
    7. Summary
  17. 14. Making Connections
    1. Choosing the Correct Relationship Model for Your Social Application
      1. Creating the Language of Connections
      2. Blocking Relationships
    2. Information Brokers
    3. Notifications and Invitations
      1. Invites and Add As Follower Requests
      2. Secure and Personal Invites
      3. Pending Invites
      4. Spam
    4. Social Network Portability
      1. Social Graph
      2. Importing Friends by the Book
    5. Spamming, Antipatterns, and Phishing
    6. Address Books, the OAuth Way
    7. Changing Relationships over Time
    8. Administering Groups
      1. Public or Private?
      2. Regulating Group Creation
    9. Summary
  18. 15. Managing Communities
    1. Social Behavior in the Real World
    2. Starting Up and Managing a Community
    3. Trolls and Other Degenerates
    4. Separating Communities
    5. Encouraging Good Behavior
      1. Authenticating Through Profile Pages
      2. Rating Posts and People
    6. Gaming the System
    7. Membership by Invitation or Selection
    8. Rewarding Good Behavior
    9. Helping the Community Manage Itself
      1. Moderating a Community
      2. Intervention and Course Correction
      3. Premoderation and Libel
      4. Extreme Measures: Banning Users and Removing Posts
      5. Absent Landlords Lead to Weak Communities
      6. Filtering and Automation
    10. Balancing Anonymity and Pseudo-Anonymity
    11. Summary
  19. 16. Writing the Application
    1. Small Is Good: A Reprise
    2. How Social Applications Differ from Web Applications
    3. Agile Methodologies
    4. Deployment and Version Control
      1. Testing Live Is Possible, but Use Conditionality
      2. Test-Driven Development
      3. Automated Builds Make Management Easier
      4. Applying Developer Tools to Social Applications
      5. Making Use of Flexible Development with Your Community
    5. Infrastructure and Web Operations
      1. Managing Operations
    6. Designing Social Applications
      1. Using Prototypes, Not Pictures
      2. Assisting Developers with Use Cases
      3. Designing in Good Behaviors
    7. Your App Has Its Own Point of View
    8. How Code Review Helps Reduce Problems
      1. The Power and Responsibility of Naming
      2. Being RESTful
    9. Beyond the Web Interface, Please
      1. i18n, L10n, and Their Friend, UTF-8
    10. Bug Tracking and Issue Management
      1. Tracking Tools
      2. Prioritizing Issues
      3. Differentiating Bugs from Feature Requests
      4. Handling Security
    11. Rapid User Interfaces
      1. Rapid Prototyping
    12. Scaling and Messaging Architectures
      1. Ajax Helps with Scaling
      2. Queuing Non-Visible Updates
      3. Real Time Versus Near Time
      4. Polling Versus Pushing
      5. XMPP Messaging
      6. External Processing: Scaling on the Fly and by the Batch
      7. Performance Testing
      8. Languages Don’t Scale
      9. Cache, Then Shard
      10. Fast and Light Data Storage
    13. Implementing Search
    14. Identity and Management of User Data
      1. OpenID for Identity
      2. What to Ask for on Registration
      3. When a User Chooses to Leave
      4. Admin Users
      5. Accessing Content via OAuth
    15. Federation
    16. Making Your Code Green and Fast
    17. Building Admin Tools and Gleaning Collective Intelligence
      1. Social Network Analysis
      2. Machine Learning and Big Data Sets
      3. Reputation Systems
    18. Summary
  20. 17. Building APIs, Integration, and the Rest of the Web
    1. “On the Internet” Versus “In the Internet”
    2. Making Your Place Within the Internet
    3. Why an API?
      1. Exposing Your Content to Search from the Internet
      2. Running Services, Not Sites
    4. Being Open Is Good
    5. Arguing for Your API Internally
    6. Implementing User Management and Open Single Sign-On
      1. Integrating Other Services
      2. Lightweight Integration Works Best
      3. Avoiding Data Migration Headaches
      4. Avoiding Duplication
      5. Email Notifications: Managing Your Output from Multiple Applications
      6. Making an API the Core of the Application
      7. Handling People and Objects, the Stuff of Social Applications
    7. Designing an API
      1. RPC
      2. REST
      3. XMPP
      4. Response Formats
    8. Comparing Social APIs
      1. Tumblr
      2. Flickr
      3. Twitter
    9. Reviewing the APIs
      1. Writable APIs
      2. Extending and Fine-Tuning Your API
      3. Wrapping API Calls
      4. Using API Alternatives
      5. Using HTML Badges
      6. Interoperability Is Harder with Snowflake APIs
      7. Sticking with Standards
      8. Standardizing APIs
      9. Using OpenSocial
      10. Creating a Standard
    10. Managing the Developer Community
      1. API and Scaling Issues
      2. Allowing Integration
      3. Real Time Versus Near Time for APIs
      4. APIs Can Be Restrictive
      5. Not Just Your Own API
    11. Create an API?
    12. Summary
  21. 18. Launching, Marketing, and Evolving Social Applications
    1. Loving and Hating the Home Page
      1. Your Site Launch
      2. The Soft-Launch Approach
      3. The Hard-Launch Approach
      4. Your Product Name
      5. A Friendly Invitation
    2. Financing Your Site
      1. Offering Premium and Freemium Models
    3. Marketing
    4. Achieving and Managing Critical Mass
      1. Arriving with Context
      2. Considering Contact Import APIs and Their Importance
      3. Using Tools and Services for Launch and Support
      4. Nurturing the First Few Hundred Users
      5. Encouraging Your Community
    5. Evolving Your Site
      1. Remaining in Beta
      2. Balancing Feature Requests and Issue Management
      3. Adding Functionality
      4. Build Something New or Refine the Old?
      5. Adding Functionality After Refining
      6. Watching for What Your Community Demands
        1. Delicious and Boolean search
        2. Flickr printing and video
        3. Twitter and @replies
      7. Keeping Up with the Competition (or Not)
      8. Avoiding Feature-Led Development
      9. Encouraging Data-Supported Development
      10. Making Useful Products (Experience-Led)
      11. Determining When a Bug Is a Bug
      12. Staying Focused and Coherent
      13. Planning for Redesigns and Refactoring
    6. Establishing the Rhythm of Your Evolving Application
    7. Summary
  22. Index
  23. About the Author
  24. Colophon
  25. Copyright