51 Matching Annotations
  1. Feb 2024
    1. One of my inquiries was for anecdotes regarding mistakes made between the twins by their near relatives. The replies are numerous, but not very varied in character. When the twins are children, they are usually distinguished by ribbons tied round the wrist or neck; nevertheless the one is sometimes fed, physicked, and whipped by mistake for the other, and the description of these little domestic catastrophes was usually given by the mother, in a phraseology that is some- [p. 158] what touching by reason of its seriousness.

  2. Jan 2024
    1. i want to now uh introduce the key concept in in whitehead's mature metaphysics concrescence

      for - key insight - concrescence - definition - concrescence - Whitehead - definition - The many become the one - Whitehead - definition - Res Potentia - Tim Eastman - definition - superject - Whitehead - definition - moment of satisfaction - Whitehead - definition - dipolar - Whitehead - definition - ingression - Whitehead definition - CONCRESCENCE - is the description of the phases of the iterative process by which reality advances from the past into the present then into the future - this definition is metaphysical and applies to all aspects of reality

      • Concrescence is the process by which

        • THE MANY BECOME THE ONE and
        • THE MANY ARE INCREASED BY ONE
          • The "many" here refers to the past
          • the perished objects in the past environment
      • There's another domain that whitehead makes reference to

        • He's a platonist in this sense, though he's a reformed platonist
        • He makes reference to this realm of eternal objects which for him are pure possibilities
        • i was mentioning Tim Eastman earlier
          • He calls this domain "RES POTENTIA", the realm of possibilities which have not yet been actualized
      • And so for Whitehead
        • the realm of possibility is infinite
        • the realm of actuality is finite
      • In the realm of actuality, there's a limited amount of certain types of experience which have been realized
        • but the realm of actuality draws upon this plenum of possibility and
        • it's because there is this plenum of possibility in relationship to the realm of actuality that
        • novelty is possible
        • new things can still happen we're not just constantly repeating the past
      • Whitehead describes the process of concrescence or each drop of experience as DIPOLAR, having two poles:

        • a physical pole and
        • a mental pole
      • Each concrescence or drop of experience begins with the physical pole

        • where the perished objects of the past environment are apprehended or felt and
        • these feelings of the past grow together into this newly emerging drop of experience
        • and then in the process of their growing together
          • the actualized perished objects of the past environment
          • are brought into comparison with eternal objects or pure potentials possibilities and
          • these possibilities INGRESS so there's
            • INGRESSION of eternal objects and
          • PREHENSION of past actualities
          • INGRESSION of potentials PREHENSIONS of past actualities
      • and what the ingression of eternal objects do is provide each occasion of experience, each concrescence with

        • the opportunity to interpret the past differently
      • to say maybe it's not like that maybe it's like this
      • and so these ingressions come into the mental pole
      • If the physical pole is what initiates the experience of each concrescing occasion

        • the mental pole is is a subsequent process that compares
          • what's been felt in the past with
          • what is possible alternatives that could be experienced that are not given yet in the past
      • The subjective form is how the occasion fills the past

      • The subjective aim is what draws the many feelings of the past towards the unification and the mental pole
        • where
          • the ingression of eternal objects and
          • the feelings of past actualities
        • are brought together into what Whitehead calls this MOMENT OF SATISFACTION
      • it's the culmination of the process of concrescence
        • where a new perspective on the universe is achieved - This is the many have become one
      • They are increased by one when the satisfaction is achieved
      • It's a new perspective on the whole
      • As soon as this new perspective is achieved
        • it becomes a SUPERJECT which is not a subject enjoying its own experience anymore
        • it's a perished subject
      • The superject is the achieved perspective that has been experienced
        • but then perishes itself int a superject-hood to become
        • one among the many that will be inherited by the next moment of experience, the next concrescence and
      • This superject has objective immortality in the sense that
        • every subsequent concrescence will inherit the satisfaction achieved by the prior concrescences
      • And so this is the most general account in Whitehead's view that we can offer

        • of the nature of reality
        • the nature of the passage of nature
        • the movement
          • out of the past
          • through the present and
          • into the future
      • Experience is always in the present and the satisfaction that is achieved by each moment of concrescence is enjoyed in the present

        • but as soon as we achieve that
        • it perishes and the next moment of concrescence arises to inherit what was achieved
        • and this is an iterative process
        • it's repeating constantly and it's cumulative
      • It's a process of growth
        • building on what's been achieved in the past
    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
      • for: BEing journey - adapt to, DH, Deep Humanity

      • comment

        • Potentiality coupled with limitations - Daseitz Suzuki and the elbow does not bend backwards.
        • The experience of the unnamable quality present in every moment - infinite potentiality
        • The mundane is the extraordinary. Even when we name it and discover it in all our scientific discoveries and articulate it, and mass produce technologies with it, is is still miraculous
      • adjacency

        • Nora Bateson's book Combining and the Douglas Rushkoff podcast interview
        • potentiality
      • adjacency statement
        • both are alluding to the pure potentiality latent in the moment
        • language can be contextualized as an unfolding of the space of potentiality to a specific trajectory. Each word added to the previous one to form a sentence is a choice in an infinite, abstract space of symbols that communicates intentionality and is designed to focus the attention of the listener to one very narrow aspect of the enormous field of infinite potentiality
    1. blah. this surveillance system is one big personality test.<br /> the problem is, they do not want a balance of all personality types or "natural order",<br /> but they do a one-sided selection by personality type.<br /> aka socialdarwinism, socialism, survival of the social, social credit score, civilization, high culture, progress, "made order", human laws, human rights, humanism, ...

  4. Oct 2023
  5. Sep 2023
    1. "Surrendering" by Ocean Vuong

      1. He moved into United State when he was age of five. He first came to United State when he started kindergarten. Seven of them live in the apartment one bedroom and bathroom to share the whole. He learned ABC song and alphabet. He knows the ABC that he forgot the letter is M comes before N.

      2. He went to the library since he was on the recess. He was in the library hiding from the bully. The bully just came in the library doing the slight frame and soft voice in front of the kid where he sit. He left the library, he walked to the middle of the schoolyard started calling him the pansy and fairy. He knows the American flag that he recognize on the microphone against the backdrop.

    1. Movies as portraying limited existence, but sometimes “signs” of consciousness

      • In my opinion, well made movies, show a lot of signs of consciousness. See, for example, LOTR, with the rhoririm charge where there is a collective consciousness forming, or the scene in which Shanks stops Akainu.
  6. Aug 2023
  7. Mar 2023
    1. We now take an opinionated stance on which second factor you should set up first – you'll no longer be asked to choose between SMS or setting up an authenticator app (known as TOTP), and instead see the TOTP setup screen immediately when first setting up 2FA.
  8. Nov 2022
    1. Doing everything PID 1 needs to do and nothing else. Things like reading environment files, changing users, process supervision are out of scope for Tini (there are other, better tools for those)
  9. Oct 2022
    1. The final lecture of the course considers Christianity as “the ever-adapting religion,” asking what elements remain constant within allits historical changes.

      Religions are ever-evolving ideas and practices, and like rivers, which are broadly similar and recognizable even over spans of time, can never be practiced or experienced the same way twice.

  10. Jul 2022
    1. We read different texts for different reasons, regardlessof the subject.

      A useful analogy here might be the idea of having a conversation with a text. Much the way you'd have dramatically different conversations with your family versus your friends, your teachers, or a stranger in line at the store, you'll approach each particular in a different way based on the various contexts in which both they exist and the contexts which you bring to them.

    1. Dogen is constantly and repeatedly trying to knock us off our intellectual center and interrupt our thinking.  He does not confirm any one solid view of so-called reality. He doesn’t want us to get stuck to one side or the other in the dynamic pivoting of life’s opposite. Do not cling to the absolute or the relative truth. They dynamically and mutually work with each other. Dogen would describe this interaction as “The Whole Works.”

      This is a nice way to describe this process...."repeatedly trying to knock us out of our intellectual center and interrupt our (one sided) thinking."

      We should observe this inherent property of our thinknig process, its one-sided nature.

  11. May 2022
    1. "I didn't fully understand it at the time, but throughout my time as a freshman at Boston College I've realized that I have the power to alter myself for the better and broaden my perspective on life. For most of my high school experience, I was holding to antiquated thoughts that had an impact on the majority of my daily interactions. Throughout my life, growing up as a single child has affected the way am in social interactions. This was evident in high school class discussions, as I did not yet have the confidence to be talkative and participate even up until the spring term of my senior year."

    2. "Specifically, when one of my classmates stated how he was struggling with the concept and another one of my classmates took the initiative to clarify it, I realized that that individual possibilities vary greatly among students."

  12. Apr 2022
    1. Every work of art can be read, according to Eco, in three distinct ways: the moral, the allegorical and the anagogical.

      Umberto Eco indicates that every work of art can be read in one of three ways: - moral, - allegorical - anagogical

      Compare this to early Christianities which had various different readings of the scriptures.

      Relate this also to the idea of Heraclitus and the not stepping into the same river twice as a viewer can view a work multiple times in different physical and personal contexts which will change their mood and interpretation of the work.

  13. Mar 2022
    1. Democratic processes take time. The goal of a legislation-writing genex is not necessarily to speed the process or increase the number of bills, but to engage a wider circle of stakeholders, support thoughtful deliberation, and improve the quality of the resulting legislation.

      What are the problems here in such a democratic process online or even in a modern context?

      People who aren't actually stakeholders feel that they're stakeholders and want to control other's actions even when they don't have a stake. (eg: abortion)

      People don't have time to become properly informed about the ever-increasing group of topics and there is too much disinformation and creation of fear, uncertainty and doubt.

      Thoughtful deliberation does not happen.

      The quality of legislation has dropped instead of increased.

      Bikeshedding is too easy.

      What if instead of electing people who run, we elected people from the electorate at random? This would potentially at least nudge us to have some representation by "one of the least of these". This would provide us to pay more attention to a broader swath of society instead of the richest and most powerful. What might the long term effects of this be?

  14. Nov 2021
    1. After Alexi McCammond was named editor in chief of Teen Vogue, people discovered and recirculated on Instagram old anti-Asian and homophobic tweets she had written a decade earlier, while still a teenager.

      Should people be judged by statements made in their youth or decades prior? Shouldn't they be given some credit for changing over time and becoming better?

      How can we as a society provide credit to people's changed contexts over time?

      This can be related to Heraclitus' river.

    2. You would think it would be a good thing for the young readers of Teen Vogue to learn forgiveness and mercy, but for the New Puritans, there is no statute of limitations.
  15. Oct 2021
  16. Sep 2021
    1. Update API usage of the view helpers by changing javascript_packs_with_chunks_tag and stylesheet_packs_with_chunks_tag to javascript_pack_tag and stylesheet_pack_tag. Ensure that your layouts and views will only have at most one call to javascript_pack_tag or stylesheet_pack_tag. You can now pass multiple bundles to these view helper methods.

      Good move. Rather than having 2 different methods, and requiring people to "go out of their way" to "opt in" to using chunks by using the longer-named javascript_packs_with_chunks_tag, they changed it to just use chunks by default, out of the box.

      Now they don't need 2 similar but separate methods that do nearly the same, which makes things simpler and easier to understand (no longer have to stop and ask oneself, which one should I use? what's the difference?).

      You can't get it "wrong" now because there's only one option.

      And by switching that method to use the shorter name, it makes it clearer that that is the usual/common/recommended way to go.

  17. Aug 2021
  18. Jun 2021
  19. Apr 2021
    1. Of course you must not use plain-text passwords and place them directly into scripts. You even must not use telnet protocol at all. And avoid ftp, too. I needn’t say why you should use ssh, instead, need I? And you also must not plug your fingers into 220 voltage AC-output. Telnet was chosen for examples as less harmless alternative, because it’s getting rare in real life, but it can show all basic functions of expect-like tools, even abilities to send passwords. BUT, you can use “Expect and Co” to do other things, I just show the direction.
  20. Mar 2021
    1. That said, I wish more people would talk both sides. Yes, every dependency has a cost. BUT the alternatives aren't cost free either. For all the ranting against micropackages, I'm not seeing a good pro/con discussion.
  21. Feb 2021
    1. For branching out a separate path in an activity, use the Path() macro. It’s a convenient, simple way to declare alternative routes

      Seems like this would be a very common need: once you switch to a custom failure track, you want it to stay on that track until the end!!!

      The problem is that in a Railway, everything automatically has 2 outputs. But we really only need one (which is exactly what Path gives us). And you end up fighting the defaults when there are the automatic 2 outputs, because you have to remember to explicitly/verbosely redirect all of those outputs or they may end up going somewhere you don't want them to go.

      The default behavior of everything going to the next defined step is not helpful for doing that, and in fact is quite frustrating because you don't want unrelated steps to accidentally end up on one of the tasks in your custom failure track.

      And you can't use fail for custom-track steps becase that breaks magnetic_to for some reason.

      I was finding myself very in need of something like this, and was about to write my own DSL, but then I discovered this. I still think it needs a better DSL than this, but at least they provided a way to do this. Much needed.

      For this example, I might write something like this:

      step :decide_type, Output(Activity::Left, :credit_card) => Track(:with_credit_card)
      
      # Create the track, which would automatically create an implicit End with the same id.
      Track(:with_credit_card) do
          step :authorize
          step :charge
      end
      

      I guess that's not much different than theirs. Main improvement is it avoids ugly need to specify end_id/end_task.

      But that wouldn't actually be enough either in this example, because you would actually want to have a failure track there and a path doesn't have one ... so it sounds like Subprocess and a new self-contained ProcessCreditCard Railway would be the best solution for this particular example... Subprocess is the ultimate in flexibility and gives us all the flexibility we need)


      But what if you had a path that you needed to direct to from 2 different tasks' outputs?

      Example: I came up with this, but it takes a lot of effort to keep my custom path/track hidden/"isolated" and prevent other tasks from automatically/implicitly going into those steps:

      class Example::ValidationErrorTrack < Trailblazer::Activity::Railway
        step :validate_model, Output(:failure) => Track(:validation_error)
        step :save,           Output(:failure) => Track(:validation_error)
      
        # Can't use fail here or the magnetic_to won't work and  Track(:validation_error) won't work
        step :log_validation_error, magnetic_to: :validation_error,
          Output(:success) => End(:validation_error), 
          Output(:failure) => End(:validation_error) 
      end
      
      puts Trailblazer::Developer.render o
      Reloading...
      
      #<Start/:default>
       {Trailblazer::Activity::Right} => #<Trailblazer::Activity::TaskBuilder::Task user_proc=validate_model>
      #<Trailblazer::Activity::TaskBuilder::Task user_proc=validate_model>
       {Trailblazer::Activity::Left} => #<Trailblazer::Activity::TaskBuilder::Task user_proc=log_validation_error>
       {Trailblazer::Activity::Right} => #<Trailblazer::Activity::TaskBuilder::Task user_proc=save>
      #<Trailblazer::Activity::TaskBuilder::Task user_proc=save>
       {Trailblazer::Activity::Left} => #<Trailblazer::Activity::TaskBuilder::Task user_proc=log_validation_error>
       {Trailblazer::Activity::Right} => #<End/:success>
      #<Trailblazer::Activity::TaskBuilder::Task user_proc=log_validation_error>
       {Trailblazer::Activity::Left} => #<End/:validation_error>
       {Trailblazer::Activity::Right} => #<End/:validation_error>
      #<End/:success>
      
      #<End/:validation_error>
      
      #<End/:failure>
      

      Now attempt to do it with Path... Does the Path() have an ID we can reference? Or maybe we just keep a reference to the object and use it directly in 2 different places?

      class Example::ValidationErrorTrack::VPathHelper1 < Trailblazer::Activity::Railway
         validation_error_path = Path(end_id: "End.validation_error", end_task: End(:validation_error)) do
          step :log_validation_error
        end
        step :validate_model, Output(:failure) => validation_error_path
        step :save,           Output(:failure) => validation_error_path
      end
      
      o=Example::ValidationErrorTrack::VPathHelper1; puts Trailblazer::Developer.render o
      Reloading...
      
      #<Start/:default>
       {Trailblazer::Activity::Right} => #<Trailblazer::Activity::TaskBuilder::Task user_proc=validate_model>
      #<Trailblazer::Activity::TaskBuilder::Task user_proc=validate_model>
       {Trailblazer::Activity::Left} => #<Trailblazer::Activity::TaskBuilder::Task user_proc=log_validation_error>
       {Trailblazer::Activity::Right} => #<Trailblazer::Activity::TaskBuilder::Task user_proc=save>
      #<Trailblazer::Activity::TaskBuilder::Task user_proc=log_validation_error>
       {Trailblazer::Activity::Right} => #<End/:validation_error>
      #<Trailblazer::Activity::TaskBuilder::Task user_proc=save>
       {Trailblazer::Activity::Left} => #<Trailblazer::Activity::TaskBuilder::Task user_proc=log_validation_error>
       {Trailblazer::Activity::Right} => #<End/:success>
      #<End/:success>
      
      #<End/:validation_error>
      
      #<End/:failure>
      

      It's just too bad that:

      • there's not a Railway helper in case you want multiple outputs, though we could probably create one pretty easily using Path as our template
      • we can't "inline" a separate Railway acitivity (Subprocess "nests" it rather than "inlines")
    2. step :direct_debit

      I don't think we would/should really want to make this the "success" (Right) path and :credit_card be the "failure" (Left) track.

      Maybe it's okay to repurpose Left and Right for something other than failure/success ... but only if we can actually change the default semantic of those signals/outputs. Is that possible? Maybe there's a way to override or delete the default outputs?

    1. Although one thing you want to avoid is using frames in such a manner that the content of the site is in the frame and a menu is outside of the frame. Although this may seem convienient, all of your pages become unbookmarkable.
    1. Iframes can have similar issues as frames and inconsiderate use of XMLHttpRequest: They break the one-document-per-URL paradigm, which is essential for the proper functioning of the web (think bookmarks, deep-links, search engines, ...).
    2. The most striking such issue is probably that of deep linking: It's true that iframes suffer from this to a lesser extent than frames, but if you allow your users to navigate between different pages in the iframe, it will be a problem.
  22. Jan 2021
  23. Dec 2020
  24. Sep 2020
    1. Svelte will not offer a generic way to support style customizing via contextual class overrides (as we'd do it in plain HTML). Instead we'll invent something new that is entirely different. If a child component is provided and does not anticipate some contextual usage scenario (style wise) you'd need to copy it or hack around that via :global hacks.
    1. They might even hate each other; the creature who already lived loathed his own deformity, and might he not conceive a greater abhorrence for it when it came before his eyes in the female form? She also might turn with disgust from him to the superior beauty of man; she might quit him, and he be again alone, exasperated by the fresh provocation of being deserted by one of his own species.

      A lot of misogyny is radiating from these lines. Victor is implying that his female creation might be so ugly that even his male creation will be offended by her existence one he sees her. But on the other hand, what if his creation isn't her type and just abandon's him? It's interesting to see how much thought Victor puts in when it comes to making a female creation...I thought he was trying to create a new species?

  25. Feb 2019
  26. Oct 2018
  27. Sep 2018
  28. Aug 2016
    1. VISITS

      I'm not sure exactly where this would fit in, but some way to reporting total service hours (per week or other time period) would be useful, esp as we start gauging traffic, volume, usage against number of service hours. In our reporting for the Univ of California, we have to report on services hours for all public service points.

      Likewise, it may be helpful to have a standard way to report staffing levels re: coverage of public service points? or in department? or who work on public services?

  29. Mar 2015
    1. an objective set for the Sprint that can be met through the implementation of Product Backlog. It provides guidance to the Development Team on why it is building the Increment. It is created during the Sprint Planning meeting. The Sprint Goal gives the Development Team some flexibility regarding the functionality implemented within the Sprint. The selected Product Backlog items deliver one coherent function, which can be the Sprint Goal. The Sprint Goal can be any other coherence that causes the Development Team to work together rather than on separate initiatives.

      an objective set for the Sprint that can be met through the implementation of Product Backlog. It provides guidance to the Development Team on why it is building the Increment. It is created during the Sprint Planning meeting. The Sprint Goal gives the Development Team some flexibility regarding the functionality implemented within the Sprint. The selected Product Backlog items deliver one coherent function, which can be the Sprint Goal. The Sprint Goal can be any other coherence that causes the Development Team to work together rather than on separate initiatives.