Frankfurt argues that bullshitters misrepresent themselves to their audience not as liars do, that is, by deliberately making false claims about what is true. Rather, bullshitters seek to convey a certain impression of themselves without being concerned about whether anything at all is true. They quietly change the rules governing their end of the conversation so that claims about truth and falsity are irrelevant. Although bullshit can take many innocent forms, excessive indulgence in it can eventually undermine the bullshitter’s capacity to tell the truth in a way that lying does not. Liars at least acknowledge that the truth matters. Because of this, bullshit is a greater enemy of the truth than lies are.

Silver’s claims that the 2024 election outcome is essentially a coin-flip. While this may be accurate—although 67/33 is pushing it—Coplan’s response partially serves to deflect future backlash about the accuracy of the prediction, to remind people that if something has, for example, 33 percent odds of happening, that means it still happens 33 percent of the time. But it also obscures the fact that the odds themselves and their attached returns, not just the events being predicted, are what reel people in.

RSpec gives us the tools to make custom matchers so that we can preserve all the expressiveness while adding specialized or even domain-specific matchers.

9.5 ere Is No One System

Heiress to one of the world’s most powerful families. Her grandfather cut her out of the $15.4 BILLION family fortune after her scandal. But she fooled the world with her “dumb blond” persona and built a $300 MILLION business portfolio. This is the crazy story of Paris Hilton:

"The Earth was flat if you went too far you would fall off Now the Earth is round if the shape change again everybody woulda start laugh The average man can’t prove of most of the things that he chooses to speak of And still won’t research and find out the root of the truth that you seek of" commenting on how new structures/theories/inventions are always at conflict with old structures/theories/inventions that refuse to accept new ideas/truths because of mental conditioning (e.g. laugh) society is in to accept everything as fact and never question/research/evolve/change. this is very much predominant in science and history, for example, Galileo was condemned and died for the truth, Copernicus's model that the Earth rotated around the sun, a truth that contradicted biblical truth. it's like what camus was complaining about in the myth of sisyphus essay, where man faces an existential crisis of absurdism when there are no absolute truths and values in the world. humanity is suffering because we're working against eachother instead of working together in order to find out the truth of all things.

"You buy a khaki pants And all of a sudden you say a Indiana Jones An' a thief out gold and thief out the scrolls and even the buried bones" criticism on how people change their appearances so easily, acclaim status/right just because they can conform to social appearances - doesn't mean that they actually are who they say they or they really mean what they do/represent. like those televangelists with their fake/unproductive compassion and care. what change are they really doing to help humanity as a whole, when they are truly only looking out for themselves and their own comfort/security, while projecting their own existence/ideologies on others. criticism on the right/ownership of ancient artifacts, knowledge and discoveries. people who claim to own knowledge or ancient artifacts are actually theives who are stealing and exploting humanity, what belongs to everyone.

But that’s not the case for a computer, or a robot, or even a corporate food service, which can’t navigate the intricacies and uncertainties of the real world with the flexibility we expect of a person. And at an even larger scale, our societal systems, whether we’re talking about laws and governments or just the ways our employers expect us to get our jobs done, don’t have that flexibility built into them. We’ve seen repeatedly how breaking corporate or government operations into thousands of disparate, rigid contracts ends in failure.

You need to understand and learn the basic ideas, from scratch.ZK is a lifetime job.

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.

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.

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.

Allow customers to set their own hierarchies

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.

Germany's duck curve – Integrating renewables into smart grids

Ungrading – focusing on student self-evaluation and metacognition

List campus-level strategies related to flexibility

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.

ActiveStorage::LogSubscriber.detach_from :active_storage

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.

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.

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.

You can access Events through a few interfaces: Webhooks (we POST data to your URL). The Events API (you GET data through the API). The Logs tab of the Control Panel (GUI).

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, } )

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.

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 "$@" }

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

git -c log.follow= log: that will unset log.follow, just for that one git log instance.

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.

The intent of this specification and related tools is to expand the reach of development containers, allow the usage of containers by themselves or different orchestration technologies, and allow any tool to manage and create them.

The focus of the dev container specification is to describe how to enrich a container for the purposes of development, rather than acting as a multi-container orchestrator format.

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.

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!

but you want to style your components yourself and not be constrained by existing design systems like Material UI

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?”

Yeah I don’t think we will find something that works for everyone in all cases. But Webpacker is quite flexible with the setup it has now. Easy to change!

Why not just prettier-ignore? Because I want to keep Prettier here. Still format my code. But just with another config. This already works with prettierrc > overrides. But this proposal is for a better usability and flexibility.

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.

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"]

You could also opt to extend your Rails configuration object: Envy.init use: MyApp::Application.config MyApp::Application.config.my_variable # => ...

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.

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 }

#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).

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.

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

# authenticated :user, lambda {|u| u.role == "admin"} do # root to: "admin/dashboard#show", as: :user_root # end

data[:users, :[], :name] = 'Matz' # :[] is next index, 0 in this case

This isn't really a downside to React; one of React's strengths is that it lets you control so much and slot React into your environment

This could be an operation, a workflow, or hand-baked Ruby code completely unrelated to Trailblazer.

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.

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.

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.

For branching out a separate path in an activity, use the Path() macro. It’s a convenient, simple way to declare alternative routes

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

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>

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>

In both filters, you’re able to rename and coerce variables. This gives you a bit more control than the simpler DSL.

As usual, you may provide your own code for dynamic filtering or renaming.

# Yes, you can use lambdas as steps, too! step ->(ctx, params:, **) { params.is_a?(Hash) }

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.

hash :with_defaults, default: {} do boolean :likes_cookies, default: true end

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.

@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

Examples of different ways of defining forms

Bureaucrat doesn't define save

Programming to interfaces is at the core of flexible structure.

At the core of parallel development, however, is the notion of flexibility. You have to write your code in such a way that you can incorporate newly discovered requirements into the existing code as painlessly as possible.

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

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

Everyone needs a task manager and Planner adapts to anyone's needs

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).

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.

However, you can also use SVG, Font Awesome, or any other icon library you wish.

aiming to be modular, flexible and without too strong an opinion on user experience

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.

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

Flexibility: your solution can be ported to other UI's, or you can replace your favourite state management form library without affecting your validation engine.

Ok, I have seen that there are lot of built-in and third party validations, but sooner or later I will face a validation rule not covered by this buffet. Can I build a custom one? Of course you can!

Yes, you cannot fully express a modern app through templates without sacrificing flexibility and code reusability.

It is possible to invoke oceanwind in a multitude of different ways.

Solid supports templating in 3 forms JSX, Tagged Template Literals, and Solid's HyperScript variant.

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.

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.

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

Defines a custom resolver.

More than one subscriber can subscribe to the same field.

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:

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.

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.

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.

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.

Use case: Wrapper components that need to render an element (e.g. because they attach event listeners). You'd probably use a <div> there by default but there may be places where this is not desirable for semantic reasons (e.g. in lists).

I would hope for it to come with React-like behavior where I could pass in a string (like div or a) and have it show up as a normal div/a element when the child component used it.

You can freely use destructuring and rest patterns in each blocks.

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.

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(); }),

variables and fallbacks in the child component css again seem verbose, and not as flexible as classes

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.

Export to MongoDb, SQL, JsonLogic or your custom format