Search
481 results for “develwithoutacause”
-
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.
-
Just released v0.1.7 of #HydroActive with the main new feature being support of the "On-Demand Definitions" community protocol I recently proposed. If you're interested to try it out, this is an easy way to give it a shot.
https://github.com/dgp1130/HydroActive/releases/tag/releases%2F0.1.7
https://github.com/webcomponents-cg/community-protocols/pull/67
-
Just released v0.1.7 of #HydroActive with the main new feature being support of the "On-Demand Definitions" community protocol I recently proposed. If you're interested to try it out, this is an easy way to give it a shot.
https://github.com/dgp1130/HydroActive/releases/tag/releases%2F0.1.7
https://github.com/webcomponents-cg/community-protocols/pull/67
-
Just released v0.1.7 of #HydroActive with the main new feature being support of the "On-Demand Definitions" community protocol I recently proposed. If you're interested to try it out, this is an easy way to give it a shot.
https://github.com/dgp1130/HydroActive/releases/tag/releases%2F0.1.7
https://github.com/webcomponents-cg/community-protocols/pull/67
-
Just released v0.1.7 of #HydroActive with the main new feature being support of the "On-Demand Definitions" community protocol I recently proposed. If you're interested to try it out, this is an easy way to give it a shot.
https://github.com/dgp1130/HydroActive/releases/tag/releases%2F0.1.7
https://github.com/webcomponents-cg/community-protocols/pull/67
-
Just released v0.1.7 of #HydroActive with the main new feature being support of the "On-Demand Definitions" community protocol I recently proposed. If you're interested to try it out, this is an easy way to give it a shot.
https://github.com/dgp1130/HydroActive/releases/tag/releases%2F0.1.7
https://github.com/webcomponents-cg/community-protocols/pull/67
-
Today's offender is a pair of #Acrux headphones which refuses to switch devices after auto-connecting to one. Then, AFAICT *has no pair button* so the only way to get it to pair is to completely disconnect it from its existing device, thereby triggering pairing mode.
Terrible experience.
-
Today's offender is a pair of #Acrux headphones which refuses to switch devices after auto-connecting to one. Then, AFAICT *has no pair button* so the only way to get it to pair is to completely disconnect it from its existing device, thereby triggering pairing mode.
Terrible experience.
-
Today's offender is a pair of #Acrux headphones which refuses to switch devices after auto-connecting to one. Then, AFAICT *has no pair button* so the only way to get it to pair is to completely disconnect it from its existing device, thereby triggering pairing mode.
Terrible experience.
-
Today's offender is a pair of #Acrux headphones which refuses to switch devices after auto-connecting to one. Then, AFAICT *has no pair button* so the only way to get it to pair is to completely disconnect it from its existing device, thereby triggering pairing mode.
Terrible experience.
-
Today's offender is a pair of #Acrux headphones which refuses to switch devices after auto-connecting to one. Then, AFAICT *has no pair button* so the only way to get it to pair is to completely disconnect it from its existing device, thereby triggering pairing mode.
Terrible experience.
-
#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?
-
A short video I did was featured today on Daniel Glejzner's
https://angularchristmascalendar.com showing off a couple Tooling features you might have missed in #Angular #v19 as well as reflecting on the state of the framework and where we're going from here.I'm #10, the snowman. Give it a watch!
-
A short video I did was featured today on Daniel Glejzner's
https://angularchristmascalendar.com showing off a couple Tooling features you might have missed in #Angular #v19 as well as reflecting on the state of the framework and where we're going from here.I'm #10, the snowman. Give it a watch!
-
A short video I did was featured today on Daniel Glejzner's
https://angularchristmascalendar.com showing off a couple Tooling features you might have missed in #Angular #v19 as well as reflecting on the state of the framework and where we're going from here.I'm #10, the snowman. Give it a watch!
-
A short video I did was featured today on Daniel Glejzner's
https://angularchristmascalendar.com showing off a couple Tooling features you might have missed in #Angular #v19 as well as reflecting on the state of the framework and where we're going from here.I'm #10, the snowman. Give it a watch!
-
A short video I did was featured today on Daniel Glejzner's
https://angularchristmascalendar.com showing off a couple Tooling features you might have missed in #Angular #v19 as well as reflecting on the state of the framework and where we're going from here.I'm #10, the snowman. Give it a watch!
-
What is the difference between extending a subclass of an object and `Object.create`-ing based on a prototype for the purposes of JS private fields? I'm surprised to get different behavior between:
```javascript
class Foo {
#foo = 'foo';doSomething(): void {
console.log(this.#foo);
}
}class Bar extends Foo {}
new Foo().doSomething(); // Works
new Bar().doSomething(); // Works
Object.create(new Foo()).doSomething(); // ERROR: Cannot read private member.
```In my mind, they should create basically the same prototype inheritance. Why does `Object.create` fail?
-
What is the difference between extending a subclass of an object and `Object.create`-ing based on a prototype for the purposes of JS private fields? I'm surprised to get different behavior between:
```javascript
class Foo {
#foo = 'foo';doSomething(): void {
console.log(this.#foo);
}
}class Bar extends Foo {}
new Foo().doSomething(); // Works
new Bar().doSomething(); // Works
Object.create(new Foo()).doSomething(); // ERROR: Cannot read private member.
```In my mind, they should create basically the same prototype inheritance. Why does `Object.create` fail?
-
What is the difference between extending a subclass of an object and `Object.create`-ing based on a prototype for the purposes of JS private fields? I'm surprised to get different behavior between:
```javascript
class Foo {
#foo = 'foo';doSomething(): void {
console.log(this.#foo);
}
}class Bar extends Foo {}
new Foo().doSomething(); // Works
new Bar().doSomething(); // Works
Object.create(new Foo()).doSomething(); // ERROR: Cannot read private member.
```In my mind, they should create basically the same prototype inheritance. Why does `Object.create` fail?
-
What is the difference between extending a subclass of an object and `Object.create`-ing based on a prototype for the purposes of JS private fields? I'm surprised to get different behavior between:
```javascript
class Foo {
#foo = 'foo';doSomething(): void {
console.log(this.#foo);
}
}class Bar extends Foo {}
new Foo().doSomething(); // Works
new Bar().doSomething(); // Works
Object.create(new Foo()).doSomething(); // ERROR: Cannot read private member.
```In my mind, they should create basically the same prototype inheritance. Why does `Object.create` fail?
-
What is the difference between extending a subclass of an object and `Object.create`-ing based on a prototype for the purposes of JS private fields? I'm surprised to get different behavior between:
```javascript
class Foo {
#foo = 'foo';doSomething(): void {
console.log(this.#foo);
}
}class Bar extends Foo {}
new Foo().doSomething(); // Works
new Bar().doSomething(); // Works
Object.create(new Foo()).doSomething(); // ERROR: Cannot read private member.
```In my mind, they should create basically the same prototype inheritance. Why does `Object.create` fail?
-
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.
-
I was having a conversation about #AbortSignal and the difficulties with managing it / passing through properly and it made me realize that #AsyncContext could totally solve this problem?
What if we had a standard `AsyncContext.signal` built-in and then anyone can check and listen to that to know when they are aborted. Even other standard functions could check this to handle abort behavior automatically.
Imagine if `fetch` automatically aborted based on this signal:
```typescript
async function parent(): Promise<void> {
await child();
}async function child(): Promise<void> {
const res1 = await fetch('/one'); // Inherits `AsyncContext.signal`.
const res2 = await fetch('/two'); // Inherits `AsyncContext.signal`.
// ...
}// Run `parent()` and timeout after 1sec.
await AsyncContext.signal.run(AbortSignal.timeout(1_000), () => parent());
```That seems pretty useful. I filed https://github.com/tc39/proposal-async-context/issues/103 to discuss the idea further.
-
#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.