benjaminjackman

Maybe you can associate html files with or use open with to pass them into a script that calls python -m http.server and creates and opens a url to the file via the python server in the browser.

That's exciting about Firefox, though I really wish that firefox would support OPFS in such a way as to allow selecting the directory where the files are located, beyond just persistence, there are some use cases where that is required (vscode.dev for example).

Precisely, or even find a way not to require commas.

I don't think we've seen a language that is explicitly designed to be as ergonomic / accommodating as possible to developers.

Something that is the good protocol truism equivalent of "be liberal in accepted input and strict produced output".

Granted that flies in the face of another programming language design best practice of having 1 way to do a particular thing.

In the docs for Node.remove_child(Node node)[1] it says

"Removes a child node. The node is NOT deleted and must be deleted manually."

Do you still have to queue_free the top node that was removed from the tree, or else how is it being deleted. Or is there a different method to call for removing it from the tree.

BTW: I really like the `_init` / `_enter_tree` / `_ready` / `_exit_tree` lifecycle as was described.

1:https://docs.godotengine.org/en/stable/classes/class_node.ht...

Sounds like Godot 4 is replacing GDNative with GDExtension. Just wondering if you have tried it out and have any thoughts. Is it a smoother experience / about the same etc.

maybe combine them with user defined !bang commands like on duckduckgo, !hn search_term (searches hn sites list from above).

For Lesson 1: I think the general pattern that ought to be followed is to "prefer undo to warnings." Undo is often harder to implement, however it's usually a superior experience.

I don't think it's clear cut that it should be out of band 100% of the time. I think there are use cases where inline is useful.

Cycles are definitely an issue, I am not sure there is even way to work around that, except to pull the cycles apart (which may not always be possible but is usually not a bad programming practice when it is). However at the library level, libraries tend not to circularly import each other. If it's being done at the inside a project level the build tool would be generating it so dealing with the module graph being invalidated may not be a hassle (or even necessarily a bad thing), in that case it could modify the files or it could be generating a lock file / import map (which I agree has benefits at that level of not forcing every source to be transpiled, but some of that probably still has to happen for module reloading e.g. appended search parameters to the module path for cache invalidation / module reloading during development like vite.js does for example, and realistically given the nature of the ecosystem some transpilation is going to have to happen either because of .ts or just because of browser differences).

For a top-level deps.ts / dep.js file pattern there probably won't be any cycles. That pattern is to declare a root deps.js file for your project that locks things down and re-exports from third party libraries a use the exports from that as the basis for other imports. For this pattern I think SRI would be extremely helpful and add enough benefit to justify it (even though SRI may not be used in the cases you listed).

Also for smaller projects or main modules having the SRI hash inline is really helpful.

Ok that makes a lot of sense, the link you shared helped explain things in denoland quite well (and reminds me that I really need to give it another go).

From the link I see this example:

    in src/deps.ts

    // Add a new dependency to "src/deps.ts", used somewhere else.
    export { xyz } from "https://unpkg.com/xyz-lib@v0.9.0/lib.ts";

    Then essentially a create/update lock-file command is run. 

    Then the lock file is checked into version control. 

    Then another developer checks it out and runs a cache reload command.

Having said I think having it in the import syntax would provide a few benefits:

1. No extra steps need to be run & hopefully IDEs could auto-complete the hash.

2. Would hopefully be standardized with the browser allowing for native browser support as well (or perhaps lock.json could be standardized with something like import maps)

3. Having it right there provides an extra level of assurance that the integrity hash is going to be used (especially in files intended to be used in the browser and in deno ... not sure how common that is though).

Hi Luca - congratulations! I have a quick question, have their been any proposals to add Subresource Integrity hashes (https://developer.mozilla.org/en-US/docs/Web/Security/Subres...) to the import syntax? I think this effects Deno more acutely than other projects since Deno supports / (encourages?) directly importing from a url with a precise version number encoded in the url. It would be nice to add another layer of safety on top and be able to assert that the module received is exactly as expected. Thanks!

Genuinely curious what the use case(s) of reading from uninitialized are. Performance?

It could be possible that [some, (0,100]%, portion of the benefit provided by] the vaccines wear off after a certain amount of time. This makes statistics like 99.7% of Waterford have been vaccinated perhaps less insightful than something like 34% (or whatever the actual number is) have been vaccinated in the last 6 months.

edit: added [some portion, (0,100]%, of the benefit provided by]

My understanding and it could be wrong is that they can't lower their rates, (and might actually have to increase to compensate for more vacancy) because it will affect their ability to finance the buildings if they have lower rates from whatever math is used to calculate the soundness of the loans. That could be causing the stickiness on price you are seeing (if it's not apocryphal).

And don't forget flipping a car is a lot faster and easier than flipping a house at much lower capital. This makes each cycle of trial and error a lot cheaper and a lot more frequent.

Also there is something to be said for a market where the customer brings the product to your location for inspection, and whose product is considerable faster to inspect more rigorously than a house.

Also the products within that market are much more uniform and share several unifying characteristic across even different makes and model so its easier to learn a good and accurate pricing function.

That gives them a lot more cycles to improve their algorithms (both human and machine based).

Plus when CarMax were starting out they likely did so with a bevy of folks already experienced and profitable at buying and selling used cars at a profit who had the systematic knowledge of how to do so in their heads.

It then was simply a matter of building up customer goodwill by focusing on another metric customers cared about, taking a perhaps slight loss to avoid the risk of being considerably ripped off by a savvy local dealer and saving oneself the anxiety induced by high pressure sales tactics.

Having said that I think Zillow could still be quite successful in this endeavor however from my experience they didn't deploy their trading algorithm in a prudent way, they massively over-traded an untested by the real world model, they trusted their paper trading (backtesting) way to much, and they didnt focus on the nuts and bolts of building a successful market making system: making actual money over and over at small size and ramping up size as your empirically demonstrated pnl grows.

Also putting trading aside they didn't have to be a flipper, they would probably naturally be more fit as an exchange+ or intermediary that provides exchange type backing and reduces the friction in buyers finding sellers, taking on risk by only making an offer when they have a bona fide buyer for fixed or % fee, but glossing over all the hassle of two people who dont know each other making a large trade. Offering services like if you dont like the house you just bought through us we will help your sell it at a cost proportional to renting no questions asked.

And Epic granted money to Godot:

https://godotengine.org/article/godot-engine-was-awarded-epi...

I just want to say thanks, I have been experimenting with using xterm.js to connect to terminal API in jupyter notebooks and it has worked really well, plug and play (even editors like vim were working without any extra effort).

Before that I was experimenting with using it as a custom shell for running commands inside a web application. In that use case it was a bit more challenging because I had never written to an actual tty before (ansi escape codes for coloring log files has been about the limit of my experience). For that use case I just really needed to send and receive text. I ended up using this library [ https://github.com/wavesoft/local-echo ] to smooth that process out until I could learn about how to do things properly.

Are any suggestions on:

1. where to learn about how ttys work to do things the right way, or

2. suggested libraries like local-echo that can wrap over some of the trickier bits of just getting text on the screen?

Thanks again for maintaining such a great & useful library!

Thank you! I just tried it and --max-filesize worked great, ... -o also worked however it would be nice if -o showed a bit of context around the match (maybe 50 chars or so before and after), still useful all the same. Thanks again.

I also default to use ag now and it is good at picking up things like .gitignores to exclude files. It works very well, I just wish it had a flag to limit the size of files searched because if a large file is found it can make the results harder to parse visually and most of the times when programming I only want to scan files that are under 100k (at most ... probably 10k is fine for a first pass).

This is really bad if the large file is some concatenated minimized javascript thing that is one massive line, then that really makes the results harder explore ( I tend to `ag foosearchterm | less -R` at that point) . Perhaps capping the line length in a result is another solution, if a line is over a couple hundred chars only show the relevant portion.

Hmm I wonder if it picked up timestamps as its initial filter.

There is sign on the wire near the traffic light that says no turns, not sure if it only applies to the other lane though.

This is a really good article and the examples are very pretty. I especially enjoyed the part about how filter:drop-shadow contours to the shape of the element (did not know that, and that's a handy trick).

However just beware that there can be a decent performance hit from having a lot of box-shadows.

Supposing there are Aliens FWIW I don’t know that they would perceive the same visible spectrum that we do, which might effect their ability to differentiate by color. And they might not even perceive colors at all perhaps focusing on patterns or perhaps use some sort acoustical sonar system of high pitched shrieks or an electrocapacitive perception captured by elongated dactyltennae hands with which they can sense the world around them.

Even after features or products are deemed to have little to no value, teams keep them around for ages instead of responsibly removing them. The most common argument we hear is, “This [small subset] customer [sic] regularly uses the feature and we’ll lose out, if we remove it.” Instead of associating unshipping with the traditional ‘What do we lose?‘ perspective, let’s reframe to a ‘What do we gain?‘ perspective. After all, unshipping can actually improve product metrics.

Being on the other end of this, maybe it's great for the business to streamline things and save costs, but as a user it's not fun having a feature I am using disappear because I am part of only a small group using it. Instead of saying 'what do we lose' (nothing except perhaps a few customers ... if the customers have an option to move platforms, which often they don't) what does the customer using the feature lose? What's our plan to replace their use case with something more efficient?

TypeScript definitions don't block and VS Code does not warn for `indices.forEach(console.log)`

When using eta-reduction in Javascript both functions and all their (optional) arguments have to be known by the programmer and future programmers, instead of needing to know only the argument-slots being used by (x,y,...) => ...

It also defends / insulates against more parameters being added in the future.

Additionally, the way `this` in javascript works (or doesn't for a lot of callbacks) also pushes against using eta-reduction.

That sounds pretty cool, is there a guide to setting that up?

Random question: Can ClojureScript be compiled in the browser? I only looked at it when it first came out and at that time the ClojureScript compiler only ran via the JVM.

This looks to be exactly what I was looking for thank you!

I really just wish GIMP (and Audacity now that I think about it) had a command palette, where I could type in the name of anything found in the menu or assigned to a keyboard shortcut. I don’t use both of them a lot so all of my time is spent search menus for what I am trying to do.

It could just be my imagination but I have noticed that Un-balanced “Granny Knot”s are less likely to get caught in pedals and chains when riding a bicycle since the loops don't stick out as far to the sides.

Two questions I had was: 1. is there some way to cache (eg LRU upto a size limit) the results of transformation functions. 2. They mentioned custom header fields as a way for clients to pass along data what about query parameters do those get passed along?