we have all of these huge applications that are gathering all this data uh and it's out there and theoretically is our data sort of but in reality they control it and you can't actually link the data to each other you only link to accessing the data through their application

if I send you a Google doc and we start all collaborating in the same same thing and it's amazing we're sharing all this data um it's kind of silly that we have to move the updates through the backb to some server out there and shipping them back here when we now have really sophisticated algorithms that can do um you know smart Conflict Free resolution that allows us to collaborate in real time and yet we're still moving all the updates to the backbone right this is very silly and it gets worse when you think about the network falling apart

let's go and and create all this great software to deploy it and kind of equalize the the the disparity of wealth across the world and ends up being locked out for by stupid issues like latency and bandwidth

something like Gangam Style has been viewed to the tune of like almost or over two billion times and when you just when you count just the data coming out of Google servers let alone all the links we're dealing with something close to 500 pedabytes of data that's a lot for a video right I mean this is clearly an issue there's no reason we should be moving around all of this data constantly through the network

The notion of pure altruism attempts to create a dichotomy between the self and others, implying that true selflessness is possible. Yet, in reality, individuals exist within a web of relationships and mutual dependencies.

Een chunk (letterlijk ‘brok’) is een verzameling elementen die sterke associaties met elkaar hebben. Samen vormen ze een betekenisvolle informatie-eenheid. Die chunks, groot of klein, gebruiken we in ons interne informatieverwerkings- en geheugensysteem. Ons brein houdt namelijk van logica en voorspelbare patronen. Het opdelen van informatie gebeurt automatisch en continu, maar kan ook bewust worden ingezet. Dat heet doel-georiënteerde chunking.Ons brein kan slechts een aantal zaken opslaan in het kortetermijngeheugen. Maar door veel gegevens te groeperen in kleinere brokjes informatie, kunnen we de limieten van ons geheugen uitdagen. En dus meer informatie verwerken en onthouden.

Positionality

The snag is that when the top-level match grabs the published_at value and applies it to the be_within(...), it is working with a string representation of the timestamp. We first need to parse that into a date object and there is no affordance for that here.

There have been many attempts over the years to address the limitations of an overly ‘linear’ approach to ToC diagramming

On Windows, that interface doesn't really exist (and is really difficult to emulate properly)

As Ramadiro worked his way through this period, he reached severaloverarching conclusions about the available materials. He concluded that muchof the available materials had been written in English, and back-translated toisiXhosa, and as such were not based on the linguistic logic of isiXhosa. They didnot take advantage of the home (oral) language resources of children in isiXhosaas the basis to build reading and writing skills. Second, taken together they didnot constitute a balanced reading programme guided by contemporary readingresearch (Pressley, 2006). There was no set of materials that combined a wholereading approach with systematic language skills (phonics, grammar etc.) inBefore... After...

Certainly, multimedia technology brings about improvement in teaching and learning, however, there are a number of limitations in this technology for educational purposes. Some of these limitations include unfriendly programming or user interface, limited resources, lack of required knowledge and skill, limited time and high cost of maintenance among others (Al-Ajmi and Aljazzaf, 2020; Putra, 2018).

Abstract

Multiline scripts (we mostly target one-liners)

“…” would be cool, but (unless I’ve missed something in Ruby 3.2+), it can only delegate all args, and foo(1, …) is impossible.

whitehead says that philosophy is an attempt to express the infinity of the universe in terms of the limitations of language

A user notices that an unchanged part of the diff already has features that are being implemented in the changes in the MR. The user leaves a comment on the unchanged part of the diff, telling the author that what they're trying to do is already present. Problem: The author cannot see that comment in the Changes tab, because the comment is outside the understood scope of the diff.

It can sort of be achieved with the current setup (via labels), but I really like where this is going -- turning everything into a similar "object" in a hierarchy rather than separate standalone structures that connect and get "labeled" to show what they are.

Enable ActiveRecord unsigned integers to use 8 bytes instead of 4. This fixes the ActiveModel::RangeError problem where AR models with perfectly fine 8 bytes primary keys are taken for ActiveModel::Type::Integer with a default limit of 4 bytes.

Annoyingly, git fetch --depth=<N> won't pick up new tags

While this works, it’s not a great developer experience. In development, we don’t always know ahead of time all the packages that need to be linked. Or keep track of the previously linked packages.This confusing behavior compounds to the poor usability and predictability of npm link.

I know that Devise offers these capabilities, but it's hard to make out how to do it without hitting their preconfigured (view?) routes.

At the same time, the vision of a good life for all integrates our in-dividual pursuit of this goal with an immediate concern for others.In other words, we can enjoy and exercise freedoms only to the extentthat doing so does not impinge on others. Achieving this vision under-lines both the crucial role of freedom but also the necessity of limitsfor this freedom to exist. Thereby, pursuing the vision of a good lifefor all has the potential of bridging current political divides, as it is avision that all people can adhere to.

Common sense is actually a pretty bad indicator of truth. Because of cognitive biases and preconceived opinions, ideas that sound right are often wrong. “Common sense is actually nothing more than a deposit of prejudices laid down in the mind prior to the age of eighteen,” Einstein presumably said.

we have onlyvery limited capabilities of predicting emissions fu-tures due to the inherent complexities and contin-gencies of social dynamic

Using a modified version of Köhler’s method, recent research has found that in 2015 drain from the South through unequal exchange amounted to $2.1 trillion (constant 2011 dollars), represented in Northern prices (Hickel et al., 2021). Köhler’s proxy approach is limited in several respects, however. It relies on PPP figures that do not adequately account for the comparatively high prices of Northern exports; it relies on GDP figures that are affected by the low prices of imports from the South; and it compares Southern exports to prices across whole economies, rather than to those of only traded goods. All of this leads to underestimating the scale of drain (see Hickel et al., 2021).

Human choices and actions could narrow or widen the safe and just corridor for human development. Considering the complex interactions, feedbacks, and non-linearities within and between societal activities and Earth system behavior, we need to advance beyond previous frameworks such as the “donut” (Raworth, 2018) to understand when “safe” and “just” ranges do and do not overlap.

Aleatoric music (also aleatory music or chance music; from the Latin word alea, meaning "dice") is music in which some element of the composition is left to chance, and/or some primary element of a composed work's realization is left to the determination of its performer(s). The term is most often associated with procedures in which the chance element involves a relatively limited number of possibilities.

I understand that multiple -f options fits almost the bill, but it doesn't always work. For example, I rather often change the name of the abstract service into something that is more meaningful in the context of the project at hand. This is something that the overriding that occurs with multiple -f options does not support.

Procs can't accept blocks as implicit arguments (the format you're trying). A proc can receive other proc objects as arguments, either explicitly, or using & arguments. Example: a = Proc.new do |&block| block.call end a.call() {puts "hi"}

yield is a bit of laguage level magic that only works in the context of a method.

Note: it is not possible to apply a boolean scope with just the query param being present, e.g. ?active, that's not considered a "true" value (the param value will be nil), and thus the scope will be called with false as argument. In order for the scope to receive a true argument the param value must be set to one of the "true" values above, e.g. ?active=true or ?active=1.

Do you know about lacolhost.com? as in, do something like blerg.lacolhost.com:3000/ as your url and it'll resolve to localhost:3000, which is where your tests are running.

As you note, Activity diagrams inherently can include concurrency and timing. If you look at this example cribbed from Wikipedia, shown below, you can observe the section with two heavy horizontal bars, and two parallel activities of "present idea" and "record idea". That is read as "start these activities in parallel, and continue only when both are complete." Flowcharts can't express this within the notation. Practically, using activity diagrams lets you think clearly about concurrent processes. I think you'll find that anyone who can read a flowchart will quickly adapt.

Examining some assumptions and limitations of research on the effects of emerging technologies for teaching and learning in higher education

That’s fine and dandy if you’re running in production and have a publicly accessible address such as your domain name but what about during development?You can’t just tell Stripe to access http://localhost because that address isn’t publicly accessible to the internet.

Lucky for us, it’s super easy to use subdomains in development nowadays. http://lvh.me is a free service that resolves itself along with all subdomains to localhost.

Multiplying two objects will merge them recursively: this works like addition but if both objects contain a value for the same key, and the values are objects, the two are merged with the same strategy.

var a = document.createElement("a"); a.href = blob; a.target = "_blank"; setTimeout(function() { click(a); });

When we do release a final version of JSON Schema, please do not use JSON Schema to guarantee an OpenAPI document is valid. It cannot do that. There are numerous constraints in the written specification that cannot be expressed in JSON Schema.

the problem with docker builds is the made-up concept of "context". Dockerfiles are not sufficient to define a build, unless they are placed under a strategic directory (aka context), i.e. "/" as an extreme, so you can access any path (note that that's not the right thing to do in a sane project either..., plus it makes docker builds very slow because docker scans the entire context at start).

I would not change the project structure to accommodate Docker (or any build tools).

Issues are starting to become cluttered as we add more capabilities to them, and they are not perfect

Using labels to show issue types is cumbersome and makes reporting views more complex.

I was wondering particularly whether there is a way to have a comment on the same line as the backslash

I was already aware that images cannot be inserted in the DOM like you would any normal image. If you write <img src="https://my-pod.com/recipes/ramen.jpg">, this will probably fail to render the image. That happens because the image will be private, and the POD can't return its contents without proper authentication.

hopefully feed readers can treat permanent redirects as a sign to permanently update their feed URLs, then I can remove it. They probably don't, much like bookmarks don't

These callbacks are focused on the transactions, instead of specific model actions.

Since elements can overlap each other in a CSS grid, it doesn't even try to align them. As its name suggests, it is a grid, not a column layout.

However, when 2 elements begin at the same grid row, they overlap.

Perhaps the most interesting limitation is that you can’t target the grid area itself.

If you happen to annotate page three, and then weeks or years later visit the single page view wouldn’t you want to see the annotation you made? If the tool you are using queries for annotations using only the URL of the document you are viewing you won’t see it.

relatively nascent with numerous challenges, which have to be addressed before they can be widely acceptedand implemented.

In addition, a component that uses Svelte's built in event forwarding system cannot allow event listeners on the "capture" phase of the event lifecycle. It also cannot allow events to be cancelable with the browser's built in preventDefault function.

It's vanilla JS, doesn't bind you to specifc syntax and that's the main reason why I like svelte that it doesn't try to sandbox you into framework constraints.

I think the issue is that it's not totally perfect. It doesn't define what should happen in parent components, it's not as flexible as onError and it doesn't allow you (for instance) to nest a svelte:head inside, or decide what to do with the rest of the rendering. What do you do with <div>My component</div> in your example? What about changing the <title>? I assume you can inspect the error...does <svelte:error> allow specifying which error types to expect?

Another limitation is that you are forced into the syntax of the {#await} block. What I mean by that is that for example you can't add a loading class to a parent. You can only render stuff for the loading state in the given block. Nowhere else.

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

The RFC2617 model is one-user, one-credentials so the case where the user may have a second set of credentials that could be authorized may be ignored. It neither suggests nor implies that some sort of login page or other non-RFC2617 authentication protocol may or may not help - that is outside the RFC2616 standards and definition.

If you need to pass multiple arguments to an action, combine them into a single object, as in use:longpress={{duration, spiciness}}

the snap-based chromium cannot access files on my separately-mounted /opt filesystem. The non-snap chromium has no such limitation. Until or unless the snap version ever is able to access all the filesystems on my device, I am willing to live with the risk of a PPA-based version.

This works in my application where there's only one shadow-dom at the time, but it's not a generic solution.

it's always the 3rd episode in a row, 2 minutes into the 3rd.

The main problem is that the browser won't even send a request with a fragment part. The fragment part is resolved right there in the browser. So it's reachable through JavaScript.

note: when using for cross domain, requires you to be able to inject a js file into the iframe... Doesn't seem like a viable option when you don't control the iframe source.

You can add event modifiers with the on:click$preventDefault$capture={handler} syntax. If you use Svelte's native on:click|preventDefault={handler} syntax, it will not compile. You have to use "$" instead of "|". (The extra S inside the | stands for SMUI.)

Please note that the strategy: :build option must be passed to an explicit call to association, and cannot be used with implicit associations:

this happens with getClient and setClient because it is a svelte context which is only available at component initialization (construction) and cannot be in an event handler.

Known Limitations

Hello, maksimets: code blocks using triple backticks (```) don't work on all versions of Reddit!Some users see this / this instead.

This cache has a small trade-off! If we request a list of data, and the API returns an empty list, then the cache won't be able to see the __typename of said list and invalidate it.

This kind of error handling does express error state (either via HTTP 500 or by the top-level "errors" key), but it doesn’t take advantage of GraphQL’s type system and can only express one error at a time.

In mutations, when errors happen, the other fields may return nil. So, if those other fields have null: false, but they return nil, the GraphQL will panic and remove the whole mutation from the response, including the errors!

In order to have the rich error data, even when other fields are nil, those fields must have null: true so that the type system can be obeyed when errors happen.

Use this to build a ClassAdder component. ClassAdder components are useful for reducing the size of your bundle. If you have tons of simple components that just need to add classes/props or set a context, using ClassAdder components means there's only one "big" Svelte component in your bundle for all of these many tiny components.

This is useful when you need to add classes to a component, since Svelte's "class:" directives don't work on components.

That’s not the only way of writing end-to-end tests in Rails. For example, you can use Cypress JS framework and IDE. The only reason stopping me from trying this approach is the lack of multiple sessions support, which is required for testing real-time applications (i.e., those with AnyCable 😉).

While rails does have nice CSRF protection, in my instance it limited me.

Note that this proposal provides private fields and methods only as declared up-front in a field declaration; private fields cannot be created later, ad-hoc, through assigning to them, the way that normal properties can. You also can't declare private fields or methods in object literals; for example, if you implement your class based on object literals, or adding individual methods to the prototype, or using a class framework, you cannot use private methods, fields or accessors.

The answer is no, we use a pattern where we do this, and have a `static` method for manufacturing the constructor.e.g.static from({prop1, prop2}) => new this(public prop1, public prop2)

I could see them--that they were advancing in life, and I was still in the same spot. So I asked my mom if I could get a job, and that's when she broke it down to me that I wasn't even from here. And that was right there like a slap in the face.

This means that you have a json structure different from that described in your question. You cannot use generic jsonb functions when the json structures differ in each row.

As the token is unique and unpredictable, it also enforces proper sequence of events (e.g. screen 1, then 2, then 3) which raises usability problem (e.g. user opens multiple tabs). It can be relaxed by using per session CSRF token instead of per request CSRF token.

The simple problem that I see with fragment identifiers is that their existence and functionality relies completely on the developer rather than the browser. Yes, the browser needs to read and interpret the identifier and identify the matching fragment. But if the developer doesn’t include any id attributes in the HTML of the page, then there will be no identifiable fragments. Do you see why this is a problem? Whether the developer has coded identifiers into the HTML has nothing to do with whether or not the page actually has fragments. Virtually every web page has fragments. In fact, sectioning content as defined in the HTML5 spec implies as much. Every element on the page that can contain content can theoretically be categorized as a “fragment”.

This doesn't work in cases where the component checking for interactivity is looking at the $- shell variable for an "i"

Using the solution above will not work for filenames with spaces (or newlines).

A space-separated list of file names doesn't really work: what if one of the file names contained spaces?

this game is purely amateur production, material selection and creation is not professional, just hope you can like this story.

For now, you will need to give the second root a different named route: authenticated :user do root to: "users#index", as: :authenticated_root end unauthenticated do root to: "main#index" end

Ever want to experience a game that makes you want to play Rocket Ghost Aidan 2? Just play this! Its completely inferior to RGA 2.

neither knows what to do with naked domain. So gnome-open http://askubuntu.com works but not gnome-open askubuntu.com. Here is a small function to make it easier to type and accept the stripped down domain name. function go { gnome-open http://$1 ; }

In the real world, we are faced with the completely unfair constraint of being human while writing programs and while debugging them, and none of these costs can ever be reduced to zero.

To the consternation of some users, 3.x employed Unicode variable names such as λ, φ, τ and π for a concise representation of mathematical operations. A downside of this approach was that a SyntaxError would occur if you loaded the non-minified D3 using ISO-8859-1 instead of UTF-8. 3.x also used Unicode string literals, such as the SI-prefix µ for 1e-6. 4.0 uses only ASCII variable names and ASCII string literals (see rollup-plugin-ascii), avoiding encoding problems.

I'm not sure about all consequences of my change and this is very complex.

You can use the :placeholder-shown pseudo class. Technically a placeholder is required, but you can use a space instead.

:placeholder-shown is super useful for us here! It’s basically the secret selector for testing if an input currently has a value or not.

This only works provided each element has a label. It will not work if you put the attribute on the element itself, because <input> elements cannot have :after pseudo elements.

Dave Rupert has a good solution that uses an input's invalid event. Instead of using the :invalid pseudo selector, he adds a CSS class to the input when it becomes invalid. We will extend this approach by removing the CSS class when the element becomes valid again.

Admittedly, both the signature and the return values of invoke feel a bit clumsy. That’s becaus we’re currently working with the low-level interfaces.

The circuit interface is a bit more clumsy but it gives you unlimited power over the way the activity will be run.

but the descriptions are limited by dependence on the actual clinical nursing situations from which they must be derived.

To make it short: we returned to the Rails Way™, lowering our heads in shame, and adhere to the Rails file and class naming structure for operations.

There is nothing wrong with building your own “service layer”, and many companies have left the Traiblazer track in the past years due to problems they had and that we think we now fixed.

# catch multi-char special key sequences read -sN1 -t 0.0001 k1 read -sN1 -t 0.0001 k2 read -sN1 -t 0.0001 k3 key+=${k1}${k2}${k3}

In this simple example, the destroy interaction doesn't do much. It's not clear that you gain anything by putting it in an interaction.

This is not a valid solution. accepts_nested_attributes_for is part of ActiveRecord, not ActiveModel.

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

A.joins(:b) .where( A.arel_table[:something_a].eq('xxx').or(B.arel_table[:something_b].eq('yyy')) )

Your grid areas can only be rectangles (like the left), not arbitrary polygons (like the right).

And if your framed content has a need to be interactive, it will struggle to do so beyond the frame.

Change any of the <option> by double clicking on the number.

It won't work if $HOME is not under /home. Really. Not even if you softlink. You need a bind mount

Why did I put the kdb in the snap file system? Because the app is sandboxed, so I had no choice.

I think this is very important feature to implement. Because for now we need to wrap target components by useless wrapper nodes.

// read-only, but visible to consumers via bind:start export let start = 0;

export const start = 0

export let start = 0