Software and philosophy

They will justify to themselves that their motivations are pure and thus socially acceptable. This presents an issue because there will be cognitive dissonance between this person and others; and in the context of needing to collaborate, all parties involved must make it known their true intentions.

As mentioned previously, there are plenty of resources for learning programming. Any of them are fine as long as you keep in mind that you should not believe everything verbatim. Though the assembly-line worker may have the finesse and speed of someone who has practiced the assembly of a particular component, they generally lack the ability to creatively adapt to circumstances; this is not a knock on the person rather the motivations of the company training the person.

The need for precision automation is typically devoid of creativity, thus the scope of their domain is very narrow, but they are able to outperform humans in that narrow scope. Most forms of education treats students as if they are automatons being trained rather than treating them to be artisans. This is where the fallacy comes into play. For people who have less experience in software development, the remaining of the book will also be practical.

Naming is an especially useful section. The parts on writing comments before coding, and comments complimenting the code are decent strategies to start with. Those with more experience under their belt my disagree with some of the recommendations. Still, they all present interesting viewpoints, backed with examples. They also make for potentially sound advice to give, when mentoring less experienced engineers. There are few books that discuss software design in a simple and approachable way, while leaving the reader novel and practical concepts to use.

A Philosophy of Software Design is a standout and recommended read for this reason. We need more resources to remind us not overcomplicate software architecture.

It will become complicated enough, module after module, layer after layer. I made one, watch it on YouTube , then read further: The problem with software architecture: it's not repeatable in the real world.

Or is it? The greatest limitation in writing software is our ability to understand the systems we are creating. The larger the program, and the more people work on it, the more difficult it is to manager complexity. Good development tools can help us deal with complexity.

But there is a limit to what we can do with tools alone. Simpler designs allow us to build larger and more powerful systems before complexity becomes overwhelming. Solid recommendations I agree with Tactical vs strategic coding : deciding when to invest for the longer-term isn't easy. Much of the book builds on this concept of module depth: It's more important for a module to have a simple interface than a simple implementation is a thought introduced in Chapter 8.

While my experience confirms this - especially when talking about distributed systems and microservices. I did find logic and examples that John used to get here as interesting. For the theory, he builds on the logic that deep modules encourage information hiding and reduce complexity. For the practice, he takes examples from students implementing a class that manages files for a GUI text editor assignment.

Students who chose a simple implementation, but complex interfaces - exposing the concept of lines - ran into far more trouble and complexity. They struggled more with this interface than those who went with a simple interface, with a complex implementation: a character-based interface. Layers should remove, not add complexity to a system Chapter 7.

The book refers to this as "different layer, different abstraction," arguing against the usage of call-through methods or decorator classes. While I agree that pass-through layers add complexity to the system and are best avoided, my experience when working in production systems tells me it's not that simple. Working within one application or codebase this complexity is more trivial to spot and eliminate. However, when working with standalone services, it's a more labor-intensive and process.

It is a good reminder to both resist the urge to build services that do too much wrapping, as well as to keep track of this kind of architecture debt. Information leakage correlated to shallow classes was an interesting observation: the first of several based on the book not based on John's own experience, but about his analysis of the student's work. He noticed how students who divided their code into many, small classes, that were shallow, ended up with much duplicated logic, caused by information leakage.

Generalizing leads to better information hiding. Not surprising to anyone who's attempted to build more generic APIs. However, taking the previous argument further, it also means generality leads to better information hiding.

Want to have simpler architecture? Consider generalizing components. The example of building a text editor during the semester is used to prove this point, with examples. Recommendations I don't necessarily agree with A strong stance against exceptions Chapter 10 was an interesting read. Topics I missed While the book does a good job covering architecture concepts when writing code, there are several areas that it does not touch on. Conclusion The book is an easy read, thanks to its short sections and good bolding.

Senior Backend Engineer at Brave Care. I'm an investor. Software engineer at Interact. Full stack software engineer at Pallet. Remote global. Browse more senior engineer and engineering leadership roles with great engineering cultures, or add your own on The Pragmatic Engineer Job board.

Ory exposes HTTP s ports and configuration of these ports. The Ory stack scales without the need for any additional external service dependencies e. Scaling horizontally is as easy as starting another process. The Ory Ecosystem assumes that the platform it's running on e. The Ory stack uses environment variables often shortened to env vars or env and files as a configuration source. All settings from a configuration file can also be set using environment variables and vice versa.

This allows systems like Kubernetes to mount, and update, configuration files using volume mounts sourced from ConfigMaps and other similar resources. Our projects support hot-reloading of configuration files support for hot reloading is not yet implemented everywhere.

Configuration settings are validated using JSON Schema and we try to make it as difficult as possible to misconfigure our software. Ory processes are stateless and share-nothing. This facilitates fast elastic scaling, rapid deployment of code or config changes, and robustness of production deploys.

The Ory stack strives to minimize startup time, taking no more than a few milliseconds to be ready.