raunioroo
any reason against using the deps.ts approach?
Not sure if I understand the question, but will reply anyway :) Annoyingly, JSR import paths look very different to deno.land style plain URL imports, in that they start different and end different.
This means you can't just set up a prefix like "@std" in the import map, and easily switch between JSR and something else by editing the import map only. So, you need to set up and map full aliases for each possible import to be able to switch repositories or use local filesystem copy, without touching the actual import statements in code.
7 replies
any reason against using the deps.ts approach?
Third downside is with deps.ts will cause all referenced libraries to be loaded and initialized whether they are used or not by the main entrypoint. If using dynamic imports that problem can be amplified. With import maps you can reference as many libraries as you like, and they will only be loaded on-demand.
7 replies
Is there a way to use Javascript as easily as Php?
VPS servers are a nice, cheap middleground between administering your own server, and ready made cloud solutions. A bit more involved in setup than your typical php service,but not too bad. Cheapest option in AWS Lightsail is around 5 bucks a month, and works great with deno (unless your app is a memory hog, in which case you should look into the more expensive options with more RAM)
40 replies
Are there any up-to-date library for date and time in Deno?
Date and time libraries seem to be somewhat inactive since JS standard Temporal API is just around the corner, and will have/has most features you'd ever need built in. And in fact usable in Deno with - - unstable-temporal. Meanwhile, there is simple but useful and up to date https://jsr.io/@std/datetime , and like you mention could bring stuff from npm. Temporal is pretty nice though, if you are ok with using unstable stuff
3 replies
Websockets API with async processing (is there a better way?)
Someone correct if I'm wrong, but I think worker comms involve some internal serialization under the hood (some relative of structuredClone?). Which would be faster than JSON, but slower than not reserializing. So I'd think it's probably a little faster to just send the string to the worker and parse the JSON there. Which makes sense also in that if you are using multiple workers to distribute load, you'd want to move as much processing to the workers as possible, keeping the main process as lightweight as possible (since every request goes through that single threaded "load balancer", you want to avoid it becoming a bottleneck).
12 replies
Websockets API with async processing (is there a better way?)
Also, not sure if it applies to websockets app like yours, but I do some heavy image processing in thread pool of sorts, and found the optimal number of processing threads to be
number_of_cores - 1
. I assume it's because if I saturate ALL the cores completely with image processing, the various other system threads or processes may get bogged down also then everything can become a bit unresponsive. But if I always have 1 semi-idle core, the system always has a place to execute background stuff on, resulting in smoother overall performance and even if slightly less "images per second", the performance "per image" is more consistent and predictable.12 replies
Websockets API with async processing (is there a better way?)
Just a thought: Could each worker have a standalone websocket server, just on their own ports? Clients would connect directly to own worker port, assigned somehow to balance workload to the number of cores. This would negate the need for all connections to go through the main process/thread, as well as negate redundant message serialization & deserialization between workers and the main process (
JSON.parse
and I assume passing messages to workers involve some semi-expensive IPC-like message serialization under the hood).12 replies
How to abstract tests to allow running different functions against the same test suite?
I mean, for some reason I used to think test files are some special, limited dialect of JS. Once I realized it is just normal code which can be organized to modules, classes, functions, exports, imports like any other app, it suddenly felt like I gained testing superpowers.
5 replies
How to abstract tests to allow running different functions against the same test suite?
I tend to wrap shared tests in a function, or functions which I then export (as functions I can run as test steps) . So the shared test file doesn't have side effects in the form of top level Deno.test() calls. Actual test suite then imports all the shared tests it wants and runs the functions. I find it good practice since this "libraries of test steps" approach has other bonuses: I can pass setup variables to the shared test step functions to simulate permutations of different environments or configs, or create fast mini test suites for things I'm currently working on, or have multiple levels of nested test steps - deno does handle and format the results of nested test steps quite nicely.
5 replies
Microservices, best practices
My takeaways:
1) Minimizing the need for the services to chat with to each other is one guideline which might also naturally lead to a divide that also makes organizational sense. Chatty services blow up the whole system incredibly fast when every piece of communication adds latency in the form of serialization/deserialization step, network hop, whatever queue/messaging system step you have, each service doing their own permission checks etc. Potentially each message kicks of a chain of other messages between the interconnected network of services etc leading to exponential latencies. If you are not really, really carefull with that, you can easily end up with a system that costs like 10x-100x in server costs than what a simple monolith on a lone server could handle.
2) Don't be afraid to duplicate data. Each service owning their own data, copying and storing their own truth with some mechanism to sync up with other services, is a bit counterintuitive, but a good way to avoid said chattiness.
5 replies
Microservices, best practices
Here's two talks which were eye-opening to me. https://www.youtube.com/watch?v=gfh-VCTwMw8 https://www.youtube.com/watch?v=p2GlRToY5HI
5 replies
Importing Buffer Type
Yeah AI looks to be about correct about the Buffer vs Uint8Array. But I'm not crypto expert, nor TS expert, so no comments whether Uint8Array is best in this particular case, or should it be ArrayBuffer, some kind of Stream or what. Uint8Array is used a lot for simple buckets of in-memory bytes, sounds like a sensible Deno/webstandard option. IIRC Uint8Array is actually a view into a backing ArrayBuffer that contains the actual data.
5 replies
could not find "deno.json" after compile
https://github.com/denoland/fresh/pull/1208/files here's a relevant looking part in fresh src
12 replies
could not find "deno.json" after compile
I'm guessing AI is correct in that something in your code or dependencies is trying to access deno.json directly. And Fresh seems to be a likely culprit here. I don't use fresh so can't help you much further sry
12 replies
update deno version on Alpine
you probably need to ask the alpine package maintainer, Jakub Jirutka. AFAIK deno team does not officially support/maintain any distribution packages or repositories. deno releasing every week or two, that means distro packages tend to be hopelessly outdated. if you are able, it's best to install deno using the distro-agnostic installer as per instructions on https://deno.com/ , then you can use the upgrade feature too
8 replies
How to troubleshoot runaway (100% CPU) deno process
For full disclosure; i'm one of the commenters in this issue, jtoppine (noticed too that someone had similar problems and had created an issue). So I guess that makes total of two people having what appears to be the same problem.
I haven't run to these freezes for a while now, everything has been running smoothly since. The cause remains a mystery, and I guess low priority now that it seems like a rare occurence. I was able to implement quick detection & recovery if it ever happens again so it's not as much as a disastrous event anymore.
Still interested in potential ways to investigate if these issues happen in the future though!
In the github issue it was suggested to run Deno with remote debugger enabled - A good idea, but feels like not practically feasible. (running a headless cloud VPS production server with debug hook enabled, and keeping a SSH tunnel open / remote debugger connected for days in hopes the issue reproduces. That is, if the debugger and remote connection even work when the process is in a 100% CPU usage, unresponsive state) Like, maybe it could work, but I kinda gave up trying to set it up without even trying :)
9 replies
Is there a way to read big files using something like .seek but with ending position as well?
Slightly annoyingly, in the past Deno used to have it's own non-standard streams API. Just like Node has it's own. Both kinda similar, but still different. But the old Deno API has been deprecated, or iirc mostly removed. Deno has now moved to a more standard-based Web Streams API (https://developer.mozilla.org/en-US/docs/Web/API/Streams_API). Standard API is nice, but it's a bit more cumbersome in some ways than the simpler, old Node or Deno API's. Standard web Streams API is kinda new and not so widely used yet in the backend, so there is not that much information and guides out there on it. That'll improve for sure in the future. But also when you try to google stuff, you now get a mix of results some using Node API, some use old Deno API, some use the new Web API. All have similar sounding methods etc which makes it a bit tedious to research
36 replies
Is there a way to read big files using something like .seek but with ending position as well?
No worries. The streaming stuffs can be hard to wrap your head around, related API's can be a bit confusing with many similarly named but different things, and since there are so many different ways to accomplish the same tasks, can be easily overwhelming to google and understand it all. I myself still struggle with that stuff. But it's worth it to learn, super useful stuff! Deno uses/offers streaming APIs for so many things it's good to take advantage of that.
36 replies