Home Page Icon
Home Page
Table of Contents for
IV. End-User Application Architectures
Close
IV. End-User Application Architectures
by Georgios Gousios, Diomidis Spinellis
Beautiful Architecture
Dedication
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 Programmer’s 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
Conway’s 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
Facebook’s 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 Won’t 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
Emacs’s Architecture
The Model: Buffers
The View: Emacs’s 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
Copyright
Search in book...
Toggle Font Controls
Playlists
Add To
Create new playlist
Name your new playlist
Playlist description (optional)
Cancel
Create playlist
Sign In
Email address
Password
Forgot Password?
Create account
Login
or
Continue with Facebook
Continue with Google
Sign Up
Full Name
Email address
Confirm Email Address
Password
Login
Create account
or
Continue with Facebook
Continue with Google
Prev
Previous Chapter
10. The Strength of Metacircular Virtual Machines: Jikes RVM
Next
Next Chapter
11. GNU Emacs: Creeping Featurism Is a Strength
Part IV. End-User Application Architectures
Chapter 11,
GNU Emacs: Creeping Featurism Is a Strength
Chapter 12,
When the Bazaar Sets Out to Build Cathedrals
Add Highlight
No Comment
..................Content has been hidden....................
You can't read the all page of ebook, please click
here
login for view all page.
Day Mode
Cloud Mode
Night Mode
Reset