Search
481 results for “develwithoutacause”
-
Lots of cool stuff in this release, I'm particularly excited with the integration into the #ChromeDevTools performance panel. It really helps build clarity around how Angular is contributing to page performance.
Even more exciting DevTools features coming soon to an Angular extension near you!
-
Lots of cool stuff in this release, I'm particularly excited with the integration into the #ChromeDevTools performance panel. It really helps build clarity around how Angular is contributing to page performance.
Even more exciting DevTools features coming soon to an Angular extension near you!
-
Giving #MonsterHunter a try for the first time with #Wilds. Wish me luck!
-
I seriously cannot understand why `npx pkg` is not interpreted as `npx pkg@latest`. That is literally my entire reason for running it.
-
This toot brought to you by #PriorityPass whom I have no concerns for publicly shaming about.
-
Is the #HAR format formally specified anywhere?
Best I can find is this (abandoned) #W3C spec.
https://w3c.github.io/web-performance/specs/HAR/Overview.html
Apparently #Chrome #Extensions receive HAR data about the network (https://developer.chrome.com/docs/extensions/reference/api/devtools/network#type-Request), but I'm struggling to understand the expected behavior for requests with binary post data, as that seems completely ambiguous.
It's days like this, where you have to backwards engineer unspecified behavior, really make you appreciate what #web #standards do for everyone. Shame extensions aren't held to that same standard.
-
#TIL about #MicroData, a way of embedding metadata inside #web pages for #SEO.
https://developer.mozilla.org/en-US/docs/Web/HTML/Microdata
Does anyone actually do this in 2024? I feel like semantic HTML combined with #OpenGraph mostly solves this problem. Is this a useful tool for web developers?
-
Since it's related, here's the `removeEventListener` API I wish we had:
```javascript
const removeListener = window.addEventListener('something', () => { /* ... */ });await someTime();
removeListener();
```Benefits:
1. You only provide the handler once, so it works great with lambdas. You don't need to keep a reference to the handler just to remove it later.
2. You don't need to provide the event twice. It's additional information to hard-code and/or dynamically track.
3. You can't accidentally `removeEventListener` on a function which was not bound in the first place (which is a no-op that often indicates a bug such as `removeEventListener('something', foo.bind(this)`).This design is basically a copy of the way #RxJS handles subscriptions, but I find this much more ergonomic and intuitive.
-
Question for people using #MicroFrontends and #Monorepos: What do your #integration tests look like?
The #Google model of monorepos always builds everything at HEAD, but doing so would not catch version skew issues that come with independent deployments. That implies that your integration tests _cannot_ just build and run everything at HEAD, you actually have to deploy each change individually to a staging environment and alert on failures.
That feels like a much more complex setup than I'm used to seeing for integration tests. Do people actually do this or is version skew a giant blind spot for microfrontend testing?
-
@jaredwhite Yeah I am wondering if it would make more sense to have a separate community protocol for initialization.
I'm very strongly of the opinion that you should never be able to get a reference to an uninitialized object (I think this is sometimes called #RAII?) Unfortunately that ship sailed for web components a long time ago. Constructors are worthless in this context too (and terrible per https://blog.dwac.dev/posts/ctor/). So maybe a protocol around initialization would help, whether that is or isn't `defer-hydration`.
-
#TIL #JavaScript #OptionalChaining "short circuits" the rest of the evaluation so you can safely write `a?.b.c()` (no need for `a?.b?.c()`).
Personally I find it kind of confusing that introducing parens or a variable changes behavior, but I can see the reasoning behind it.
-
More seriously, this is a legitimate #cybersecurity vulnerability in #USBank which should be fixed ASAP.
USBank is training it's users to just put their banking information into any site which asks and actively hurts the security of it's own users as well trains those users to do the same for any other service. What's the point of telling users to look for the padlock and check the origin, if sites will disregard it altogether anyways?
-
Are there any web frameworks out there which push the majority of user code off the main thread?
I'm thinking of an architecture such as automatically loading your #React components into a #WebWorker, doing all rendering off main thread, and then having the framework pass the VDom back to the main thread to be reconciled on the actual document.
I know various frameworks have experimented with web workers (including #Angular), but I don't know if any quite used this kind of approach? I'm curious if anyone has tried this and what the outcome was.
-
I'm part way through the #Ahsoka series and I have to say, it was a really weird narrative choice to have #Dory show up and ask the star whales for help. Way too convenient that Earth whales and star whales speak the same language.
I guess this is just the #DisneyExtendedUniverse we live in now.
-
I had been hoping to spend some time this weekend on #HydroActive, but #Akuma is just too much fun right now.
-
CW: #EldenRing #ShadowOfTheErdtree #Midra
Just beat #Midra and I think he's my favorite boss of the DLC so far. His attacks and combos are really clear, so none of his moves felt cheap.
The #FrenziedFlame stuff is really cool set dressing in the area and fun attacks. He looks awesome with the yellow fire effect and I'm glad they don't really do damage over time. It would have been really easy to treat his lingering fire like #Mohg's bloodflame and get annoying very quickly, but the devs didn't go that route and I'm greatly appreciative.
My one nitpick is that the boss can occasionally one-shot you if an attack also triggers madness, since you're stunned and likely to get hit a second time plus the raw madness damage. A 1-2-3 hit like that will usually kill. It's not too difficult to manage the madness meter or use some consumables, so I don't mind it too much though.
10/10 boss, would go mad again.
-
Am I the only one who thinks we got #greenfield and #brownfield backwards?
I always hear those terms as planting a farm, where a brown field implies you can do what you want from scratch, but a green field means you have to work around the existing vegetation and produce.
Apparently the terms come from civil engineering, not farming and refer more to developed / undeveloped real estate.
en.wikipedia.org/wiki/Greenfi...
en.wikipedia.org/wiki/Brownfi...Would most people intuit that meaning without this background? Feels like a bad analogy for software engineers.
-
Playing with #ESModules in #Node today and had some fun.
-
What could we do if the #web spec supported defining multiple #ESModules in the same file? I wonder if that would allow runtime linking of chunked #JavaScript in more flexible ways than the format can currently support? I'm imagining a syntax like:
```
// File: /user.js// No need to request /logger.js, just
// inline it the first time it's needed.
module '/logger.js' {
export function log() { }
}// Define `/user.js` module.
import { log } from '/logger.js';
function logUser() { }
``````
// File: /analytics.js// Can reuse '/logger.js' without having
// to download it separately.
import { log } from '/logger.js';
function collect() { }
```This way servers could trivially move '/logger.js' between '/user.js' or '/analytics.js' at runtime per-user based on whatever chunk the user downloaded first.
https://github.com/tc39/proposal-module-declarations seems to explore this, though everything is lexically bound so I don't see how you could support this particular use case. Maybe I'm missing something?
-
Literal #ShowerThought #idea: A #JavaScript "composite" #WeakMap. Returns a value for a given array of references. All weakly referenced to avoid memory leaks. Something like:
```
const map = new CompositeWeakMap();
const keys = [ {}, {}, {} ];map.set(keys, 'test');
map.get(keys); // 'test'
```Not 100% sure it's possible since `WeakMap` is only keyed by a single reference, but I think it's possible if you chain two `WeakMap` objects together. I have an implementation in my head, but I'll have to actually try it to see if it works for real. 🤔
-
@angelmunoz Maybe #htm? I think you can use that on the server like regular #Preact.
-
-
#rules_prerender can actually do this and it's a very powerful feature, but using it in that ecosystem requires buying into a much larger toolchain not everyone will want.
https://github.com/dgp1130/rules_prerender/
I'm imagining a more flexible, standalone tool which could be effectively used in any web toolchain.
-
@passle The full repo is here with the relevant source code, explanation of how it works, and some notable caveats.
https://github.com/dgp1130/out-of-order-streaming/
It's a very cool idea to incorporate into any #SSR component model using shadow DOM. I'll have to consider it for #rules_prerender if and when we get to SSR support.
