A blog and website by Peter Bengtsson
14 February 2019 0 comments Linux, MacOSX, Nginx, Web development
I have Nginx 1.15.8 installed with Homebrew on my macOS. By default the /usr/local/etc/nginx/nginx.conf it set to...:
worker_processes 1;
But, from the documentation, it says:
"The optimal value depends on many factors including (but not limited to) the number of CPU cores, the number of hard disk drives that store data, and load pattern. When one is in doubt, setting it to the number of available CPU cores would be a good start (the value “auto” will try to autodetect it)." (bold emphasis mine)
What is the ideal number for me? The performance of Nginx on my laptop doesn't really matter. But for my side-projects it's important to have a fast Nginx since it serves static HTML and lots of static assets. However, on my personal servers I have a bunch of other resource hungry stuff going on that I know is more likely to need the resources, like Elasticsearch and uwsgi.
To figure this out, I wrote a benchmark program that requested a small index.html about 10,000 times across 10 concurrent clients with hey.
hey -n 10000 -c 10 http://peterbecom.local/plog/variable_cache_control/awspa
I ran this 10 times between changing the worker_processes in the nginx.conf file. Here's the output:
1 WORKER PROCESSES
BEST : 13,607.24 reqs/s
2 WORKER PROCESSES
BEST : 17,422.76 reqs/s
3 WORKER PROCESSES
BEST : 18,886.60 reqs/s
4 WORKER PROCESSES
BEST : 19,417.35 reqs/s
5 WORKER PROCESSES
BEST : 19,094.18 reqs/s
6 WORKER PROCESSES
BEST : 19,855.32 reqs/s
7 WORKER PROCESSES
BEST : 19,824.86 reqs/s
8 WORKER PROCESSES
BEST : 20,118.25 reqs/s
Or, as a graph:
Now note, this is done here on my MacBook Pro. Not on my Ubuntu DigitalOcean servers. For now, I just want to get a feeling for how these numbers correlate.
Conclusion
The benchmark isn't good enough. The numbers are pretty stable but I'm doing this on my laptop with multiple browsers idling, Slack, and Spotify running. Clearly, the throughput goes up a bit when you allocate more workers but if anything can be learned from this, start with going beyond 1 for a quick fix and from there start poking and more exhaustive benchmarks. And don't forget, if you have time to go deeper on this, to look at the combination of worker_connections and worker_processes.
12 February 2019 0 comments Javascript, ReactJS, Web development
1. Create a create-react-app first:
create-react-app myapp
2. Enter it and install node-sass and bulmaswatch
cd myapp
yarn add bulma bulmaswatch node-sass
3. Edit the src/index.js to import index.scss instead:
-import "./index.css";
+import "./index.scss";
4. "Rename" the index.css file:
git rm src/index.css
touch src/index.scss
git add src/index.scss
5. Now edit the src/index.scss to look like this:
@import "node_modules/bulmaswatch/darkly/bulmaswatch";
This assumes your favorite theme was the darkly one. You can obviously change that later.
6. Run the app:
BROWSER=none yarn start
7. Open the browser at http://localhost:3000
That's it! However, the create-react-app default look doesn't expose any of the cool stuff that Bulma can style. So let's rewrite our src/App.js by copying the minimal starter HTML from the Bulma documentation. So make the src/App.js
component look something like this:
class App extends Component {
render() {
return (
<section className="section">
<div className="container">
<h1 className="title">Hello World</h1>
<p className="subtitle">
My first website with <strong>Bulma</strong>!
</p>
</div>
</section>
);
}
}
Now it'll look like this:
Yes, it's not much but it's a great start. Over to you to take this to infinity and beyond!
Not So Secret Sauce
In the rushed instructions above the choice of theme was darkly. But what you need to do next is go to https://jenil.github.io/bulmaswatch/, click around and eventually pick the one you like. Suppose you like spacelab, then you just change that @import ... line to be:
@import "node_modules/bulmaswatch/spacelab/bulmaswatch";
11 February 2019 0 comments Javascript, Web Performance, Node, Web development
tl;dr; minimalcss 0.8.2 introduces a 20% post-processing optimization by lumping many CSS selectors to their parent CSS selectors as a pre-emptive cache.
In minimalcss the general core of it is that it downloads a DOM tree, as HTML, parses it and parses all the CSS stylesheets associated. These might be from <link ref="stylesheet"> or <style> tags.
Once the CSS stylesheets are turned into an AST it loops over each and every CSS selector and asks a simple question; "Does this CSS selector exist in the DOM?". The equivalent is to open your browser's Web Console and type:
>>> document.querySelectorAll('div.foo span.bar b').length > 0
falseFor each of these lookups (which is done with cheerio by the way), minimalcss reduces the CSS, as an AST, and eventually spits the AST back out as a CSS string. The only problem is; it's slow. In the case of view-source:https://semantic-ui.com/ in the CSS it uses, there are 6,784 of them. What to do?
First of all, there isn't a lot you can do. This is the work that needs to be done. But one thing you can do is be smart about which selectors you look at and use a "decision cache" to pre-emptively draw conclusions. So, if this is what you have to check:
#example .alternate.stripe#example .theming.stripe#example .solid .column p b#example .solid .column p
As you process the first one you extract that the parent CSS selector is #example and if that doesn't exist in the DOM, you can efficiently draw conclusion about all preceeding selectors that all start with #example .... Granted, if they call exist you will pay a penalty of doing an extra lookup. But that's the trade-off that this optimization is worth.
Check out the comments where I tested a bloated page that uses Semantic-UI before and after. Instead of doing 3,285 of these document.querySelector(selector) calls, it's now able too come to the exact same conclusion with just 1,563 lookups.
Sadly, the majority of the time spent processing lies in network I/O and other overheads but this work did reduce something that used to take 6.3s (median) too 5.1s (median).
06 February 2019 0 comments Javascript, ReactJS
React 16.8.0 with Hooks was released today. A big deal. Executive summary; components as functions is all the rage now.
What used to be this:
class MyComponent extends React.Component {
...
componentDidMount() {
...
}
componentDidUpdate() {
...
}
render() { STUFF }
}
...is now this:
function MyComponent() {
...
React.useEffect(() => {
...
})
return STUFF
}
Inside the useEffect "side-effect callback" you can actually update state. But if you do, and this is no different that old React.Component.componentDidUpdate, it will re-run the side-effect callback. Here's a simple way to cause an infinite recursion:
// DON'T DO THIS
function MyComponent() {
const [counter, setCounter] = React.useState(0);
React.useEffect(() => {
setCounter(counter + 1);
})
return <p>Forever!</p>
}
The trick is to pass a second argument to React.useEffect that is a list of states to exclusively run on.
Here's how to fix the example above:
function MyComponent() {
const [counter, setCounter] = React.useState(0);
const [times, setTimes] = React.useState(0);
React.useEffect(
() => {
if (times % 3 === 0) {
setCounter(counter + 1);
}
},
[times] // <--- THIS RIGHT HERE IS THE KEY!
);
return (
<div>
<p>
Divisible by 3: {counter}
<br />
Times: {times}
</p>
<button type="button" onClick={e => setTimes(times + 1)}>
+1
</button>
</div>
);
}
You can see it in this demo.
Note, this isn't just about avoiding infinite recursion. It can also be used to fit your business logic and/or an optimization to avoid executing the effect too often.
06 February 2019 0 comments Javascript, ReactJS, Web development
tl;dr; You can use error instanceof window.Response
to distinguish between fetch exceptions and fetch responses.
When you do something like...
const response = await fetch(URL);
...two bad things can happen.
- The XHR request fails entirely. I.e. there's not even a response with a HTTP status code.
- The response "worked" but the HTTP status code was not to your liking.
Either way, your React app needs to deal with this. Ideally in a not-too-clunky way. So here is one take on this challenge/opportunity which I hope can inspire you to extend it the way you need it to go.
The trick is to "clump" exceptions with responses. Then you can do this:
function ShowServerError({ error }) {
if (!error) {
return null;
}
return (
<div className="alert">
<h3>Server Error</h3>
{error instanceof window.Response ? (
<p>
<b>{error.status}</b> on <b>{error.url}</b>
<br />
<small>{error.statusText}</small>
</p>
) : (
<p>
<code>{error.toString()}</code>
</p>
)}
</div>
);
}
The greatest trick the devil ever pulled was to use if (error instanceof window.Reponse) {. Then you know that error thing is the outcome of THIS = await fetch(URL) (or fetch(URL).then(THIS) if you prefer). Another good trick the devil pulled was to be aware that exceptions, when asked to render in React does not naturally call its .toString() so you have to do that yourself with {error.toString()}.
This codesandbox demonstrates it quite well. (Although, at the time of writing, codesandbox will spew warnings related to testing React components in the console log. Ignore that.)
If you can't open that codesandbox, here's the gist of it:
React.useEffect(() => {
url &&
(async () => {
let response;
try {
response = await fetch(url);
} catch (ex) {
return setServerError(ex);
}
if (!response.ok) {
return setServerError(response);
}
// do something here with `await response.json()`
})(url);
}, [url]);
By the way, another important trick is to be subtle with how you put the try { and } catch(ex) {.
// DON'T DO THIS
try {
const response = await fetch(url);
if (!response.ok) {
setServerError(response);
}
// do something here with `await response.json()`
} catch (ex) {
setServerError(ex);
}
Instead...
// DO THIS
let response;
try {
response = await fetch(url);
} catch (ex) {
return setServerError(ex);
}
if (!response.ok) {
return setServerError(response);
}
// do something here with `await response.json()`
If you don't do that you risk catching other exceptions that aren't exclusively the fetch() call. Also, notice the use of return inside the catch block which will exit the function early leaving you the rest of the code (de-dented 1 level) to deal with the happy-path response object.
Be aware that the test if (!response.ok) is simplistic. It's just a shorthand for checking if the "status in the range 200 to 299, inclusive". Realistically getting a response.status === 400 isn't an "error" really. It might just be a validation error hint from a server, and likely the await response.json() will work and contain useful information. No need to throw up a toast or a flash message that the communication with the server failed.
Conclusion
The details matter. You might want to deal with exceptions entirely differently from successful responses with bad HTTP status codes. It's nevertheless important to appreciate two things:
Handle complete fetch() failures and feed your UI or your retry mechanisms.
You can, in one component distinguish between a "successful" fetch() call and thrown JavaScript exceptions.
01 February 2019 2 comments Python
tl;dr; Use f"{number:,}" to thousands format an integer to a string.
I keep forgetting and having to look this up every time. Hopefully by blogging about it, this time it'll stick in my memory. And hopefully in yours too :)
Suppose you have a number, like 1234567890 and you want to display it, here's how you do it:
>>> number = 1234567890
>>> f"{number:,}"
'1,234,567,890'
In the past, before Python 3.6, I've been using:
>>> number = 1234567890
>>> format(number, ",")
'1,234,567,890'
All of this and more detail can be found in PEP 378 -- Format Specifier for Thousands Separator. For example, you can do this beast too:
>>> number = 1234567890
>>> f"{number:020,.2f}"
'0,001,234,567,890.00'
which demonstrates (1) how to do zero-padding (of length 20), (2) the thousands comma, (3) round to 2 significant figures. All useful weapons to be able to draw from the top of your head.
UPDATE
Also, incredibly useful is the equivalent of somestring.ljust(10):
>>> mystr = "peter"
>>> f"{mystr:10}"
'peter '
>>> f"{mystr:>10}"
' peter'
