Search
481 results for “develwithoutacause”
-
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.
-
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.
-
-
@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.
-
@surma @jaffathecake Very cool stuff! I'm a big proponent of build systems and I've always been frustrated with how web devs seem to couple bundlers and build systems together into a single tool, when they are completely different concepts. Would love to see more build system usage in the web space!
On the #Bazel front, I happen to be working on #rules_prerender, a ruleset for doing static site generation in Bazel, built on top of #aspect_rules_js.
https://github.com/dgp1130/rules_prerender/
It's maybe 90% feature complete towards 1.0, but unfortunately not yet documented. I've been distracted and haven't had the time to builds the docs site (examples are more thorough if you can follow what they're doing).
https://github.com/dgp1130/rules_prerender/tree/d5c9ac48b2f221d64c9bf9bf9b026e859f29a56e/examples/
I don't know if that would be useful for you, but I figured it tied in with the web + build systems + Bazel theme so it might be interesting to you.
-
Are there any good #web conferences / meetups with an #RFP open in the #BayArea or virtual?
There are a few projects I've been working on which I'd love to give talks about and share with the community (not Angular related). Could be talking about any/all of:
1. #HydroActive - A different take on hydration in an HTML-first world. https://github.com/dgp1130/HydroActive/
2. #rules_prerender - A #Bazel ruleset serving as a fast and scalable #StaticSiteGenerator. https://github.com/dgp1130/rules_prerender/
3. #HTMLFragments - A no-tooling, web standard-based approach to HTML over the wire. https://blog.dwac.dev/posts/html-fragments/Greatly appreciate boosts for reach!
-
This change also has a side benefit of giving you full control over the `ts_project` which compiles your prerendering logic. No more awkward wrapping in #rules_prerender, much cleaner!
-
Just landed a major update to #rules_prerender yesterday. I redesigned the core component API to better express dependencies between different "slices" of a component. For example, if you only depend on the client-side JavaScript, the bundler will still find the associated CSS styles.
https://github.com/dgp1130/rules_prerender/issues/40
Really excited about the direction here! Next step is the actual documentation site.
-
Speaking of not writing documentation: I also prototyped a very cool idea for how to greatly simplify the developer experience of #rules_prerender *and* make it understand even more complex dependency graphs.
Still more experimenting to be done, but I'm hopeful this is a viable strategy and will be a big improvement for developers! 😁
-
Released a new version of #rules_prerender with full #Preact support built-in.
https://github.com/dgp1130/rules_prerender/releases/tag/releases%2F0.0.27
Getting closer and closer to something I'd be willing to call a 1.0.0!
Biggest open issue is still actually writing all the documentation, though I keep getting distracted by other features.
-
After a lot of work, I've finally landed a release of #Bazel #rules_prerender which is compatible with #aspect_rules_js! https://github.com/dgp1130/rules_prerender/releases/tag/releases%2F0.0.17
This has been a long time coming, and the issue shows how big a change this was (https://github.com/dgp1130/rules_prerender/issues/48). It didn't help that I kept getting distracted with other things and forgot everything I was doing. 😅
#aspect_rules_js does seem like a solid improvement and it sets up #rules_prerender for a lot of awesome improvements in the future (#ESM, #bzlmod, better bundling, etc.) Super excited about where we can take this next!
Shout out to @alexeagle and Greg Magolan (who I don't think is on Mastodon?) for their help, couldn't have done it without you!
-
A sincere "fuck you" to #GetYourGuide (and any other app) which listed a tour fully online, let me pay and complete the transaction, and email me the result. But instead of emailing me a QR code, it emails me a link to their *native app*, forces me to install the 40 MB binary on mobile roaming data, remember the password to log in to the same one-off account made to purchase the ticket, *and then* show me the QR code to show the tour guide. Just email me the damn QR code!
This accomplishes *nothing* but adding 14 clicks, 5 - 20 minutes to the check in time (depending on how easily the user guesses their password), and requiring a mobile data connection.
-
"New frameworks are using compilers to optimize the code you write into efficient DOM operations, like #Svelte and #Astro."
Me: *cries in #Angular*
"I think there's a framework that does everything with template literals"
"I think you mean #HTMX"
Me: *cries in #LitElement*
-
Great post on #ClosureCompiler, it's history at #Google and how it evolved compared to #TypeScript.
https://effectivetypescript.com/2023/09/27/closure-compiler/
I can help with one of the last points:
> True to form, this tool [tsickle] is open source but pretty inscrutable to an outsider. It may be used by Angular but I couldn't tell.
I can confirm that Angular does *not* run `tsickle` or Closure in user projects with `ng build`. There was an experiment some years ago where we tried this to see if we could improve bundle sizes, but found that asking users to write Closure-optimizable code was too difficult and hard to justify outside Google. As a result, we never ran this in prod.
I believe we do technically run `tsickle` in Angular GitHub repositories, as we have a unique build system setup with #Bazel and #rules_nodejs. If you've ever contributed to Angular, you probably ran `tsickle`. We've been trying to remove this dependency, but I don't think it's happened yet.
-
Looking into the current state-of-the-art for #NodeJS security and I'm kind of baffled by how primitive it is compared to browsers.
* No #TrustedTypes.
* No `SafeHtml`.
* No #ContentSecurityPolicy.
* No permission abstractions.
* Not even a way to ban `eval()`.Best thing I've found is `--frozen-intrinsics`, which is interesting, and I don't think there's a browser equivalent. You still have to freeze `globalThis` though to get much value out of it.
https://nodejs.org/en/docs/guides/security/#monkey-patching-cwe-349
There are also some interesting security policies, which look like they have a lot of potential. However they're all experimental right now and seem focused on code integrity.
https://nodejs.org/api/permissions.html
This this really the state-of-the-art for #Node security right now? Am I missing something?
-
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! 🙃
-
It's incredible to me just how many #banking applications have completely distinct user accounts for different parts of their system. Just setting up a new account now and it was the *third* login screen I found which was the correct one. The first two gave no indication I was on the wrong login either, they just didn't work.
I can only assume this is a product of #ConwaysLaw. It would be hilarious if it weren't so depressing.
-
As for what I hope would be next (keep in mind I did not play #RE2Remake or #RE3Remake): I don't think it's worth remaking #RE5 given it's general reception. I'd much rather see this team make a brand new Resident Evil game in this engine. They've clearly got a solid track record at this point and we never really got a "good" over-the-shoulder RE game after 4 (until the remakes).
I'd love to see an entirely new, from scratch experience built with these mechanics and engine as a starting point.
This does kind of put the team in the same position as the RE franchise was post-RE4, where they previously fucked it all up. However, RE4 was a very unique "lightning in a bottle" moment where it got so many things right on the first try. Now that we've had several games of bad ideas and the RE 2/3 remakes, I feel like we should have a better sense of what does and doesn't work which will hopefully lead to a better end product than RE5 was. Just what I'd like to see anyways.
-
@josep Personally I'm partial to #WebDriverIO since it actually uses the #WebDriver specification and is a little more future-proof as a result IMHO. Also comes with #Angular integration!
```
$ ng add @wdio/schematics
``` -
@slightlyoff I use #JSON5 in a Chrome Extension I own solely to comment the manifest and it works great.
I do think the bigger issue is that JSON is a terrible configuration language (but great wire format!). We should be using #TOML, #YAML, or something else more targeted for that use case.
-
@slightlyoff I use #JSON5 in a Chrome Extension I own solely to comment the manifest and it works great.
I do think the bigger issue is that JSON is a terrible configuration language (but great wire format!). We should be using #TOML, #YAML, or something else more targeted for that use case.
-
@slightlyoff I use #JSON5 in a Chrome Extension I own solely to comment the manifest and it works great.
I do think the bigger issue is that JSON is a terrible configuration language (but great wire format!). We should be using #TOML, #YAML, or something else more targeted for that use case.
