64 Matching Annotations
  1. Mar 2024
  2. Feb 2024
    1. 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.
  3. Jan 2024
    1. Newton's notebook was done in a tête-bêche (French for "head-to-toe") style in which he flipped the notebook over and began using it from the back to the front as a means of starting a second notebook within to separate the contents.

  4. Sep 2023
    1. The indentation of the remaining lines can be corrected with other cops such as IndentationConsistency and EndAlignment.
  5. Aug 2023
    1. 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.

      This is an extreme statement which bundles together a lot without direct evidence.

      Written in an era in which there was a lot of pro-Democracy and anti-Communist discussion, Hutchins is making an almost religious statement here which binds education and democracy in the ways in which the Catholic church bound education and religion in scholasticism. While scholasticism may have had benefits, it also caused a variety of ills which took centuries to unwind into the Enlightenment.

      Why can't we separate education from democracy? Can't education of this sort live in other polities? Hasn't it? Does critical education necessarily lead to democracy?

      What does the explorable solution space of admixtures of critical reasoning and education look like with respect to various forms of government? Could a well-educated population thrive under collectivism or socialism?

      The definition of "natural slavery" here is contingent and requires lots of context, particularly of the ways in which Aristotle used it versus our current understanding of chattel slavery.

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

      Interesting history and possible solutions.

      Dewey on the humanization of work front running the dramatic changes of and in work in an industrial age?


      Note here the potential coupling of democracy and education as dovetailing ideas rather than separate ideas which can be used simultaneously. We should take care here not to end up with potential baggage that could result in society and culture the way scholasticism combined education and religion in the middle ages onward.

  6. Apr 2023
    1. 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.
  7. Sep 2022
  8. Aug 2022
    1. 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
  9. Jun 2022
  10. Mar 2022
  11. Feb 2022
    1. Remember, our wizard controller is responsible for showing and updating steps, but our top-level controller is still responsible for managing our Pet models.
    1. 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.
  12. Nov 2021
  13. Jul 2021
    1. 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.
    2. 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.
  14. Jun 2021
  15. Apr 2021
  16. Mar 2021
    1. For pluggability, an endpoint is split into a Protocol and an Adapter part. This separates generic logic from environment-dependent code.
    2. 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.
    1. 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.
    2. 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.
    3. 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.
  17. en.wikipedia.org en.wikipedia.org
    1. 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.
  18. Feb 2021
    1. You’re free to test this activity in a separate unit test.
    2. Whatever data from the outside is needed in the activity has to be passed explicitely into the activity’s call method.
    1. 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.
    1. 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.
    1. 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.
  19. Jan 2021
    1. 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.
  20. Dec 2020
  21. Nov 2020
    1. 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.
  22. Oct 2020
    1. 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.
    1. 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.”

      Parnas published a paper in 1972 about what heuristics are best to decide when to decompose a system into modules.

      His conclusion is that it is almost always wrong to start with a representation such as a flowchart (because things change).

      Instead he recommends focusing on a list of difficult design decisions, or decisions, once made, that will likely change. Then design each module is designed to hide such decisions from others.

    1. "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.

      Dijkstra posits that a characteristic of what he calls "intelligent thinking" is the tendency to practice a "separation of concerns". By this he means thinking about concepts separate of one another for the sake of their own consistency, rather than simultaneously, which doesn't help in ordering your thinking.

  23. Sep 2020
    1. 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.
    1. 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.
  24. Jul 2020
    1. 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?”
  25. May 2020
    1. 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.

      Dijkstra suggested that instead of concerning ourselves with a software system that meets the user's needs, we should first separate our concerns.

      We should first concern ourselves with the user's needs and draw up careful specifications – properties to which the system should adhere should it satisfy the user's needs.

      With those specifications in hand we can concern ourselves with making a system guaranteed to have stated properties.

      The problem with this thinking, which the software industry would later discover, is that a user's needs cannot be accurately or completely determined before building the system. We learn more about what is needed by the process of building.

      This is an instance of the [[Separation of concerns]] not working.

      This is also why the industry has settled on a technique to build iteratively (Agile), always leaving the option open to change course.

    2. 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.

      When you've developed an idea, you will typically want to communicate that idea so that it can be understood and used more generally. Dijkstra calls this reaching "general acceptance".

      To do so, you must communicate the idea in a way so that it can be properly understood and used. For certain ideas this becomes a challenging problem in and of itself.

      Many forgo this challenge, and instead of figuring out what new language they need to invent to most accurately communicate the idea, they use legacy language and end up communicating their idea less effectively, in pursuit of general acceptance.

      Dijkstra says that the proper way of dealing with this dilemma is to separate your concerns. You separate your concern of the solution from the concern of communicating the solution.

      When you've reached a solution that is of such high quality that it deserves communicating – and only then – do you concern yourself with its presentation.

    1. presentation was nearly always considered separately, rather than being embedded in the markup itself
    2. 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.
    3. 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"
  26. Dec 2019
  27. Nov 2019
    1. React Native has also used this pattern in TouchableWithoutFeedback
    2. we use a LOT of injector components to abstract out logic and nicely separate concerns like style, animation, and interactions from our layout components.
  28. Oct 2019
    1. 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.