when I've worked with pre and perinal psychology people think oh well this is psychology this is mental health but really it's not it's more than that it's a holistic Body Mind practice where implicit somatic memory is alive and active and actually informing how we behave and choices that we make in the present

working group three is just Exxon in Disguise um you know there are good people in working group three but working group three and integrated assessment models good people working some of the people are good people there working in deeply subjective boundaries that have been set up by we mustn't Rock the political boat

A justice approach, by contrast, requires at least boundaries that minimise significant harm to human health and wellbeing and to other species (panel 2) while ensuring access to necessary resources and services.

Is this thing dead? No! Not at all! There's not a lot of activity here because it's stable and working!

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.

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

And events are just data so can process, enrich, filter, aggregate, visualise the data with your own tools.

One part of React that I've always championed is how it's just JavaScript. I like that in React you don't use a distinct template syntax and instead embed JavaScript, compared to Svelte's templating language

I will always find React's approach easier - at least in my head - and I think more friendly to people familiar with JavaScript who are learning a library.

Another important MicroJS attribute is independence. Ember, Backbone—even Bootstrap to a degree–have hard dependencies on other libraries. For example, all three rely on jQuery. A good MicroJS library stands by itself with no dependencies. There are exceptions to the rule, but in general, any dependency is another small MicrojJS library.

D3 now passes events directly to listeners, replacing the d3.event global and bringing D3 inline with vanilla JavaScript and most other frameworks.

Last week, I shared how to check if an input is empty with CSS. Today, let’s talk about the same thing, but with JavaScript.

You can do and impressive amount of form validation with just HTML attributes. You can make the user experience pretty clean and clear with CSS selectors.

the client form validation is the one I like a lot, because, for example, by adding required attribute to an input, I don’t need to write any additional JavaScript to warn a user, when the user submits a form without filling out the required fields

Here's another plain ES2015/2017 version

There’s no additional logic from Trailblazer happening here. The function returns a well-defined hash which is passed as an argument to step.

Keyword arguments allow to define particular parameters as required. Should the parameter be missing, they also provide a way to set a default value. This is all done with pure Ruby.

This is how the same example would look like using raw monads:

Operations define the flow of their logic using the DSL and implement the particular steps with pure Ruby.

The main realization came when I figured out that the main_model was just another association. This means we can move a lot of logic to just that class and reason about it a lot better.

If you teach your users to trust that URL bar is supposed to not change when they click links (e.g. your site uses a big iframe with all the actual content), then the users will not notice anything in the future either in case of actual security vulnerability.

The point is, just because you don’t see it, doesn’t mean it’s not happening. It’s been more than two years and as far as I know, no one has ever noticed one of my requests. Maybe it’s been in your site this whole time

My frustration is mainly from Svelte's choices that are very un-JavaScript-like. It doesn't have to be "like React/Vue". React is React because it doesn't restrict what you can do with JavaScript for the most part. It's just common FP practice to fold/map.

It's really helpful that Svelte stores are easy to use in plain JS. We can change a state store over completely to Svelte and make the Angular components subscribe to that store as well without needing to maintain and sync 2 copies of the state.

Mostly it is pure JS once it gets inside the browser, so you can debug effectively which is not the case with Vue for example.

All validators can be used independently. Inspried by functional programming paradigm, all built in validators are just functions.

FormValidation.validators.creditCard().validate({

FormValidation.formValidation(formElement

If the react cargo cult didn't have the JSX cowpath paved for them and acclimated to describing their app interface with vanilla javascript, they'd cargo cult around that. It's really about the path of least resistance and familiarity.

hyperscript is much simpler to refactor and DRY up your code than with JSX, because, being vanilla javascript, its easier to work with variable assignment, loops and conditionals.

This is valid javascript! Or harmony or es6 or whatever, but importantly, it's not happening outside the js environment. This also allows us to use our standard tooling: the traceur compiler knows how to turn jsx`<div>Hello</div>`; into the equivalent browser compatible es3, and hence we can use anything the traceur compile accepts!

Hooks embrace JavaScript closures and avoid introducing React-specific APIs where JavaScript already provides a solution.

Yes, we use CSS. I thought a Svelte mantra was to use the existing language(s). This is fundamental CSS

One of the arguments that's frequently deployed in favour of JSX-based frameworks over template-based ones is that JSX allows you to use existing language constructs:

But what all frameworks have in common is to write JS and this could convince users of React but also newcomers that know JS.

This is what I love about React, it's JavaScript basically, not a DSL

I would rather you vote against my position because you had an opposing view than vote with my position because you flipped a coin.

Summer surprised us