22 Matching Annotations
  1. Sep 2024
    1. from 6–15% in some landscapes (eg, riparian ecosystems, agricultural landscapes with high crop diversity) to 50% in others (eg, in sloping landscapes, or landscapes where erosion or natural hazards are frequent).

      for - earth system boundary - biodiversity - human modified ecosystems - minimum varies depending on specific local context

    2. The exact area, quality, and spatial configuration required varies by contribution and location, and thus could not be estimated on a global scale, necessitating local translation, assessment of local context, demand for specific NCP, and application of best practices.

      for earth system boundary - biodiversity - human modified ecosystems - only local translation is possible

    3. 10% of natural or semi-natural habitat per km2 is a sharper threshold, below which evidence suggests that many NCP would almost no longer be provided.

      for - stats - earth system boundary - biodiversity - human modified ecosystems -absolute minimum of 10% - below this, many of Nature's contribution to people would no longer be provided

    4. safe boundary of at least 20–25% of natural or semi-natural habitat per km2 in human-modified lands (ie, urban and agro-ecosystems) is needed to support both Earth-system NCP and local NCP, in addition to the functions provided by largely intact lands.

      for - stats - earth system boundary - biodiversity - human modified ecosystems - minimum of 20 to 25% natural / semi-natural habitat per square kilometer

    5. human-modified ecosystems, we systematically analysed six critical NCP at local scales

      for - stats - earth system boundary - biodiversity - human modified ecosystems - 6 critical Nature's Contribution to People at local scales

      stats - earth system boundary - biodiversity - human modified ecosystems - 6 critical Nature's Contribution to People at local scales - pollination pest and disease control - water-quality regulation - soil protection - natural hazards mitigation - recreation

    6. We capture the main components by identifying safe boundaries for two complementary and synthetic measures of biodiversity: the area of largely intact natural ecosystems, and the functional integrity of ecosystems heavily modified by human pressures.

      for - biodiversity - safe earth system boundaries - 2 measures - intact natural ecosystems - ecosystems modified by human pressures - question - quantification of biodiversity tipping points at various scales

      question - quantification of biodiversity tipping points at various scales - As ecologist David Suzuki often says, economy depends on ecology, not the other way around - Is there quantification at different potential tipping points for extinction for biodiversity at different scales and localities?

  2. Jan 2024
    1. 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.

      Certainly! Let's break down the provided code snippets:

      1. What is it and why is it used?

      In Mongoose, a schema is a blueprint for defining the structure of documents within a collection. When you define a schema, you can also attach methods to it. These methods become instance methods, meaning they are available on the individual documents (instances) created from that schema.

      Instance methods are useful for encapsulating functionality related to a specific document or model instance. They allow you to define custom behavior that can be executed on a specific document. In the given example, the findSimilarTypes method is added to instances of the Animal model, making it easy to find other animals of the same type.

      2. Syntax:

      Using methods object directly in the schema options:

      javascript const animalSchema = new Schema( { name: String, type: String }, { methods: { findSimilarTypes(cb) { return mongoose.model('Animal').find({ type: this.type }, cb); } } } );

      Using methods object directly in the schema:

      javascript animalSchema.methods.findSimilarTypes = function(cb) { return mongoose.model('Animal').find({ type: this.type }, cb); };

      Using Schema.method() helper:

      javascript animalSchema.method('findSimilarTypes', function(cb) { return mongoose.model('Animal').find({ type: this.type }, cb); });

      3. Explanation in Simple Words with Examples:

      Why it's Used:

      Imagine you have a collection of animals in your database, and you want to find other animals of the same type. Instead of writing the same logic repeatedly, you can define a method that can be called on each animal instance to find similar types. This helps in keeping your code DRY (Don't Repeat Yourself) and makes it easier to maintain.

      Example:

      ```javascript const mongoose = require('mongoose'); const { Schema } = mongoose;

      // Define a schema with a custom instance method const animalSchema = new Schema({ name: String, type: String });

      // Add a custom instance method to find similar types animalSchema.methods.findSimilarTypes = function(cb) { return mongoose.model('Animal').find({ type: this.type }, cb); };

      // Create the Animal model using the schema const Animal = mongoose.model('Animal', animalSchema);

      // Create an instance of Animal const dog = new Animal({ type: 'dog', name: 'Buddy' });

      // Use the custom method to find similar types dog.findSimilarTypes((err, similarAnimals) => { console.log(similarAnimals); }); ```

      In this example, findSimilarTypes is a custom instance method added to the Animal schema. When you create an instance of the Animal model (e.g., a dog), you can then call findSimilarTypes on that instance to find other animals with the same type. The method uses the this.type property, which refers to the type of the current animal instance. This allows you to easily reuse the logic for finding similar types across different instances of the Animal model.

      Certainly! Let's go through each part and explain it in simple terms: ### 1. `this` in Mongoose: - **What is `this`?** In JavaScript, `this` refers to the current context or object. In Mongoose, particularly within methods and middleware functions, `this` represents the instance (document) the function is currently operating on. - **Why is it used?** `this` is used to access and modify the properties of the current document. For example, in a Mongoose method, `this` allows you to refer to the fields of the specific document the method is called on. ### 2. Example: Let's use the `userSchema.pre("save", ...)`, which is a Mongoose middleware, as an example: ```javascript userSchema.pre("save", async function (next) { if (!this.isModified("password")) { next(); } else { this.password = await bcrypt.hash(this.password, 10); next(); } }); ``` - **Explanation in Simple Words:** - Imagine you have a system where users can sign up and set their password. - Before saving a new user to the database, you want to ensure that the password is securely encrypted (hashed) using a library like `bcrypt`. - The `userSchema.pre("save", ...)` is a special function that runs automatically before saving a user to the database. - In this function: - `this.isModified("password")`: Checks if the password field of the current user has been changed. - If the password is not modified, it means the user is not updating their password, so it just moves on to the next operation (saving the user). - If the password is modified, it means a new password is set or the existing one is changed. In this case, it uses `bcrypt.hash` to encrypt (hash) the password before saving it to the database. - The use of `this` here is crucial because it allows you to refer to the specific user document that's being saved. It ensures that the correct password is hashed for the current user being processed. In summary, `this` in Mongoose is a way to refer to the current document or instance, and it's commonly used to access and modify the properties of that document, especially in middleware functions like the one demonstrated here for password encryption before saving to the database.

    Tags

    Annotators

    URL

  3. Nov 2023
    1. ut certain groups like the poor, non-Europeans, and the physically and mentally disabled may lack the conditions to develop rationality.
    2. rationality in liberal theory and how it can create hierarchies

      no

    3. xcludes women from the political sphere and confines them to the private sphere.
    4. division between the private and political spheres in liberalism, arguing that it allows for hierarchies and domination to go unregulated.

      but the gender inequality isn't based upon property so could be changed without impacting the foundation of the theory

    5. property means that the interests of servants and other propertyless individuals may not be represented in the rules of the contract.

      no

  4. Aug 2023
  5. May 2023
  6. Mar 2023
  7. Aug 2022
  8. Mar 2018
    1. have been selectively bred

      There's a difference between selective breeding and altering via genetic engineering. I believe that genetic modification falls into the second category, always.