philanthropy is in some ways the the most symbolic externalization of neoliberal capitalism. Some people have amassed huge amounts of wealth through a rigged game of extraction and destruction of life. And then it's also presented back to us as an alternative to capitalism that somehow philanthropy can solve the problems that capital created in the first place. And in many ways, that is the fundamental paradox and the absurdity of modern philanthropy.

we're really invoking a call for philanthropy to be in the liberation of capital in a way that can support transition pathways. What we refer to as transition pathways is other ways of being and knowing that are in co-creative relationship with life itself.

The great koan collection, Mumonkan, means The Gateless Gate. Gateless Gate means you can enter the Way anywhere, even here, even now, even like this. The great dualism in our lives as lay people is to imagine this divide between us and the real thing, to feel that the gate is a monastery gate, the gate right here.

it is through the ascetic formations of monasticism that an opening was made for reevaluating labor positively rather than negatively

Free and open-source licenses use these existing legal structures for an inverse purpose

Now we understand why there has to be an inner reality which is made of qualia and an outer reality which is made a lot of symbols, shareable symbols, what we call matter.

This is the most simulative version of a controller. It will try and mimic real user behaviour. It's the recommended version to use when the goal of the load-test is finding out how many concurrently active users the target instance supports.

you can Google data if you're good you can Google information but you cannot Google an idea you cannot Google Knowledge because having an idea acquiring knowledge this is what is happening on your mind when you change the way you think and I'm going to prove that in the next yeah 20 or so minutes that this will stay analog in our closed future because this is what makes us human beings so unique and so Superior to any kind of algorithm

If you are okay with the user appending arbitrary query params without enforcing an allow-list, you can bypass the strong params requirement by using request.params directly:

Instance methods Instances of Models are documents. Documents have many of their own built-in instance methods. We may also define our own custom document instance methods. // define a schema const animalSchema = new Schema({ name: String, type: String }, { // Assign a function to the "methods" object of our animalSchema through schema options. // By following this approach, there is no need to create a separate TS type to define the type of the instance functions. methods: { findSimilarTypes(cb) { return mongoose.model('Animal').find({ type: this.type }, cb); } } }); // Or, assign a function to the "methods" object of our animalSchema animalSchema.methods.findSimilarTypes = function(cb) { return mongoose.model('Animal').find({ type: this.type }, cb); }; Now all of our animal instances have a findSimilarTypes method available to them. const Animal = mongoose.model('Animal', animalSchema); const dog = new Animal({ type: 'dog' }); dog.findSimilarTypes((err, dogs) => { console.log(dogs); // woof }); Overwriting a default mongoose document method may lead to unpredictable results. See this for more details. The example above uses the Schema.methods object directly to save an instance method. You can also use the Schema.method() helper as described here. Do not declare methods using ES6 arrow functions (=>). Arrow functions explicitly prevent binding this, so your method will not have access to the document and the above examples will not work.

But I do question why lib and not something in app is the common suggestion for classes/modules who do not fall into the default set of folders (models, controllers, jobs, etc). Is it just because it's what we've been doing for so long? To me feels like we're trying to shoehorn the lib folder into further being a kitchen sink (now holding rake tasks and miscellaneous classes), rather than just saying "your Ruby classes/modules go somewhere in app because they're application code".

The "Dokkōdō" (Japanese: 獨行道) ("The Path of Aloneness", "The Way to Go Forth Alone", or "The Way of Walking Alone") is a short work written by Miyamoto Musashi a week before he died in 1645. It consists of 21 precepts. "Dokkodo" was largely composed on the occasion of Musashi giving away his possessions in preparation for death, and was dedicated to his favorite disciple, Terao Magonojō (to whom the earlier Go rin no sho [The Book of Five Rings] had also been dedicated), who took them to heart. "Dokkōdō" expresses a stringent, honest, and ascetic view of life.

no we don't

How Large Is A Note?

So far for the obligatory warning. I get the point, I even agree with the argument, but I still want to send a POST request. Maybe you are testing an API without a user interface or you are writing router tests? Is it really impossible to simulate a POST request with Capybara? Nah, of course not!

It's a great way to test various limits. When you think about this even more, it's a little mind-bending, as we're trying to impose a global clock ("who is the most up to date") on a system that inherently doesn't have a global clock. When we scale time down to nanoseconds, this affects us in the real world of today: a light-nanosecond is not very far.

Interestingly, Rails doesn't see this in their test suite because they set this value during setup:

Stores are the idiomatic Svelte way when you need to import "reactivity" from your normal JS sources.

I am firmly convinced that asserting on the state of the interface is in every way superior to asserting on the state of your model objects in a full-stack test.

Inflections go the other way around.In classic mode, given a missing constant Rails underscores its name and performs a file lookup. On the other hand, zeitwerk mode checks first the file system, and camelizes file names to know the constant those files are expected to define.While in common names these operations match, if acronyms or custom inflection rules are configured, they may not. For example, by default "HTMLParser".underscore is "html_parser", and "html_parser".camelize is "HtmlParser".

The more your tests resemble the way your software is used, the more confidence they can give you.

Now consider we want to handle numbers in our known value set: const KNOWN_VALUES = Object.freeze(['a', 'b', 'c', 1, 2, 3]) function isKnownValue(input?: string | number) { return typeof(input) === 'string' && KNOWN_VALUES.includes(input) } Uh oh! This TypeScript compiles without errors, but it's not correct. Where as our original "naive" approach would have worked just fine. Why is that? Where is the breakdown here? It's because TypeScript's type system got in the way of the developer's initial intent. It caused us to change our code from what we intended to what it allowed. It was never the developer's intention to check that input was a string and a known value; the developer simply wanted to check whether input was a known value - but wasn't permitted to do so.

There are many projects that does not use the master branch as default. For example, Next.js uses the canary branch, the npm CLI and many more other projects uses stuff like prod, production, dev, develop, release, beta, head.

targeting what the user actually sees

The most important guideline to give is the following: Write clean unit tests if there is actual value in testing a complex piece of logic in isolation to prevent it from breaking in the future Otherwise, try to write your specs as close to the user’s flow as possible

It’s better to test a component in the way the user interacts with it: checking the rendered template.

or simply install the package to devDependencies rather than dependencies, which will cause it to get bundled (and therefore compiled) with your app:

“Who cares? Let’s just go with the style-guide” — to which my response is that caring about the details is in the heart of much of our doings. Yes, this is not a major issue; def self.method is not even a code smell. Actually, that whole debate is on the verge of being incidental. Yet the learning process and the gained knowledge involved in understanding each choice is alone worth the discussion. Furthermore, I believe that the class << self notation echoes a better, more stable understanding of Ruby and Object Orientation in Ruby. Lastly, remember that style-guides may change or be altered (carefully, though!).

This isn't really a downside to React; one of React's strengths is that it lets you control so much and slot React into your environment

Svelte is different in that by default most of your code is only going to run once; a console.log('foo') line in a component will only run when that component is first rendered.

we want source maps in production (like DHH)

I totally understand that there may be a majority still considering this a bad practice and thus keeping it disabled by default in production seem ok. But there could at least be an option to enable it for people who want to, no?

After waiting years for sprockets to support this we were very happy to see that sprockets 4 officially added support (thanks ), but then when trying to upgrade we noticed there's actually no way to use it in production... (without brittle hacks mentioned above).

Rails still encourages you to dump all validation errors at the top of a form, which is lulzy in this age of touchy UX

Webshim is opinionated, that a developer should always solve a problem the HTML5 way.

In production, you will never trigger one specific callback or a particular validation, only. Your application will run all code required to create a Song object, for instance. In Trailblazer, this means running the Song::Create operation, and testing that very operation with all its side-effects.

There’s no need to test controllers, models, service objects, etc. in isolation

Run the complete unit with a certain input set, and test the side-effects. This differs to the Rails Way™ testing style, where smaller units of code, such as a specific validation or a callback, are tested in complete isolation. While that might look tempting and clean, it will create a test environment that is not identical to what happens in production.

Instead of one big code pile, activities will gently enforce a clean, standardized way for organizing code.

the Activity component is the heart of TRB

Have you ever felt like a framework was getting in the way instead of helping you go faster? Maybe you’re stuck on some simple task that would be easy to do manually, but your framework is making you jump through configuration hoops. I end up getting lost in a sea of documentation (or no documentation), and the search for that one magical config key takes just a tad bit too long. It’s a productivity sink, and worse than the time delay it adds to my frustration throughout the day.

I'm not a fan of listing exceptions functions can throw, especially here in Python, where it's easier to ask forgiveness than permission.

In other words: the controllers usually contain only routing and rendering code and dispatch instantly to a particular operation/activity class.

Instead of dealing with a mix of before_filters, Rack-middlewares, controller code and callbacks, an endpoint is just another activity and allows to be customized with the well-established Trailblazer mechanics.

Endpoint is the missing link between your routing (Rails, Hanami, …) and the “operation” to be called. It provides standard behavior for all cases 404, 401, 403, etc and lets you hook in your own logic like Devise or Tyrant authentication, again, using TRB activity mechanics.

What this means is: I better refrain from writing a new book and we rather focus on more and better docs.

To make it short: we returned to the Rails Way™, lowering our heads in shame, and adhere to the Rails file and class naming structure for operations.

There is nothing wrong with building your own “service layer”, and many companies have left the Traiblazer track in the past years due to problems they had and that we think we now fixed.

In Trailblazer, models are completely empty. They solely contain associations and finders. No business logic is allowed in models.

While Trailblazer offers you abstraction layers for all aspects of Ruby On Rails, it does not missionize you. Wherever you want, you may fall back to the "Rails Way" with fat models, monolithic controllers, global helpers, etc. This is not a bad thing, but allows you to step-wise introduce Trailblazer's encapsulation in your app without having to rewrite it.

In Ruby 3 we now have a “rightward assignment” operator. This flips the script and lets you write an expression before assigning it to a variable. So instead of x = :y, you can write :y => x

This is a breaking change so it'll have to go into a major release. I was working on a v4 release but it's too much. I think I'm going to pair it back and we can add this to the new v4. When I have that ready, I'll rebase the merge onto that branch.

The Timeless Way of Building is the first in a series of books which describe an entirely new attitude to architec- ture and planning. The books are intended to provide a complete working alternative to our present ideas about ar- chitecture, building, and planning—~an alternative which will, we hope, gradually replace current ideas and practices,

We don’t do politics, and we certainly don’t do religion. You’re bringing these here by using terms such as “politicians” or “evil”.

Depending on what other component libraries you’ve used, you may be used to handling events by passing callback functions to component properties, or using a special event syntax – Svelte supports both, though one is usually more appropriate than the other depending on your situation. This post explains both ways.

Adding layer of settings and complexity for the end user might also bring bad practices to keep a comfortable use of app’s by installing snap without confinement…

Jbuilder gives you a simple DSL for declaring JSON structures that beats manipulating giant hash structures. This is particularly helpful when the generation process is fraught with conditionals and loops.

I think the main difference between the two are the way API are served. Some smelte components need you to input big chunk of json as props, while i prefer keep props as primitive types and in the other hand give you different components tags to compose.

There are a few intentional behavioral differences between Dart Sass and Ruby Sass. These are generally places where Ruby Sass has an undesired behavior, and it's substantially easier to implement the correct behavior than it would be to implement compatible behavior. These should all have tracking bugs against Ruby Sass to update the reference behavior.

You’ll learn how to cause stack overflows, illegal memory access, andother common flaws that plague C programs so that you know what you’re upagainst

If you have a better/simpler/"more official" solution, I'd still love to see it!

Modules from the following layer can require anything from all the previous layers, but not vice versa.

http://facebook.github.io/jsx/#why-not-template-literals (respectfully disagree)

Svelte chooses a reverse approach.

Svelte doesn't re-render, so you need to respond to component mount/dismount and prop changes separately as they are distinct concepts and never tied together, unlike in React.

While react hooks were one of the catalysts for v3 we don't agree with with the APIs or the model and won't be emulating it.

Sometimes, you may be tempted to write that wrapper. Because all your (React or Vue or insert your reactive framework here) instincts tell you so.Resist the temptation. There is a better way. A svelter way. Introducing: the use-directive (a.k.a. “actions”).

However, especially when starting out, it’s very easy to fall into the “this is how I did things in my previous framework” trap.

Disclaimer: I’m new to Svelte so this isn’t so much a recommendation as it is a “I guess this is a way to do it 🤷‍♂️”

But maybe this PR should still be merged until he finds time for that?

I think Svelte's approach where it replaces component instances with the component markup is vastly superior to Angular and the other frameworks. It gives the developer more control over what the DOM structure looks like at runtime—which means better performance and fewer CSS headaches, and also allows the developer to create very powerful recursive components.

I went against the grain, applying other tools that people have written over the years to directly perform the job at hand which do not involve entering a program for awk or a shell to run, with answers like https://unix.stackexchange.com/a/574309/5132 and https://unix.stackexchange.com/a/578242/5132 . Others have done similar. https://unix.stackexchange.com/a/584274/5132 and https://unix.stackexchange.com/a/569600/5132 are (for examples) answers that show alternative tools to answers employing shell script and (yet again) awk programs, namely John A. Kunze's jot and rs (reshape), which have been around since 4.2BSD for goodness' sake!

The carefully crafted Medium story can give the appearance that- at the nadir of your professional life- you are above it all, you are concerned about others, and you are a soulful human being moving on to an even more lucrative future.

In natural languages, some apparent tautologies may have non-tautological meanings in practice. In English, "it is what it is" is used to mean 'there is no way of changing it'.[1] In Tamil, vantaalum varuvaan literally means 'if he comes, he will come', but really means 'he just may come'.[2]

many organisations block torrents (for obvious reasons) and I know, for example, that either of these options would have posed insurmountable hurdles at my previous employment

Actually, I probably would have ended up just paying for it myself due to the procurement challenges of even a single-digit dollar amount, but let's not get me started on that

"The more your tests resemble the way your software is used, the more confidence they can give you. "

You want to write maintainable tests for your React components. As a part of this goal, you want your tests to avoid including implementation details of your components and rather focus on making your tests give you the confidence for which they are intended. As part of this, you want your testbase to be maintainable in the long run so refactors of your components (changes to implementation but not functionality) don't break your tests and slow you and your team down.

We try to only expose methods and utilities that encourage you to write tests that closely resemble how your web pages are used.

The more your tests resemble the way your software is used, the more confidence they can give you.

Most of the damaging features have to do with encouraging testing implementation details. Primarily, these are shallow rendering, APIs which allow selecting rendered elements by component constructors, and APIs which allow you to get and interact with component instances (and their state/properties) (most of enzyme's wrapper APIs allow this).

Living The Way of Knowledge BUILDING THE FOUNDATION FOR BECOMING A MAN OR WOMAN OF KNOWLEDGE IN AN EMERGING WORLD