rupy

So far everything after epoll that I have compared with falls short. So to reimplement my foundation (with all the bugs) will not be worth it. I will however compare Javas NIO (epoll) with the new Virtual Threads IO (without pinning). http://github.com/tinspin/rupy

I built the cluster thick instead: https://github.com/tinspin/rupy And selfhost on home fiber. Saves space and cools silently. Mixing old 2 and 4 for different use cases. Raspberry 5 and 3588 are too hot. Not in the picture Mean Well 50W passive PSU.

With my SaaS/PaaS you hot-deploy async. to all global nodes with complete (type last code character to ready) turnaround of ~1-2 seconds on live (just enough time to switch to your client/browser): http://github.com/tinspin/rupy It also allows for session persistence, so you can test the dev/bug feature without logging in again. And yes code becomes more manageable if you work like this because it encourages modularity.

Did you look at http://github.com/tinspin/rupy?

How this article does not mention SSE, comet or chunking escapes me. What does their definition of event-driven really look like in practice. Nobody has a clue. Here is the ideal event driven system, it's async-to-async: https://github.com/tinspin/rupy/wiki/Fuse The example is not working because I had to shut down the services for multiple reasons, but the high level of it is that you use 4 (potentially different) threads to do one request/response middle man transaction. That way you have _zero_ io-wait or thread idling. I'm surprised nobody has copied this approach since I invented it 10 years ago. I understand why though you need your entire chain to be async and that means rewriting everything and that is a big risk when it's hard to debug. But if you succeed you can build something that is 10x perf/watt than all other implementation

Packaging should always just be zip. Security can just be a OTP: https://github.com/tinspin/rupy/blob/master/src/se/rupy/http...

You need to multi-thread your server on shared memory to build many-to-many solutions. The simplest way to get that working is Java + NIO with concurrent package, I have done it for you: http://github.com/tinspin/rupy My web server outperforms everything on the planet for multiplayer. Websockets are notoriously hard to parallelize if you want shared memory which you need for many-to-many, mostly because JavaScript and C++ have very poor atomic concurrency, or atleast I never found any Websocket server that could do it.

I think we're all confused over the definition. Also one might understand what all the proponents are talking about better if they think about this more as a process and not some technological solution: https://github.com/tinspin/rupy/wiki/Process All input I have is you want your code to run on many machines, in fact you want it to run the same on all machines you need to deliver and preferably more. Vertically and horizontally at the same time, so your services only call localhost but in many separate places. This in turn mandates a distributed database. And later you discover it has to be capable of async-to-async = no blocking ever anywhere in the whole solution. The way I do this is I hot-deploy my applications async. to all servers in the cluster, this is what a cluster node looks like in practice (the name next to Host: is the node

I have one in Java: https://github.com/tinspin/rupy (Which is better for a server, Java does not crash and it can do atomic shared parallelism between cores with OO code something you would need to use arrays to achieve in C/C++ without VM + GC.) Here is the 2000 lines of code of the entire database: http://root.rupy.se/code?path=/Root.java&space Darkmode: http://edit.rupy.se/?path=/Root.java&space And here you can try it out: http://root.rupy.se

The smallest PaaS you have ever seen is one order of magnitude larger than mine: https://github.com/tinspin/rupy And I bet you the same goes for performance, mine can share data between cores atomically.

I use 1TB SanDisk (Raspberry 2) and 4GB Panasonic SLC (Raspberry 4) in my distributed database cluster: http://github.com/tinspin/rupy In my experience industrial versions of mainstream cards are less reliable! I agree, you have to measure latency and longevity on these edge (maximum longevity or space) SD cards as bandwidth is limited by SPI (4 is not really that much faster than 2). USB3 is not stable enough for 99.9999 uptime. If you use the cards above and mostly write once on the 1TB and replicate all that data on 3 cards in 2 geographical locations in realtime (6x in total minimum = you have redundancy even if one node fails on local and global level) you should be fine. After having 8GB Odroid MMC fail on me twice after 5 years, I invested in Intel Atom servers with X25-E (65nm SLC 100.000 writes per bit) drives as backup plan if t

I made the most efficient and scalable HTTP app server with integrated distributed JSON database to replace all serverside software I was depending on: http://github.com/tinspin/rupy If you want to be able to run production servers on Raspberry 2 & 4 this is today your only real alternative. Now I'm building a 3D action MMO that runs on the Raspberry 4, good luck getting Unity or Unreal to work on that device! The biggest waste of electricity is AAA gaming, both because it uses alot but also because it creates nothing of value. Follow Minecraft (btw also a waste of energy) modding and Roblox and extrapolate, useful gaming allows you to OWN your work.

The data is here: http://fuse.rupy.se/about.html Under Performance. Per watt the fuse/rupy platform completely crushes all competition for real-time action MMOs because of 2 reasons: - Event driven protocol design, averages at about 4 messages/player/second (means you cannot do spraying or headshots f.ex. which is another feature in my game design opinion). - Java's memory model with atomic concurrency parallelism over shared memory which needs a VM and GC to work (C++ copied that memory model in C++11, but it failed completely because they lack both VM and GC, but that model is still to this day the one C++ uses), you can read more about this here: https://github.com/tinspin/rupy/wiki These keep the internal latency of the server below maybe 100 microseconds at saturation, which no C++ server can handle even remotely, unless they copy Ja

I would look at my own app-server: https://github.com/tinspin/rupy It's not the most well documented but it's the smallest implementation while still being one of the most performant so you can learn more than just SSE.

Absolutely not, HTTP/1.1 is the way to make SSE fly: https://github.com/tinspin/rupy/wiki/Comet-Stream Old page, search for "event-stream"... Comet-stream is a collection of techniques of which SSE is one. My experience is that SSE goes through anti-viruses better!