14 Matching Annotations
  1. 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

  2. Dec 2023
      • for: futures - neo-Venetian crypto-networks, Global Chinese Commons, GCC, cosmolocal, coordiNation, somewheres, everywheres, nowheres, Global System One, Global System Two, Global System Three, contributory accounting, fourth sector, protocol cooperative, mutual coordination economics

      • summary

      • learned something new
        • I learned a number of new ideas from reading Michel's article. He gives a brief meta-history of our political-socio-economic system, using Peter Pogany's framework of Global System One, Two and Three and within this argues for why a marriage of blockchain systems and cosmolocal production systems could create a "fourth sector" for the transition to Global System Three.
        • He cites evidence of existing trends already pointing in this direction, drawing from his research in P2P Foundation
    1. Global System One
      • for: definition - Global System One
  3. Apr 2023
    1. You should only write on the front side of the paper slips, so it is possible to read the note during searches without the need to take it out.

      Luhmann mentions that he only wrote on one side so that he didn't need to physically remove notes from the box when searching it. There is a level of lost productivity if one needs to physically remove a card to read it and then replace it; this lost productivity is magnified if one uses their slip box regularly over the span of many years.

  4. Mar 2023
  5. Nov 2022
    1. Our familiarity with these elements makes the overall story seem plausible, even—or perhaps especially—when facts and evidence are in short supply.

      Storytelling tropes play into our system one heuristics and cognitive biases by riding on the tailcoats of familiar story plotlines we've come to know and trust.

      What are the ways out of this trap? Creating lists of tropes which should trigger our system one reactions to switch into system two thinking patterns? Can we train ourselves away from these types of misinformation?

  6. Sep 2022
    1. https://web.archive.org/web/20120122115952/http://pileofindexcards.org/blog/2006/10/13/one-pocket-rule/

      Noguchi Yukio had a "one pocket rule" which they first described in “「超」整理法 (cho seiri ho)”. The broad idea was to store everything in one place as a means of saving time by not needing to search in multiple repositories for the thing you were hunting for. Despite this advice the Noguchi Filing System didn't take complete advantage of this as one would likely have both a "home" and an "office" system, thus creating two pockets, a problem that exists in an analog world, but which can be mitigated in a digital one.

      The one pocket rule can be seen in the IndieWeb principles of owning all your own data on your own website and syndicating out from there. Your single website has the entire store of all your material which makes search much easier. You don't need to recall which platform (Twitter, Facebook, Instagram, et al.) you posted something on, you can save time and find the thing much more quickly by searching one place.


      This principle also applies to zettelkasten and commonplace books (well indexed), which allow you to find the data or information you put into them quickly and easily.

  7. Jun 2022
    1. If you ignore that inner voice of intuition, over time it will slowlyquiet down and fade away. If you practice listening to what it is tellingyou, the inner voice will grow stronger. You’ll start to hear it in allkinds of situations. It will guide you in what choices to make andwhich opportunities to pursue. It will warn you away from people andsituations that aren’t right for you. It will speak up and take a standfor your convictions even when you’re afraid.I can’t think of anything more important for your creative life—andyour life in general—than learning to listen to the voice of intuitioninside. It is the source of your imagination, your confidence, and yourspontaneity

      While we have evolved a psychological apparatus that often gives us good "gut feelings" (an actual physical "second brain"), we should listen careful to them, but we should also learn to think about, analyze, and verify these feelings so we don't fall prey to potential cognitive biases.

  8. May 2022
    1. This came in the context of weighing what she stood to gain and lose in leaving a staff job at BuzzFeed. She knew the worth of what editors, fact-checkers, designers, and other colleagues brought to a piece of writing. At the same time, she was tired of working around the “imperatives of social media sharing.” Clarity and concision are not metrics imposed by the Facebook algorithm, of course — but perhaps such concerns lose some of their urgency when readers have already pledged their support.

      Continuing with the idea above about the shift of Sunday morning talk shows and the influence of Hard Copy, is social media exerting a negative influence on mainstream content and conversation as a result of their algorithmic gut reaction pressure? How can we fight this effect?

  9. Mar 2022
  10. Sep 2020
  11. May 2020
  12. Oct 2018