206 Matching Annotations
  1. Last 7 days
  2. Mar 2024
  3. Feb 2024
    1. american mathematician alfred bartlett 00:01:12 in his long teaching career repeatedly said the greatest weakness of the human race is its inability to understand the exponential function

      for - quote - Alfred Bartlett - exponential function

      quote - Alfred Bartlett - The greatest weakness of the human race is its inability to understand the exponential function

  4. Jan 2024
    1. So organized, initiatives can collectively co-evolve and co-emerge into a purposeful transformation system oriented towards whole system change

      for - quote - whole system change - bottom up whole system change - open function SRG/ Deep Humanity/ Indyweb / Indranet / TPF framework - definition - transformation catalyst

      quote - (see below) - A transformation catalyst is an actor who - brings together numerous initiatives and actors around a shared and co-defined set of interests - with an action agenda in mind. - The TC stewards these actors through a set of three general (dialogue- and action-based) processes that can be adapted - to the unique context, needs, and interests - of each system and its players. - So organized, initiatives can collectively co-evolve and co-emerge - into a purposeful transformation system - oriented towards whole system change in a given context (which could happen - locally, - regionally, - bioregionally, or even more broadly - depending on the actors and orientations involved

    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

  5. Dec 2023
    1. Measure Execution Time With time.thread_time()

      The time.thread_time() reports the time that the current thread has been executing.

      The time begins or is zero when the current thread is first created.

      Return the value (in fractional seconds) of the sum of the system and user CPU time of the current thread.

      It is an equivalent value to the time.process_time(), except calculated at the scope of the current thread, not the current process.

      This value is calculated as the sum of the system time and the user time.

      thread time = user time + system time

      The reported time does not include sleep time.

      This means if the thread is blocked by a call to time.sleep() or perhaps is suspended by the operating system, then this time is not included in the reported time. This is called a “thread-wide” or “thread-specific” time.

    2. Measure Execution Time With time.process_time()

      The time.process_time() reports the time that the current process has been executed.

      The time begins or is zero when the current process is first created.

      Calculated as the sum of the system time and the user time:

      process time = user time + system time

      System time is time that the CPU is spent executing system calls for the kernel (e.g. the operating system)

      User time is time spent by the CPU executing calls in the program (e.g. your code).

      When a program loops through an array, it is accumulating user CPU time. Conversely, when a program executes a system call such as exec or fork, it is accumulating system CPU time.

      The reported time does not include sleep time.

      This means if the process is blocked by a call to time.sleep() or perhaps is suspended by the operating system, then this time is not included in the reported time. This is called a “process-wide” time.

      As such, it only reports the time that the current process was executed since it was created by the operating system.

    3. Measure Execution Time With time.perf_counter()

      The time.perf_counter() function reports the value of a performance counter on the system.

      It does not report the time since epoch like time.time().

      Return the value (in fractional seconds) of a performance counter, i.e. a clock with the highest available resolution to measure a short duration. It does include time elapsed during sleep and is system-wide.

      The returned value in seconds with fractional components (e.g. milliseconds and nanoseconds), provides a high-resolution timestamp.

      Calculating the difference between two timestamps from the time.perf_counter() allows high-resolution execution time benchmarking, e.g. in the millisecond and nanosecond range.

      The timestamp from the time.perf_counter() function is consistent, meaning that two durations can be compared relative to each other in a meaningful way.

      The time.perf_counter() function was introduced in Python version 3.3 with the intended use for short-duration benchmarking.

      The perf_counter() function was specifically designed to overcome the limitations of other time functions to ensure that the result is consistent across platforms and monotonic (always increasing).

      For accuracy, the timeit module uses the time.perf_counter() internally.

    4. Measure Execution Time With time.time()

      The time.time() function reports the number of seconds since the epoch (epoch is January 1st 1970, which is used on Unix systems and beyond as an arbitrary fixed time in the past) as a floating point number.

      The result is a floating point value, potentially offering fractions of a seconds (e.g. milliseconds), if the platforms support it.

      The time.time() function is not perfect.

      It is possible for a subsequent call to time.time() to return a value in seconds less than the previous value, due to rounding.

      Note: even though the time is always returned as a floating point number, not all systems provide time with a better precision than 1 second. While this function normally returns non-decreasing values, it can return a lower value than a previous call if the system clock has been set back between the two calls.

    1. because the value isn't there yet. A promise is just a marker that it will be available at some point in the future. You cannot convert asynchronous code to synchronous, though. If you order a pizza, you get a receipt that tells you that you will have a pizza at some point in the future. You cannot treat that receipt as the pizza itself, though. When you get your number called you can "resolve" that receipt to a pizza. But what you're describing is trying to eat the receipt.
  6. Nov 2023
    1. Grabe, Mark. “Student and Professional Note-Taking.” Substack newsletter. Mark’s Substack (blog), November 10, 2023. https://markgrabe.substack.com/p/student-and-professional-note-taking?publication_id=1857743&utm_campaign=email-post-title&r=77i35.

      Educator Mark Grabe looks at some different forms of note taking with respect to learning compared lightly with note taking for productivity or knowledge management purposes.

      Note taking for: - learning / sensemaking - personal knowledge management - productivity / projects - thesis creation/writing/other creative output (music, dance, etc.)

      Not taken into account here is the diversity of cognitive abilities, extent of practice (those who've practiced at note taking for longer are likely to be better at it), or even neurodiversity, which becomes an additional layer (potentially noise) on top of the research methodologies.

  7. Sep 2023
    1. I don't know why I can't do Evergreen and Atomic Notes.. .t3_16r8k0b._2FCtq-QzlfuN-SwVMUZMM3 { --postTitle-VisitedLinkColor: #9b9b9b; --postTitleLink-VisitedLinkColor: #9b9b9b; --postBodyLink-VisitedLinkColor: #989898; }

      reply to u/SouthernEremite at https://www.reddit.com/r/Zettelkasten/comments/16r8k0b/i_dont_know_why_i_cant_do_evergreen_and_atomic/

      If you're not using your notes to create or write material and only using them as a form of sensemaking, then perhaps you don't need to put as much work or effort into the permanent notes portion of the work? Ask yourself: "Why are you taking notes? What purpose do they serve?" Is the form and level you're making them in serving those purposes? If not, work toward practicing to make those two align so that your notes are serving an actual purpose for you. Anything beyond this is make-work and you could spend your time more profitably somewhere else.

    1. def self.make_lazy(*methods) methods.each do |method| define_method method do |*args, &block| lazy.public_send(method, *args, &block) end end end
  8. Jun 2023
    1. The function symbol notation is the least used notational system in jazz. As the namesuggests, this notation specifies the harmonic function of individual chords and evencomplete chord progressions. It has the potential of being useful to notate specificbehaviors of chords that may not—at least, not on the surface level—indicate that theybelong to a particular functional family of chords. As such, function symbols enable theperception of harmonic progressions from a more structural perspective. Function symbolsindicate neither the architecture nor the specific scale degrees of chords. This style ofnotation is more conceptual than it is representative of a specific surface event. The termssurface level and structural level are used to describe musical events and the degree oftheir importance. “Structural” events occur beneath the musical “surface” and areresponsible for the overall tonal, harmonic, and melodic forces controlling the piece.Function symbols use three labels: T for tonic-type chords, PD for predominant-typechords, and D for dominant-type chords.
    2. harmonic functioncan be defined as a contextual feature that can be attributed to a chord, a family of chords,harmonic progressions, or even to complete melodic phrases. These features are uniquefor each of the following functions: the tonic, the predominant, and the dominant. Theinteraction between these three creates a system of functional tonality, which undergirdsthe structure of tonal jazz and common-practice music
    3. Chapter 3 defines harmonic function
  9. Apr 2023
    1. Daniel Schmachtenberger has spoken at length about the ‘generator functions’ of existential risk, in essence the deeper driving causes.

      Definition - generator function of existential risk - the deeper driving cause of existential risk - two examples of deep causes - rivalrous dynamics - complicated systems consuming their complex substrate

      Claim - Alexander Beiner claims that - the generator function of these generator functions is physicalism

  10. Mar 2023
  11. Dec 2022
    1. His note taking technique has a high distraction potential and is time consuming.

      highlight from https://www.reddit.com/user/ManuelRodriguez331/ <br /> https://www.reddit.com/r/Zettelkasten/comments/zigwo3

      Anecdotal evidence of how some might view zettelkasten note-taking practices, particularly when they have no end goal or needs in mind.

      Form follows function

      /comment/izs0u3b/?utm_source=reddit&utm_medium=web2x&context=3

  12. Nov 2022
    1. phytoncides, antibacterial and antimicrobial substances that trees and other plants release into the air to help them fight diseases and harmful organisms. When humans breathe in these substances—typically by spending time in nature—their health can improve. Across several studies, phytoncides have been shown to boost immune function, increase anticancer protein production, reduce stress hormones, improve mood, and help people relax. 

      I always feel better during and after a forest walk.

  13. Sep 2022
    1. IntertextsAs Jonathan Culler writes: “Liter-ary works are not to be consideredautonomous entities, ‘organicwholes,’ but as intertextual con-structs: sequences which havemeaning in relation to other textswhich they take up, cite, parody,refute, or generally transform.” ThePursuit of Signs (Ithaca, NY: CornelUniversity Press, 1981), 38.

      Throughout Rewriting: How To Do Things With Texts (Utah State University Press, 2006) Joseph Harris presents highlighted sidebar presentations he labels "Intertexts".

      They simultaneously serve the functions of footnotes, references, (pseudo-)pull quotes, and conversation with his own text. It's not frequently seen this way, but these intertexts serve the function of presenting his annotations of his own text to model these sorts of annotations and intertextuality which he hopes the reader (student) to be able to perform themselves. He explicitly places them in a visually forward position within the text rather than hiding them in the pages' footnotes or end notes where the audience he is addressing can't possibly miss them. In fact, the reader will be drawn to them above other parts of the text when doing a cursory flip through the book upon picking it up, a fact that underlines their importance in his book's thesis.


      This really is a fantastic example of the marriage of form and function as well as modelling behavior.


      cc: @remikalir

  14. Aug 2022
    1. 不得不说集成 SpringCloud Function 之后,消息的发送和接收又迈进了一个崭新的阶段,但 <functionName> + -in- + <index> 这样的配置规约我觉得让我有些难受......甚至目前我认为 3.1 之前被废弃的注解方式也许更适合我们开发使用

      新趋势

  15. Jul 2022
    1. randomFormat starts with a lowercase letter, making it accessible only to code in its own package (in other words, it's not exported).

      function name starts with a lowercase

    1. Any Go function can return multiple values. For more, see Effective Go.

      function can return multiple values.

      func Hello(name string) (string, error) { return name, nil }

  16. Jun 2022
    1. <?php$base = array("orange", "banana", "apple", "raspberry");$replacements = array(0 => "pineapple", 4 => "cherry");$replacements2 = array(0 => "grape");$basket = array_replace($base, $replacements, $replacements2);print_r($basket);?> The above example will output: Array ( [0] => grape [1] => banana [2] => apple [3] => raspberry [4] => cherry )

      array_replace() replaces the values of array with values having the same keys in each of the following arrays.

  17. May 2022
  18. www-ncbi-nlm-nih-gov.proxy-bloomu.klnpa.org www-ncbi-nlm-nih-gov.proxy-bloomu.klnpa.org
    1. disrupts the biogenesis and processing of miRNAs with subsequent disruption in control of gene

      effects miRNA

    1. DICER1 variants cause a hereditary cancer predisposition

      -Gene: DICER1 -PMID: 29343557 -Inheritance Pattern: DICER1 is inherited as an autosomal dominant condition with decreased penetrance -Disease Entity: earlier onset disease, multisite disease, 0-2 site disease, cystic lung disease, familial disease, bilateral disease, stage IA/IB, bilateral disease -mutation: germline loss-of-function mutation, missense mutation, Intronic mutations, hotspot mutation, second somatic mutation, truncating mutations, biallelic mutation -zygosity: heterozygosity -Family History: -testing should be considered for those with a family history of DICER1-associated conditions so that appropriate surveillance can be undertaken. -Individuals at 50% risk of a germline pathogenic variant based on family history who do not pursue genetic testing should follow surveillance guidelines as -if they have a DICER1 mutation unless/until genetic testing confirms that they did not inherit the familial mutation When a pulmonary cyst is identified in a young child with a pathogenic germline -DICER1 variant or family history of a DICER1-associated condition, it should be assumed to be Type I PPB until proven otherwise

      Other Information: -Case: Risk for most DICER1-associated neoplasms is highest in early childhood and decreases in adulthood -affected phenotype may simply result from probabilities of generating the characteristic “loss-of-function plus hotspot” two hit typical of a DICER1 syndrome neoplasm. -Caseprevioustesting: presymptomatic testing of a minor child, should be discussed and factored into the decision process, as some individuals may choose, and have the right to choose, not to know their/their child’s genetic status. -gnomAD: n/a

  19. Apr 2022
    1. All of the major books that were to follow – Sade /Fourier / Loyola (1997), The Pleasure of the Text (1975), RolandBarthes by Roland Barthes (1977), A Lover’s Discourse (1990), andCamera Lucida (1993) – are texts that are ‘plural’ and ‘broken’, andwhich are ‘constructed from non-totalizable fragments and fromexuberantly proliferating “details”’ (Bensmaïa, 1987: xxvii-xxxviii).In all of the above cases the fragment becomes the key unit ofcomposition, with each text structured around the arrangement ofmultiple (but non-totalisable) textual fragments.

      Does the fact that Barthes uses a card index in his composition and organization influence the overall theme of his final works which could be described as "non-totalizable fragments"?

  20. Mar 2022
    1. he basic function of an anaesthesia machine is to prepare a gas mixture of precisely known, but variable composition. The gas mixture can then be delivered to a breathing system.
  21. Feb 2022
  22. Jan 2022
    1. My gut told me calling an async function from the setTimeout callback was a bad thing. Since the setTimeout machinery ignores the return value of the function, there is no way it was awaiting on it. This means that there will be an unhandled promise. An unhandled promise could mean problems if the function called in the callback takes a long time to complete or throws an error.
    1. const originalUnhandledRejection = window.onunhandledrejection; window.onunhandledrejection = (e) => { console.log('we got exception, but the app has crashed', e); // or do Sentry.captureException(e); originalUnhandledRejection(e); }
  23. www.npmjs.com www.npmjs.com
    1. co(function* () {  var result = yield Promise.resolve(true);  return result;}).then(function (value) {  console.log(value);}, function (err) {  console.error(err.stack);});
  24. Nov 2021
  25. Oct 2021
    1. const fetchWithJSONHeaders = applyDefaults(fetch, { headers: { "Content-Type": "application/json" } }); const fetchWithTextHeaders = applyDefaults(fetch, { headers: { "Content-Type": "application/text" } }); // Fetch JSON content const response = await fetchWithJSONHeaders("/users", { method: "GET" });
    1. But there is a lot of things we didn’t handle: How do we pass function arguments through? How do we maintain scope (the value of this)? How do we get the return value? What if an error happens?
    1. A wrapper function is a design concept where a very minimal function is using another function to do it's "work" for it, sometimes using a slightly different set of arguments.
  26. Jul 2021
    1. Keerthivasan, S., Şenbabaoğlu, Y., Martinez-Martin, N., Husain, B., Verschueren, E., Wong, A., Yang, Y. A., Sun, Y., Pham, V., Hinkle, T., Oei, Y., Madireddi, S., Corpuz, R., Tam, L., Carlisle, S., Roose-Girma, M., Modrusan, Z., Ye, Z., Koerber, J. T., & Turley, S. J. (2021). Homeostatic functions of monocytes and interstitial lung macrophages are regulated via collagen domain-binding receptor LAIR1. Immunity, 54(7), 1511-1526.e8. https://doi.org/10.1016/j.immuni.2021.06.012

  27. Jun 2021
    1. The problem is, algorithms were never designed to handle such tough choices. They are built to pursue a single mathematical goal, such as maximizing the number of soldiers’ lives saved or minimizing the number of civilian deaths. When you start dealing with multiple, often competing, objectives or try to account for intangibles like “freedom” and “well-being,” a satisfactory mathematical solution doesn’t always exist.

      We do better with algorithms where the utility function can be expressed mathematically. When we try to design for utility/goals that include human values, it's much more difficult.

    1. json_array_elements_text ( json ) → setof text jsonb_array_elements_text ( jsonb ) → setof text Expands the top-level JSON array into a set of text values. select * from json_array_elements_text('["foo", "bar"]') → value ----------- foo bar
    1. graphqlSync is a relatively recent addition to GraphQL.js that lets you execute a query that you know is going to return synchronously and get the result right away, rather than getting a promise. Since we know that introspection won’t require calling any asynchronous resources, we can safely use it here.
  28. May 2021
    1. This function runs on every request, for both pages and endpoints, and determines the response. It receives the request object and a function called resolve, which invokes SvelteKit's router and generates a response accordingly.
  29. Apr 2021
    1. The role of the terminal emulator process is:

      Shows the relationship between a "terminal emulator" and a pseudoterminal, as alluded to in the intro:

      is a pair of pseudo-devices, one of which, the slave, emulates a hardware text terminal device, the other of which, the master, provides the means by which a terminal emulator process controls the slave.

    1. Other physicists and mathematicians at the turn of the century came close to arriving at what is currently known as spacetime. Einstein himself noted, that with so many people unraveling separate pieces of the puzzle, "the special theory of relativity, if we regard its development in retrospect, was ripe for discovery in 1905."

      Interesting. This acts as evidence for the hypothesis that environments/conditions are powerful forcing functions.

      It also acts as evidence against the argument of the "lone genius".

  30. Mar 2021
    1. Or if you need to change the way the string is assembled, you can provide a proc, for example: if defined?(BetterErrors) BetterErrors.editor = proc { |file, line| "vscode://file/%{file}:%{line}" % { file: URI.encode_www_form_component(file), line: line } } end
    1. Suppose that the validate task was getting quite complex and bloated. When writing “normal” Ruby, you’d break up one method into several. In Trailblazer, that’s when you introduce a new, smaller activity.
  31. Feb 2021
    1. Though rarer in computer science, one can use category theory directly, which defines a monad as a functor with two additional natural transformations. So to begin, a structure requires a higher-order function (or "functional") named map to qualify as a functor:

      rare in computer science using category theory directly in computer science What other areas of math can be used / are rare to use directly in computer science?

    1. # Set the model name to change the field names generated by the Rails form helpers def self.model_name=(name) @_model_name = ActiveModel::Name.new(self, nil, name) end
    1. The central ideas of this design pattern closely mirror the semantics of first-class functions and higher-order functions in functional programming languages. Specifically, the invoker object is a higher-order function of which the command object is a first-class argument.
    1. def self.attribute(name, type = ActiveModel::Type::Value.new, **options) super attribute_type = attribute_types[name.to_s] # Add the ? method for boolean attributes alias_boolean(name) if attribute_type.is_a?(ActiveModel::Type::Boolean) # store date attribute names so we can merge the params during # initialization date_attributes << name if attribute_type.class.in?(DATE_TYPES) end
  32. Jan 2021
    1. While custom iterators are a useful tool, their creation requires careful programming due to the need to explicitly maintain their internal state. Generator functions provide a powerful alternative: they allow you to define an iterative algorithm by writing a single function whose execution is not continuous. Generator functions are written using the function* syntax.
  33. Dec 2020
    1. Remember that async functions always return promises. This promise rejects if any uncaught error occurs in the function. If your async function body returns a promise that rejects, the returned promise will reject too.
  34. Nov 2020
    1. // DO NOT INLINE this variable. For backward compatibility, foundations take a Partial<MDCFooAdapter>. // To ensure we don't accidentally omit any methods, we need a separate, strongly typed adapter variable.

      I wish I understood what they meant and why this is necessary

    1. proteases

      Is a group of enzymes whose catalytic function is hydrolyzing peptide bonds of proteins. Also referred to as proteolytic enzymes or even proteinases.

    1. Frontend frameworks are a positive sum game! Svelte has no monopoly on the compiler paradigm either. Just like I think React is worth learning for the mental model it imparts, where UI is a (pure) function of state, I think the frontend framework-as-compiler paradigm is worth understanding. We're going to see a lot more of it because the tradeoffs are fantastic, to where it'll be a boring talking point before we know it.
    1. διαδικασία Definition from Wiktionary, the free dictionary Jump to navigation Jump to search Greek

      Greek Noun

      διαδικασία • (diadikasía) f (plural διαδικασίες)

      1. procedure, process, method, protocol
      2. (computing) function, subroutine, procedure
  35. Oct 2020
    1. Final Form makes the assumption that your validation functions are "pure" or "idempotent", i.e. will always return the same result when given the same values. This is why it doesn't run the synchronous validation again (just to double check) before allowing the submission: because it's already stored the results of the last time it ran it.
    1. Another example:

      const expensiveOperation = async (value) => {
        // return Promise.resolve(value)
          // console.log('value:', value)
          await sleep(1000)
          console.log('expensiveOperation: value:', value, 'finished')
          return value
      }
      
      var expensiveOperationDebounce = debounce(expensiveOperation, 100);
      
      // for (let num of [1, 2]) {
      //   expensiveOperationDebounce(num).then(value => {
      //     console.log(value)
      //   })
      // }
      (async () => { await sleep(0   ); console.log(await expensiveOperationDebounce(1)) })();
      (async () => { await sleep(200 ); console.log(await expensiveOperationDebounce(2)) })();
      (async () => { await sleep(1300); console.log(await expensiveOperationDebounce(3)) })();
      // setTimeout(async () => {
      //   console.log(await expensiveOperationDebounce(3))
      // }, 1300)
      

      Outputs: 1, 2, 3

      Why, if I change it to:

      (async () => { await sleep(0   ); console.log(await expensiveOperationDebounce(1)) })();
      (async () => { await sleep(200 ); console.log(await expensiveOperationDebounce(2)) })();
      (async () => { await sleep(1100); console.log(await expensiveOperationDebounce(3)) })();
      

      Does it only output 2, 3?

    1. Methods have fixed arities to support auto-currying.
    2. // `lodash/padStart` accepts an optional `chars` param. _.padStart('a', 3, '-') // ➜ '--a' // `lodash/fp/padStart` does not. fp.padStart(3)('a'); // ➜ ' a'
    3. The lodash/fp module promotes a more functional programming (FP) friendly style by exporting an instance of lodash with its methods wrapped to produce immutable auto-curried iteratee-first data-last methods.
    1. One of the significant differences between the two is that a call to a partially applied function returns the result right away, not another function down the currying chain; this distinction can be illustrated clearly for functions whose arity is greater than two.
    2. Currying and partial function application are often conflated.
    1. It looks like you accidentally passed resolve() (immediately invoking the function) directly to setTimeout rather than passing a function to invoke it. So it was being resolved immediately instead of after a 1000 ms delay as intended.

      I guess this is the "immediately invoked function" problem.

      Not to be confused with: immediately invoked function expression. (Since it is a regular named function and not a function expression.)

    2. You should not create a new debounce function on every render with: return new Promise(resolve => { debounce(() => resolve(this.getIsNameUnique(name)), 2000); }); Instead you should just wrap your whole function isNameUnique with the debounce (see my sandbox). By creating a new debounce function on every hit, it cannot 'remember' that is was called or that is will be called again. This will prevent the debouncing.
    1. If you define a variable outside of your form, you can then set the value of that variable to the handleSubmit function that 🏁 React Final Form gives you, and then you can call that function from outside of the form.
    1. The results of a DEXA scan are most often reported as T-scores. A T-score compares a person’s bone density to the average peak bone density of a healthy 30-year-old population of the same gender. A T-score of −1.0 or above indicates normal bone density. A person with a T-score between −1.0 and −2.5 has low bone density, which is a condition referred to as osteopenia. A person with a T-score of −2.5 or below is diagnosed with osteoporosis.

      T score levels for bone density.

    1. In the third step of bone remodeling, the site is prepared for building. In this stage, sugars and proteins accumulate along the bone’s surface, forming a cement line which acts to form a strong bond between the old bone and the new bone that will be made. These first three steps take approximately two to three weeks to complete.

      Bone remodeling process.

    2. In adulthood, our bones stop growing and modeling, but continue to go through a process of bone remodeling.

      I would challenge that fact.

    3. Bone tissue cells include osteoprogenitor cells, osteoblasts, osteoclasts, and osteocytes. The osteoprogenitor cells are cells that have not matured yet. Once they are stimulated, some will become osteoblasts, the bone builders, and others will become osteoclasts, the cells that break bone down. Osteocytes are the most abundant cells in bone tissue. Osteocytes are star-shaped cells that are connected throughout the bone and exchange nutrients from bones to the blood and lymph.

      The Asteo Class of Bone Tissue

    4. Your bones are stronger than reinforced concrete. Bone tissue is a composite of fibrous collagen strands that resemble the steel rebar in concrete and a hardened mineralized matrix that contains large amounts of calcium, just like concrete.

      What Is Bone?

    1. In React 0.12 time frame we did a bunch of small changes to how key, ref and defaultProps works. Particularly, they get resolved early on in the React.createElement(...) call. This made sense when everything was classes, but since then, we've introduced function components. Hooks have also make function components more prevalent. It might be time to reevaluate some of those designs to simplify things (at least for function components).
    1. Return a tagged template function hx from a hyperscript-style factory function h