Software Architecture Quotes

The ideal architect should be a man of letters, a skillful draftsman, a mathematician, familiar with historical studies, a diligent student of philosophy, acquainted with music, not ignorant of medicine, learned in the responses of jurisconsults, familiar with astronomy and astronomical calculations.

Almost everything we know about good software architecture has to do with making software easy to change

I'm a programmer. I like programming. And the best way I've found to have a positive impact on code is to write it.

Cloud first software architecture is critical to designing efficient systems. All the hardware need to be capable of the most sophisticated things and then we can focus our attention on improving software capabilities.

A basic principle of data processing teaches the folly of trying to maintain independent files in synchonism.

Science does not work by proving statements true, but rather by proving statements false.

All race conditions, deadlock conditions, and concurrent update problems are due to mutable variables.

Dijkstra once said, “Testing shows the presence, not the absence, of bugs.” In other words, a program can be proven incorrect by a test, but it cannot be proven correct. All that tests can do, after sufficient testing effort, is allow us to deem a program to be correct enough for our purposes.

Just as the Hare was overconfident in its speed, so the developers are overconfident in their ability to remain productive.

The perfect kind of architecture decision is the one which never has to be made

This is the monstrosity in love, lady, that the will is infinite, and the execution confined; that the desire is boundless, and the act a slave to limit. —William Shakespeare

If change is the only constant in the universe, then software change is not only constant but ubiquitous.

The first value of software—behavior—is urgent but not always particularly important. The second value of software—architecture—is important but never particularly urgent.

The goal of software architecture is to minimize the human resources required to build and maintain the required system.

thinking of software architecture as a standalone concept that can be designed in isolation and then implemented by any group of teams is fundamentally wrong.

1. “First make it work.” You are out of business if it doesn’t work. 2. “Then make it right.” Refactor the code so that you and others can understand it and evolve it as needs change or are better understood. 3. “Then make it fast.” Refactor the code for “needed” performance.

Architecting for the enterprise, when all you really need is a cute little desktop tool, is a recipe for failure.

Just by making the architect role explicit, a team can effectively resolve many technical conflicts.

The problem that Dijkstra recognized, early on, was that programming is hard, and that programmers don’t do it very well.

The Dependency Inversion Principle (DIP) tells us that the most flexible systems are those in which source code dependencies refer only to abstractions, not to concretions.

The main lesson here is that not every problem can be solved at the level of abstraction where it manifests.

An architecture that is not documented, and not communicated, may still be a good architecture, but the risks surrounding it are enormous. —RK

If you think good architecture is expensive, try bad architecture. —Brian Foote and Joseph Yoder

Conway’s law: Organizations which design systems … are constrained to produce designs which are copies of the communication structures of these organizations.

Quality is not an act, it is a habit. —Aristotle

Architecture must be carefully distinguished from implementation. As Blaauw has said, "Where architecture tells what happens, implementation tells how it is made to happen.

When a child has learned this architecture, he can tell time as easily from a wristwatch as from a church tower.

Software has two types of value: the value of its behavior and the value of its structure. The second of these is the greater of the two because it is this value that makes software soft.

The way you keep software soft is to leave as many options open as possible, for as long as possible. What are the options that we need to leave open? They are the details that don’t matter.

Consider thinking of architectural decisions as investments and take into account the associated rate of return, it is a useful approach for finding out how pragmatic or fit for purpose every option on the table is.

In 1966, Derrida delivered a paper entitled “Structure Sign and Play in the Discourse of the Human Sciences” (which is a wonderful paper, right up there with the original DynamoDB paper and the Page Rank algorithm paper).

The primary cost of maintenance is in spelunking and risk. Spelunking is the cost of digging through the existing software, trying to determine the best place and the best strategy to add a new feature or to repair a defect.

Where technology acquisition was once the province of the CIO, today it’s the practitioner leading that process, because by the time a CIO typically hears about a project today, a majority of the technology and architectural decisions have already been made.

Good software systems begin with clean code. On the one hand, if the bricks aren’t well made, the architecture of the building doesn’t matter much. On the other hand, you can make a substantial mess with well-made bricks. This is where the SOLID principles come in.

Twenty minutes later, Three Body’s Von Neumann architecture human-formation computer had begun full operations under the Qin 1.0 operating system. “Run solar orbit computation software ‘Three Body 1.0’!” Newton screamed at the top of his lungs. “Start the master computing module! Load the differential calculus module! Load the finite element analysis module! Load the spectral method module! Enter initial condition parameters … and begin calculation!” The motherboard sparkled as the display formation flashed with indicators in every color. The human-formation computer began the long computation.

Connascence, in the context of software engineering, refers to the degree of coupling between software components. (Connascence.io hosts a handy reference to the various types of connascence.) Software components are connascent if a change in one would require the other(s) to be modified in order to maintain the overall correctness of the system.

It is important to note that the design of an entire brain region is simpler than the design of a single neuron. As discussed earlier, models often get simpler at a higher level—consider an analogy with a computer. We do need to understand the detailed physics ofsemiconductors to model a transistor, and the equations underlying a single real transistor are complex. A digital circuit that multiples two numbers requires hundreds of them. Yet we can model this multiplication circuit very simply with one or two formulas. An entire computer with billions of transistors can be modeled through its instruction set and register description, which can be described on a handful of written pages of text and formulas. The software programs for an operating system, language compilers, and assemblers are reasonably complex, but modeling a particular program—for example, a speech recognition programbased on hierarchical hidden Markov modeling—may likewise be described in only a few pages of equations. Nowhere in such a description would be found the details ofsemiconductor physics or even of computer architecture. A similar observation holds true for the brain. A particular neocortical pattern recognizer that detects a particular invariant visualfeature (such as a face) or that performs a bandpass filtering (restricting input to a specific frequency range) on sound or that evaluates the temporal proximity of two events can be described with far fewer specific details than the actual physics and chemicalrelations controlling the neurotransmitters, ion channels, and other synaptic and dendritic variables involved in the neural processes. Although all of this complexity needs to be carefully considered before advancing to the next higher conceptual level, much of it can be simplified as the operating principles of the brain are revealed.

The label “jack-of-all-trades but master of none” is normally meant to be derogatory, implying that the labelee lacks the focus to really dive into a subject and master it. But, when your online shopping application is on the fritz and you’re losing orders by the hundreds as each hour passes, it’s the jack-of-all-trades who not only knows how the application’s code works but can also do low-level UNIX debugging of your web server processes, analyze your RDBMS’s configuration for potential performance bottlenecks, and check your network’s router configuration for hard-to-find problems. And, more important, after finding the problem, the jack-of-all-trades can quickly make architecture and design decisions, implement code fixes, and deploy a new fixed system to production. In this scenario, the manufacturing scenario seems quaint at best and critically flawed at worst.

There is something new: A globe about the size of a grapefruit, a perfectly detailed rendition of Planet Earth, hanging in space at arm's length in front of his eyes. Hiro has heard about this but never seen it. It is a piece of CIC software called, simply, Earth. It is the user interface that CIC uses to keep track of every bit of spatial information that it owns—all the maps, weather data, architectural plans, and satellite surveillance stuff.

The architecture of a software system is the shape given to that system by those who build it. The form of that shape is in the division of that system into components, the arrangement of those components, and the ways in which those components communicate with each other. The purpose of that shape is to facilitate the development, deployment, operation, and maintenance of the software system contained within it. The strategy behind that facilitation is to leave as many options open as possible, for as long as possible

We wrote our software to know the detailed structure of the disk. It knew that the disk had 200 cylinders and 10 heads, and that each cylinder had several dozen sectors per head. It knew which cylinders held the Agents, Employers, and Members. All this was hard-wired into the code. ... One day a more experienced programmer joined our ranks. When he saw what we had done, the blood drained from his face, and he stared aghast at us, as if we were aliens of some kind. Then he gently advised us to change our addressing scheme to use relative addresses.

Jobs’s reluctance to make the Mac compatible with the architecture of the Lisa was motivated by more than rivalry or revenge. There was a philosophical component, one that was related to his penchant for control. He believed that for a computer to be truly great, its hardware and its software had to be tightly linked. When a computer was open to running software that also worked on other computers, it would end up sacrificing some functionality. The best products, he believed, were “whole widgets” that were designed end-to-end, with the software closely tailored to the hardware and vice versa. This is what would distinguish the Macintosh, which had an operating system that worked only on its own hardware, from the environment that Microsoft was creating, in which its operating system could be used on hardware made by many different companies.

The physical structure of the Internet presents a suggestive story about the concentration of power - it contains "backbones" and "hubs" - but power on the Internet is not spatial but informational; power inheres in protocol. The techno-libertarian utopianism associated with the Internet, in the gee-whiz articulations of the Wired crowd, is grounded in an assumption that the novelty of governance by computer protocols precludes control by corporation or state. But those entities merely needed to understand the residence of power in protocol and to craft political and technical strategies to exert it. In 2006, U.S. telecommunications providers sought to impose differential pricing on the provision of Internet services. The coalition of diverse political interests that formed in opposition - to preserve "Net Neutrality" - demonstrated a widespread awareness that control over the Net's architecture is control of its politics.

By the architecture of a system, I mean the complete and detailed specification of the user interface. For a computer this is the programming manual. For a compiler it is the language manual. For a control program it is the manuals for the language or languages used to invoke its functions. For the entire system it is the union of the manuals the user must consult to do his entire job. The architect of a system, like the architect of a building, is the user's agent. It is his job to bring professional and technical knowledge to bear in the unalloyed interest of the user, as opposed to the interests of the salesman, the fabricator, etc.[2] Architecture must be carefully distinguished from implementation. As Blaauw has said, "Where architecture tells what happens, implementation tells how it is made to happen."[3] He gives as a simple example a clock, whose architecture consists of the face, the hands, and the winding knob. When a child has learned this architecture, he can tell time as easily from a wristwatch as from a church tower. The implementation, however, and its realization, describe what goes on inside the case—powering by any of many mechanisms and accuracy control by any of many.

2006 interview by Jim Gray, Amazon CTO Werner Vogels recalled another watershed moment: We went through a period of serious introspection and concluded that a service-oriented architecture would give us the level of isolation that would allow us to build many software components rapidly and independently. By the way, this was way before service-oriented was a buzzword. For us service orientation means encapsulating the data with the business logic that operates on the data, with the only access through a published service interface. No direct database access is allowed from outside the service, and there’s no data sharing among the services.3 That’s a lot to unpack for non–software engineers, but the basic idea is this: If multiple teams have direct access to a shared block of software code or some part of a database, they slow each other down. Whether they’re allowed to change the way the code works, change how the data are organized, or merely build something that uses the shared code or data, everybody is at risk if anybody makes a change. Managing that risk requires a lot of time spent in coordination. The solution is to encapsulate, that is, assign ownership of a given block of code or part of a database to one team. Anyone else who wants something from that walled-off area must make a well-documented service request via an API.

The moral here is that nature and nurture should not be opposed. Pure learning, in the absence of any innate constraints, simply does not exist. Any learning algorithm contains, in one way or another, a set of assumptions about the domain to be learned. Rather than trying to learn everything from scratch, it is much more effective to rely on prior assumptions that clearly delineate the basic laws of the domain that must be explored, and integrate these laws into the very architecture of the system. The more innate assumptions there are, the faster learning is (provided, of course, that these assumptions are correct!). This is universally true. It would be wrong, for example, to think that the AlphaGo Zero software, which trained itself in Go by playing against itself, started from nothing: its initial representation included, among other things, knowledge of the topography and symmetries of the game, which divided the search space by a factor of eight. Our brain too is molded with assumptions of all kinds. Shortly, we will see that, at birth, babies' brains are already organized and knowledgeable. They know, implicitly, that the world is made of things that move only when pushed, without ever interpenetrating each other (solid objects)—and also that it contains much stranger entities that speak and move by themselves (people). No need to learn these laws: since they are true everywhere humans live, our genome hardwires them into the brain, thus constraining and speeding up learning. Babies do not have to learn everything about the world: their brains are full of innate constraints, and only the specific parameters that vary unpredictably (such as face shape, eye color, tone of voice, and individual tastes of the people around them) remain to be acquired.

Stanford University’s John Koza, who pioneered genetic programming in 1986, has used genetic algorithms to invent an antenna for NASA, create computer programs for identifying proteins, and invent general purpose electrical controllers. Twenty-three times Koza’s genetic algorithms have independently invented electronic components already patented by humans, simply by targeting the engineering specifications of the finished devices—the “fitness” criteria. For example, Koza’s algorithms invented a voltage-current conversion circuit (a device used for testing electronic equipment) that worked more accurately than the human-invented circuit designed to meet the same specs. Mysteriously, however, no one can describe how it works better—it appears to have redundant and even superfluous parts. But that’s the curious thing about genetic programming (and “evolutionary programming,” the programming family it belongs to). The code is inscrutable. The program “evolves” solutions that computer scientists cannot readily reproduce. What’s more, they can’t understand the process genetic programming followed to achieve a finished solution. A computational tool in which you understand the input and the output but not the underlying procedure is called a “black box” system. And their unknowability is a big downside for any system that uses evolutionary components. Every step toward inscrutability is a step away from accountability, or fond hopes like programming in friendliness toward humans. That doesn’t mean scientists routinely lose control of black box systems. But if cognitive architectures use them in achieving AGI, as they almost certainly will, then layers of unknowability will be at the heart of the system. Unknowability might be an unavoidable consequence of self-aware, self-improving software.

What is WordPress? WordPress is an online, open source website creation tool written in PHP. But in non-geek speak, it’s probably the easiest and most powerful blogging and website content management system (or CMS) in existence today. Many famous blogs, news outlets, music sites, Fortune 500 companies and celebrities are using WordPress. WordPress is web software you can use to create a beautiful website, blog, or app. We like to say that WordPress is both free and priceless at the same time. There are thousands of plugins and themes available to transform your site into almost anything you can imagine. WordPress started in 2003 with a single bit of code to enhance the typography of everyday writing and with fewer users than you can count on your fingers and toes. Since then it has grown to be the largest self-hosted blogging tool in the world, used on millions of sites and seen by tens of millions of people every day. You can download and install a software script called WordPress from wordpress.org. To do this you need a web host who meets the minimum requirements and a little time. WordPress is completely customizable and can be used for almost anything. There is also a servicecalled WordPress.com. WordPress users may install and switch between different themes. Themes allow users to change the look and functionality of a WordPress website and they can be installed without altering the content or health of the site. Every WordPress website requires at least one theme to be present and every theme should be designed using WordPress standards with structured PHP, valid HTML and Cascading Style Sheets (CSS). Themes: WordPress is definitely the world’s most popular CMS. The script is in its roots more of a blog than a typical CMS. For a while now it’s been modernized and it got thousands of plugins, what made it more CMS-like. WordPress does not require PHP nor HTML knowledge unlinke Drupal, Joomla or Typo3. A preinstalled plugin and template function allows them to be installed very easily. All you need to do is to choose a plugin or a template and click on it to install. It’s good choice for beginners. Plugins: WordPress’s plugin architecture allows users to extend the features and functionality of a website or blog. WordPress has over 40,501 plugins available. Each of which offers custom functions and features enabling users to tailor their sites to their specific needs. WordPress menu management has extended functionalities that can be modified to include categories, pages, etc. If you like this post then please share and like this post. To learn more About website design in wordpress You can visit @ tririd.com Call us @ 8980010210

A software architecture is defined by a configuration of architectural elements--components, connectors, and data--constrained in their relationships in order to achieve a desired set of architectural properties.

I borrow from the world of philosophy, having studied and fallen in love with it in graduate school, and finding its rigors and explosive power very helpful in my 20-year career in tech.

One cannot be successful as an architect without thinking of not only what to do, but how to get it done within an organization, which requires knowing why it should matter to someone who isn’t a technologist.

One of my favorite books, and one that changed how I think about software and the evolution of ideas, was A Pattern Language by Christopher Alexander (Oxford University Press).

There are two jobs in the world that people want to do the most while knowing the least about: architect and strategist.

What is Tableau Tableau Software is a highly scalable client-server architecture. It is an application that resides on your computer and used for individuals and publishing data sources as well as workbooks to tableau server. Which is allows for instantaneous insight by transforming data into interactive visualizations? Read from OnlineITGuru at Tableau Online Course

This manifests in two ways. First, many senior developers start writing the infrastructure that other developers use, rather than using existing (often open source) software. We once worked with a client who had once been on the cutting edge of technology. They built their own application server, web framework in Java, and just about every other bit of infrastructure. At one point, we asked if they had built their own operating system, too, and when they said, “No,” we asked, “Why not?!? You built everything else from scratch!” Upon reflection, the company needed capabilities that weren’t available. However, when open-source tools became available, they already owned their lovingly hand-crafted infrastructure. Rather than cut over to the more standard stack, they opted to keep their own because of minor differences in approach. A decade later, their best developers worked in full-time maintenance mode, fixing their application server, adding features to their web framework, and other mundane chores. Rather than applying innovation on building better applications, they permanently slaved away on plumbing.

So there you have it. O Software Architect, you must see the future. You must guess—intelligently. You must weigh the costs and determine where the architectural boundaries lie, and which should be fully implemented, and which should be partially implemented, and which should be ignored. But this is not a one-time decision. You don’t simply decide at the start of a project which boundaries to implement and which to ignore. Rather, you watch. You pay attention as the system evolves. You note where boundaries may be required, and then carefully watch for the first inkling of friction because those boundaries don’t exist. At that point, you weigh the costs of implementing those boundaries versus the cost of ignoring them—and you review that decision frequently. Your goal is to implement the boundaries right at the inflection point where the cost of implementing becomes less than the cost of ignoring. It takes a watchful eye.

The component structure cannot be designed from the top down. It is not one of the first things about the system that is designed, but rather evolves as the system grows and changes.

The success of the scaling-up process depends upon the fact that the conceptual integrity of each piece has been radically improved—that the number of minds determining the design has been divided by seven. So it is possible to put 200 people on a problem and face the problem of coordinating only 20 minds, those of the surgeons. For that coordination problem, however, separate techniques must be used, and these are discussed in succeeding chapters. Let it suffice here to say that the entire system also must have conceptual integrity, and that requires a system architect to design it all, from the top down. To make that job manageable, a sharp distinction must be made between architecture and implementation, and the system architect must confine himself scrupulously to architecture.

Conceptual integrity does require that a system reflect a single philosophy and that the specification as seen by the user flow from a few minds. Because of the real division of labor into architecture, implementation, and realization, however, this does not imply that a system so designed will take longer to build. Experience shows the opposite, that the integral system goes together faster and takes less time to test. In effect, a widespread horizontal division of labor has been sharply reduced by a vertical division of labor, and the result is radically simplified communications and improved conceptual integrity.

For it to be successful, the architect must • remember that the builder has the inventive and creative responsibility for the implementation; so the architect suggests, not dictates; • always be prepared to suggest a way of implementing anything he specifies, and be prepared to accept any other way that meets the objectives as well; • deal quietly and privately in such suggestions; • be ready to forego credit for suggested improvements. Normally the builder will counter by suggesting changes to the architecture. Often he is right—some minor feature may have unexpectedly large costs when the implementation is worked out.

Having studied both the possible risks and the likely rewards, the Guardian’s managers decided both to “open in” the website, by bringing in more data and applications from the outside, and to “open out” the site, by enabling partners to create products using Guardian content and services on other digital platforms. To work toward the “open out” goal, the Guardian created a set of APIs that made its content easily available to external parties. These interfaces include three different levels of access. The lowest access tier, which the paper calls Keyless, allows anyone to use Guardian headlines, metadata, and information architecture (that is, the software and design elements that structure Guardian data and make it easier to access, analyze, and use) without requesting permission and without any requirement to share revenues that might be generated. The second access tier, Approved, allows registered developers to reprint entire Guardian articles, with certain time and usage restrictions. Advertising revenues are shared between the newspaper and the developers. The third and highest access tier, Bespoke, is a customized support package that provides unlimited use of Guardian content—for a fee.

Uncertain quantitative criteria must be given as a range: the least , the nominal, and the most. If this range cannot be given, then the required behavior is not understood. As an architecture unfolds it can be checked against these criteria to see if it is (still) in tolerance. As the performance against some criteria drifts over time, valuable feedback is obtained. Finding these ranges and checking against them is a time-consuming and expensive business. If no one cares enough about the system being "performant" (neither a requirement nor a word) to pay for performance trials, then more than likely performance doesn't matter. You are then free to focus your architectural efforts on aspects of the system that are worth paying for.

Unfortunately it's far too easy to get wrapped up in the process of design, enthralled by architecture in abstract. The fact is that specifications alone have no value. The ultimate goal of a software project is a production system. A software architect must always keep an eye on this goal, and remember that design is merely a means to an end, not an end in itself. An architect for a skyscraper who ignored the laws of physics to make the building more beautiful would soon regret it. Losing sight of the goal of working code spells serious trouble for any project.

As the shape of political geography and the architecture of planetary-scale computation as a whole, The Stack is an accidental megastructure, one that we are building both deliberately and unwittingly and is in turn building us in its own image.

John Hennessy and David Patterson: they are titled Computer Organization and Design: The Hardware/Software Interface and Computer Architecture: A Quantitative Approach (both published by Morgan Kaufmann).

Traditionally, the goal of architecture has been scalability, reliability, and security. But today it’s important that the architecture also enables the rapid and safe delivery of software. You’ll learn that the microservice architecture is an architecture style that gives an application high maintainability, testability, and deployability.

…because as we know, there are known knowns; there are things we know we know. We also know there are known unknowns; that is to say we know there are some things we do not know. But there are also unknown unknowns — the ones we don’t know we don’t know.

The concept of failure is central to the design process, and it is by thinking in terms of obviating failure that successful designs are achieved. ... Although often an implicit and tacit part of the methodology of design, failure considerations and proactive failure analysis are essential for achieving success. And it is precisely when such considerations and analyses are incorrect or incomplete that design errors are introduced and actual failures occur.

The goal of the principles is the creation of mid-level software structures that: • Tolerate change, • Are easy to understand, and • Are the basis of components that can be used in many software systems.

SRP: The Single Responsibility Principle An active corollary to Conway’s law: The best structure for a software system is heavily influenced by the social structure of the organization that uses it so that each software module has one, and only one, reason to change.

Transitive dependencies are a violation of the general principle that software entities should not depend on things they don’t directly use. We’ll encounter that principle again when we talk about the Interface Segregation Principle and the Common Reuse Principle.

Don’t refer to volatile concrete classes. Refer to abstract interfaces instead. This rule applies in all languages, whether statically or dynamically typed. It also puts severe constraints on the creation of objects and generally enforces the use of Abstract Factories.

Don’t derive from volatile concrete classes. This is a corollary to the previous rule, but it bears special mention. In statically typed languages, inheritance is the strongest, and most rigid, of all the source code relationships; consequently, it should be used with great care. In dynamically typed languages, inheritance is less of a problem, but it is still a dependency—and caution is always the wisest choice.

Classes and modules that are grouped together into a component should be releasable together. The fact that they share the same version number and the same release tracking, and are included under the same release documentation, should make sense both to the author and to the users.

Analyzing the trade-offs between disintegration drivers and integration drivers is the secret to getting service granularity right.

Architecture represents the significant design decisions that shape a system, where significant is measured by cost of change. —Grady Booch

Architecture is the decisions that you wish you could get right early in a project, but that you are not necessarily more likely to get them right than any other. —Ralph Johnson

A good architecture comes from understanding it more as a journey than as a destination, more as an ongoing process of enquiry than as a frozen artifact.

Architecture is a hypothesis, that needs to be proven by implementation and measurement. —Tom Gilb

OCP: The Open-Closed Principle Bertrand Meyer made this principle famous in the 1980s. The gist is that for software systems to be easy to change, they must be designed to allow the behavior of those systems to be changed by adding new code, rather than changing existing code.

LSP: The Liskov Substitution Principle Barbara Liskov’s famous definition of subtypes, from 1988. In short, this principle says that to build software systems from interchangeable parts, those parts must adhere to a contract that allows those parts to be substituted one for another.

The SRP says to separate the code that different actors depend on.

If component A should be protected from changes in component B, then component B should depend on component A.

Architects separate functionality based on how, why, and when it changes, and then organize that separated functionality into a hierarchy of components.

To comply with these rules, the creation of volatile concrete objects requires special handling. This caution is warranted because, in virtually all languages, the creation of an object requires a source code dependency on the concrete definition of that object. In most object-oriented languages, such as Java, we would use an Abstract Factory to manage this undesirable dependency.

THE COMMON CLOSURE PRINCIPLE Gather into components those classes that change for the same reasons and at the same times. Separate into different components those classes that change at different times and for different reasons.

This is the Single Responsibility Principle restated for components. Just as the SRP says that a class should not contain multiples reasons to change, so the Common Closure Principle (CCP) says that a component should not have multiple reasons to change.

If we tried to design the component dependency structure before we designed any classes, we would likely fail rather badly. We would not know much about common closure, we would be unaware of any reusable elements, and we would almost certainly create components that produced dependency cycles. Thus the component dependency structure grows and evolves with the logical design of the system.

THE STABLE ABSTRACTIONS PRINCIPLE A component should be as abstract as it is stable.

Arranging our systems into a plugin architecture creates firewalls across which changes cannot propagate. If the GUI plugs in to the business rules, then changes in the GUI cannot affect those business rules.

It is far more common to fight your way through terrible software designs than it is to enjoy the pleasure of working with a good one.

ISP: The Interface Segregation Principle This principle advises software designers to avoid depending on things that they don’t use.

THE ACYCLIC DEPENDENCIES PRINCIPLE Allow no cycles in the component dependency graph.

THE STABLE DEPENDENCIES PRINCIPLE Depend in the direction of stability.

the history of software development technology is the story of how to conveniently create plugins to establish a scalable and maintainable system architecture.

Variables in functional languages do not vary.

All race conditions, deadlock conditions, and concurrent update problems are due to mutable variables. You cannot have a race condition or a concurrent update problem if no variable is ever updated. You cannot have deadlocks without mutable locks.

In Clojure, an atom is a special kind of variable whose value is allowed to mutate under very disciplined conditions that are enforced by the swap! function.

When we think of a software architect, we think of someone who has power, and who commands respect.

But what is software architecture? What does a software architect do, and when does he or she do it? First of all, a software architect is a programmer; and continues to be a programmer. Never fall for the lie that suggests that software architects pull back from code to focus on higher-level issues. They do not! Software architects are the best programmers, and they continue to take programming tasks, while they also guide the rest of the team toward a design that maximizes productivity. Software architects may not write as much code as other programmers do, but they continue to engage in programming tasks. They do this because they cannot do their jobs properly if they are not experiencing the problems that they are creating for the rest of the programmers.