Beautiful Architecture. Leading Thinkers Reveal the Hidden Beauty in Software Design - Helion

ebook

Autor: Diomidis Spinellis, Georgios Gousios
ISBN: 978-05-965-5439-2
stron: 430, Format: ebook
Data wydania: 2009-01-15
Księgarnia: Helion

Cena książki: 135,15 zł (poprzednio: 157,15 zł)
Oszczędzasz: 14% (-22,00 zł)

Osoby, które kupiły tę książkę, wybierały także »

Tagi: Programowanie

What are the ingredients of robust, elegant, flexible, and maintainable software architecture? Beautiful Architecture answers this question through a collection of intriguing essays from more than a dozen of today's leading software designers and architects. In each essay, contributors present a notable software architecture, and analyze what makes it innovative and ideal for its purpose.

Some of the engineers in this book reveal how they developed a specific project, including decisions they faced and tradeoffs they made. Others take a step back to investigate how certain architectural aspects have influenced computing as a whole. With this book, you'll discover:

How Facebook's architecture is the basis for a data-centric application ecosystem
The effect of Xen's well-designed architecture on the way operating systems evolve
How community processes within the KDE project help software architectures evolve from rough sketches to beautiful systems
How creeping featurism has helped GNU Emacs gain unanticipated functionality
The magic behind the Jikes RVM self-optimizable, self-hosting runtime
Design choices and building blocks that made Tandem the choice platform in high-availability environments for over two decades
Differences and similarities between object-oriented and functional architectural views
How architectures can affect the software's evolution and the developers' engagement

Go behind the scenes to learn what it takes to design elegant software architecture, and how it can shape the way you approach your own projects, with Beautiful Architecture.

Osoby które kupowały "Beautiful Architecture. Leading Thinkers Reveal the Hidden Beauty in Software Design", wybierały także:

Zen Steve'a Jobsa 29,67 zł, (8,90 zł -70%)
ASP.NET MVC. Kompletny przewodnik dla programistów interaktywnych aplikacji internetowych w Visual Studio 86,77 zł, (26,90 zł -69%)
jQuery, jQuery UI oraz jQuery Mobile. Receptury 57,74 zł, (17,90 zł -69%)
Scratch. Komiksowa przygoda z programowaniem 36,06 zł, (11,90 zł -67%)
Baltie. Kurs video. Poziom pierwszy. Elementarz programowania w języku wizualnym 59,00 zł, (26,55 zł -55%)

Spis treści

Beautiful Architecture. Leading Thinkers Reveal the Hidden Beauty in Software Design eBook -- spis treści

Beautiful Architecture
- SPECIAL OFFER: Upgrade this ebook with OReilly
- Foreword
- Preface
  - How This Book Is Organized
    - Part I: On Architecture
    - Part II: Enterprise Application Architecture
    - Part III: Systems Architecture
    - Part IV: End-User Application Architectures
    - Part V: Languages and Architecture
  - Principles, Properties, and Structures
  - Conventions Used in This Book
  - Using Code Examples
  - Safari Books Online
  - How to Contact Us
  - Acknowledgments
- I. On Architecture
  - 1. What Is Architecture?
    - Introduction
      - The Role of Architect
      - The Role of the Software Architect
      - What Constitutes a Software Architecture?
      - Architecture Versus Design
    - Creating a Software Architecture
    - Architectural Structures
      - The Information Hiding Structures
      - The Uses Structures
      - The Process Structures
        
        Process gives work to
        
        Process gets resources from
        
        Process shares resources with
        
        Process contained in module
      - Access Structures
      - Summary of Structures
    - Good Architectures
    - Beautiful Architectures
    - Acknowledgments
    - References
  - 2. A Tale of Two Systems: A Modern-Day Software Fable
    - The Messy Metropolis
      - Down the Tubes
        
        Incomprehensibility
        
        Lack of cohesion
        
        Unnecessary coupling
        
        Code problems
        
        Problems outside the code
        
        Clear requirements
      - Where Is It Now?
      - A Postcard from the Metropolis
    - Design Town
      - First Steps into Design Town
      - The Story Unfolds
        
        Locating functionality
        
        Consistency
        
        Growing the architecture
        
        Deferring design decisions
        
        Maintaining quality
        
        Managing technical debt
        
        Unit tests shape design
        
        Time for design
        
        Working with the design
      - Where Is It Now?
    - So What?
    - Your Turn
    - References
- II. Enterprise Application Architecture
  - 3. Architecting for Scale
    - Introduction
    - Context
      - The First Goal
      - The Game World
      - Latency Is the Enemy
    - The Architecture
      - The Macro Structure
      - The Basic Services
      - Communication Services
      - Task Portability
    - Thoughts on the Architecture
      - Parallelism and Latency
      - Betting on the Future
      - Simplifying the Programmers Job
  - 4. Making Memories
    - Capabilities and Constraints
    - Workflow
    - Architecture Facets
      - Modules and Launcher
        
        ApplicationContext
        
        Module dependencies
        
        Launcher
      - Kiosk-Style GUI
      - UI and UI Model
        
        Forms
        
        Properties
        
        Bindings
        
        Application facade
      - Interchangeable Workstations
        
        Image repositories
        
        NIO image transfer
        
        Fast and robust
      - Database Migrations
        
        Updates as objects
        
        Regular exercise
        
        Safety features
        
        Field results
      - Immutable Data and Ubiquitous GUIDs
      - Render Farm
        
        Conways Law, applied
        
        DVD loading
        
        Render pipeline
        
        Fail fast
        
        Scale out
    - User Response
    - Conclusion
    - References
  - 5. Resource-Oriented Architectures: Being In the Web
    - Introduction
    - Conventional Web Services
    - The Web
    - Resource-Oriented Architectures
    - Data-Driven Applications
    - Applied Resource-Oriented Architecture
    - Conclusion
  - 6. Data Grows Up: The Architecture of the Facebook Platform
    - Introduction
      - Some Application Core Data
      - Some Facebook Core Data
      - Facebooks Application Platform
    - Creating a Social Web Service
      - Data: Creating an XML Web Service
      - A Simple Web Service Authentication Handshake
    - Creating a Social Data Query Service
      - Method Call Batching
      - FQL
        
        Architecture of FQL
    - Creating a Social Web Portal: FBML
      - Applications on Facebook: Directly Rendering HTML, CSS, and JS
      - Applications on Facebook: iframes
      - Applications on Facebook: FBML As Data-Driven Execution Markup
        
        Direct HTML tags
        
        Data-display tags
        
        Data-execution tags
        
        Design-only tags
        
        Replacement HTML tags
        
        Functionality package tags
        
        FBML: A small example
      - FBML Architecture
        
        Implementing direct HTML tags in FBML
        
        Implementing data-display tags in FBML
        
        Data-execution tags in FBML
        
        Putting it all together
    - Supporting Functionality for the System
      - Platform Cookies
      - FBJS
      - Service Improvement Summary
    - Summation
- III. Systems Architecture
  - 7. Xen and the Beauty of Virtualization
    - Introduction
    - Xenoservers
    - The Challenges of Virtualization
    - Paravirtualization
    - The Changing Shape of Xen
    - Changing Hardware, Changing Xen
    - Lessons Learned
      - Paravirtualization
      - Open Source Development
    - Further Reading
  - 8. Guardian: A Fault-Tolerant Operating System Environment
    - Tandem/16: Some Day All Computers Will Be Built Like This
    - Hardware
      - Diagnosis
      - Repair
    - Mechanical Layout
    - Processor Architecture
      - Memory Addressing
      - Procedure Calls
      - Action of the PCAL and SCAL Instructions
    - The Interprocessor Bus
    - Input/Output
    - Process Structure
      - Process Pairs
    - Message System
      - Process Pairs, Revisited
      - Synchronization
      - Networking: EXPAND and FOX
        
        System names
        
        FOX
    - File System
      - File Naming
      - Asynchronous I/O
      - Interprocess Communication
      - System Messages
      - Device I/O
      - Security
      - File Access Security
    - Folklore
    - The Downside
      - Performance
      - Hardware Limitations
      - Missed Opportunities
      - Split Brain
    - Posterity
    - Further Reading
  - 9. JPC: An x86 PC Emulator in Pure Java
    - Introduction
    - Proof of Concept
      - Potential Processor Performance Tests
    - The PC Architecture
    - Java Performance Tips
    - Four in Four: It Just Wont Go
    - The Perils of Protected Mode
    - Fighting A Losing Battle
      - Microcoding: Less Is More or More Is Less
    - Hijacking the JVM
      - Compiling: How to Reinvent the Wheel
        
        Simple code generation
        
        Handling exceptions
        
        Bytecode manipulation
      - Class Loading and Unloading, but on a Big Scale
        
        Codeblock replacement
    - Ultimate Flexibility
      - Flexible Data Anywhere
      - Flexible Auditing and Support
      - Flexible Computing Anywhere
    - Ultimate Security
    - It Feels Better the Second Time Around
  - 10. The Strength of Metacircular Virtual Machines: Jikes RVM
    - Background
    - Myths Surrounding Runtime Environments
      - As Runtime Compilers Must Be Fast, They Must Be Simple
      - Unlimited Analysis in a Static Compiler Must Mean Better Performance
      - Runtime Analysis Uses a Lot of Resources
      - Dynamic Class Loading Inhibits Performance
      - Garbage Collection Is Slower Than Explicit Memory Management
      - Summary
    - A Brief History of Jikes RVM
    - Bootstrapping a Self-Hosting Runtime
      - Object Layout
      - Runtime Memory Layout
      - Compiling the Primordials and Filling in the JTOC
      - The Boot Image Runner and VM.boot
    - Runtime Components
      - Basic Execution Model
      - Adaptive Optimization System
      - Optimizing Compilation
        
        HIR
        
        LIR
        
        MIR
        
        Factored control flow graph
        
        Scalar and extended array SSA forms
        
        Partial evaluation
        
        On-stack replacement
        
        Summary
      - Exception Model
      - Magic, Annotations, and Making Things Go Smoothly
      - Thread Model
      - Native Interface
      - Class Loaders and Reflection
      - Garbage Collection
        
        Jikes RVM integration
        
        Summary
    - Lessons Learned
    - References
- IV. End-User Application Architectures
  - 11. GNU Emacs: Creeping Featurism Is a Strength
    - Emacs in Use
    - Emacss Architecture
      - The Model: Buffers
      - The View: Emacss Redisplay Engine
      - The Controller: Emacs Lisp
    - Creeping Featurism
      - Creeping Featurism and User Interface Complexity
        
        How complex is the Model?
        
        How complex is the command set?
      - Creeping Featurism and Maintainability
    - Two Other Architectures
      - Eclipse
      - Firefox
  - 12. When the Bazaar Sets Out to Build Cathedrals
    - Introduction
    - History and Structure of the KDE Project
    - Akonadi
      - Background
      - The Evolution of Akonadi
      - The Akonadi Architecture
      - The First Release and Beyond
    - ThreadWeaver
      - Introduction to ThreadWeaver: Or, How Complicated Can It Be to Load a File?
      - Core Concepts and Features
      - Declarative Concurrency: A Thumbnail Viewer Example
      - From Concurrency to Scheduling: How to Implement Expected Behavior Systematically
      - A Crazy Idea
- V. Languages and Architecture
  - 13. Software Architecture: Object-Oriented Versus Functional
    - Overview
    - The Functional Examples
    - Assessing the Modularity of Functional Solutions
      - Extendibility Criteria
      - Assessing the Functional Approach
      - Levels of Modularity
      - The Functional Advantage
      - State Intervention
    - An Object-Oriented View
      - Combinators Are Good, Types Are Better
      - Using Software Contracts and Genericity
      - The Modularization Policy
      - Inheritance
      - Polymorphism, Polymorphic Containers, and Dynamic Binding
      - Deferred Classes and Features
    - Assessing and Improving OO Modularity
      - Reusing Operations
      - Extendibility: Adding Types
      - Extendibility: Adding Operations
    - Agents: Wrapping Operations into Objects
      - The Agent Mechanism
      - Scope of Agents
      - An Agent-Based Library to Make the Visitor Pattern Unnecessary
      - Assessment
    - Acknowledgments
    - References
  - 14. Rereading the Classics
    - Everything Is an Object
    - Types Are Defined Implicitly
    - Problems
    - Brick and Mortar Architecture
    - References
- A. Afterword
- B. Contributors
- Index
- About the Authors
- Colophon
- SPECIAL OFFER: Upgrade this ebook with OReilly