Search
481 results for “develwithoutacause”
-
#Idea: Open a new #GoogleDoc and write out a bunch of bullet points about a document/memo/essay you want to write then click "Extensions > Convert to Prose". This would call #ChatGPT (or whatever) and convert those bullet points into a full doc which structures the ideas, elaborates a bit, and provides a concrete starting point.
I know I always start docs with a bunch of bullet points and slowly expand on them. Having a robot start that process would help get complex ideas on paper and help with the "blank document" problem.
-
#Idea: Open a new #GoogleDoc and write out a bunch of bullet points about a document/memo/essay you want to write then click "Extensions > Convert to Prose". This would call #ChatGPT (or whatever) and convert those bullet points into a full doc which structures the ideas, elaborates a bit, and provides a concrete starting point.
I know I always start docs with a bunch of bullet points and slowly expand on them. Having a robot start that process would help get complex ideas on paper and help with the "blank document" problem.
-
#Idea: Open a new #GoogleDoc and write out a bunch of bullet points about a document/memo/essay you want to write then click "Extensions > Convert to Prose". This would call #ChatGPT (or whatever) and convert those bullet points into a full doc which structures the ideas, elaborates a bit, and provides a concrete starting point.
I know I always start docs with a bunch of bullet points and slowly expand on them. Having a robot start that process would help get complex ideas on paper and help with the "blank document" problem.
-
#Idea: Open a new #GoogleDoc and write out a bunch of bullet points about a document/memo/essay you want to write then click "Extensions > Convert to Prose". This would call #ChatGPT (or whatever) and convert those bullet points into a full doc which structures the ideas, elaborates a bit, and provides a concrete starting point.
I know I always start docs with a bunch of bullet points and slowly expand on them. Having a robot start that process would help get complex ideas on paper and help with the "blank document" problem.
-
@jerod It's a bit early, but how about a #WebComponent library for adding hydration and interactivity without duplicating your build or rendering logic?
https://techhub.social/@develwithoutacause/109547375333703560
-
Just wasted an hour debugging why:
```BUILD
load("@aspect_rules_ts//ts:defs.bzl", "ts_config")
load("@npm//@bazel/typescript:index.bzl", "ts_config")ts_config(
name = "tsconfig",
src = "tsconfig.json",
)
```Wasn't working as expected.
Apparently #Bazel #Starlark is just ok with loading the same symbol from two different locations and has no complaints! 🙃
-
@tbroyer Thanks for sharing that. I'd heard of the approach but don't think I'd read that article specifically. The performance metrics are very interesting.
I think the difference is that #HTMLFragments routing is technically an #SPA approach and keeps #JavaScript context between routes in a way that a #ServiceWorker navigation would not.
HTML Fragments as a concept is also a little more flexible beyond rendering full pages. It allows you to dynamically render individual components instead of a full page. For example, you can use it to infinite scroll a list, or edit an item of the list and rerender on the server without invalidating the whole page. This is discussed more in the original post:
https://blog.dwac.dev/posts/html-fragments/
For a fully static site with a lot of content, I think the service worker approach could work well, while HTML fragments provides a bit more interactivity.
-
@tbroyer Thanks for sharing that. I'd heard of the approach but don't think I'd read that article specifically. The performance metrics are very interesting.
I think the difference is that #HTMLFragments routing is technically an #SPA approach and keeps #JavaScript context between routes in a way that a #ServiceWorker navigation would not.
HTML Fragments as a concept is also a little more flexible beyond rendering full pages. It allows you to dynamically render individual components instead of a full page. For example, you can use it to infinite scroll a list, or edit an item of the list and rerender on the server without invalidating the whole page. This is discussed more in the original post:
https://blog.dwac.dev/posts/html-fragments/
For a fully static site with a lot of content, I think the service worker approach could work well, while HTML fragments provides a bit more interactivity.
-
@tbroyer Thanks for sharing that. I'd heard of the approach but don't think I'd read that article specifically. The performance metrics are very interesting.
I think the difference is that #HTMLFragments routing is technically an #SPA approach and keeps #JavaScript context between routes in a way that a #ServiceWorker navigation would not.
HTML Fragments as a concept is also a little more flexible beyond rendering full pages. It allows you to dynamically render individual components instead of a full page. For example, you can use it to infinite scroll a list, or edit an item of the list and rerender on the server without invalidating the whole page. This is discussed more in the original post:
https://blog.dwac.dev/posts/html-fragments/
For a fully static site with a lot of content, I think the service worker approach could work well, while HTML fragments provides a bit more interactivity.
-
@tbroyer Thanks for sharing that. I'd heard of the approach but don't think I'd read that article specifically. The performance metrics are very interesting.
I think the difference is that #HTMLFragments routing is technically an #SPA approach and keeps #JavaScript context between routes in a way that a #ServiceWorker navigation would not.
HTML Fragments as a concept is also a little more flexible beyond rendering full pages. It allows you to dynamically render individual components instead of a full page. For example, you can use it to infinite scroll a list, or edit an item of the list and rerender on the server without invalidating the whole page. This is discussed more in the original post:
https://blog.dwac.dev/posts/html-fragments/
For a fully static site with a lot of content, I think the service worker approach could work well, while HTML fragments provides a bit more interactivity.
-
@tbroyer Thanks for sharing that. I'd heard of the approach but don't think I'd read that article specifically. The performance metrics are very interesting.
I think the difference is that #HTMLFragments routing is technically an #SPA approach and keeps #JavaScript context between routes in a way that a #ServiceWorker navigation would not.
HTML Fragments as a concept is also a little more flexible beyond rendering full pages. It allows you to dynamically render individual components instead of a full page. For example, you can use it to infinite scroll a list, or edit an item of the list and rerender on the server without invalidating the whole page. This is discussed more in the original post:
https://blog.dwac.dev/posts/html-fragments/
For a fully static site with a lot of content, I think the service worker approach could work well, while HTML fragments provides a bit more interactivity.
-
@jjude The routing demo is here:
https://github.com/dgp1130/html-fragments-routing-demo/
And the original #HTMLFragments demo of a Twitter clone is here:
https://github.com/dgp1130/html-fragments-demo
Which links are dead? The post is pretty new, so I would hope anything I referenced is still up, but maybe I typo-d something...
-
@jjude The routing demo is here:
https://github.com/dgp1130/html-fragments-routing-demo/
And the original #HTMLFragments demo of a Twitter clone is here:
https://github.com/dgp1130/html-fragments-demo
Which links are dead? The post is pretty new, so I would hope anything I referenced is still up, but maybe I typo-d something...
-
@jjude The routing demo is here:
https://github.com/dgp1130/html-fragments-routing-demo/
And the original #HTMLFragments demo of a Twitter clone is here:
https://github.com/dgp1130/html-fragments-demo
Which links are dead? The post is pretty new, so I would hope anything I referenced is still up, but maybe I typo-d something...
-
@jjude The routing demo is here:
https://github.com/dgp1130/html-fragments-routing-demo/
And the original #HTMLFragments demo of a Twitter clone is here:
https://github.com/dgp1130/html-fragments-demo
Which links are dead? The post is pretty new, so I would hope anything I referenced is still up, but maybe I typo-d something...
-
@jjude The routing demo is here:
https://github.com/dgp1130/html-fragments-routing-demo/
And the original #HTMLFragments demo of a Twitter clone is here:
https://github.com/dgp1130/html-fragments-demo
Which links are dead? The post is pretty new, so I would hope anything I referenced is still up, but maybe I typo-d something...
-
@tomayac 😁 I hadn't heard of "mini apps", I'll have to read more in that series, but the use of iframes sounds very similar. It reminds me a bit of the `embed` element I proposed here: https://blog.dwac.dev/posts/html-fragments/#ecosystem
I imagine sandboxing would make those iframes tricky to work with in a lot of respects. With #HTMLFragments, at least everything is in the same frame and has the same JS execution context.
-
@tomayac 😁 I hadn't heard of "mini apps", I'll have to read more in that series, but the use of iframes sounds very similar. It reminds me a bit of the `embed` element I proposed here: https://blog.dwac.dev/posts/html-fragments/#ecosystem
I imagine sandboxing would make those iframes tricky to work with in a lot of respects. With #HTMLFragments, at least everything is in the same frame and has the same JS execution context.
-
@tomayac 😁 I hadn't heard of "mini apps", I'll have to read more in that series, but the use of iframes sounds very similar. It reminds me a bit of the `embed` element I proposed here: https://blog.dwac.dev/posts/html-fragments/#ecosystem
I imagine sandboxing would make those iframes tricky to work with in a lot of respects. With #HTMLFragments, at least everything is in the same frame and has the same JS execution context.
-
@tomayac 😁 I hadn't heard of "mini apps", I'll have to read more in that series, but the use of iframes sounds very similar. It reminds me a bit of the `embed` element I proposed here: https://blog.dwac.dev/posts/html-fragments/#ecosystem
I imagine sandboxing would make those iframes tricky to work with in a lot of respects. With #HTMLFragments, at least everything is in the same frame and has the same JS execution context.
-
@tomayac 😁 I hadn't heard of "mini apps", I'll have to read more in that series, but the use of iframes sounds very similar. It reminds me a bit of the `embed` element I proposed here: https://blog.dwac.dev/posts/html-fragments/#ecosystem
I imagine sandboxing would make those iframes tricky to work with in a lot of respects. With #HTMLFragments, at least everything is in the same frame and has the same JS execution context.
-
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?
-
New blog post: Building a #router with #HTMLFragments.
https://blog.dwac.dev/posts/html-fragments-routing/
This explorers how we can use HTML fragments to define routes, load them dynamically, and then apply them to the main page content. It talks about more complexities with streaming #HTML (because I didn't learn my lesson last time) and even has a bonus section on shipping an application server _inside_ a #ServiceWorker.
Lots of interesting stuff, I hope you check it out!
-
New blog post: Building a #router with #HTMLFragments.
https://blog.dwac.dev/posts/html-fragments-routing/
This explorers how we can use HTML fragments to define routes, load them dynamically, and then apply them to the main page content. It talks about more complexities with streaming #HTML (because I didn't learn my lesson last time) and even has a bonus section on shipping an application server _inside_ a #ServiceWorker.
Lots of interesting stuff, I hope you check it out!
-
New blog post: Building a #router with #HTMLFragments.
https://blog.dwac.dev/posts/html-fragments-routing/
This explorers how we can use HTML fragments to define routes, load them dynamically, and then apply them to the main page content. It talks about more complexities with streaming #HTML (because I didn't learn my lesson last time) and even has a bonus section on shipping an application server _inside_ a #ServiceWorker.
Lots of interesting stuff, I hope you check it out!
-
New blog post: Building a #router with #HTMLFragments.
https://blog.dwac.dev/posts/html-fragments-routing/
This explorers how we can use HTML fragments to define routes, load them dynamically, and then apply them to the main page content. It talks about more complexities with streaming #HTML (because I didn't learn my lesson last time) and even has a bonus section on shipping an application server _inside_ a #ServiceWorker.
Lots of interesting stuff, I hope you check it out!
-
New blog post: Building a #router with #HTMLFragments.
https://blog.dwac.dev/posts/html-fragments-routing/
This explorers how we can use HTML fragments to define routes, load them dynamically, and then apply them to the main page content. It talks about more complexities with streaming #HTML (because I didn't learn my lesson last time) and even has a bonus section on shipping an application server _inside_ a #ServiceWorker.
Lots of interesting stuff, I hope you check it out!
-
So apparently #Firefox is at least partially right here. `document.write()` implicitly resets the document meaning `document.body` gets reset to `null` and recreated when #HTML is parsed.
My mistake was observing the `document.body` _before_ the reset, so content streams into a _new_ `<body />` element I'm not observing.
The solution is to `document.open()` explicitly to reset the document early, _and then_ observe `document.body`. Subsequent `document.write()` calls will append to that `<body />` tag and trigger mutations.
There's still some weird divergences between Firefox and #Chrome / #Safari which could probably be addressed, but I was able to make #HTMLFragments work at least.
https://github.com/dgp1130/html-fragments-demo/commit/97901e3d0ddaf38b4ef170d81719eddb52cab090
Shout out to Olli Pettay for identifying the issue so quickly!
-
So apparently #Firefox is at least partially right here. `document.write()` implicitly resets the document meaning `document.body` gets reset to `null` and recreated when #HTML is parsed.
My mistake was observing the `document.body` _before_ the reset, so content streams into a _new_ `<body />` element I'm not observing.
The solution is to `document.open()` explicitly to reset the document early, _and then_ observe `document.body`. Subsequent `document.write()` calls will append to that `<body />` tag and trigger mutations.
There's still some weird divergences between Firefox and #Chrome / #Safari which could probably be addressed, but I was able to make #HTMLFragments work at least.
https://github.com/dgp1130/html-fragments-demo/commit/97901e3d0ddaf38b4ef170d81719eddb52cab090
Shout out to Olli Pettay for identifying the issue so quickly!
-
So apparently #Firefox is at least partially right here. `document.write()` implicitly resets the document meaning `document.body` gets reset to `null` and recreated when #HTML is parsed.
My mistake was observing the `document.body` _before_ the reset, so content streams into a _new_ `<body />` element I'm not observing.
The solution is to `document.open()` explicitly to reset the document early, _and then_ observe `document.body`. Subsequent `document.write()` calls will append to that `<body />` tag and trigger mutations.
There's still some weird divergences between Firefox and #Chrome / #Safari which could probably be addressed, but I was able to make #HTMLFragments work at least.
https://github.com/dgp1130/html-fragments-demo/commit/97901e3d0ddaf38b4ef170d81719eddb52cab090
Shout out to Olli Pettay for identifying the issue so quickly!