he represents this in his writing with the point um it's it's the uh everything is a portal to everything else everything is in relationship with everything else there is nothing that is not in relationship with everything uh one point is a doorway to All Points

the point of futuring is that you need to connect facts and fictions because that is how this these future Visions become socially performative

To put it bluntly, Web3 and the crypto economy is still largely an ‘exit’ play for financial and coding elites, practicing the arbitrage of nation-states, but without much connections to local communities and resilient production; Similarly, local communities engaged in relocalized and regenerative production are not in sync with the mutual coordination capacities developed in the crypto/web3 context.

we're using post in the way postmodernists use post, which is it's informed by modernism, it's informed by capitalism without being able to transcend it necessarily because capitalism and it's the most recent incarnation of capitalism, which is neoliberalism, is like the oxygen that we breathe. It's all encompassing. It's totalitarian in its nature. And it's pervasive. And so in that sense, we say we have to be informed by the logic of the dominant system.

often I get the question, what should we do? And they expect  me to talk about um, mobility and, um how to reduce flying and  all forms of consumer choices. And they get surprised when I say  that the number one issue is talk to your friends.

Who says it's not a word? Not a word, simply because lexicographers have not recognized it? When a lexicographer recognizes it, it has already been in use! Even Mr. Fiske says it is a word, although he obviously disprefers it.

I think you linguists worry too much. It's a simple enough formation using a very common prefix, and while it is not clear whether "I disprefer" means "I do not prefer" or "I prefer something other than" or "I prefer the opposite of" or "I stop preferring", either it'll settle down to one meaning or it'll carry a range. So what? This is the first time I've heard the word but I don't find it particularly puzzling.

what's the point what am i g to get out of this it's the same question actually

I got no actual help from my long Verizon Support chat session and I kept asking if there is a block list they use that they could check (or a whitelist I could be added to...but fat chance) my IP for, since that is clearly what the error is calling out, but they never acknowledged that particular part of my questions, just ignored it.

Why should this conversation be separate from other conversations about the work to be done? Design is one consideration alongside frontend and backend considerations, which often all intersect and require the same participants. Shifting this discussion to a separate work item can result in disjointed conversations and difficulty finding where a decision was made.

Rupert Read has the best idea I have heard re international climate negotiations: countries that are serious should have their own conference where they collaborate on strong targets, plans, etc. Part of which should be recognising the dangers of remaining reliant on the petrostates, planning to transcend that reliance and sanctioning them

One more example of a simple approach to this that might help a lot too is add a PORO generator. It could be incredibly basic - rails g poro MyClass yields class MyClass end But by doing that and landing the file in the app/models directory, it would make it clear that was the intended location instead of lib.

But it's so essential that we go to this place that our brain gave us a solution. Evolution gave us a solution. And it's possibly one of the most profound perceptual experiences. And it's the experience of awe.

What I do care about, though, is that we might start to accept and adopt opinions like “that feature is bad”, or “this sucks”, without ever pausing to question them or explore the feature ourselves.

Exposing properties gives you a way to hide the implementation. It also allows you to change the implementation without changing the code that uses it (e.g. if you decide to change the way data are stored in the class)

If it's dangerous, note it in the class/method Javadocs, don't just blindly slam the door shut.

个人学习可能取决于他人行为的主张突出了将学习环境视为一个涉及多个互动参与者的系统的重要性

Rebuilding the same Dockerfile should result in the same version of the image being packaged, even if the second build happens several versions later, or the build should fail outright, such that an inadvertent rebuild of a Dockerfile tagged as 0.1.0 doesn't end up containing 0.2.3.

While there are many great answers regarding the "glyph not found" glyph, that won't help you actually detect it, as the text string in code will still have the character regardless of the font used to render it.

I'm afraid you missed the joke ;-) While you believe spaces are required on both sides of an em dash, there is no consensus on this point. For example, most (but not all) American authorities say /no/ spaces should be used. That's the joke. In writing a line about "only one way to do it", I used a device (em dash) for which at least two ways to do it (with spaces, without spaces) are commonly used, neither of which is obvious -- and deliberately picked a third way just to rub it in. This will never change ;-)

the errors that you get from JSON schema can sometimes be very confusing. I wanted to be able to generate errors that could easily be understood to speed up debugging time.

additionalProperties applies to all properties that are not accounted-for by properties or patternProperties in the immediate schema.

Weak sequencing reduces to a parallel merge when the operands are on different sets of participants. Weak sequencing reduces to strict sequencing when the operands work on the same participant.

Boilerplate is only boilerplate if it's the same everywhere, which it shouldn't be.

Code that is per-component instance should go into a second <script> tag.

A final cluster gathers lenses that explore phenomena that are arguably more elastic and with the potential to both indirectly maintain and explicitly reject and reshape existing norms. Many of the topics addressed here can be appropriately characterized as bottom-up, with strong and highly diverse cultural foundations. Although they are influenced by global and regional social norms, the expert framing of institutions, and the constraints of physical infrastructure (from housing to transport networks), they are also domains of experimentation, new norms, and cultural change. Building on this potential for either resisting or catalyzing change, the caricature chosen here is one of avian metaphor and myth: the Ostrich and Phoenix cluster. Ostrich-like behavior—keeping heads comfortably hidden in the sand—is evident in different ways across the lenses of inequity (Section 5.1), high-carbon lifestyles (Section 5.2), and social imaginaries (Section 5.3), which make up this cluster. Yet, these lenses also point to the power of ideas, to how people can thrive beyond dominant norms, and to the possibility of rapid cultural change in societies—all forms of transformation reminiscent of the mythological phoenix born from the ashes of its predecessor. It is conceivable that this cluster could begin to redefine the boundaries of analysis that inform the Enabler cluster, which in turn has the potential to erode the legitimacy of the Davos cluster. The very early signs of such disruption are evident in some of the following sections and are subsequently elaborated upon in the latter part of the discussion.

we have no way to know that the line nameMap[3] = "bob"; isn't somewhere in your program

Good catch, @Hokascha. The project claims support for cross-domain iframes, but reading the docs reveals that it does still require server access to the embedded domain.

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.

Whether you agree or not, to me there's nothing in this world that is entirely apolitical - when there are people there is politics. You don't have to agree with my views, nor do I expect you to. Diversity and disagreement is what drives mankind forward.

This is why for a recent Angular+Rails project we chose to use a testing stack from the backend technology’s ecosystem for e2e testing.

yes, the excessive pleasantries are purely for irony/humor, i would normally get straight to the point

2 out of 3 people in my household do not find it easy to understand. Maybe that is is not representative, but keep in mind that something you yourself understand (or in this case think you understand) always seems easy.

Notice the use of Enter key after backslash in the sed command.

“Who cares? Let’s just go with the style-guide” — to which my response is that caring about the details is in the heart of much of our doings. Yes, this is not a major issue; def self.method is not even a code smell. Actually, that whole debate is on the verge of being incidental. Yet the learning process and the gained knowledge involved in understanding each choice is alone worth the discussion. Furthermore, I believe that the class << self notation echoes a better, more stable understanding of Ruby and Object Orientation in Ruby. Lastly, remember that style-guides may change or be altered (carefully, though!).

It is also the first game I've seen whose icon for "mute" is not a crossed-out speaker/note, but a symbol for "pause" in musical notation...

send a courier straight from collection to delivery, point to point

Svelte is different in that by default most of your code is only going to run once; a console.log('foo') line in a component will only run when that component is first rendered.

All too often, people get hung up on the wrong aspects of the Unix Philosophy, and miss the forest for the trees

As to opinions about the shortcomings of the language itself, or the standard run-times, it’s important to realize that every developer has a different background, different experience, different needs, temperament, values, and a slew of other cultural motivations and concerns — individual opinions will always be largely personal and, to some degree, non-technical in nature.

Money could be good if it is spent to provide some of the above things. Money on it's own is hard because then it means I would have to spend time book-keeping and managing instead of programming.

There are myriads of platformers around, it's an oversaturated market, and just like industrial designer Karim Rashid said about there being no excuse by this point to make an uncomfortable chair, there's no excuse by this point to make a boring patformer.

In other words, once you've used Maybe you cannot hit nil with a missing method. This is remarkable because even &. doesn't save you from omitting || "No state" at the end of the computation. Basically, that's what they call "Type Safety".

Software architecture is about making fundamental structural choices that are costly to change once implemented.

note that TRB source code modifications are not proprietary

For this one we'll define a helper method to handle raising the correct errors. We have to do this because calling .run! would raise an ActiveInteraction::InvalidInteractionError instead of an ActiveRecord::RecordNotFound. That means Rails would render a 500 instead of a 404.

My understanding of "programming to an interface" is different than what the question or the other answers suggest. Which is not to say that my understanding is correct, or that the things in the other answers aren't good ideas, just that they're not what I think of when I hear that term.

If the program was important enough, Microsoft might actually go ahead and add some hack to their implementation so the the program would continue to work, but the cost of that is increased complexity (with all the ensuing problems) of the Windows code. It also makes life extra-hard for the Wine people, because they try to implement the WinAPI as well, but they can only refer to the documentation for how to do this, which leads to many programs not working as they should because they (accidentally or intentionally) rely on some implementation detail.

DSLs can be problematic for the user since the user has to manage state (e.g. am I supposed to call valid? first or update_attributes?). This is exactly why the #validate is the only method to change state in Reform.

So the hard and unsolvable problem becomes: how up-to-date do you really need to be?

After considering the value we place, and the tradeoffs we make, when it comes to knowing anything of significance, I think it becomes much easier to understand why cache invalidation is one of the hard problems in computer science

Now let me ask you, do you write JS for a single page application differently from a "traditional" web application? I sure hope you do! In a "traditional" application, you can get away with being sloppy because every time the user navigates to a new page, their browser destroys the DOM and the JavaScript context. SPAs, though, require a more thoughtful approach.

We can certainly explain the issues snap cause without using political or religious arguments. We did so in the documentation I linked to above.

This is a dynamic value because of hybrid devices which can use a mix of mouse and touch input.

The best place to let the developers know, and track those bugs is in the bug tracker. There are hundreds of forums online, all over the place in many languages. We can’t be expected to read all of them. Anyone with a launchpad ID (thus, anyone who has an account on this discourse instance) has the capability to file a bug. I’d strongly recommend doing so, for each specific issue. Taking just a few minutes to do that will help tremendously.

It’s worth mentioning that Svelte limits its scope to being only a UI component framework. Like React, it provides the view layer, but it has more batteries included with its component-scoped CSS and extensible stores for state management. Others like Angular and Vue provide a more all-in-one solution with official routers, opinionated state management, CLIs, and more. Sapper is Svelte’s official app framework that adds routing, server-side rendering, code splitting, and some other essential app features, but it has no opinions about state management and beyond. Some devs prefer Svelte’s minimal approach that defers problems to userland, encouraging more innovation, choice, and fragmentation, and other devs prefer a more fully integrated toolkit with a well-supported happy path.

There's a huge area of seemingly obvious user-centric products that don't exist simply because there isn't a working business model to support it.

Svelte by itself is great, but doing a complete PWA (with service workers, etc) that runs and scales on multiple devices with high quality app-like UI controls quickly gets complex. Flutter just provides much better tooling for that out of the box IMO. You are not molding a website into an app, you are just building an app. If I was building a relatively simple web app that is only meant to run on the web, then I might still prefer Svelte in some cases.

The index.js file is the main entry point and imports and exports everything from internal.js that you want to expose to the outside world.

One of Svelte's advantages, for me, is that I can test out ideas with relatively few lines of code. the #with feature could save me from adding a separate component for the content of an #each loop. I get frustrated when I have to create a new file, move the content of the #each clause, import it as a component, and add attributes and create exports for that, and implement events to send messages back, and event handlers, when I just wanted to test a small feature.

Wondering how to get field state from multiple fields at once? People coming from Redux-Form might be wondering where the equivalent of Redux Form's Fields component is, as a way to get state from several fields at once. The answer is that it's not included in the library because it's so easy to write one recursively composing Field components together.

Also, if you don't put that implementation of URLSearchParams in the global scope you're not using it as a polyfill but a ponyfill, and those are meant for your code, not for external dependencies.

However, this would lead to further divergence. Tooling that is built around the assumptions imposed by template literals wouldn't work. It would undermine the meaning of template literals. It would be necessary to define how JSX behaves within the rest of the ECMAScript grammar within the template literal anyway.

DX: start sapper project; configure eslint; eslint say that svelt should be dep; update package.json; build fails with crypt error; try to figure what the hell; google it; come here (if you have luck); revert package.json; add ignore error to eslint; Maybe we should offer better solution for this.

When the message say function was called outside component initialization first will look at my code and last at my configuration.

Most simple example: <script> import ChildComponent from './Child.svelte'; </script> <style> .class-to-add { background-color: tomato; } </style> <ChildComponent class="class-to-add" /> ...compiles to CSS without the class-to-add declaration, as svelte currently does not recognize the class name as being used. I'd expect class-to-add is bundled with all nested style declarations class-to-add is passed to ChildComponent as class-to-add svelte-HASH This looks like a bug / missing feature to me.

The language should work for developers, not the other way around.

feel like there needs to be an easy way to style sub-components without their cooperation

The problem with working around the current limitations of Svelte style (:global, svelte:head, external styles or various wild card selectors) is that the API is uglier, bigger, harder to explain AND it loses one of the best features of Svelte IMO - contextual style encapsulation. I can understand that CSS classes are a bit uncontrollable, but this type of blocking will just push developers to work around it and create worse solutions.

I'm just pushing on the "is this really a good idea" front

have EU based users (i.e any website running cookies that isn’t actively blocking EU based users);

Its purpose is to decrease the reliance on privacy policies and enhance the ability for people to share and control personal information.

I know, you don't trust Mozilla but do you also not trust the developer? I absolutely do! That is the whole point of this discussion. Mozilla doesn't trust S3.Translator or jeremiahlee but I do. They blocked page-translator for pedantic reasons. Which is why I want the option to override their decision to specifically install few extensions that I'm okay with.

I appreciate the vigilance, but it would be even better to actually publish a technical reasoning for why do you folks believe Firefox is above the device owner, and the root user, and why there should be no possibility through any means and configuration protections to enable users to run their own code in the release version of Firefox.

A language that features polymorphism allows developers to program in the general rather than program in the specific. $(document).ready(function() { recordAdModuleData(2964, "impressions","Dictionary Ad"); });

All of which means — per EU law — it should be equally easy for website visitors to choose not to be tracked as to agree to their personal data being processed.