I’m really pleased with your podcast. You do a great job. Thanks!

I mostly agree with you. But I would like also to mention about this episode:
- Security
Security can be introduced into an existing system after the system is designed and implemented. Of course you need a corresponding architecture to support this (e.g. interceptor architecture).
- Reuseability
OO (or more general any programming language) archived this. Just for an example the JDK itself or any other library.
- Balancing forces
* Performance vs scalability:
Personal, I don’t see the conflict in general. If you consider performance as throughput and/or latency, you can archive better performance when you have a scalable system (scalable means just add more res sources and you get more performance).
* Performance vs maintainability:
By decoupling everything by using interfaces is a very good idea. It increases several other characteristics. It does not decrease performance. This is a myth about abstractions. In general a system with cleared defined responsibility by it’s components can performance very well if it is good design and implemented. If it is implemented poorly by using for everything remote invocations, this does nothing to do with maintainability.
* Performance vs portability
By introducing layers and is about introducing abstractions. Abstractions costs performance is a myth about abstractions. If you use well defined abstractions and the implementation is done well, it will increase performance heavily.
* Security vs useability
I don’t agree with your general statement that security decreases useability. It depends how you implement security.

Regards
Jörg Bächtiger