129 Matching Annotations
  1. Last 7 days
  2. Jan 2024
    1. The "meaning" will tell Gitlab how to interpret the relation. For example, a "parent/child" relation will have the meaning set to "one is a part of another", and then user may define a "subtask" and "subcomponent" relations to distinguish two situations, but Gitlab will understand because all three will have the same meaning and it can render a tree with three different kinds of edges.
    2. There is also #8988 (closed) about custom fields. It there is some flexible architecture like in Drupal - all entities can have custom fields (and some form widget and some formatter), so building other features what needs to store data is more simple.
    3. Such a generic approach will allow the Relations to fit any reasonable workflow, because possible relations are defined by users, just like the Labels are.
    1. One way is to have a very simple model of the same thing like Github and let users decide on the hierarchy of things. If Gitlab really want to go one step further and give users more then its really important simplicity is not killed in the process.
  3. Dec 2023
    1. 08:00 Ryan Holiday built in a bunch of structure — as he progressed more in his career, he transitioned to flexibility.

      • See ZK on balancing Confucius and Lao Tzu
  4. Nov 2023
    1. Ungrading – focusing on student self-evaluation and metacognition

      Link to an external resource that can be annotated by students

  5. Sep 2023
    1. It is possible to use the List-Unsubscribe header even if you do not want to use subscription tracking. This is useful for users who want to provide their recipients an easy way to unsubscribe from their emails without relying on SendGrid’s tracking features. Continue reading below for an explanation of the List-Unsubscribe header, and how you can use it when sending email via SendGrid.
  6. Jul 2023
    1. ActiveStorage::LogSubscriber.detach_from :active_storage

      It's nice that it's that easy to "opt out" of the default provided log subscriber and (if desired) swap in your own custom one that does whatever you want.

  7. Mar 2023
    1. The Inflexibility of DNS Traditionally, the root record of a domain needed to point to an IP address (known as an A -- for "address" -- Record). While it may not seem like a big deal, tying a service to an IP address can be extremely limiting.
  8. Dec 2022
    1. Enum:"add" "delete" An additional flag parameter with the value add will add masks provided in the request body to the list. A flag value delete will delete masks from the list. If there's no parameter provided, masks are replaced.
  9. Nov 2022
    1. Though this is a hash extension, it conveniently allows for arrays to be present in the nested structure. This feature makes the extension particularly useful for working with JSON API responses.
    1. So when configuring Capybara, I'm using ignore_default_browser_options, and only re-use this DEFAULT_OPTIONS and exclude the key I don't want Capybara::Cuprite::Driver.new( app, { ignore_default_browser_options: true, window_size: [1200, 800], browser_options: { 'no-sandbox': nil }.merge(Ferrum::Browser::Options::Chrome::DEFAULT_OPTIONS.except( "disable-features", "disable-translate", "headless" )), headless: false, } )
    1. Socrates is turned into a systematic set of psycho-technologies that you internalise into your metacognition. So, what became crucial for Plato, as we saw, was argumentation. But for Antisthenes the actual confrontation with Socrates was more important. Both Plato and Antisthenes are interested in the transformation that Socrates is affording.Plato sees this happening through argumentation. Antesthenes sees it as happening through confrontation because... And you can see how they're both right, because in Socratic elenchus, Socrates comes up and he argues with you. But of course he's also confronting you. We talked about how he was sort of slamming the Axial revolution into your face! So, Antesthenes has a follower, Diogenes, and Diogenes epitomizes this: This confrontation. And by looking at the kinds of confrontation we can start to see what the followers of Antesthenes are doing. So Diogenes basically does something analogous to provocative performance art. He gets in your face in a way that tries to provoke you to realizations. Those kinds of insights that will challenge you. He tries to basically create aporia in you, that shocked experience that you had when confronting Socrates that challenges you to radically transform your life. But instead of using argumentation and discussion, as Socrates did and Plato picked up on, they were really trying to hone in on how to try to be as provocative as possible.

      John Vervaeke on Socrates becoming set of psychotechnologies to internalize and augment metacognition. Agues agumentation become central for Plato, whereas confrontation itself become central for Antisthenes. They're disagree about how the cause of the transformation through the Socratic approach

      Unclear is stoics take up Plato's mantle of argumentation orientation, but they at least seem distinct from the Cynics (Antisthenes & teach Diogenes

      Aporia is moment of shock from experience that you're radically transformed. Could be from Diogenes' provocative performance art or through discourse a la Plato & Socrates

      Nietzche may have favored Cynics approach over stoic/Socratic. Possible parallel in left-hand path and right-hand path. Quick & risky vs. slow & steady

  10. Oct 2022
    1. Functions are much more flexible than aliases. The following would overload the usual ls with a version that always does ls -F (arguments are passed in $@, including any flags that you use), pretty much as the alias alias ls="ls -F" would do: ls () { command ls -F "$@" }
  11. Sep 2022
    1. You can tell the lint command to validate specific API definitions by using their names from the apis object, like in the following example: Copy Copied redocly lint core@v2
  12. Jun 2022
    1. Thus flexibility is an important virtue in computer-assisted textual analysis, and testing a project on a subset of texts or methods can avoid wasted effort.

      Flexibility has almost become a sought-after characteristics of any projects ever conducted in this world, let alone those that belong to the school of humanities. Any individual or group entering a long-term project should be aware that predicting the outcome of the project is never a part of their project. It's impossible to identify and avoid surprise factors on a long road, but it's definitely possible to have an open mindset that's ready fpr any difficulty coming along the way and for brainstorming solutions that resolve this "shock". In many cases, these unexpected variables are what that renders the project memorable and special and sustainable and valid and reliable. In many cases, changing the initial direction of the project when faced with these unforeseen elements are for the better and produce even better results. Testing out different methods on textual analysis is a particularly great advice for those who are bound to carry a project in the coming future.

  13. Mar 2022
    1. I believe this is partly due to a militant position on free software. Some advocates believe so strongly that users should be able to recompile their software that they force them to do so. They break libraries seemingly on purpose just to say, “Recompile! Oh you can’t? That’ll teach you to use binary software!” Of course users don’t want to recompile their software, but what users actually want is usually lost on GNOME developers.
  14. Feb 2022
  15. Jan 2022
  16. www.npmjs.com www.npmjs.com
    1. The yieldable objects currently supported are: promises thunks (functions) array (parallel execution) objects (parallel execution) generators (delegation) generator functions (delegation) Nested yieldable objects are supported, meaning you can nest promises within objects within arrays, and so on!
  17. Dec 2021
    1. The PSU Faculty Senate Academic Quality Committee shared that concern earlier this year with administrators. They also worried about quality of learning for students.“For example, we know from the shift to remote that not everything that works in a classroom works on Zoom, and vice-versa,” the committee wrote. “Will faculty need to plan their courses and classroom activities for two different types of audiences? Or will faculty simply lecture or do some kind of low student-input activity, given the potential logistical challenges of handling the two different groups?”
  18. Sep 2021
  19. Aug 2021
    1. In the vast majority of cases when I'm using prettier-ignore I'm only really looking to prevent it from breaking my code into new lines, whilst keeping its other transformations such as switching quotes and adding space between brackets. When ignoring single lines, fixing these formatting problems by hand is very manageable. With the ability to have Prettier ignore entire blocks of code I think the ability to specify what you want it to ignore is essential.
  20. Jun 2021
    1. Once a variable is specified with the use method, access it with EnvSetting.my_var Or you can still use the Hash syntax if you prefer it: EnvSetting["MY_VAR"]
    1. As it turns out, it’s pretty easy to write your own arg parser once you understand the mechanics of the language. Doing so affords you the ability to cast all manner of spells to bend arguments to your will.
  21. Apr 2021
    1. logger.tag_formatter.default(Lumberjack::Formatter.new.clear.add(Object, :inspect)) logger.tag_formatter.default(Lumberjack::Formatter::InspectFormatter.new) logger.tag_formatter.default { |value| value.inspect }
    1. #2 Non-real-time variant - What about groups who don't like that real-time part of the game? We really think that is the best way to play, but we realize it isn't a fun or even possible option for everyone. We're including an alternative rule that removes all the speed elements and is still fun (in a different way).
    1. The developers allowed for players to play their own level of challenge whether it's using the active pause, fast forward or multi-level undo function.
    1. With Stack Overflow for Teams being a flexible platform, we’ve seen customers use it for a wide variety of use cases: A platform to help onboard new employees A self-serve help center to reduce support tickets Collaboration and documentation to drive innersource initiatives Breaking down silos and driving org wide transformation like cloud migration efforts A direct customer support platform Enable people who are working towards a common goal, whether a startup or a side project, to develop a collective knowledge base
  22. Mar 2021
    1. If you prefer not to use tabs and like files to be opened as buffers inside a current running Vim instance then simply replace "--remote-tab-silent" with "--remote-silent" in the above scripts.
    1. Second, I don't agree that there are too many small modules. In fact, I wish every common function existed as its own module. Even the maintainers of utility libraries like Underscore and Lodash have realized the benefits of modularity and allowed you to install individual utilities from their library as separate modules. From where I sit that seems like a smart move. Why should I import the entirety of Underscore just to use one function? Instead I'd rather see more "function suites" where a bunch of utilities are all published separately but under a namespace or some kind of common name prefix to make them easier to find. The way Underscore and Lodash have approached this issue is perfect. It gives consumers of their packages options and flexibility while still letting people like Dave import the whole entire library if that's what they really want to do.
    1. Normally you should not register a named module, but instead register as an anonymous module: define(function () {}); This allows users of your code to rename your library to a name suitable for their project layout. It also allows them to map your module to a dependency name that is used by other libraries.
  23. 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. In both filters, you’re able to rename and coerce variables. This gives you a bit more control than the simpler DSL.
    3. As usual, you may provide your own code for dynamic filtering or renaming.
    1. If you have value objects or you would like to build one object from another, you can use the converter option. It is only called if the value provided is not an instance of the class or one of its subclasses.
    2. hash :with_defaults, default: {} do boolean :likes_cookies, default: true end
    3. By default, hashes remove any keys that aren't given as nested filters. To allow all hash keys, set strip: false. In general we don't recommend doing this, but it's sometimes necessary.
    1. @adisos if reform-rails will not match, I suggest to use: https://github.com/orgsync/active_interaction I've switched to it after reform-rails as it was not fully detached from the activerecord, code is a bit hacky and complex to modify, and in overall reform not so flexible as active_interaction. It has multiple params as well: https://github.com/orgsync/active_interaction/blob/master/spec/active_interaction/modules/input_processor_spec.rb#L41

      I'm not sure what he meant by:

      fully detached from the activerecord I didn't think it was tied to ActiveRecord.

      But I definitely agree with:

      code is a bit hacky and complex to modify

    1. Examples of different ways of defining forms

      Wow, that's a lot of different ways.

      The inline_form way in particular seems interesting to me, though it's worth noting that that method is just an example, not actually part of this project's code, so it's not really a first-class option like the other options.

    2. Bureaucrat doesn't define save

      It's probably just as well, since it will almost always need to be overridden with custom logic...

    1. initialize(model) accepts an instance of the model that the form represents.

      By designing this so there is a main model, it isn't as flexible as Reform's "Composition" module that lets you compose it in any way you want, including having as many as you want top-level "main" modules that your form is comprised of.

  24. Jan 2021
    1. Another possible syntax is {#slot bar}<Foo/>{/slot}, which would also allow a bunch of DOM nodes and components inside the slot, without them needing to be from a single component
  25. Dec 2020
    1. Better contribution workflow: We will be using GitHub’s contribution tools and features, essentially moving MDN from a Wiki model to a pull request (PR) model. This is so much better for contribution, allowing for intelligent linting, mass edits, and inclusion of MDN docs in whatever workflows you want to add it to (you can edit MDN source files directly in your favorite code editor).
  26. Nov 2020
    1. The syntax of the fallback, like that of custom properties, allows commas. For example, var(--foo, red, blue) defines a fallback of red, blue — anything between the first comma and the end of the function is considered a fallback value.
    1. However, you can also use SVG, Font Awesome, or any other icon library you wish.
    1. Broadly speaking, modularity is the degree to which a system's components may be separated and recombined, often with the benefit of flexibility and variety in use.
    1. Another possible syntax is {#slot bar}<Foo/>{/slot}, which would also allow a bunch of DOM nodes and components inside the slot, without them needing to be from a single component

      I like it

  27. Oct 2020
    1. This means you have the full language at your disposal. You are not limited to premade helpers and directives to control how your view renders (although Solid ships with some). Neither Vue and Svelte offer this level of control.
    1. The $ contract for auto-sub­scrib­ing is lovely in its sim­plic­ity and flex­i­bil­ity. You can adapt your own preferred state-man­age­ment pattern or library, with or without Svelte stores as helpers. Svelte does not fuss about how you want to manage your state.
    1. If you return an object, then it is possible to resolve an import to a different id while excluding it from the bundle at the same time. This allows you to replace dependencies with external dependencies without the need for the user to mark them as "external" manually via the external option
    2. Defines a custom resolver.
  28. Sep 2020
    1. But what if we want to use it in a legacy app built with for example Bootstrap 3 and lots of jQuery where there's no sign of Node.js? No problem! We'll just use the IIFE build and instantiate the component class through its global constructor:
    1. Then, the projects that use these libraries get to process these import statements how they like when they are bundled. For the ones that wish to load jQuery from a global, we again mark 'jquery' as an external—since we still don't want Rollup to bundle jQuery—and as a global.
    1. This has already forced me to forgo Svelte Material because I would like to add some actions to their components but I cannot and it does not make sense for them to cater to my specific use-case by baking random stuff into the library used by everyone.
    2. The point of the feature is to not rely on the third-party author of the child component to add a prop for every action under the sun. Rather, they could just mark a recipient for actions on the component (assuming there is a viable target element), and then consumers of the library could extend the component using whatever actions they desire.
    3. They don't need to add a prop for every action. The action itself can be passed in as a prop. <script> export let action; </script> <div use:action>whatever</div> The argument for the action can be another prop or can be part of the same prop.
    1. A function that takes the value from the input and name of the field and converts the value into the value you want stored as this field's value in the form. Common usecases include converting strings into Numbers or parsing localized dates into actual javascript Date objects.
    1. We must always return at least some validation rule. So first off if value !== undefined then we'll return our previous validation schema. If it is undefined then we'll use the yup.mixed().notRequired() which will just inform yup that nothing is required at the optionalObject level. optionalObject: yup.lazy(value => { if (value !== undefined) { return yup.object().shape({ otherData: yup.string().required(), }); } return yup.mixed().notRequired(); }),
    1. Instead of providing defaults, React has left these things to the community. As a result, a vibrant and diverse ecosystem has sprung up. It provides a great deal of flexibility for how you architect your React applications and how you adapt React to best suit your team.
  29. Aug 2020
    1. Java may have been designed as a completely object oriented language, but when Java SE 8 was released in 2014, it added Lambda expressions (aka closures), which added some functional programming elements. Not every problem is best served by OOP, and by adding Lambdas, Java became more flexible. 
  30. Jul 2020
  31. Jun 2020
  32. May 2020
  33. Apr 2020
    1. The method name is generated by replacing spaces with underscores. The result does not need to be a valid Ruby identifier though, the name may contain punctuation characters etc. That's because in Ruby technically any string may be a method name. This may require use of define_method and send calls to function properly, but formally there's little restriction on the name.
  34. Mar 2020
    1. Change every detail of your pop-ups and bottom bars or build your own consent experience using the powerful JavaScript API.
    1. For several reasons the Simple backend shipped with Active Support only does the "simplest thing that could possibly work" for Ruby on Rails3 ... which means that it is only guaranteed to work for English and, as a side effect, languages that are very similar to English. Also, the simple backend is only capable of reading translations but cannot dynamically store them to any format.That does not mean you're stuck with these limitations, though. The Ruby I18n gem makes it very easy to exchange the Simple backend implementation with something else that fits better for your needs, by passing a backend instance to the I18n.backend= setter.
  35. Dec 2019
    1. It's not customizable enough and there aren't enough distinct fields for inevitably complex work tasks. Google Sheets fixes that. No, it's not a to do list app, but that's why I love it. It's an app I already use. It's extremely customizable.
    1. It's not for beginners, but it's extremely flexible once you get a handle on things. If sticking to a system is hard for you, I highly recommend giving this system a try.
    2. Best to-do list app for taking control of your to-do list
    1. For example: I wanted a way to add recurring tasks to my list, so I wrote a simple bash script called goodmorning.sh. It uses the command prompt client to quickly add a bunch of tasks to my todo list of choice. I run this script first thing in the morning every workday, and I like it better than any built-in system I’ve found for recurring tasks, because it’s fully under my control.
    2. There are thousands of to-do list apps out there, in part because no system works perfectly for everyone. I’m not going to say todo.txt is the exception, and that it will work for everyone, because that would be crazy. But todo.txt is the most flexible tool I’ve come across. In part, this is because of the sheer number of clients available, but also because the simplicity lends itself to improvisation.

      First time I've seen improvisation used like this.

    3. It’s flexible in precisely the way so many modern apps aren’t, and if you like tweaking things until they’re just right, I can’t recommend it enough.
    1. The beauty of todo.txt is that it's completely unstructured; the fields you can attach to each task are only limited by your imagination.
    1. Webpack supports the ability to run multiple builds by exporting an array of configurations instead of a single configuration.
  36. Jul 2019
    1. conventional forms of teaching and learning are not useful to prepare students for our dynamic and constantly shifting 21st century society

      This is a bold statement but we should also be aware of that with our choices as teachers, we are shaping the society of the 21st century as well. Also, not everything "old" is necessarily useless and bad, so we need to distinguish between "modern" and "valuable" as well as "old" and "worthless". I think one of the most important value that we need to teach to our students and to ourselves, too, is flexibility.

  37. Mar 2018
  38. Aug 2015
  39. 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.

  40. Oct 2013
    1. both to teach what is right and to refute what is wrong, and in the performance of this task to conciliate the hostile, to rouse the careless, and to tell the ignorant both what is occurring at present and what is probable in the future. But once that his hearers are friendly, attentive, and ready to learn, whether he has found them so, or has himself made them so the remaining objects are to be carried out in whatever way the case requires. If the hearers need teaching, the matter treated of must be made fully known by means of narrative. On the other hand, to clear up points that are doubtful requires reasoning and the exhibition of proof. If, however, the hearers require to be roused rather than instructed, in order that they may be diligent to do what they already know, and to bring their feelings into harmony with the truths they admit, greater vigor of speech is needed. Here entreaties and reproaches, exhortations and upbraidings, and all the other means of rousing the emotions, are necessary.

      The orator must be able to read the audience and adjust rhetoric accordingly