Java EE勉強会
MenuBar
編集
添付
新規
最終更新
一覧
単語検索
MakingSenseofStreamPr11ceocessing
/
Case Study Web Application Developers Driven to Insanity
-- 雛形とするページ --
2008-04-19のスイーツ
2008-05-17のスイーツ
ActiveRecord
BSA
BSA/A Pattern Language for Strategic Product Management
BSA/Alternative Thoughts on Software Architecture
BSA/Architectural Care and Feeding
BSA/Architectural Evolution and Maturation Features versus Capabilities
BSA/Augmenting the Product Development Process
BSA/Back Doors
BSA/Beware the Promises You Make
BSA/Brand Element Customizations
BSA/Brand Elements
BSA/Brand and Brand Elements
BSA/Business Ramifications
BSA/Business and License Model Symbiosis
BSA/Changing Brand Elements
BSA/Chapter 1 Chapter Summary
BSA/Chapter 10 Chapter Summary
BSA/Chapter 11 Chapter Summary
BSA/Chapter 12 Chapter Summary
BSA/Chapter 13 Chapter Summary
BSA/Chapter 14 Chapter Summary
BSA/Chapter 15 Chapter Summary
BSA/Chapter 16 Chapter Summary
BSA/Chapter 2 Chapter Summary
BSA/Chapter 3 Chapter Summary
BSA/Chapter 4 Chapter Summary
BSA/Chapter 5 Chapter Summary
BSA/Chapter 6 Chapter Summary
BSA/Chapter 7 Chapter Summary
BSA/Chapter 8 Chapter Summary
BSA/Chapter 9 Chapter Summary
BSA/Choosing a Software Deployment Architecture
BSA/Common Software Business Models
BSA/Common Software Business Models/Hardware〜
BSA/Common Software Business Models/Metering
BSA/Common Software Business Models/Time-Based Access or Usage
BSA/Common Software Business Models/Transaction
BSA/Configuration
BSA/Context Diagrams and Target Products
BSA/Contracts - Where the Action Is
BSA/Corporate Influences on Deployment Architecture
BSA/Creating Architectural Understanding
BSA/Creating Layerd Business Architectures
BSA/Creating Portable Applications
BSA/Creating Results in the Short Run while Working in the Long Run
BSA/Creating an Architecture
BSA/Crucial Product Management Concepts
BSA/Customer Control
BSA/Customer Influences on Deployment Architectures
BSA/Defining Software Architecture
BSA/Deployment Architecture
BSA/Deployment Architectures and the Distribution of Work
BSA/Deployment Choice Influences on Software Architecture
BSA/Deployment Choices
BSA/Digital Identity Management
BSA/Early Forces in Solution Development
BSA/Enforcing Licensing Models
BSA/Enforcing Licensing Models/The Client
BSA/Establishing a Baseline
BSA/Feature Benefit Map
BSA/Finishing Touches
BSA/Generating Clarity
BSA/Harnessing Feedback
BSA/Honoring License Agreements
BSA/How to Install
BSA/I Want to Know What’s Happening
BSA/Information Security
BSA/Installation
BSA/Installation and Architecture
BSA/Integration and Extension at the Business Logic Layers
BSA/Integration and Extension of Persistent Data
BSA/It Isn’t Like That
BSA/License Fees
BSA/Licensing Economics
BSA/Licensing Risks Rewards
BSA/Like Installation, Only Worse
BSA/Log Format and Management
BSA/Logging Services
BSA/Logs
BSA/Making Upgrades Less Painful
BSA/Managing APIs Over Multiple Releases
BSA/Managing In-License Brands
BSA/Managing In-Licensed Technology
BSA/Market Events Market Rhythms
BSA/Market Map
BSA/Market Maturity Influences on the Business Model
BSA/Market Maturity and Upgrades
BSA/Mental Models, Metaphors, and Usability
BSA/Not Just the Facts
BSA/Open Source Licensing
BSA/Ouch! That Might Hurt
BSA/Patterns and Architecture
BSA/Postprocessing Log Data
BSA/Principles First, Second, and Third
BSA/Product Development Processes Creating Release 1.0
BSA/Product Development Processes Creating Release n.n.n
BSA/Projecting the Future
BSA/Release Identification
BSA/Release Management
BSA/Release Management Influences on Tarchitecture
BSA/Release Management Introduction
BSA/Rights Associated with Business Models
BSA/SKUs and Serial Numbers
BSA/Secret Algorithms or Secret Keys
BSA/Security
BSA/Security and Marketecture
BSA/Software Architecture
BSA/Software Security
BSA/Tarchitectural Influences on User Interface Design
BSA/Tarchitectural Support for the Business Model
BSA/Tarchitectural Support for the Business Model/Transaction
BSA/Technology In-Licensing
BSA/The Business Case for Portability
BSA/The Business Plan
BSA/The Future of Consumer Software
BSA/The Information Appliance
BSA/The Matrix of Pain
BSA/The Need for Speed/Performance and Tarchitectural Impact〜
BSA/The Need for Speed/〜Responding to the User
BSA/The Out of Box Experience
BSA/The Tarchitecture Roadmap
BSA/The Team
BSA/Transaction Security
BSA/Upgrade
BSA/Usability
BSA/Usability Is about Money
BSA/Viruses, Hackers, and Pirates
BSA/What Is Product Management
BSA/When Business Models Collide, Negotiations Ensue
BSA/Who Is Responsible for What
BSA/Why Product Management Matters
BSA/Why Software Architecture Matters
BSA/Working in Unison
BSA/Yes, You Really Need This
BaseAction
BracketName
Chapter Two. Communication and the Use of Language
DDD
DDD/A Declarative Style of Design
DDD/A Design for Developers
DDD/A Final Look
DDD/AGGREGATE Boundaries
DDD/Abstract Core
DDD/Aggregates
DDD/An Escalation of Distillations
DDD/Analysis Patterns Are Knowledge to Draw On
DDD/Angles of Attack
DDD/Anticorruption Layer
DDD/Applying and Implementing SPECIFICATION
DDD/Assertions
DDD/Assessment First
DDD/Associations
DDD/Bounded Context
DDD/CONFORMIST
DDD/Chapter Eight. Breakthrough
DDD/Chapter Eleven. Applying Analysis Patterns
DDD/Chapter Fifteen. Distillation
DDD/Chapter Five. A Model Expressed in Software
DDD/Chapter Four. Isolating the Domain
DDD/Chapter Fourteen. Maintaining Model Integrity
DDD/Chapter Nine. Making Implicit Concepts Explicit
DDD/Chapter Seven. Using the Language An Extended Example
DDD/Chapter Seventeen. Bringing the Strategy Together
DDD/Chapter Six. The Life Cycle of a Domain Object
DDD/Chapter Sixteen. Large-Scale Structure
DDD/Chapter Ten. Supple Design
DDD/Chapter Thirteen. Refactoring Toward Deeper Insight
DDD/Chapter Twelve. Relating Design Patterns to the Model
DDD/Choosing Appropriate Layers
DDD/Choosing Refactoring Targets
DDD/Choosing Your Model Context Strategy
DDD/Closure of Operations
DDD/Cohesive Mechanisms
DDD/Combining Large-Scale Structures and BOUNDED CONTEXTS
DDD/Combining Large-Scale Structures and Distillation
DDD/Composite
DDD/Conceptual Contours
DDD/Contemplate Contradictions
DDD/Context Map
DDD/Continuous Integration
DDD/Continuous Learning
DDD/Core Domain
DDD/Crisis as Opportunity
DDD/Customer/Supplier Development Teams
DDD/Decision Support Responsibilities
DDD/Declarative Design
DDD/Deep Model-Supple Design
DDD/Deep Models
DDD/Deep Models Distill
DDD/Designing Associations in the Shipping Domain
DDD/Designing Objects for Relational Databases
DDD/Digging Out Concepts
DDD/Distinguishing ENTITIES and VALUE Objects
DDD/Documents and Diagrams
DDD/Domain Vision Statement
DDD/Entities (a.k.a. Reference Objects)
DDD/Epilogue
DDD/Epilogues
DDD/Evolving Order
DDD/Example A Working Prototype of the Warehouse Packer
DDD/Example Chemical Warehouse Packer
DDD/ExampleEarning Interest with Accounts
DDD/ExampleInsight into the Nightly Batch
DDD/Explanatory Models
DDD/Explicit Constraints
DDD/Exploration Teams
DDD/Factories
DDD/Focus on Basics
DDD/Foreword
DDD/GENERIC SUBDOMAINS
DDD/GLOSSARY
DDD/Hands-On Modelers
DDD/Highlighted Core
DDD/How Restrictive Should a Structure Be?
DDD/How to Model Less Obvious Kinds of Concepts
DDD/III-Deep Models
DDD/Ingredients of Effective Modeling
DDD/Initiation
DDD/Intention-Revealing Interfaces
DDD/Introducing a New Feature
DDD/Introducing the Cargo Shipping System
DDD/Isolating the Domain
DDD/KNOWLEDGE LEVEL
DDD/Knowledge Crunching
DDD/Knowledge-Rich Design
DDD/Layered Architecture
DDD/Letting the Bones Show
DDD/Listen to Language
DDD/Looking Forward
DDD/MODULES in the Shipping Model
DDD/Model-Driven Design
DDD/Modeling Out Loud
DDD/Modeling Paradigms
DDD/Modeling Paradigms and Tool Support
DDD/Modules (a.k.a. Packages)
DDD/Object Creation
DDD/One Team, One Language
DDD/Open Host Service
DDD/Opportunities
DDD/Other Kinds of Isolation
DDD/Part I Putting the Domain Model to Work
DDD/Part II The Building Blocks of a Model-Driven Design
DDD/Part III Refactoring Toward Deeper Insight
DDD/Part IV Strategic Design
DDD/Pattern Name
DDD/Pause for Refactoring
DDD/Pluggable Component Framework
DDD/Preface
DDD/Prior Art
DDD/Processes as Domain Objects
DDD/Published Language
DDD/Read the Book
DDD/Refactoring Toward a Fitting Structure
DDD/References
DDD/Relationships Between BOUNDED CONTEXTS
DDD/Repositories
DDD/Responsibility Layers
DDD/SERVICES
DDD/SPECIFICATION
DDD/SYSTEM METAPHOR
DDD/Scrutinize Awkwardness
DDD/Segregated Core
DDD/Selecting REPOSITORIES
DDD/Separate Ways
DDD/Shared Kernel
DDD/Side -Effect-Free Functions
DDD/Six Essentials for Strategic Design Decision Making
DDD/Standalone Classes
DDD/Story of a Breakthrough
DDD/Strategy (A.K.A.Policy)
DDD/The Discovery Process
DDD/The Smart UI Anti-Pattern
DDD/The Use of Patterns in This Book
DDD/Timing
DDD/Transformations
DDD/Try, Try Again
DDD/Ubiquitous Language
DDD/Unifying an Elephant
DDD/Value Objects
DDD/Walking Through Scenarios
DDD/Who Sets the Strategy?
DDD/Why Not FLYWEIGHT?
DDDテンプレート
DSL
DSL/A short dip into language theory
DSL/Adaptive Model
DSL/Alternative Computational Models
DSL/Alternative Tokenization
DSL/Annotation
DSL/Annotations
DSL/Architecture of DSL Processing
DSL/Assorted Tactics
DSL/BNF
DSL/Choosing What to Generate
DSL/Class Symbol Table
DSL/Closure
DSL/Closures
DSL/Code Generation
DSL/Communication with Domain Experts
DSL/Composing DSLs
DSL/Construction Builder
DSL/Context Variable
DSL/Cost of Building
DSL/DSL Lifecycle
DSL/Decision Table
DSL/Defining Domain Specific Languages
DSL/Delimiter Directed Translation
DSL/Dependency Network
DSL/Dynamic Reception
DSL/Elements of language workbenches
DSL/Embedded Translation
DSL/Embedment Helper
DSL/Evolving into Generality
DSL/Expression Builder
DSL/External DSL Miscellany
DSL/Fluent and command-query APIs
DSL/Foreign Code
DSL/Function Sequence
DSL/Generation Gap
DSL/Gothic Security
DSL/Grammars and Syntax
DSL/Handling Errors
DSL/How to generate
DSL/Implementing an External DSL
DSL/Language Workbenches
DSL/Languages and Model
DSL/Learning Curve
DSL/Literal Collections
DSL/Literal Extension
DSL/Literal List
DSL/Literal Map
DSL/Macro
DSL/Macros
DSL/Method Chaining
DSL/Migrating DSLs
DSL/Mixing in the Host Language
DSL/Mixing-in Another Language
DSL/Model Ignorant Generation
DSL/Model-Aware Generation
DSL/Nested Closure
DSL/Nested Expression
DSL/Nested Function
DSL/Object Scoping
DSL/Output Production Strategy
DSL/Parse Tree Manipulation
DSL/Parsing Data
DSL/Preface
DSL/Problems with DSLs
DSL/Production Rule System
DSL/Programmer Familiarity
DSL/Programming Miss Grant's Controller
DSL/Runtime Configuration
DSL/Schema-Definition Languages and Meta-Models
DSL/Semantic Model
DSL/Source and Projectional Editing
DSL/State Machine
DSL/Strong Expressiveness Boundary
DSL/Symbol Table
DSL/Syntactic Analysis Strategy
DSL/Syntactic Newlines
DSL/Syntax Directed Translation
DSL/Templated Generation
DSL/Testing with DSLs
DSL/Textual Polishing
DSL/The MDD view of the Language Landscape
DSL/The State Machine Model
DSL/The need for a parsing layer
DSL/The workings of a parser
DSL/Transformer Generation
DSL/Tree Construction
DSL/Using Code-Generation
DSL/Using Functions
DSL/Using Grammars to Choose Internal Elements
DSL/Using Language Workbenches
DSL/Visualization
DSL/Why Use a DSL?
DSL/Wider Language Processing
DSL/template
DSLテンプレート
DataMapper
EIP
EIP/.NET Request-Reply Example
EIP/A Loosely Coupled Integration Solution
EIP/Aggregator
EIP/Asynchronous Implementation with MSMQ
EIP/Asynchronous Implementation with TIBCO ActiveEnterprise
EIP/Canonical Data Model
EIP/Case Study Bond Pricing System
EIP/Ch10 Introduction
EIP/Ch11 Introduction
EIP/Ch2 Introduction
EIP/Ch3 Introduction
EIP/Ch4 Introduction
EIP/Ch5 Introduction
EIP/Ch6 Introduction
EIP/Ch7 Introduction
EIP/Ch8 Introduction
EIP/Channel Adapter
EIP/Channel Purger
EIP/Checking Status
EIP/Claim Check
EIP/Command Message
EIP/Competing Consumers
EIP/Composed Message Processor
EIP/Conclusion
EIP/Content Enricher
EIP/Content Filter
EIP/Content-Based Router
EIP/Control Bus
EIP/Correlation Identifier
EIP/Datatype Channel
EIP/Dead Letter Channel
EIP/Detour
EIP/Document Message
EIP/Durable Subscriber
EIP/Dynamic Router
EIP/Emerging Standards and Futures in Enterprise Integration
EIP/Enhancing the Management Console
EIP/Envelope Wrapper
EIP/Event Message
EIP/Event-Driven Consumer
EIP/File Transfer
EIP/Format Indicator
EIP/Guaranteed Delivery
EIP/Idempotent Receiver
EIP/Integration Challenges
EIP/Invalid Message Channel
EIP/JMS Publish-Subscribe Example
EIP/JMS Request-Reply Example
EIP/Loan Broker Example
EIP/Loan Broker System Management
EIP/Loose Coupling
EIP/Message
EIP/Message Broker
EIP/Message Bus
EIP/Message Channel
EIP/Message Dispatcher
EIP/Message Endpoint
EIP/Message Expiration
EIP/Message Filter
EIP/Message History
EIP/Message Router
EIP/Message Sequence
EIP/Message Store
EIP/Message Translator
EIP/Messaging
EIP/Messaging Bridge
EIP/Messaging Gateway
EIP/Messaging Mapper
EIP/New Catalog
EIP/Normalizer
EIP/One-Minute EAI
EIP/Pattern Form Summary
EIP/Pipes and Filters
EIP/Point-to-Point Channel
EIP/Polling Consumer
EIP/Problem Solving with Patterns
EIP/Process Manager
EIP/Publish-Subscribe Channel
EIP/Recipient List
EIP/Remote Procedure Invocation
EIP/Request-Reply
EIP/Resequencer
EIP/Return Address
EIP/Routing Slip
EIP/Scatter-Gather
EIP/Selective Consumer
EIP/Service Activator
EIP/Shared Database
EIP/Smart Proxy
EIP/Splitter
EIP/Structuring Channels
EIP/Summary
EIP/Synchronous Implementation Using Web Services
EIP/Test Message
EIP/The Need for Integration
EIP/The Wide World of Integration
EIP/Transaction Client
EIP/Transactional Client
EIP/Verify the Credit Bureau Operation
EIP/WS-*
EIP/What Is Messaging_Commercial Messaging Systems
EIP/Widgets Gadgets R Us An Example
EIP/Wire Tap
EIP/ebXML and
FAQ
FormatRule
FormattingRules
FrontPage
Help
InterWiki
InterWikiName
InterWikiSandBox
InterWikiテクニカル
JavaEE勉強会
KPT
Link
MailingList
MakingSenseofStreamProcessing
MakingSenseofStreamProcessing/1. Replication
MakingSenseofStreamProcessing/2. Secondary Indexes
MakingSenseofStreamProcessing/3. Caching
MakingSenseofStreamProcessing/4. Materialized Views
MakingSenseofStreamProcessing/Bottled Water Change Data Capture with PostgreSQL and Kafka
MakingSenseofStreamProcessing/Bringing Together Event Sourcing and Stream Processing
MakingSenseofStreamProcessing/Bringing the Unix Philosophy to the Twenty-First Century
MakingSenseofStreamProcessing/CEP, Actors, Reactive, and More
MakingSenseofStreamProcessing/Case Study Web Application Developers Driven to Insanity
MakingSenseofStreamProcessing/Composability Requires a Uniform Interface
MakingSenseofStreamProcessing/Conclusion
MakingSenseofStreamProcessing/Conclusion Use Logs to Make Your Infrastructure Solid
MakingSenseofStreamProcessing/Database = Log of Changes
MakingSenseofStreamProcessing/Event Sourcing From the DDD Community
MakingSenseofStreamProcessing/Events and Stream Processing
MakingSenseofStreamProcessing/Example Implementing Twitter
MakingSenseofStreamProcessing/Further Reading
MakingSenseofStreamProcessing/How Databases Are Used
MakingSenseofStreamProcessing/How Logs Are Used in Practice
MakingSenseofStreamProcessing/Implementing Google Analytics A Case Study
MakingSenseofStreamProcessing/Implementing the Snapshot and the Change Stream
MakingSenseofStreamProcessing/Introducing Change Data Capture
MakingSenseofStreamProcessing/Making Sure Data Ends Up in the Right Places
MakingSenseofStreamProcessing/Materialized Views Self-Updating Caches
MakingSenseofStreamProcessing/Pipes and Composability
MakingSenseofStreamProcessing/Simple Log Analysis with Unix Tools
MakingSenseofStreamProcessing/Solving the Data Integration Problem
MakingSenseofStreamProcessing/Status of Bottled Water
MakingSenseofStreamProcessing/Streaming All the Way to the User Interface
MakingSenseofStreamProcessing/Summary Four Database-Related Ideas
MakingSenseofStreamProcessing/The Logical Decoding Output Plug-In
MakingSenseofStreamProcessing/The Ubiquitous Log
MakingSenseofStreamProcessing/The Unbundled Database
MakingSenseofStreamProcessing/The Unix Philosophy of Distributed Data
MakingSenseofStreamProcessing/Tools Putting Ideas into Practice
MakingSenseofStreamProcessing/Transactions and Integrity Constraints
MakingSenseofStreamProcessing/Turning the Database Inside Out
MakingSenseofStreamProcessing/Unix Architecture versus Database Architecture
MakingSenseofStreamProcessing/Using Append-Only Streams of Immutable Events
MakingSenseofStreamProcessing/Using Logs to Build a Solid Data Infrastructure
MakingSenseofStreamProcessing/Why Avro?
MakingSenseofStreamProcessing/Why Kafka?
MenuBar
MessageQueue
MicroservicesVsSOA
MicroservicesVsSOA/Comparing Architecture Capabilities
MicroservicesVsSOA/Comparing Architecture Characteristics
MicroservicesVsSOA/Comparing Service Characteristics
MicroservicesVsSOA/Middleware vs. API Layer
MicroservicesVsSOA/Summary
MicroservicesVsSOA/The World of Service-Based Architectures
ModernJavaEEDesignPatterns
ModernJavaEEDesignPatterns/Additional Technologies and Team Considerations
ModernJavaEEDesignPatterns/Conclusion
ModernJavaEEDesignPatterns/Designing Software for a Scalable Enterprise
ModernJavaEEDesignPatterns/Enterprise Development Today
ModernJavaEEDesignPatterns/History of Java EE
ModernJavaEEDesignPatterns/Independently Deployable and Fully Contained
ModernJavaEEDesignPatterns/Java EE and Microservices
ModernJavaEEDesignPatterns/Microservices Best Practices
ModernJavaEEDesignPatterns/Microservices Design Pattern
Object Creation
PHP
PukiWiki
RecentDeleted
ReentrantLock
SERVICES
SFSB
SLSB
SandBox
Services
SmartProxyReplyConsumer
The Domain Layer Is Where the Model Lives
WikiEngines
WikiName
WikiWikiWeb
YukiWiki
withoutEJB
ふりかえり
ネタ
プログラミングClojure
ヘルプ
ポジションペーパ
議事録
議事録/第01回
議事録/第02回
議事録/第03回
議事録/第04回
議事録/第05回
議事録/第06回
議事録/第07回
議事録/第39回
議事録/第41回
議事録/第42回
議事録/第43回
議事録/第44回
議事録/第45回
議事録/第46回
議事録/第47回
議事録/第48回
議事録/第51回
議事録/第52回
議事録/第53回
議事録/第54回
議事録/第55回
議事録/第56回
進め方
雛形
雛形/JavaEE勉強会
整形ルール
第11回 J2EE勉強会
日本語
用意するもの
タイムスタンプを変更しない
テキスト整形のルールを表示する