The proliferation of open source and software-as-a-service products means that, increasingly so, your software will be one with the universe. As time passes and the internet matures, writing code is going to be more about coordinating efforts between managers of open source projects and “software as a service” providers. The efficiency gains of not re-implementing someone else's well-developed software will make this increased distribution inevitable and fast. Our efforts will need to take this into account and it will change the way we write code.
This model of distributing code concerns does not inherently change the way we should fundamentally think about architecting our code but it will change the processes we use to execute our architectures. Principles of building clean application interfaces with maximum code decoupling have always been of vital importance and that will not really change on a micro-level. What will change is how we must coordinate, communicate and test our software. When more of your code relies on external forces, you will not be able to rely on scheduling and deadlines like you once tried to. If an open source maintainer or a service provider’s schedule does not match up with yours, you can do a bit to help, but ultimately you must shift your process to account for the many asynchronous timelines you will be working with. The agile methodology of software development predicts and accounts for a lot of the uncertaintly but we must pay attention to evolving needs in order to make these practices adaptable to modern demands.
Open source and SAAS have already achieved their revolutions so you could say the future is already here, but I want to tell you that it will only get more... futury. We have, by and large, not yet adopted our “best practices” to account for these factors. We still try to do more in-house than we need to do, we still rely too much on internal timeframe estimations and deadlines that are harder and harder to pin down and we still rely on testing infrastructures that mock and stub ad nauseam to account for the lack of control within our systems, making far too many assumptions about the reliability of our code.
The future of software development and testing will be about building maximally flexible systems, solid lines of external communication, extensive documentation, and automated testing infrastructures that act more like monitoring solutions than deterministic systems as we often see them today. More of the logic core to your business or project will not live within your walls and will not be under your control in the strict manner it is today, just as the servers of your code have long since left the building. In exchange for the control we are used to, we will gain immense power by coordinating our efforts. We just need to be ready and accepting.