Episode 25: Architecture Pt. 2
Recording Venue:
Guest(s):
Host(s): Markus Michael
In this Episode, Michael and Markus continue the discussion about the fundamentals of software architecture (we’re doing it without Alex, because it is really hard to find a suitable time for all of us on the phone :-)). We talk about the various quality attributes (such as performance, scalability, maintainability and many more) and how they relate to each other.
Links:
- A nice article about requirements categorization from Kevlin Henney
- Design & Use of Software Architectures – Adopting and evolving a product-line approach by Jan Bosch contains a very practical introduction to software architecture
- Large scale software architecture
Podcast: Play in new window | Download
Subscribe: Apple Podcasts | RSS
Tags: architecture, Technology Talk
SE Radio Alerts
Hello Team
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