# architecture-pattern

Published articles for architecture-pattern.

This is one page of public article previews, not the complete archive. Follow Next page to continue. Summaries are not the original full articles.

## A Simple MVI Architecture Approach Using LiveData

DevFeed: [A Simple MVI Architecture Approach Using LiveData](<https://devfeed.tech/articles/simple-mvi-32343.md>)

Original publisher: [Read original article](<https://dustn.dev/page/presentations/2019-08-14-simple-mvi/>)

Author: dustin@dustn.dev (Dustin Summers)

Published: 2026-09-17T04:13:15.404035Z

Content type: opinion

Language: en

Sources: [Dustin Summers](<https://devfeed.tech/sources/dustin-summers.md>)

Topics: [Android](<https://devfeed.tech/topics/android.md>), [Dagger](<https://devfeed.tech/topics/dagger.md>)

Tags: [architecture](<https://devfeed.tech/tags/architecture.md>), [architecture-pattern](<https://devfeed.tech/tags/architecture-pattern.md>), [error](<https://devfeed.tech/tags/error.md>), [livedata](<https://devfeed.tech/tags/livedata.md>), [loading](<https://devfeed.tech/tags/loading.md>), [mvi](<https://devfeed.tech/tags/mvi.md>)

### AI overview

A talk from Android Summit 2019 discusses a simple implementation of the MVI architecture pattern using LiveData and the Loading, Content, Error pattern.

### Source excerpt

This was a talk provided by myself and Dan Lowe at Android Summit, 2019. In this we discuss a simple approach to the MVI (Model, View, Intent) Architecture Pattern using LiveData and the common Loading, Content, Error Pattern. Link to Dan's blog post is here which is what our talk was based around.

## A guide to Transformer architecture in modern language models

DevFeed: [A guide to Transformer architecture in modern language models](<https://devfeed.tech/articles/a-deep-dive-into-the-transformer-architecture-33578.md>)

Original publisher: [Read original article](<https://blog.algomaster.io/p/transformer-architecture>)

Author: Ashish Pratap Singh

Published: 2026-05-14T04:15:11Z

Content type: tutorial

Language: en

Sources: [AlgoMaster Newsletter](<https://devfeed.tech/sources/algomaster-newsletter.md>)

Topics: [Transformer architecture](<https://devfeed.tech/topics/transformer-architecture.md>), [LLMs](<https://devfeed.tech/topics/llms.md>), [Transformer](<https://devfeed.tech/topics/transformer.md>)

Tags: [architecture-pattern](<https://devfeed.tech/tags/architecture-pattern.md>), [better](<https://devfeed.tech/tags/better.md>), [deep-dive](<https://devfeed.tech/tags/deep-dive.md>), [layer](<https://devfeed.tech/tags/layer.md>), [llms](<https://devfeed.tech/tags/llms.md>), [model](<https://devfeed.tech/tags/model.md>), [parallel](<https://devfeed.tech/tags/parallel.md>), [performance](<https://devfeed.tech/tags/performance.md>), [semantics](<https://devfeed.tech/tags/semantics.md>), [sequence](<https://devfeed.tech/tags/sequence.md>), [syntax](<https://devfeed.tech/tags/syntax.md>), [tokens](<https://devfeed.tech/tags/tokens.md>), [transformer-architecture](<https://devfeed.tech/tags/transformer-architecture.md>), [transformers](<https://devfeed.tech/tags/transformers.md>)

### AI overview

This tutorial explains the Transformer architecture, including its original encoder-decoder design for translation and the decoder-only variant used for modern language generation. It describes decoder components such as masked multi-head self-attention, feed-forward networks, layer normalization, and residual connections, and introduces the Pre-LayerNorm pattern.

### Source excerpt

A single 2017 research paper changed the future of AI forever and gave rise to multiple unicorn companies.

## Patterns & Best Practices in Event-Driven Systems

DevFeed: [Patterns & Best Practices in Event-Driven Systems](<https://devfeed.tech/articles/patterns-best-practices-in-event-driven-systems-30800.md>)

Original publisher: [Read original article](<https://devblog.kogan.com/blog/patterns-amp-best-practices-in-event-driven-systems>)

Author: Victor Wenas

Published: 2025-12-08T06:14:51Z

Content type: tutorial

Language: en

Sources: [Kogan.com](<https://devfeed.tech/sources/kogan-com.md>)

Topics: [event driven](<https://devfeed.tech/topics/event-driven.md>), [systems](<https://devfeed.tech/topics/systems.md>), [Publish-subscribe pattern](<https://devfeed.tech/topics/pubsub.md>)

Tags: [architecture](<https://devfeed.tech/tags/architecture.md>), [architecture-pattern](<https://devfeed.tech/tags/architecture-pattern.md>), [decoupling](<https://devfeed.tech/tags/decoupling.md>), [event-driven](<https://devfeed.tech/tags/event-driven.md>), [event-sourcing](<https://devfeed.tech/tags/event-sourcing.md>), [latency](<https://devfeed.tech/tags/latency.md>), [patterns](<https://devfeed.tech/tags/patterns.md>), [systems](<https://devfeed.tech/tags/systems.md>)

### AI overview

This tutorial explains three event-driven architecture patterns: event notification, Event-Carried State Transfer, and Event Sourcing. It describes their trade-offs, including service coupling, additional data fetches, payload size, schema management, resilience, and latency.

### Source excerpt

Designing Robust, Scalable, Maintainable Event Architectures Event-driven architecture (EDA) gives teams the ability to build decoupled, scalable systems that evolve independently. In the previous article, we introduced the idea using a restaurant analogy: instead of shouting instructions across the kitchen, teams place "dockets" on the rail and stations take what they need. We'll continue that analogy lightly in this post--sprinkling it here and there--while focusing on the engineering patterns that make event-driven systems work in practice. Core Patterns in Event-Driven ArchitecturePattern 1: Event Notification An event notification is a tiny message that simply declares "something happened." It doesn't contain all the details--just enough for downstream systems to react. Think of it like a kitchen bell dinging: The bell doesn't contain the meal. It's just a signal. The cook still needs to check the ticket rail (the database) for the details of the order 12345. Example { "eventName": "OrderCreated", "orderId": 12345, "createdAt": "2025-11-26T01:00:00Z" } Why it's useful Extremely lightweight Easy to publish, easy to fan out Consumers decide how much extra data they need Trade-offs Consumers must fetch details themselves More cross-service calls -> more coupling Higher latency when many consumers query upstream systems Use this pattern when the event is a simple trigger--like a bell, not a full meal. Pattern 2: Event-Carried State Transfer (ECST) In Event-Carried State Transfer, the event carries all required data so consumers don't need to make additional calls. It's the equivalent of the chef not only ringing the bell but also placing the complete plated dish on the pass. No one needs to ask questions--everything needed is right there. { "eventName": "OrderPacked", "orderId": 12345, "items": [ { "sku": "ABC123", "qty": 2 } ], "warehouseId": 19, "totalWeightGrams": 1850 } Why it's powerful Zero need for back-calls -> full decoupling Highly resilient--consumers can proces

## Reclaim the reactivity of your state management, say no to imperative MVI

DevFeed: [Reclaim the reactivity of your state management, say no to imperative MVI](<https://devfeed.tech/articles/reclaim-the-reactivity-of-your-state-management-say-no-to-imperative-mvi-25932.md>)

Original publisher: [Read original article](<https://proandroiddev.com/reclaim-the-reactivity-of-your-state-management-say-no-to-imperative-mvi-3b23ca6b8537?source=rss-7a8d96da8cb6------2>)

Author: Gabor Varadi

Published: 2022-05-02T05:05:46Z

Content type: opinion

Language: en

Sources: [Stories by Gabor Varadi on Medium](<https://devfeed.tech/sources/stories-by-gabor-varadi-on-medium.md>)

Topics: [reactive](<https://devfeed.tech/topics/reactive.md>), [Redux](<https://devfeed.tech/topics/redux.md>), [Elm](<https://devfeed.tech/topics/elm.md>), [JavaScript](<https://devfeed.tech/topics/javascript.md>), [Programming](<https://devfeed.tech/topics/programming.md>)

Tags: [android](<https://devfeed.tech/tags/android.md>), [android-app-development](<https://devfeed.tech/tags/android-app-development.md>), [androiddev](<https://devfeed.tech/tags/androiddev.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [architecture-pattern](<https://devfeed.tech/tags/architecture-pattern.md>), [clean-code](<https://devfeed.tech/tags/clean-code.md>), [elm](<https://devfeed.tech/tags/elm.md>), [javascript](<https://devfeed.tech/tags/javascript.md>), [model-view-intent](<https://devfeed.tech/tags/model-view-intent.md>), [mvi](<https://devfeed.tech/tags/mvi.md>), [reactive](<https://devfeed.tech/tags/reactive.md>), [redux](<https://devfeed.tech/tags/redux.md>), [state](<https://devfeed.tech/tags/state.md>), [state-management](<https://devfeed.tech/tags/state-management.md>)

### AI overview

The article critiques imperative MVI-style state management as overly complex and boilerplate-heavy. It traces MVI's web-oriented history through Cycle.js, The Elm Architecture, and Redux, and questions whether those patterns fit statically typed application development.

### Source excerpt

Do you find yourself chasing for "clean code, clean architecture, clean design, clean state management" yet still feel bogged down in a sea of boilerplate for even the simplest of tasks -- such as showing a simple list fetched with a coroutine? Surely this could be done in a single line or maybe about seven, but it certainly shouldn't need gigantic case-whens, three layers of indirection, and so on? Well, normally you could just invoke functions on ViewModel and it would work, but if you're forced to seek the "architectural holy grail", no one around you will trust your code unless you add at least one sealed class called ViewActions, and increase the cyclomatic complexity of your "action handler" function until it feels "just clean enough". (After all, surely the more completely unrelated things a single function does based on its argument, the more it has a "single responsibility" of handling literally everything, which is why you know it's definitely the best possible way to do it. 😏) Anyway, the boilerplate of coupling together all aspects into a single class, whether it is a function call or state property, this all has a history: namely, it came from the web. The brief history of MVI MVI stands for "model-view-intent" and comes from a (not very popular for use in production) Javascript framework called Cycle.js, hand-in-hand with a (not popular anymore) concept called "The Elm Architecture" defined as the best practices and intended use of an experimental (and since 2019, unmaintained) "functional-reactive programming language for the web" called ELM. Then again, these didn't come from a vacuum either -- the originator is Redux, in 2015. The general idea was to implement a state machine using the command processor pattern in Javascript, thereby supporting "undo" functionality (also often referred to as "time-travel debugging"). Of course, most design decisions of Redux only make sense for Javascript -- as it is a language with no static typing. It makes sense to

## Choosing an Architecture Pattern for Android Applications

DevFeed: [Choosing an Architecture Pattern for Android Applications](<https://devfeed.tech/articles/mvwtf-demystifying-architecture-patterns-22826.md>)

Original publisher: [Read original article](<http://androidessence.com/mvwtf/>)

Author: Adam McNeilly

Published: 2019-08-16T00:00:00Z

Content type: tutorial

Language: en

Sources: [Android Essence](<https://devfeed.tech/sources/android-essence.md>)

Topics: [Android](<https://devfeed.tech/topics/android.md>), [mvc](<https://devfeed.tech/topics/mvc.md>), [App](<https://devfeed.tech/topics/app.md>), [Code](<https://devfeed.tech/topics/code.md>)

Tags: [android](<https://devfeed.tech/tags/android.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [architecture-pattern](<https://devfeed.tech/tags/architecture-pattern.md>), [mvc](<https://devfeed.tech/tags/mvc.md>), [mvi](<https://devfeed.tech/tags/mvi.md>), [mvvm](<https://devfeed.tech/tags/mvvm.md>), [patterns](<https://devfeed.tech/tags/patterns.md>)

### AI overview

This tutorial explains why Android applications need architecture patterns and compares approaches including MVC, MVP, MVVM, MVI, and MVU. It emphasizes separating application code into distinct components rather than placing all code in an Activity.

### Source excerpt

As an Android developer, one of the questions I constantly see asked within the community is "what architecture pattern should I use?" This discussion usually leads to a handful of buzzwordy acronyms: MVC MVP MVVM MVI MVU?? (We don't talk about this but apparently it's the new kid on the block) This can be really intimidating to new Android devs, as well as seasoned veterans who are constantly questioning if they're using the right one. Whether you're trying to decide which one to learn, or wondering if the one you already use is best for you, this post will help lead you to the right decision.

## Twitch for Android: From Meme to Dream

DevFeed: [Twitch for Android: From Meme to Dream](<https://devfeed.tech/articles/twitch-for-android-from-meme-to-dream-20456.md>)

Original publisher: [Read original article](<https://medium.com/twitch-news/twitch-for-android-from-meme-to-dream-141e6b7e8416?source=rss----3ae745429979--engineering>)

Author: Joaquim Verges

Published: 2019-02-26T21:45:39Z

Content type: article

Language: en

Sources: [Twitch](<https://devfeed.tech/sources/twitch.md>)

Topics: [Android](<https://devfeed.tech/topics/android.md>), [Mobile](<https://devfeed.tech/topics/mobile.md>), [test](<https://devfeed.tech/topics/test.md>), [unit test](<https://devfeed.tech/topics/unit-test.md>), [ui](<https://devfeed.tech/topics/ui.md>), [Code](<https://devfeed.tech/topics/code.md>)

Tags: [android](<https://devfeed.tech/tags/android.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [architecture-pattern](<https://devfeed.tech/tags/architecture-pattern.md>), [development](<https://devfeed.tech/tags/development.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [mobile](<https://devfeed.tech/tags/mobile.md>), [test](<https://devfeed.tech/tags/test.md>), [twitch](<https://devfeed.tech/tags/twitch.md>), [ui](<https://devfeed.tech/tags/ui.md>), [unit-test](<https://devfeed.tech/tags/unit-test.md>)

### AI overview

Twitch describes how its PogDroid Android app grew from a small app with basic streaming and chat functionality into a larger project. The team redesigned the app, rewrote much of it, introduced a common MVP architecture, and organized code into data, presentation, and view layers to make unit testing easier.

### Source excerpt

Meet PogDroid, our beloved Android app, to watch the latest memes unfold live while on the go. PogDroid started with very humble beginnings, and has seen incredible growth in the past couple of years. We quadrupled the team, redesigned the entire app, and rewrote most of it in only a few months using the latest and greatest Android has to offer. Buckle up: this is PogDroid's epic adventure. Level 1: Meme app with big dreams Back in March 2017, PogDroid was maintained by a very small team of engineers, and covered the most basic functionality of Twitch: browse and watch a stream with Chat. Old PogDroid, before the big makeover Mobile, and Android in particular, was getting more and more users, and the company decided it was time for a serious investment in PogDroid. The plan was to give the app a fresh new look, and build up some important features that were missing. The team grew only a little bit, but were tasked to take on this big project. As with most apps maintained by a very small team, the code structure was a mess. It became clear that such a big redesign compounded with adding new features could not be built cleanly on top of the current foundation. There was no common pattern to build screens, not a single unit test, and a lot of core classes were more than 3,000 lines of code long, with very complex state management, handling everything from network requests to UI rendering. We all agreed that in order to make PogDroid what we were dreaming of, we first needed to rethink its foundations. Step 1: Agree on a common architecture pattern The first thing we did is come up with a common design pattern to build features and screens. We wanted this design pattern to be: easy to understand hard to get wrong flexible enough to be applied to any feature or screen easy to unit test We quickly settled on a straightforward MVP pattern that looks like this: With these layers in mind, it became easy to categorize the type of classes we needed for every feature: Typical c

## Perfect is the Enemy of the Good

DevFeed: [Perfect is the Enemy of the Good](<https://devfeed.tech/articles/perfect-is-the-enemy-of-the-good-22305.md>)

Original publisher: [Read original article](<https://www.thecodedself.com/Perfect-Is-The-Enemy-Of-The-Good/>)

Author: Keegan Rush

Published: 2018-11-13T00:00:00Z

Content type: opinion

Language: en

Sources: [The Coded Self](<https://devfeed.tech/sources/the-coded-self.md>)

Topics: [Development](<https://devfeed.tech/topics/development.md>), [Programming](<https://devfeed.tech/topics/programming.md>), [Concurrency](<https://devfeed.tech/topics/concurrency.md>), [reactive](<https://devfeed.tech/topics/reactive.md>), [Dependency injection](<https://devfeed.tech/topics/dependency-injection.md>), [Mocking](<https://devfeed.tech/topics/mocking.md>), [App](<https://devfeed.tech/topics/app.md>)

Tags: [architecture](<https://devfeed.tech/tags/architecture.md>), [architecture-pattern](<https://devfeed.tech/tags/architecture-pattern.md>), [async](<https://devfeed.tech/tags/async.md>), [concurrency](<https://devfeed.tech/tags/concurrency.md>), [dependency-injection](<https://devfeed.tech/tags/dependency-injection.md>), [development](<https://devfeed.tech/tags/development.md>), [dispatchqueue](<https://devfeed.tech/tags/dispatchqueue.md>), [mocking](<https://devfeed.tech/tags/mocking.md>), [programming](<https://devfeed.tech/tags/programming.md>), [queue](<https://devfeed.tech/tags/queue.md>), [reactive](<https://devfeed.tech/tags/reactive.md>), [reactive-programming](<https://devfeed.tech/tags/reactive-programming.md>)

### AI overview

The author reflects on a side project whose elaborate architecture and extensive tooling created hidden complexity, debugging difficulties, and development friction. The article examines the use of RxSwift, VIPER, Swinject, Cuckoo, and Flow Operations in an app and argues that architectural perfection can undermine practical progress.

### Source excerpt

How the Wrong Architecture Can Cripple Development A couple of years ago, I was working on a side project with a few friends. We thought that it would be the next big thing. We put our collective best efforts into it; I worked long, hard hours fleshing out the scaffolding of the perfect architecture. Little did I know that my effort would doom the project to join the abyss of failed projects as quickly as it had begun. We had the best tools Since this was The Next Big Thing™, we used everything at our disposal. RxSwift for reactive programming VIPER for our architecture pattern Swinject for dependency injection Cuckoo for mocking Flow Operations for managing navigation The Flow Operations were a particularly interesting concept, inspired by the Advanced NSOperations session from WWDC 2015. We used Flow Operations to manage navigation in the app. For instance, if you wanted to register a new user, you'd invoke a RegisterFlowOperation. A FlowOperation was a subclass of Operation: class FlowOperation: Operation The Operation class represents the code and data for a task of your choosing. It also handles concurrency and dependencies. So, our Flow Operations represented the task of flowing from one screen to another in an app. Operations can be dependent on each other - for instance, the EditProfileFlowOperation is dependent on the SignInFlowOperation. If you've already signed in, you can edit your profile, but if you haven't, then you'll be directed to sign in if you invoke the EditProfileFlowOperation. How does it work? There was a lot of hidden complexity in the Flow Operation system, and some trickiness that you wouldn't notice until you started using it. I'll briefly go over some of the code. You could sell products in this app we were building. This is how you'd start the Sell Flow: private func startSellFlow() { DispatchQueue.global().async { [navController = navController] in let flow = SellFlowOperation(navigationController: navController) flow.beginFlow() flow.

## Building An Application With MVVM

DevFeed: [Building An Application With MVVM](<https://devfeed.tech/articles/building-an-application-with-mvvm-22796.md>)

Original publisher: [Read original article](<http://androidessence.com/building-an-app-with-mvvm/>)

Author: Adam McNeilly

Published: 2018-10-28T00:00:00Z

Content type: tutorial

Language: en

Sources: [Android Essence](<https://devfeed.tech/sources/android-essence.md>)

Topics: [Development](<https://devfeed.tech/topics/development.md>), [LineageOS](<https://devfeed.tech/topics/lineageos.md>), [Mobile](<https://devfeed.tech/topics/mobile.md>), [App](<https://devfeed.tech/topics/app.md>)

Tags: [android](<https://devfeed.tech/tags/android.md>), [android-architecture](<https://devfeed.tech/tags/android-architecture.md>), [android-development](<https://devfeed.tech/tags/android-development.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [architecture-pattern](<https://devfeed.tech/tags/architecture-pattern.md>), [building](<https://devfeed.tech/tags/building.md>), [patterns](<https://devfeed.tech/tags/patterns.md>)

### AI overview

This tutorial introduces the MVVM architecture pattern for Android application development. It explains the roles of the Model, View, and ViewModel components, including how the ViewModel maintains state, interacts with the data source, and handles relevant business logic. It also compares MVVM's communication flow with MVP.

### Source excerpt

This is the second post in what will be an ongoing series to demonstrate a few different architecture patterns that are used for Android development. You can find the code for each of them, often appearing before the blog posts, by following this repo. Give it a star! In our previous post we discussed the MVP architecture for building an app. This time, we're going to check out MVVM.

## Building An Application With MVP

DevFeed: [Building An Application With MVP](<https://devfeed.tech/articles/building-an-application-with-mvp-22795.md>)

Original publisher: [Read original article](<http://androidessence.com/building-an-app-with-mvp/>)

Author: Adam McNeilly

Published: 2018-10-20T00:00:00Z

Content type: tutorial

Language: en

Sources: [Android Essence](<https://devfeed.tech/sources/android-essence.md>)

Topics: [Android](<https://devfeed.tech/topics/android.md>), [android-development](<https://devfeed.tech/topics/android-development.md>), [Development](<https://devfeed.tech/topics/development.md>), [ui](<https://devfeed.tech/topics/ui.md>), [data](<https://devfeed.tech/topics/data.md>), [Code](<https://devfeed.tech/topics/code.md>), [Server](<https://devfeed.tech/topics/server.md>)

Tags: [android](<https://devfeed.tech/tags/android.md>), [android-development](<https://devfeed.tech/tags/android-development.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [architecture-pattern](<https://devfeed.tech/tags/architecture-pattern.md>), [building](<https://devfeed.tech/tags/building.md>), [business-logic](<https://devfeed.tech/tags/business-logic.md>), [code](<https://devfeed.tech/tags/code.md>), [communication](<https://devfeed.tech/tags/communication.md>), [component](<https://devfeed.tech/tags/component.md>), [context](<https://devfeed.tech/tags/context.md>), [data](<https://devfeed.tech/tags/data.md>), [development](<https://devfeed.tech/tags/development.md>), [flow](<https://devfeed.tech/tags/flow.md>), [repo](<https://devfeed.tech/tags/repo.md>), [source](<https://devfeed.tech/tags/source.md>)

### AI overview

This tutorial introduces the Model View Presenter (MVP) architecture pattern for Android development. It explains the roles of the model, view, and presenter, and describes how they communicate while keeping the model and view separated.

### Source excerpt

This is the first post in what will be an ongoing series to demonstrate a few different architecture patterns that are used for Android development. You can find the code for each of them, often appearing before the blog posts, by following this repo. Give it a star! The first architecture pattern we're going to walk through is MVP.

## Ziggurat iOS App Architecture

DevFeed: [Ziggurat iOS App Architecture](<https://devfeed.tech/articles/ziggurat-ios-app-architecture-15968.md>)

Original publisher: [Read original article](<https://developer.squareup.com/blog/ziggurat-ios-app-architecture>)

Author: Square Engineering

Published: 2015-12-18T17:10:00Z

Content type: article

Language: en

Sources: [Square Corner Blog RSS Feed](<https://devfeed.tech/sources/square-corner-blog-rss-feed.md>)

Topics: [iOS](<https://devfeed.tech/topics/ios.md>), [Swift](<https://devfeed.tech/topics/swift.md>), [mvc](<https://devfeed.tech/topics/mvc.md>), [flux](<https://devfeed.tech/topics/flux.md>), [React Native](<https://devfeed.tech/topics/react-native.md>)

Tags: [architecture](<https://devfeed.tech/tags/architecture.md>), [architecture-pattern](<https://devfeed.tech/tags/architecture-pattern.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [flux](<https://devfeed.tech/tags/flux.md>), [ios](<https://devfeed.tech/tags/ios.md>), [mvc](<https://devfeed.tech/tags/mvc.md>), [react-native](<https://devfeed.tech/tags/react-native.md>), [swift](<https://devfeed.tech/tags/swift.md>)

### AI overview

The article introduces Ziggurat, a layered and testable iOS architecture pattern for Swift that uses immutable view models and one-way data flow. It explains how the pattern aims to reduce data complexity and cognitive load, produce smaller classes, and address testing, debugging, and shared-state problems associated with Model-View-Controller.

### Source excerpt

Several steps beyond model view controller