22 February 2019 0 comments Python, Django, Web development
This an optimization story that should not surprise anyone using the Django ORM. But I thought I'd share because I have numbers now! The origin of this came from a real requirement. For a given parent model, I'd like to extract the value of the name column of all its child models, and the turn all these name
strings into 1 MD5 checksum string.
Variants
The first attempted looked like this:
artist = Artist.objects.get(name="Bad Religion")
names = []
for song in Song.objects.filter(artist=artist):
names.append(song.name)
return hashlib.md5("".join(names).encode("utf-8")).hexdigest()
The SQL used to generate this is as follows:
SELECT "main_song"."id", "main_song"."artist_id", "main_song"."name",
"main_song"."text", "main_song"."language", "main_song"."key_phrases",
"main_song"."popularity", "main_song"."text_length", "main_song"."metadata",
"main_song"."created", "main_song"."modified",
"main_song"."has_lastfm_listeners", "main_song"."has_spotify_popularity"
FROM "main_song" WHERE "main_song"."artist_id" = 22729;
Clearly, I don't need anything but just the name column, version 2:
artist = Artist.objects.get(name="Bad Religion")
names = []
for song in Song.objects.filter(artist=artist).only("name"):
names.append(song.name)
return hashlib.md5("".join(names).encode("utf-8")).hexdigest()
Now, the SQL used is:
SELECT "main_song"."id", "main_song"."name"
FROM "main_song" WHERE "main_song"."artist_id" = 22729;
But still, since I don't really need instances of model class Song I can use the .values() method which gives back a list of dictionaries. This is version 3:
names = []
for song in Song.objects.filter(artist=a).values("name"):
names.append(song["name"])
return hashlib.md5("".join(names).encode("utf-8")).hexdigest()
This time Django figures it doesn't even need the primary key value so it looks like this:
SELECT "main_song"."name" FROM "main_song" WHERE "main_song"."artist_id" = 22729;
Last but not least; there is an even faster one. values_list(). This time it doesn't even bother to map the column name to the value in a dictionary. And since I only need 1 column's value, I can set flat=True. Version 4 looks like this:
names = []
for name in Song.objects.filter(artist=a).values_list("name", flat=True):
names.append(name)
return hashlib.md5("".join(names).encode("utf-8")).hexdigest()
Same SQL gets used this time as in version 3.
The benchmark
Hopefully this little benchmark script speaks for itself:
from songsearch.main.models import *
import hashlib
def f1(a):
names = []
for song in Song.objects.filter(artist=a):
names.append(song.name)
return hashlib.md5("".join(names).encode("utf-8")).hexdigest()
def f2(a):
names = []
for song in Song.objects.filter(artist=a).only("name"):
names.append(song.name)
return hashlib.md5("".join(names).encode("utf-8")).hexdigest()
def f3(a):
names = []
for song in Song.objects.filter(artist=a).values("name"):
names.append(song["name"])
return hashlib.md5("".join(names).encode("utf-8")).hexdigest()
def f4(a):
names = []
for name in Song.objects.filter(artist=a).values_list("name", flat=True):
names.append(name)
return hashlib.md5("".join(names).encode("utf-8")).hexdigest()
artist = Artist.objects.get(name="Bad Religion")
print(Song.objects.filter(artist=artist).count())
print(f1(artist) == f2(artist))
print(f2(artist) == f3(artist))
print(f3(artist) == f4(artist))
# Reporting
import time
import random
import statistics
functions = f1, f2, f3, f4
times = {f.__name__: [] for f in functions}
for i in range(500):
func = random.choice(functions)
t0 = time.time()
func(artist)
t1 = time.time()
times[func.__name__].append((t1 - t0) * 1000)
for name in sorted(times):
numbers = times[name]
print("FUNCTION:", name, "Used", len(numbers), "times")
print("\tBEST", min(numbers))
print("\tMEDIAN", statistics.median(numbers))
print("\tMEAN ", statistics.mean(numbers))
print("\tSTDEV ", statistics.stdev(numbers))
I ran this on my PostgreSQL 11.1 on my MacBook Pro with Django 2.1.7. So the database is on localhost.
The results
276
True
True
True
FUNCTION: f1 Used 135 times
BEST 6.309986114501953
MEDIAN 7.531881332397461
MEAN 7.834429211086697
STDEV 2.03779968066591
FUNCTION: f2 Used 135 times
BEST 3.039121627807617
MEDIAN 3.7298202514648438
MEAN 4.012803678159361
STDEV 1.8498943539073027
FUNCTION: f3 Used 110 times
BEST 0.9920597076416016
MEDIAN 1.4405250549316406
MEAN 1.5053835782137783
STDEV 0.3523240470133114
FUNCTION: f4 Used 120 times
BEST 0.9369850158691406
MEDIAN 1.3251304626464844
MEAN 1.4017681280771892
STDEV 0.3391019435930447
Discussion
I guess the
hashlib.md5("".join(names).encode("utf-8")).hexdigest() stuff is a bit "off-topic" but I checked and it's roughly 300 times faster than building up the names list.
It's clearly better to ask less of Python and PostgreSQL to get a better total time. No surprise there. What was interesting was the proportion of these differences. Memorize that and you'll be better equipped if it's worth the hassle of not using the Django ORM in the most basic form.
Also, do take note that this is only relevant in when dealing with many records. The slowest variant (f1) takes, on average, 7 milliseconds.
Summarizing the difference with percentages compared to the fastest variant:
f1 - 573% slowerf2 - 225% slowerf3 - 6% slowerf4 - 0% slower
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.
