Wide Awake Developers

« Coupling and Coevolution | Main | Life's Little Frustrations »

Topics in Architecture

I'm working on a syllabus for an extensive course on web architecture. This will be for experienced programmers looking to become architects.

Like all of my work about architecture, this covers technology, business, and strategic aspects, so there's an emphasis on creating high-velocity, competitive organizations.

In general, I'm aiming for a mark that's just behind the bleeding edge. So, I'm including several of the NoSQL persistence technologies, for example, but not including Erjang because it's too early. (Or is that "erl-y"? )

(What I'd really love to do is make a screencast series out of all of these. I'm daunted, though. There's a lot of ground to cover here!)

EDIT: Added function and OO styles of programming. (Thanks @deanwampler.) Added JRuby/Java under languages. (Thanks @glv.)

I'm interested in hearing your feedback. What would you add? Remove?

  • Methods and Processes

    • Systems Thinking/Learning Organization
    • High Velocity Organizations
    • Safety Culture
    • Error-Inducing Systems ("Normal Accidents")
    • Points of Leverage
    • Fundamental Dynamics: Iteration, Variation, Selection, Feedback, Constraint
    • 5D architecture
    • Failures of Intuition
    • ToC
    • Critical Chain
    • Lean Software Development
    • Real Options
    • Strategic Navigation
    • OODA
    • Tempo, Adaptation
    • XP
    • Scrum
    • Lean
    • Kanban
    • TDD
  • Architecture Styles

    • REST / ROA
    • SOA
    • Pipes & Filters
    • Actors
    • App-server centric
    • Event-Driven Architecture
  • Web Foundations

    • The "architecture" of the web
    • HTTP 1.0 & 1.1
    • Browser fetch behaviors
    • HTTP Intermediaries
  • The Nature of the Web

    • Crowdsourcing
    • Folksonomy
    • Mashups/APIs/Linked Open Data
  • Testing

    • TDD
    • Unit testing
    • BDD/Spec testing
    • ScalaCheck
    • Selenium
  • Persistence

    • Redis
    • CouchDB
    • Neo4J
    • eXist
    • "Web-shaped" persistence
  • Technical architecture

    • 8 Fallacies of Distributed Computing
    • CAP Theorem
    • Scalability
    • Reliability
    • Performance
    • Latency
    • Capacity
    • Decoupling
    • Safety
  • Languages and Frameworks

    • Spring
    • Groovy/Grails
    • Scala
    • Lift
    • Clojure
    • Compojure
    • JRuby
    • Rails
    • OSGi
  • Design

    • Code Smells
    • Object Thinking
    • Object Design
    • Functional Thinking
    • API Design
    • Design for Operations
    • Information Hiding
    • Recognizing Coupling
  • Deployment

    • Physical
    • Virtual
    • Multisite
    • Cloud (AWS)
    • Chef
    • Puppet
    • Capistrano
  • Build and Version Control

    • Git
    • Ant
    • Maven
    • Leiningen
    • Private repos
    • Collaboration across projects

Comments

Looks very good and having it as a screencast series seems like an excellent idea.

Looks great to me, although I'm not qualified to give much of an opinion on the actual programming side of things.

In Methods and Processes, I'd like to see a session on types of architecture - e.g., web, content, process, and so on. If you have a formal taxonomy of architecture types, I think it'd be fascinating.

I'd add a section on releasable architectures; the stuff that Michael Nygard went over in Release It on what happens AFTER a site gets released.

That is to say, making the application be easily monitored, be easily administered (turning off bits of the app without turning off other bits, including circuit breakers and bulkheads) and building in flexible logging that can be switched around on the fly. This is something that developers consistently miss and only realize the importance of when the site goes down or starts oddly in productin.

That is, of course, if you weren't Michael Nygard already. Duh.

Thank you for the plug, though!

There are several section here from "Release It!". Design for Operations covers the issues around logging (transparency in general, really) and configuration management. Other major topics I dealt with in the book fall under Safety, Reliability, and Capacity.

Great list ...
I would add:
- a simple generic introduction on the difference of scale between application/project architecture v.s. Enterprise architecture, at least to make things clearer.
- something on Event Driven Architecture and event correlation
- JMS
- different elements of web app performance
- OWASP Top Ten flaws for security
- continuous build (Hudson and sonar)
- teamin and developping in the cloud: how to develop with others located on the web. See some of my thoughts here: http://blog.resilient-it.com/2010/01/teaching-it-in-new-economy.html

May be you should do less also in term of Method and processes.

Hi Michael,

I like the idea of the project and was thinking that at least some of what you list perhaps better serve as prerequisites for your course.

E.g. Scala or Clojure or Lisp, Lift or Compojure or ... , Git or Mercurial or ....

In essence, if your course is for experienced developers, why wouldn't they know this sort of (development) stuff already and now need guidance on patterns, design style, taste etc?

What about a section about Domain Driven Design and Model Driven Design?

/Jeppe

Great. I think Object/Data Modeling is another under represented area in training. Too many people end up with the Animal, Mammal, Dog version of inheritance and assume that's the way you should code it- forgetting about how to map it to an efficient persistence structure. Somewhere you can learn things like the Coad's Domain Neutral Component, Fowler's Analysis Patterns, David Hay's work and put them into practice modeling complex domains would be good.

Where do we sign up?

Great list.

Everything's interesting, but I'd probably be very brief on the process/method part – that doesn't seem to be essential to the architecture aspect.

I think "Architecture Styles" should include Client/Server and Distributed Objects, if only to mention why they're not applicable in your opinion.

I think "Caching" merits a top-level entry under "Web Foundations", as do CDNs.

"Persistence" should mention relational databases. They are still the default, aren't they? At least you'd have to explain why you don't mention them IMO.

I think you should go light on the process, development, deployment, and testing stuff and focus on issues like persistence, styles, technical architecture (scalability, availability, etc.), and design.

One way to touch on/work in the other stuff would be to structure the book as a series of examples you work through that illustrate the problems (styles, persistence, etc.). You could demonstrate some different languages, development and deployment techniques, etc. for each different example.

That's a lot of work though!!!

Post a comment

(If you haven't left a comment here before, you may need to be approved by the site owner before your comment will appear. Until then, it won't appear on the entry. Thanks for waiting.)