We should think about the number of simultaneous connections (peak and average) and the message rate/payload size. I think, the threshold to start thinking about AnyCable (instead of just Action Cable) is somewhere between 500 and 1000 connections on average or 5k-10k during peak hours.

We chose to define the frontend in one technology stack (Angular+TypeScript/JavaScript) and the backend in another (Ruby+Ruby on Rails), but both came together to fulfill a singular product vision.

network requests are a big deal, and having to deal with this kind of thing is one of the prices of switching away from server-side rendering to a distributed system

The globalThis property provides a standard way of accessing the global this value (and hence the global object itself) across environments. Unlike similar properties such as window and self, it's guaranteed to work in window and non-window contexts. In this way, you can access the global object in a consistent manner without having to know which environment the code is being run in.

Unlike browsers, you can access raw Set-Cookie headers manually using Headers.raw(). This is a node-fetch only API.

When fetch runs on the server, the resulting response will be serialized and inlined into the rendered HTML. This allows the subsequent client-side load to access identical data immediately without an additional network request.

Database permissionsAccountRole membershipSnowInventoryUserDatabase Owner

The thing that makes the client-side invocation return the same data as the server-side one is that the results of calling fetch during SSR are serialized and inlined into the page. This ensures consistency when the page hydrates, and saves network round-trips (and also means less data needs to come over the wire, since everything can get compressed using the same gzip dictionary or whatever).

You might even consider a Raspberry Pi to power a lightweight media center or server. These ARM-based systems aren’t as powerful, but they’re inexpensive, customizable, and use a very small amount of power.

The HTML5 form validation techniques in this post only work on the front end. Someone could turn off JavaScript and still submit jank data to a form with the tightest JS form validation.To be clear, you should still do validation on the server.

With these JavaScript techniques, the display of server validation errors could be a lot simpler if you expect most of your users to have JS enabled. For example, Rails still encourages you to dump all validation errors at the top of a form, which is lulzy in this age of touchy UX. But you could do that minimal thing with server errors, then rely on HTML5 validation to provide a good user experience for the vast majority of your users.

Therefore client side validation should always be treated as a progressive enhancement to the user experience; all forms should be usable even if client side validation is not present.

It's important to remember that even with these new APIs client side validation does not remove the need for server side validation. Malicious users can easily workaround any client side constraints, and, HTTP requests don't have to originate from a browser.

Since you have to have server side validation anyways, if you simply have your server side code return reasonable error messages and display them to the end user you have a built in fallback for browsers that don't support any form of client side validation.

-apache

Think first: why do you want to use it in the browser? Remember, servers must never trust browsers. You can't sanitize HTML for saving on the server anywhere else but on the server.

Note that preload will run both on the server side and on the client side. It may therefore not reference any APIs only present in the browser.

Preload functions are typically used to load data that the page depends on, hence its name. This avoids the user seeing the page update as it loads, as is typically the case with client-side loading.

I put together a POC that resembles react-rails and helps with server- and client-side rendering, and provides a view helper (svelte_component):

webpacker-svelte misses server-side rendering, though.

If you are running your own instance of the Hypothesis annotation server

Because Jamstack projects don’t rely on server-side code, they can be distributed instead of living on a single server. Serving directly from a CDN unlocks speeds and performance that can’t be beat. The more of your app you can push to the edge, the better the user experience.

If you want a reference to the global object that works in any context, you can read this from a directly-called function. const global = (function() {return this})();. This evaluates to window in the browser, self in a service worker and global in nodejs.

emphasizing that 'this' and 'global object' are two different things not only in Node.js but in JavaScript in general

(That's a SMUI button and card running in a Sapper instance (and the markup is there on page load with JS turned off).)

I want to run docker daemon with TLS enabled but client certificate authentication disabled so that clients can verify authenticity of docker daemon but docker daemon doesn't need to verify clients.

Ubiquity: you can also run your validation on the server side (e.g. nodejs)

Use a node-style require() to organize your browser code and load modules installed by npm.

browserify is a tool for compiling node-flavored commonjs modules for the browser.

Node doesn't have a DOM available. So in order to render HTML we use string concatenation instead. This has the fun benefit of being quite efficient, which in turn means it's great for server rendering!

Think of JavaScript. In the browser you don't have direct access to the file system. In Node.js you have. Same programming language. Different APIs.

and serve as pre-prints to work that may live later on, or always exist in their current format

It's designed for Single Page Applications (SPA). If you need Server Side Rendering then consider using Sapper.

Leverages hash-based routing, which is optimal for SPAs and doesn't require any server-side processing

Node.js code must be run by the node process, not the browser (the code must run in the server).

Modules using code that doesn’t exist in browsers such as process.env.NODE_ENV and forcing you to convert or polyfill it.

Some modules, like events or util, are built in to Node.js. If you want to include those (for example, so that your bundle runs in the browser), you may need to include rollup-plugin-node-polyfills.

Ways of delivering JavaScript source code

First class TypeScript support means that both of these two systems do a good job of handling TypeScript code.

To add documentation on a Svelte component that will show up as a docstring in LSP-compatible editors, you can use an HTML comment with the @component tag:

It's recommended to put the fetch in onMount rather than at the top level of the <script> because of server-side rendering (SSR). With the exception of onDestroy, lifecycle functions don't run during SSR, which means we can avoid fetching data that should be loaded lazily once the component has been mounted in the DOM.

When is your site not built with the Jamstack? Any project that relies on a tight coupling between client and server is not built with the Jamstack.

python -m http.server 8000

By rendering important parts of the application with the real data on the server-side, an isomorphic application can show a meaningful initial page. On the other hand, client rendering application can’t show any meaningful information until it fetches all external data it needs. In the meantime, the only thing a user will see is a loading indicator.

One thing that matters is if code uses browser-specific (example: Dom) or server-specific (example: filesystem) features.

This is a non-dom based javascript execution environment. It usually only contains the base javascript language spec libraries and objects along with modules to communicate with OS features (available through commonjs require).

server-side rendering is strict about configuration, and the best way to find out what's wrong is to compare your project to an already working setup. Check out the reference implementations, bit by bit.

// require('hammerjs') when in a browser. This is safe because Hammer is only // invoked in componentDidMount, which is not executed on the server. var Hammer = (typeof window !== 'undefined') ? require('hammerjs') : undefined

Second, uBlock Origin does not have a dedicated server, it can't "phone home" with your browsing data, there is only GitHub, and GitHub is completely unrelated to uBlock Origin.

Is there a home server?

docker-openresty/alpine/Dockerfile.fat

Some users have deployed independent Hypothesis servers, and at least one uses an API-compatible reimplementation of the Hypothesis server.

Engineering Challenges

Server-Sent Events utilize a regular HTTP octet streams, and therefore are limited to the browser’s connection pool limit of ~6 concurrent HTTP connections per server. But they provide a standard way of pushing data from the server to the clients over HTTP, which load balancers and proxies understand out-of-the-box. The biggest advantage being that, exactly as WebSockets, they utilize only one TCP connection. The biggest disadvantage is that Server-Sent Events don’t provide a mechanism to detect dropped clients until a message is sent.

Server-sent Event(SSE) in Python and here is why I thought Python is a great server-side language for SSE

“pre-print” versions of manuscripts

InOpenXtheadtagURLislinkedtoanOpenXZone,inthefollowingformat

protected platform whereby many expert reviewers could read and comment on submissions, as well as on fellow reviewers’ comments

intelligent crowd reviewing

npm install --save-dev webpack webpack-dev-server react-hot-loader

sudo npm install --save-dev webpack-dev-server -g

Docker Swarm을 이용한 쉽고 빠른 분산 서버 관리 : Docker Swarm으로 서버 오케스트레이션 하는 방법을 설명한 글이다. 현재 사용 가능한 오케스트레이션 도구들의 장단점도 정리되어 있고 Swarm이 제공하는 기능을 설명한 후 실제로 따라 해 보면서 테스트해볼 수 있게 글이 작성되어 있어서 오케스트레이션 도구를 검토하고 있다면 찬찬히 읽어봐야 할 글이다. 얼마 전에 Docker Swarm을 보고 간단하면서 기능이 강력해서 꽤 좋은 인상을 받았는데 정리된 글이 나와서 반갑다.(한국어)

We're sorry, the requested URL was not found on this server.

http://localhost:port/bigdata/sparql