Disable all observers in your test suite by default. They should not be complicating your model tests because they should have separate concerns anyway. You don't need to unit test that observers actually fire, because ActiveRecord's test suite does that, and your integration tests will cover it.

It’s generally good from a separations of concerns point of view and to reduce risk – migrations are scary enough as it is!

As the functionof the caU number is separation, so the function of references isconcentration.

when projects want to keep strict boundaries within their code and avoid becoming an entangled monolith. This is for example the case for Yarn itself, or many enterprise codebases.

Comparing to Mash your custom class lacks mash-like deep initializer which is a different concern from MethodAccess. So you just need a smart initializer extracted from Mash (just like MergeInitializer but deep), probably implemented as a separate extension. So It's a initializer issue, not an issue of MethodAccess.

The indentation of the remaining lines can be corrected with other cops such as IndentationConsistency and EndAlignment.

If leisure and political power requirethis education, everybody in America now requires it, andeverybody where democracy and industrialization penetratewill ultimately require it. If the people are not capable ofacquiring this education, they should be deprived of politicalpower and probably of leisure. Their uneducated politicalpower is dangerous, and their uneducated leisure is degrad-ing and will be dangerous. If the people are incapable ofachieving the education that responsible democratic citizen-ship demands, then democracy is doomed, Aristotle rightlycondemned the mass of mankind to natural slavery, and thesooner we set about reversing the trend toward democracythe better it will be for the world.

Democracy and Education was written before the assemblyline had achieved its dominant position in the industrialworld and before mechanization had depopulated the farmsof America.

Why do so many businesses share their data openly, for free? Most often, the answer is scale. As companies grow, the staff within those companies realize they have more ideas than they have the time and resources to develop them. It’s typically easier to work with other external companies that specialize in these ideas than build them in-house. By creating APIs, a company allows third-party developers to build applications that improve adoption and usage of its platform. That way, a business can build an ecosystem that becomes dependent on the data from their API, which often leads to additional revenue opportunities.

The media type specification and registration procedure is now a separate document, to make it clear that it is independent of MIME.

I'm building a Rails API with a separate web frontend app as "just another API client" (various smartphone apps to follow as well). In the previous "monolithic" version of the service, where all the server side was rolled into one Rails app

The focus of the dev container specification is to describe how to enrich a container for the purposes of development, rather than acting as a multi-container orchestrator format.

ransack is a very dirty solution that completely integrates the Searching, Sorting, and Views as requirements of eachother

Remember, our wizard controller is responsible for showing and updating steps, but our top-level controller is still responsible for managing our Pet models.

At this point I would call into question the job of Event to both be responsible for managing what gets charged and how something should be charged. I would probably investigate moving those to external service classes to keep charging responsibilities out of a simple event object.

Now your whole WS logic can be encapsulated in your JS module. That makes for good separation of concern.

What is risky here is that the concern (mixin) knows a lot about the model it gets included in. It is what is called a circular dependency. Song and Album depend on Trashable for trashing, Trashable depends on both of them for featured_authors definition. The same can be said for the fact that a trashed field needs to exist in both models in order to have the Trashable concern working.

This works nicely wherever we show authors, but after we deploy to production, the folks from other parts of the world won’t get notified anymore about their songs. Mistakes like these are easy to make when using concerns.

Do add business logic to helpers or utilities, so you can test them separately from your component.

If anything it thwarts separation of concerns to a degree.

I opened a new thread to discuss that aspect.

There is no request.env in functional tests because the functional tests are supposed to remain at the controller level.

For pluggability, an endpoint is split into a Protocol and an Adapter part. This separates generic logic from environment-dependent code.

Note how a handful of default steps lead into six standardized termini, allowing to plug protocols into different adapters. Imagine replacing your self-written API adapter with a canonical JSON-API adapter, for example.

By treating even small functions like a black box it promotes separation of concerns and allows said black box to evolve independently.

The elimination of what is arguably the biggest monoculture in the history of software development would mean that we, the community, could finally take charge of both languages and run-times, and start to iterate and grow these independently of browser/server platforms, vendors, and organizations, all pulling in different directions, struggling for control of standards, and (perhaps most importantly) freeing the entire community of developers from the group pressure of One Language To Rule Them All.

JavaScript needs to fly from its comfy nest, and learn to survive on its own, on equal terms with other languages and run-times. It’s time to grow up, kid.

If JavaScript were detached from the client and server platforms, the pressure of being a monoculture would be lifted — the next iteration of the JavaScript language or run-time would no longer have to please every developer in the world, but instead could focus on pleasing a much smaller audience of developers who love JavaScript and thrive with it, while enabling others to move to alternative languages or run-times.

PyPy aims to provide a common translation and support framework for producing implementations of dynamic languages, emphasizing a clean separation between language specification and implementation aspects.

Additionally, you may add debugging steps, error handler or rewire the conditions dynamically without touching the original snippet.

You’re free to test this activity in a separate unit test.

Whatever data from the outside is needed in the activity has to be passed explicitely into the activity’s call method.

While routing and redirecting/rendering still happens in Rails, all remaining steps are handled in the endpoint.

An endpoint links your routing with your business code. The idea is that your controllers are pure HTTP routers, calling the respective endpoint for each action. From there, the endpoint takes over, handles authentication, policies, executing the domain code, interpreting the result, and providing hooks to render a response.

Read about the motivation to understand why this separation of concerns is important.

As a result, dry-types, dry-struct and dry-schema were born. These projects should be considered as virtus' successors, with better separation of concerns and better features.

This is done to separate internal representations of information from the ways information is presented to and accepted from the user.

Keep your domain in one place. If you ever get mad at your web host and decide to move your site, you’ll also probably want to transfer your domain if it’s registered with the old host. Domain transfers can be annoying, time-consuming, and confusing. But if you’ve registered the domain elsewhere, you don’t have to do anything except update your DNS settings to point to the new host.

Allows you to separate the tippy's positioning from its trigger source.

"Headless Tippy" refers to Tippy without any of the default element rendering or CSS. This allows you to create your own element from scratch and use Tippy for its logic only.

There is seldom any good reason to use this option. Mixing ERB into your controllers defeats the MVC orientation of Rails and will make it harder for other developers to follow the logic of your project. Use a separate erb view instead.

It does not include any user interface at all (not even a terminal UI)

We all know that real business logic does not belong in the presentation layer, but what about simple presentation-oriented things like coloring alternate rows in table or marking the selected option in a <select> dropdown? It seems equally wrong to ask the controller/business logic code to compute these down to simple booleans in order to reduce the logic in the presentation template. This route just lead to polluting the business layer code with presentation-oriented logic.

Separation of concerns: You will avoid having your business logic being tied up to the UI

I'm personally open to any other solutions, especially in how we might be able to untie from React, but, for now, inline-XML markup (JSX) is OK with me.

By using HTML as the uniform interface, we can separate the interface from the engine.

In 1972 David L. Parnas published a classic paper entitled On the Criteria To Be Used in Decomposing Systems into Modules. It appeared in the December issue of the Communications of the ACM, Volume 15, Number 12. In this paper, Parnas compared two different strategies for decomposing and separating the logic in a simple algorithm. The paper is fascinating reading, and I strongly urge you to study it. His conclusion, in part, is as follows: “We have tried to demonstrate by these examples that it is almost always incorrect to begin the decomposition of a system into modules on the basis of a flowchart. We propose instead that one begins with a list of difficult design decisions or design decisions which are likely to change. Each module is then designed to hide such a decision from the others.”

"Let me try to explain to you, what to my taste is characteristic for all intelligent thinking. It is, that one is willing to study in depth an aspect of one's subject matter in isolation for the sake of its own consistency, all the time knowing that one is occupying oneself only with one of the aspects. We know that a program must be correct and we can study it from that viewpoint only; we also know that it should be efficient and we can study its efficiency on another day, so to speak. In another mood we may ask ourselves whether, and if so: why, the program is desirable. But nothing is gained —on the contrary!— by tackling these various aspects simultaneously. It is what I sometimes have called "the separation of concerns", which, even if not perfectly possible, is yet the only available technique for effective ordering of one's thoughts, that I know of. This is what I mean by "focussing one's attention upon some aspect": it does not mean ignoring the other aspects, it is just doing justice to the fact that from this aspect's point of view, the other is irrelevant. It is being one- and multiple-track minded simultaneously.

React Aria separates the behavior and accessibility implementation for many common UI components out into React Hooks, which enables them to be reused easily between design systems. You remain in complete control over the rendering and styling aspects of your components, but get most of the behavior, accessibility, and internationalization support for free.

React is an isomorphic/universal framework. That means that there is a virtual representation of the UI component tree, and that is separate from the actual rendering that it outputs in the browser.

what may be nice here would be to allow the user to specify an event to run validation with, and to remove it from the exported handleChange. This way handleChange is responsible exclusively for updating the value in the store, and actions are responsible for updating the error state.

Both versions have generally the same content (e.g. the text of an article) but they may have different presentations.

The key to successfully creating reusable components using both render props and scoped slots is being able to correctly separate behavior from presentation. Each time you create a new UI component, think “What is the core behavior of this component? Can I use this anywhere else?”

The task of "making a thing satisfying our needs" as a single responsibility is split into two parts "stating the properties of a thing, by virtue of which it would satisfy our needs" and "making a thing guaranteed to have the stated properties". Business data processing systems are sufficiently complicated to require such a separation of concerns and the suggestion that in that part of the computing world "scientific thought is a non-applicable luxury" puts the cart before the horse: the mess they are in has been caused by too much unscientific thought.

Some time ago I visited the computing center of a large research laboratory where they were expecting new computing equipment of such a radically different architecture, that my colleagues had concluded that a new programming language was needed for it if the potential concurrency were to be exploited to any appreciable degree. But they got their language design never started because they felt that their product should be so much like FORTRAN that the casual user would hardly notice the difference "for otherwise our users won't accept it". They circumvented the problem of explaining to their user community how the new equipment could be used at best advantage by failing to discover what they should explain. It was a rather depressing visit.... The proper technique is clearly to postpone the concerns for general acceptance until you have reached a result of such a quality that it deserves acceptance. It is the significance of your message that should justify the care that you give to its presentation, it may be its "unusualness" that makes extra care necessary.

presentation was nearly always considered separately, rather than being embedded in the markup itself

This concept is variously referred to in markup circles as the rule of separation of presentation and content, separation of content and style, or of separation of semantics and presentation.

First proposed as a somewhat less unwieldy catchall phrase to describe the delicate art of "separating document structure and contents from semantics, presentation, and behavior"

And since it’s just a client, you can always use the todo.txt format text file created by it in the very beginning with any other client. Give it a try.

Why a rewrite? To finally have a clean split between GUI code and logic.

REST's client-server separation of concerns

allows us to clearly separate concerns and reuse them on other elements

React Native has also used this pattern in TouchableWithoutFeedback

we use a LOT of injector components to abstract out logic and nicely separate concerns like style, animation, and interactions from our layout components.

Rack middleware is more than "a way to filter a request and response" - it's an implementation of the pipeline design pattern for web servers using Rack. It very cleanly separates out the different stages of processing a request - separation of concerns being a key goal of all well designed software products.