What are `falsy` values in JavaScript

2022-04-07T00:00:00+00:00

While learning JavaScript you may have come across something like "value X is falsy". This relates to how the value is evaluated in a Boolean context, which is mainly in if-statements but also when casting to a boolean value</a>.</p>

The JavaScript values that evaluate to false</code> in a Boolean context are:</p>

Value</th> Type</th></tr></thead>

false</code></td> Boolean</td></tr>

''</code>, ""</code>, ``</code></td> String</td></tr>

0</code></td> Number</td></tr>

-0</code></td> Number</td></tr>

NaN</code></td> Number</td></tr>

0n</code></td> BigInt</td></tr>

null</code></td> Object</td></tr>

undefined</code></td> Undefined</td></tr>

document.all</code> (Don't ask me why)</td>

HTMLAllCollection</td></tr> </tbody></table>

Notice here that empty arrays and empty objects are not considered falsy.</p>

If there is falsy, what about truthy</h2>

Obviously when there are falsy values, there must be truthy values too. Which, logically, are values that evaluate to true</code> in a Boolean context. These truthy values are just all the other values which are not considered falsy.</p>


Casting values to booleans in JavaScript
2022-04-06T00:00:00+00:00
Converting values to a different type in JavaScript might work a little different than expected if you come from another programming language. JavaScript doesn’t have a specific syntax for type casting, which is present in a language like PHP to name one.</p>
Instead you instance an object of your preferred type and pass the value to cast as an argument. So in the case of booleans you would write something similar the following:</p>
const </span>bool </span>= </span>Boolean</span>(</span>"Hello"</span>); </span>// => true
</span>const </span>ball </span>= </span>Boolean</span>(</span>""</span>); </span>// => false
</span></code></pre>
That will convert all values to true</code> expect for JavaScript's falsy-values</a>. With the falsy-values being: undefined</code>, null</code>, false</code>, 0</code>, -0</code>, 0n</code>, NaN</code> and ""</code>. Note here that an empty array or empty object are not considered falsy.</p>
Double-negate</h2>
While using Boolean()</code> is at least super explicit there is a shorter syntax too which might has your preference. And that is using a double negation (!!</code>).</p>
const </span>bool </span>= !!</span>"Hello"</span>; </span>// => true
</span>const </span>ball </span>= !!</span>""</span>; </span>// => false
</span></code></pre>
The logic behind the double negation is that using negate once (!</code>) will evaluate the following expression to a boolean value, but also negates it. Negating that result, which is already a boolean value, undoes the first negation.</p>
See if you can crack the following, if you do you should be good to go when it comes to using double negation.</p>
0 </span>== </span>false</span>; </span>// => true
</span>0 </span>=== </span>false</span>; </span>// => false
</span>
</span>Boolean</span>(</span>0</span>); </span>// => false
</span>Boolean</span>(</span>5</span>); </span>// => true
</span>
</span>!</span>0</span>; </span>// => true
</span>!</span>5</span>; </span>// => false
</span>
</span>!!</span>0</span>; </span>// => false
</span>!!</span>5</span>; </span>// => true
</span></code></pre>



Solve `'v-if' should be moved to the wrapper element` in Vue.js
2022-04-05T00:00:00+00:00
When you use the eslint-plugin-vue package, which is the official ESLint plugin for Vue, to format your Vue code you will encounter some warnings and errors here and there. Such as the following one:</p>
This 'v-if' should be moved to the wrapper element.
</span></code></pre>
This error or warning occurs whenever you use both the v-for</code> and v-if</code> directive on the same HTML element. You might do so whenever you prefer to hide or not render the list based on a certain condition. As the warning suggest, the preferred way of doing this is by moving dat conditional to HTML element that contains the list with the v-for</code>.</p>
So instead of:</p>
<!-- Vue ESLint doesn't like this -->
</span><</span>template</span>>
</span>  <</span>ul </span>v-for</span>=</span>"item in items" </span>v-if</span>=</span>"showItems"</span>>
</span>    <</span>li</span>>{{ item }}</</span>li</span>>
</span>  </</span>ul</span>>
</span></</span>template</span>>
</span></code></pre>
The ESLint rule prefers this:</p>
<!-- And prefers you to do this -->
</span><</span>template</span>>
</span>  <</span>div </span>v-if</span>=</span>"showItems"</span>>
</span>    <</span>ul </span>v-for</span>=</span>"item in items"</span>>
</span>      <</span>li</span>>{{ item }}</</span>li</span>>
</span>    </</span>ul</span>>
</span>  </</span>div</span>>
</span></</span>template</span>>
</span></code></pre>
Using v-show</code> instead of v-if</code> will not cause this warning as well. They do have different performance penalties you should be aware of.</p>
<</span>template</span>>
</span>  <</span>ul </span>v-for</span>=</span>"item in items" </span>v-show</span>=</span>"showItems"</span>>
</span>    <</span>li</span>>{{ item }}</</span>li</span>>
</span>  </</span>ul</span>>
</span></</span>template</span>>
</span></code></pre>
You can disable the [vue/no-use-v-if-with-v-for]</code> rule all together by adding the following to the rules</code> section of you ESLint config file:</p>
'vue/no-use-v-if-with-v-for'</span>: </span>'off'
</span></code></pre>
For more information, read the docs</a>.</p>


Use `await` in Vue components with async methods
2022-04-04T00:00:00+00:00
The already not-so-recent-anymore ES7 changes to JavaScript introduced the async</code> and await</code> keywords. They allow for some syntactic sugar around JavaScript Promises.</p>
They can make asynchronous code more easy to read, and therefore worthy to look into for your Vue.js methods.</p>
You can use async</code> and await</code> for your lifecycle hooks, methods and watcher functions. One exception here is computed properties, which don’t allow the use of async</code> and await</code>.</p>
In order to use await</code> in the methods of you Vue component you prefix the method name with the async</code> keyword. See the following example, where you see custom async methods as well as async lifecycle hooks such as mounted</code> and created</code>.</p>
<</span>script</span>>
</span>  </span>export default </span>{
</span>    </span>data</span>() {
</span>      </span>return </span>{
</span>        token: </span>undefined</span>,
</span>        user: </span>undefined</span>,
</span>      };
</span>    },
</span>    </span>async </span>created</span>() {
</span>      this.token </span>= await </span>fetchUser();
</span>    },
</span>    </span>async </span>mounted</span>() {
</span>      this.user </span>= await </span>this.fetchUser();
</span>    },
</span>    methods: {
</span>      </span>async </span>getToken</span>() {
</span>        </span>const </span>token </span>= await </span>Cookie</span>.read(</span>"token"</span>);
</span>        </span>return </span>token;
</span>      },
</span>      </span>async </span>fetchUser</span>() {
</span>        </span>const </span>user </span>= await </span>api.get(</span>"user"</span>, { token: this.token });
</span>        </span>return </span>user;
</span>      },
</span>    },
</span>  };
</span></</span>script</span>>
</span></code></pre>
Browser support</h2>
Although the async</code> and await</code> should be available in all recently updated modern browsers, you might want to double check the browser support</a> just in case.</p>
If you need to support Internet Explorer in you Vue app than using a JavaScript transpiler like Babel</a> will allow you to use async</code>/await</code> in your Vue methods.</p>


Pass data to components in Vue.js with props
2022-04-03T00:00:00+00:00
Once you start to split up your Vue application in multiple components, you will at some point want to share variable values from a component to one of its child components. Probably the most straightforward way of passing data to child components in your Vue application is by using component props.</p>
Before you start with props it is good to understand that they have a one-way dataflow, changes are only propagated from parent to childs.</p>
Whenever you try to change the value of a prop in a child component those changes are not applied to the parent component. To reason from the other direction, whenever props change in the parent component, changes to props in a child component are not persisted. So you are better off to treat props as read-only data</strong>.</p>
If you do need reactivity there, you can potentially use props to set an initial value for a data property of your child component.</p>
Define props using the options API</h2>
In the child component you need to define the props under the props</code> key in your script section.</p>
<</span>script</span>>
</span>  </span>// ChildComponent.vue
</span>  </span>export default </span>{
</span>    props: [</span>"name"</span>],
</span>    computed: {
</span>      </span>welcome</span>() {
</span>        </span>return </span>`Hello </span>${this.name}</span>`</span>;
</span>      },
</span>    },
</span>  };
</span></</span>script</span>>
</span></code></pre>
From the parent component you can set the props value of the child component by using attributes. You can either set a hardcoded value or bind a value using :</code>, the shorthand of v-bind</code>.</p>
<</span>template</span>>
</span>  <</span>child-component </span>:name</span>=</span>"userName"</span>>
</span>  <</span>child-component </span>name</span>=</span>"Koen"</span>>
</span></</span>template</span>>
</span></code></pre>
The props are directly available under this</code> in your child component, so in the above example we can access the name using this.name</code>.</p>
Define props using the composition API</h2>
Using the composition API which is new in Vue 3 you can pass the props to as the first argument to you setup()</code> function.</p>
<</span>script</span>>
</span>  </span>// ChildComponent.vue
</span>  </span>export default </span>{
</span>    props: [</span>"name"</span>],
</span>    </span>setup</span>(</span>props</span>) {
</span>      </span>// ...
</span>    },
</span>  };
</span></</span>script</span>>
</span></code></pre>
In case you use a setup script (<script setup></code>) in single file components you can make use of the defineProps()</code> function to define your component props.</p>
<</span>script </span>setup</span>>
</span>  </span>// ChildComponent.vue
</span>  </span>const </span>props </span>= </span>defineProps([</span>"name"</span>]);
</span></</span>script</span>>
</span></code></pre>
Typed props</h2>
Besides defining props as an array of strings there is an object notation available as well. Which allows to define the property type as well. Your options for the types are String</code>, Number</code>, Boolean</code>, Array</code>, Object</code> and Function</code>. This type is not in any way enforced by Vue, so passing a number while a string is expected will not break your component per-se. However, it will log a friendly warning to the developer console in your browser. Which may helps to spot errors early on.</p>
<</span>script</span>>
</span>  </span>// ChildComponent.vue
</span>  </span>export default </span>{
</span>    props: {
</span>      name: </span>String</span>,
</span>    },
</span>    computed: {
</span>      </span>welcome</span>() {
</span>        </span>return </span>`Hello </span>${this.name}</span>`</span>;
</span>      },
</span>    },
</span>  };
</span></</span>script</span>>
</span></code></pre>
Vuex or Pinia Global state</h2>
Sharing data with child components is useful. But it can get messy pretty quick as well. Imagine sharing data using props to a child component, which in turn shares it with one of its child components, and that child component shares it with another child component which eventually will be the one that displays that value.</p>
For such a case you are better off using an alternative to component props, that alternative should probably be a global state management library like Vuex</a> or Pinia</a>. Both libraries allow you to share reactive data of your application across all components. Whenever such a global state item changes value, Vue takes care of the re-rendering of components automatically for you.</p>


Get an element by its ID using Vue.js
2022-04-02T00:00:00+00:00
With plain JavaScript you find yourself regularly jumping into the DOM, to get the attributes of an element, add event handlers and other operations. For these actions there is a good chance you would have used the good old JavaScript function document.getElementById</code>, which would hand you back the HTML element you wish to manipulate.</p>
The Vue framework, luckily, hides most of the DOM operations behind a friendly API. Instead of needing to call addEventListener("click", function () {...}</code>, you can bind an event directly to an HTML element using v-on:click=”...”</code> or its shorthand notation @click=”...”</code>. Or when you need to access a value of a form input, you can easily set up a data property in your Vue component and bind it to the form input using v-model</code>.</p>
However, once in a while I do need to access DOM elements directly. When I need to get the dimensions in pixels of an element for example. For such a use-case you can</em> fall back on using the native JavaScript document.getElementById</code> function again. But Vue has something built-in for such a use-case as well, namely template refs</strong>.</p>
Defining template refs</h2>
A template ref, short for reference I assume, allows you to easily access an HTML element in your Vue code. A template ref is created by adding the special ref=”...”</code> attribute to an element in your template.</p>
<</span>template</span>>
</span>  <</span>img </span>ref</span>=</span>"picture" </span>src</span>=</span>"example.png" </span>/>
</span></</span>template</span>>
</span></code></pre>
Next, once the component is mounted</strong> we can access our img</code> element using the picture</code> reference. But how to do so depends on whether using the options API or the new composition API which was introduced in Vue 3.</p>
Accessing refs using the options API</h2>
In the options API your template references are accessible as a property of this.$refs</code>. So in our example we can example we can access the img</code> element via this.$refs.picture</code>. Do keep in mind that this element only exists after the component in mounted, so try to access the picture</code> ref in the created</code> lifecycle hook will return null</code> instead of the HTML element.</p>
<</span>template</span>>
</span>  <</span>img </span>ref</span>=</span>"picture" </span>src</span>=</span>"example.png" </span>/>
</span></</span>template</span>>
</span>
</span><</span>script</span>>
</span>  </span>export default </span>{
</span>    </span>mounted</span>() {
</span>      </span>const </span>height </span>= </span>this.$refs.picture.clientHeight;
</span>    },
</span>  };
</span></</span>script</span>>
</span></code></pre>
Accessing refs using the composition API</h2>
The composition API obviously allows for accessing template refs as well. However, you need to pay a bit more attention to detail here. In your setup</code> script, or setup()</code> function if you prefer that, you need to define a variable named the same as your ref and assign it to ref(null)</code>.</p>
After the component is mounted, you can access the ref using the variable you defined. Where this differs from the options API is that your HTML element lives under <ref>.value</code> instead of directly under <ref></code>. In our example the HTML element itself can be accessed as picture.value</code>.</p>
<</span>template</span>>
</span>  <</span>img </span>ref</span>=</span>"picture" </span>src</span>=</span>"example.png" </span>/>
</span></</span>template</span>>
</span>
</span><</span>script </span>setup</span>>
</span>  </span>import </span>{ ref, onMounted } </span>from </span>"vue"</span>;
</span>
</span>  </span>// IMPORTANT: Variable should be named the same as the ref.
</span>  </span>const </span>picture </span>= </span>ref(</span>null</span>);
</span>
</span>  onMounted(() </span>=> </span>{
</span>    </span>const </span>height </span>= </span>picture.value.clientHeight;
</span>  });
</span></</span>script</span>>
</span></code></pre>


String casing in PHP
2021-12-21T00:00:00+00:00
Lowercase the whole string</h2>
In order to lowercase a PHP string you need the strtolower()</code> function. It takes a string as a parameter and returns the lowercase result of the string passed as a parameter.</p>
See the following example:</p>
<?php
</span>
</span>$nl </span>= </span>strtolower</span>(</span>'The Netherlands'</span>);
</span>echo </span>$nl;
</span>//-> the netherlands
</span></code></pre>
The result depends on the locale that is set, in the default English locale that is set in "C" some special characters are not lowercased such as the "Ä".</p>
See the docs: strtolower</a></p>
Uppercase the whole string</h2>
To uppercase an entire string you need the PHP function strtoupper()</code>. It takes a string as a parameter and returns the lowercase result of the string passed as a parameter.</p>
See the following example:</p>
<?php
</span>
</span>$nl </span>= </span>strtoupper</span>(</span>'The Netherlands'</span>);
</span>echo </span>$nl;
</span>//-> THE NETHERLANDS
</span></code></pre>
See the docs: strtoupper</a></p>
Uppercase the first letter of a string</h2>
Besides functions that work on the entire string PHP provides functions that work on just a substring of the string that is passed as a parameter, one of them is the ucfirst()</code> function (short for uppercase the first letter).</p>
See the following example:</p>
<?php
</span>
</span>$nl </span>= </span>ucfirst</span>(</span>'the netherlands'</span>);
</span>echo </span>$nl;
</span>//-> The netherlands
</span></code></pre>
You should keep in mind that this function only changes the case of the first letter in a string. So take a look at the following example:</p>
<?php
</span>
</span>$nl </span>= </span>ucfirst</span>(</span>'THE NETHERLANDS'</span>);
</span>echo </span>$nl;
</span>//-> THE NETHERLANDS
</span></code></pre>
So in order to only have the first letter uppercased it might be preferable, depending on the strings you expect, to combine ucfirst()</code> with strtolower()</code> as the following example demonstrates:</p>
<?php
</span>
</span>$nl </span>= </span>ucfirst</span>(</span>strtolower</span>(</span>'THE NETHERLANDS'</span>));
</span>echo </span>$nl;
</span>//-> The netherlands
</span></code></pre>
See the docs: ucfirst</a></p>
Uppercase the first letter of each word</h2>
Besides upper casing the first letter of a string you can uppercase the first character of each word in a string with ucwords()</code>.</p>
<?php
</span>
</span>$nl </span>= </span>ucwords</span>(</span>'the netherlands'</span>);
</span>echo </span>$nl;
</span>//-> The Netherlands
</span></code></pre>
Just as with ucfirst()</code> only the casing of the first letters are changed. Other letters that are already uppercased maintain their casing. So in order to only have the first letter uppercased it might be safer to combine ucwords()</code> with strtolower()</code>.</p>
<?php
</span>
</span>$nl </span>= </span>ucwords</span>(</span>strtolower</span>(</span>'THE NETHERLANDS'</span>));
</span>echo </span>$nl;
</span>//-> The Netherlands
</span></code></pre>
What the ucwords function considers words is determined by the value of a second parameter to this function. This second parameter sets the characters that are considered word separators, meaning that the characters in a string after</em> such a character are considered to be a different word.</p>
The default value of this separator parameter is set to " \t\r\n\f\v"</code>, notice the space in there as well. The other values are in order the escape sequences of the: horizontal tab, carriage return, newline, form-feed and vertical tab.</p>
We can overwrite this second parameter as follows:</p>
<?php
</span>
</span>$nl </span>= </span>ucwords</span>(</span>'the-netherlands'</span>);
</span>echo </span>$nl;
</span>//-> The-netherlands
</span>$nl </span>= </span>ucwords</span>(</span>'the-netherlands'</span>, </span>'-'</span>);
</span>echo </span>$nl;
</span>//-> The-Netherlands
</span></code></pre>
See the docs: ucwords</a></p>


Solving `cannot assign twice to immutable variable` in Rust
2021-12-20T00:00:00+00:00
If you encountered the error cannot assign twice to immutable variable</code> you most likely tried to reassign a value to an immutable variable. Variables in Rust are by default immutable, meaning that the variable only gets a value assigned at the time that the variable is declared.</p>
Consider the following main function for example, in which we create variable a</code> and set its value to 0</code>. On the next line we try to set the value of a</code> to 1</code>.</p>
fn </span>main</span>() {
</span>    </span>let</span> a </span>= </span>0</span>;
</span>    a </span>= </span>1</span>;
</span>}
</span></code></pre>
This code spawns the following error:</p>
error[E0384]: cannot assign twice to immutable variable `a`
</span> --> src/main.rs:3:5
</span>  |
</span>2 |     let a = 0;
</span>  |         -
</span>  |         |
</span>  |         first assignment to `a`
</span>  |         help: consider making this binding mutable: `mut a`
</span>3 |     a = 1;
</span>  |     ^^^^^ cannot assign twice to immutable variable
</span>
</span>For more information about this error, try `rustc --explain E0384`.
</span></code></pre>
In order to fix this problem we have two options available:</p>

Make the variable mutable.</li>
Rewrite the code so that you don’t need to reassign a value to an immutable variable.</li>
</ul>
Let's stick to the first option for now; declaring a mutable variable. Which is also the suggestion given to us by the Rust compiler. In order to declare a mutable variable in Rust you use the mut</code> keyword after let</code>, mut</code> being short for mutable.</p>
So in order to solve the problem as seen in the previous example we can rewrite our program as follows:</p>
fn </span>main</span>() {
</span>    </span>let </span>mut</span> a </span>= </span>0</span>;
</span>    a </span>= </span>1</span>;
</span>}
</span></code></pre>
Immutable variables cannot be modified once they have been declared. This is one of Rust’s features that provide your code with type safety. However, sometimes mutable variables are just very convenient.</p>


List installed packages with `yum` on CentOS
2021-12-17T00:00:00+00:00
The yum</code> package manager is the package manager of choice to install RPM packages on CentOS, Red Hat and Amazon Linux. No coincidence there since these three Linux distributions are closely related to each other.</p>
Besides just installing, updating and removing packages on your system yum</code> conveniently provides a command to see which packages are currently installed as well.</p>
To see which packages are installed on your system you can use the yum list</code> command, see the following example:</p>
$ yum list installed
</span></code></pre>
You might need to prefix the command with sudo</code> depending on how the permissions are set up on your system.</p>
Since the output of the command is probably quite long you may prefer to use a terminal text viewer like less</code> or view</code>.</p>
$ yum list installed | less
</span></code></pre>
Check if a certain package is installed with yum</h2>
To search for a specific package in your installed packages, this is useful if you need to check whether a certain package is actually installed on your system, you may pipe (|</code>) the output to the grep</code> command.</p>
For example, the following commands will list the installed packages of which the name contains the substring “python”:</p>
$ yum list installed | grep "python"
</span></code></pre>
List the installed packages with rpm</code></h2>
If you can use yum</code> you probably have access to the rpm</code> command as well. RPM is both a package manager as well as a file format for RPM packages. RPM is currently short for RPM Package Manager and at first as Red Hat Package Manager.</p>
The rpm</code> package manager is more a low-level tool for managing packages, but for listing installed packages it is just as useful.</p>
To list all installed packages you use the options -q</code> and -a</code>. The -q</code> option is used to query the installed packages, the -a</code> option tells rpm</code> to query all packages. So in order to list all the installed packages you use the following command:</p>
$ rpm -qa
</span></code></pre>
To search for a specific package that might be installed you run the command without the -a</code> option and provide the package name you would like to search for. For example see the following command which searches for the “python3” package:</p>
$ rpm -q python3
</span>python3-3.7.10-1.amzn2.0.1.x86_64
</span></code></pre>
And once again: you might need to prefix the command with sudo</code>.</p>


How to generate an .nvmrc file with the current Node.js version
2021-11-18T00:00:00+00:00
In the .nvmrc</code> file you may specify the Node.js version you would prefer to use in your project. Normally you create this file in your project's root directory. The Node Version Manager (nvm</a>) respects the version set in this file. Meaning the nvm subcommands use</code>, install</code>, exec</code>, run</code>, etc. will use the version that is set in the .nvmrc</code> file.</p>
In order to set your current Node.js version in the .nvmrc</code> file you may run the following command.</p>
node -v > .nvmrc
</span></code></pre>
The line above makes use of the ></code>-redirection operator of your shell to write the standard output of the node -v</code> command to the .nvmrc</code> file. If the file doesn’t exist yet it will be created. If it did exist however, the contents of the file will be overwritten.</p>
It is important</strong> to take into account that nvm does not change your Node.js version automatically once you are located in a directory containing a .nvmrc</code> file, the subcommands of nvm just take this file into account. So you still need to run nvm use</code> in order to set the right version of Node.js using nvm. The nvm docs</a> do show you how you can automate this step for the shell you are using.</p>
Use the latest Node LTS version</h2>
Besides setting an exact version in your .nvmrc file there are other alternatives too. You may set your Node.js version to the latest long term support (lts) version for example:</p>
echo "lts/*" > .nvmrc
</span></code></pre>
Use the latest Node version</h2>
Another option would be to default to the latest available option, you do this by just setting the contents of the .nvmrc</code> file to “node”:</p>
echo "node" > .nvmrc
</span></code></pre>


Replacing hugo by zola as static site generator for my blog
2021-10-31T00:00:00+00:00
After going from Jekyll to Gatsby to Hugo I now landed on the Zola</a> static site generator. Static site generator hopping is the new Distro hopping I guess :).</p>
1. Jekyll</h2>
I started with Jekyll</a> just because it was easy and I was pretty curious about Github Pages. There were quite some themes laying around to be used and it just worked. I basically discarded my Jekyll site for the following reasons; content changes with the serve</code> command were a bit slow; around 2 seconds. I used to run this command without the --incremental</code> option, which only re-builds pages that changed because I encountered a couple flaws with it. I am not completely sure anymore what those flaws were and a good chance that they have been fixed already so don’t let that discourage you.</p>
Besides that, as a young developer doing front-end work from time to time I wanted something fancier. Enter Gatsby.</p>
2. Gatsby</h2>
Second in line was Gatsby</a> as my static site generator. I just grabbed the official blog starter</a>, added a dark mode toggle and ran with it. It served me pretty well for a while. However… the main thing that bugged me was GraphQL.Whenever I wanted to customize something apparently trivial I found myself spending hours.</p>
Besides that the build time was quite slow, more than two minutes or so. I started using Netlify to host my site and I am not yet willing to go past my 300 free build minutes, I am a little cheap I guess :).</p>
It was also a little bit too fancy, which is quite ironically one of the reasons I chose Gatsby. Enter something more boring: Hugo.</p>
3. Hugo</h2>
Wow Hugo</a> fast! I went from 2 minutes of build time in Netlify to around 30 seconds of which the actual build command takes less than a second. I just grabbed the paper theme</a> and customized it a little.</p>
Mainly for my own archive, here is a screenshot of the previous Hugo site. It is a bit plain but it did the job very well.
</p>
So why did I move away from Hugo? Probably partially because I was bored or so. But second was the templating language in Hugo. It probably isn’t all too difficult but sitting down and figuring out how it worked just got in the way of the thing I wanted to do.</p>
4. Giving Zola a try now</h2>
After Googling around a bit I found Zola</a>. At the time of writing it seems to be a bit early in development. But it works pretty nice. In terms of being fast it’s pretty close to Hugo and it uses a templating language that’s inspired by Jinja2 and the Django templating language, which I know already so that made me pretty happy.</p>
I gave Zola a try and gave my site a make-over, inspired by the Adidoks theme</a>. Putting it live today, being quite happy with the end result.</p>


Async generator functions in Python
2021-09-22T00:00:00+00:00
Asynchronous generator functions are part of Python version 3.6, they were introduced by PEP-525</a>. Asynchronous generator functions are much like regular asynchronous functions except that they contain the yield</code> keyword in the function body. Which in turn, makes them much like regular generators, except for that you can use the await</code> keyword in there as well.</p>
When calling an asynchronous generator function, the result that is returned is an asynchronous generator object. In contrast to calling regular asynchronous functions which return a coroutine object.</p>
async </span>def </span>async_generator</span>():
</span>    </span>yield
</span>
</span>print</span>(async_generator())
</span># => <async_generator object async_generator at 0x7f4eb88b5c10>
</span>
</span>async </span>def </span>async_function</span>():
</span>    </span>pass
</span>
</span>print</span>(async_function())
</span># => <coroutine object async_function at 0x7f4eb8f52d40>
</span></code></pre>
Since the asynchronous generator is, no surprise, asynchronous you are allowed to use the await</code> keyword inside the asynchronous generator.</p>
You can use this, for example, to send out HTTP requests in the asynchronous generator and yielding the response.</p>
async </span>def </span>download_pages</span>(</span>urls</span>):
</span>    </span>for </span>url </span>in </span>urls:
</span>        response </span>= await </span>get_response(url)
</span>        </span>yield </span>response
</span></code></pre>
Besides asynchronous iterables you can use asynchronous generators with the async for</code>-loop as well.</p>


Solving `Failed to execute 'importNode' on 'Document'` in Alpine.js
2021-08-12T00:00:00+00:00
When you encounter the following error you most likely are not using a <template></code> tag in a for loop in Alpine.js.</p>
Alpine Expression Error: Failed to execute 'importNode' on 'Document': parameter 1 is not of type 'Node'.
</span></code></pre>
Let's for example consider the following Alpine component.</p>
<</span>div </span>x-data</span>=</span>"{ users: ['You', 'Me', 'Someone Else'] }"</span>>
</span>  <</span>ul </span>x-for</span>=</span>"user in users"</span>>
</span>    <</span>li </span>x-text</span>=</span>"user"</span>></</span>li</span>>
</span>  </</span>ul</span>>
</span></</span>div</span>>
</span></code></pre>
At least in Alpine.js version 3 this will show the error as mentioned above and not render any list items. This is due to the fact that x-for</code> directives should only be declared on <template></code> tags, which contain only one root element. So the above example can be fixed as follows:</p>
<</span>ul </span>x-data</span>=</span>"{ users: ['You', 'Me', 'Someone Else'] }"</span>>
</span>  <</span>template </span>x-for</span>=</span>"user in users"</span>>
</span>    <</span>li </span>x-text</span>=</span>"user"</span>></</span>li</span>>
</span>  </</span>template</span>>
</span></</span>ul</span>>
</span></code></pre>
The Alpine.js docs</a> define two rules you should keep in mind when using x-for</code>:</p>

x-for must</strong> be declared on a <template></code> element</li>
That <template></code> element must</strong> have only one root element</li>
</ul>
The <template></code> tag is a special HTML5 tag that is not visually rendered on a webpage directly. Instead it is meant to be instantiated with JavaScript once a page is loaded. You can think of it as an elements that just holds content, which you can render dynamically and reuse multiple times if you need to. A side note here is that Internet Explorer does not support</a> the usage of the <template></code> tag.</p>
Further Readings:</h3>

Alpine docs on x-for</a></li>
</ul>


Solving `Cannot read property 'cloneNode' of undefined` in Alpine.js
2021-08-11T00:00:00+00:00
If you are developing with Alpine.js you may encounter the following error at some point:</p>
Alpine Expression Error: Cannot read property 'cloneNode' of undefined
</span></code></pre>
Most likely you are using the x-if</code> directive on an HTML element other than <template></code>. In Alpine.js, the x-if</code> directive should only</strong> be applied on <template></code> elements and not on the element you wish to hide or display with conditional rendering.</p>
So let's consider the following element for example.</p>
<</span>h1 </span>x-if</span>=</span>"page === ''"</span>>Home</</span>h1</span>>
</span></code></pre>
In order to get the above to work properly we need to wrap the h1</code> in a template</code> tag. As is shown in the following example:</p>
<</span>template </span>x-if</span>=</span>"page === ''"</span>>
</span>  <</span>h1</span>>Home</</span>h1</span>>
</span></</span>template</span>>
</span></code></pre>
The <template></code> tag is a special HTML5 tag that is not visually rendered on a webpage directly. Instead it is meant to be instantiated with JavaScript once a page is loaded. You can think of it as an elements that just holds content, which you can render dynamically and reuse multiple times if you need to. A side note here is that Internet Explorer does not support</a> the usage of the <template></code> tag.</p>
Alternatively you can possibly use x-show</code> instead of x-if</code> if it better suits your use-case. The x-show</code> directive uses CSS to hide elements and therefore doesn't require the use of the <template></code> tag. Alpine does so by setting the display property to "none".</p>
Further Readings:</h3>

Alpine docs on x-if</a></li>
Alpine docs on x-show</a></li>
</ul>


Print object as dict in a Django template
2021-05-26T00:00:00+00:00
When you need to debug an object or model instance in Django templates spinning up a debugger is probably the most appropriate thing to do. However, debugging with print statements can be just so convenient. Just make sure to not push the print statements to production, it will drive your fellow devs mad.</p>
Printing objects in Python gets you their string representation, you can easily get around that by using .__dict__</code>:</p>
>>> </span>u </span>= </span>User()
</span>>>> </span>u.__dict__
</span>{</span>'_state'</span>: </span><</span>django.db.models.base.ModelState </span>object </span>at </span>0x7fadd961d820</span>></span>, </span>'id'</span>: </span>None</span>, </span>'password'</span>: </span>''</span>, </span>'last_login'</span>: </span>None</span>, </span>'is_superuser'</span>: </span>False</span>, </span>'username'</span>: </span>''</span>, </span>'first_name'</span>: </span>''</span>, </span>'last_name'</span>: </span>''</span>, </span>'email'</span>: </span>''</span>, </span>'is_staff'</span>: </span>False</span>, </span>'is_active'</span>: </span>True</span>, </span>'date_joined'</span>: datetime.datetime(</span>2021</span>, </span>5</span>, </span>26</span>, </span>10</span>, </span>4</span>, </span>9</span>, </span>501219</span>, </span>tzinfo</span>=<</span>UTC</span>></span>)}
</span></code></pre>
In Django templates this trick doesn't work unfortunately. If you try something like the code below you end up with an TemplateSyntaxError</code> saying: Variables and attributes may not begin with underscores: 'object.__dict__'</code>.</p>
{% extends 'layouts/base.html' %} {% block content %} {{ object.__dict__ }} {%
</span>endblock content %}
</span></code></pre>
One way around this, for debugging purposes, is with a custom template filter. Lets adjust the above example somewhat, we will load a tag library called debug</code> and add the as_dict</code> template filter to the template:</p>
{% extends 'layouts/base.html' %} {% load debug %} {% block content %} {{
</span>object|as_dict }} {% endblock content %}
</span></code></pre>
This debug</code> tag library is not yet registered, actually it doesn't even exist yet. In order to register the tag library we will add is as a library to the TEMPLATES settings in settings.py</code></p>
TEMPLATES </span>= </span>[
</span>    {
</span>        </span>'OPTIONS'</span>: {
</span>            </span>...
</span>            </span>'libraries'</span>:{
</span>                </span>'debug'</span>: </span>'project.templatetags.debug'</span>,
</span>            }
</span>        },
</span>    },
</span>]
</span></code></pre>
Next we need to create the library we added to the settings, with the path: project/templatetags/debug.py</code>.</p>
In this templatetags library we add the as_dict</code> filter we used before in our template.</p>
from </span>django </span>import </span>template
</span>
</span>register </span>= </span>template.Library()
</span>
</span>
</span>def </span>as_dict</span>(</span>value</span>):
</span>    </span>return </span>value.__dict__
</span>
</span>
</span>register.filter(</span>'as_dict'</span>, as_dict)
</span></code></pre>


Set the current user in a Django CreateView
2021-05-25T00:00:00+00:00
Often when creating a model via a form in Django you want to relate that object to the currently logged in user, or the business to which the current user relates to in its turn.</p>
You may set the current user for a new object in the form_valid</code> method of a CreateView</code>. Make sure to require a login, otherwise there is no current user to be set.</p>
from </span>django.contrib.auth.mixins </span>import </span>LoginRequiredMixin
</span>from </span>django.views.generic.edit </span>import </span>CreateView
</span>
</span>from </span>projects.models </span>import </span>Project
</span>
</span>
</span>class </span>CredentialsCreateView</span>(</span>LoginRequiredMixin</span>, </span>CreateView</span>):
</span>    model </span>= </span>Project
</span>    fields </span>= </span>[</span>'title'</span>]
</span>
</span>    </span>def </span>form_valid</span>(</span>self</span>, </span>form</span>):
</span>        form.instance.user </span>= </span>self.request.user
</span>        </span>return </span>super</span>().form_valid(form)
</span></code></pre>


Adding a placeholder to form fields in Django
2021-05-24T00:00:00+00:00
HTML placeholders in form inputs can be super useful to let the user know what kind of value you are expecting. Setting a placeholder attribute on a HTML element is straightforward, but in Django you normally let a Form class deal with rendering your HTML form.</p>
Therefore, in order to set a placeholder value for a form field in Django you should pass the placeholder as an attribute to a form widget.</p>
from </span>django </span>import </span>forms
</span>
</span>
</span>class </span>ApiCredentialsForm</span>(</span>forms.Form</span>):
</span>    key </span>= </span>forms.CharField(</span>widget</span>=</span>forms.PasswordInput(
</span>      </span>attrs</span>=</span>{</span>'placeholder'</span>: </span>'*******'</span>}))
</span>    token </span>= </span>forms.CharField(</span>widget</span>=</span>forms.PasswordInput(
</span>      </span>attrs</span>=</span>{</span>'placeholder'</span>: </span>'*******'</span>}))
</span>
</span></code></pre>


Restart a service with SaltStack when a config file changes
2021-05-23T00:00:00+00:00
In Linux many services require a restart when a config file is changed. Having to do this manually every time you change a configuration can be a pain. So doing this automatically would be great. With SaltStack you can achieve this by using watch</a> in a state.</p>
nginx</span>:
</span>  </span>service.running</span>:
</span>    - </span>reload</span>: </span>True
</span>    - </span>enable</span>: </span>true
</span>    - </span>watch</span>:
</span>        - </span>file</span>: </span>nginx
</span>  </span>file.managed</span>:
</span>    - </span>name</span>: </span>/etc/nginx/sites-enabled/website
</span>    - </span>source</span>: </span>salt://nginx/website
</span></code></pre>
By "watching" a different state Salt makes sure to restart the service when the specified state has changed.</p>


Render template directly from Django middleware
2021-05-22T00:00:00+00:00
In Django you normally specify templates to be rendered from a view class or function. Instead you can render a template directly from the Django middleware as well, as an alternative to redirecting to a different view.</p>
For example you may want to render a maintenance template if your site is in maintenance mode. In that case you can directly call the render function that can be imported from django.shortcuts</code>.</p>
This example may look like the following:</p>
from </span>django.conf </span>import </span>settings
</span>from </span>django.shortcuts </span>import </span>render
</span>
</span>
</span>class </span>MaintenanceMiddleware</span>:
</span>    </span>def </span>__init__</span>(</span>self</span>, </span>get_response</span>):
</span>        self.get_response </span>= </span>get_response
</span>
</span>    </span>def </span>__call__</span>(</span>self</span>, </span>request</span>):
</span>        </span>if </span>settings.IN_MAINTENANCE:
</span>            </span>return </span>render(request, </span>'maintenance.html)</span>
</span>        </span>return</span> self.get_response(request)
</span></code></pre>


Target minions by multiple grains with Salt
2021-05-21T00:00:00+00:00
With Salt there is a whole host of ways to target minions. In most cases I prefer to target minions based on certain grains.</p>
$ salt -G 'role:webserver' test.ping
</span></code></pre>
However, this allows you to only target minions by a single grain. In order to target minions based on multiple grains you use compound matchers</strong>.</p>
$ salt -C 'G@role:webserver and G@role:worker' test.ping
</span></code></pre>
See the salt docs</a> for more information about compound matchers.</p>
You may combine these compound expressions to define node groups</a> in the configuration of the salt-master. This configuration is a YAML file which is by default located at /etc/salt/master</code>, on the salt-master obviously.</p>
An node group definition in the master configuration would look like the following for example:</p>
nodegroups</span>:
</span>  </span>django</span>: </span>"G@role:webserver and G@role:worker"
</span></code></pre>
By defining this django</code> node group you can target all the matching minions with the following command:</p>
$ salt -N django test.ping
</span></code></pre>


Hiding admin pages using Django middleware
2021-05-20T00:00:00+00:00
You normally render Django templates from your views. However, in some cases you may want to short circuit something and not let a request get that far into your application.</p>
The guys on the Django Chat Podcast made a case in a security episode</a> for changing the Django admin URL prefix to anything</em> other than /admin</code>.</p>
Of course this does not make the Django admin itself any more secure, however you exclude some script kiddies scanning the web for Django sites (by looking for the Django admin at /admin</code>).</p>
I have been taking a different "security through obscurity" approach for making the Django admin unavailable for others. Instead of changing the URL of the admin I raise a 404 in a custom middleware class to non-superuser when they try to access an admin route. In this case, superusers have to be logged in first via the website itself before they can access the admin pages.</p>
This middleware class looks like the following:</p>
from </span>django.http </span>import </span>Http404
</span>
</span>
</span>class </span>AdminPagesMiddleware</span>:
</span>    </span>def </span>__init__</span>(</span>self</span>, </span>get_response</span>):
</span>        self.get_response </span>= </span>get_response
</span>
</span>    </span>def </span>__call__</span>(</span>self</span>, </span>request</span>):
</span>        </span>if </span>request.path.startswith(</span>'/admin'</span>) </span>and not </span>request.user.is_superuser:
</span>            </span>raise </span>Http404()
</span>        </span>return </span>self.get_response(request)
</span></code></pre>
We should not forget to register the middleware as well :).</p>
MIDDLEWARE </span>= </span>[
</span>    </span>...
</span>    </span>'project.middleware.auth_middleware.AdminPagesMiddleware'</span>,
</span>    </span>...
</span>]
</span></code></pre>
And you definitely want tests for this middleware.</p>
from </span>django.urls </span>import </span>reverse
</span>from </span>django.test </span>import </span>TestCase, Client
</span>from </span>django.contrib.auth </span>import </span>get_user_model
</span>
</span>
</span>class </span>AdminPagesMiddlewareTestCase</span>(</span>TestCase</span>):
</span>    </span>def </span>test_throws_404_for_anonymous_users</span>(</span>self</span>):
</span>        r </span>= </span>self.client.get(</span>'/admin/'</span>, </span>follow</span>=</span>True</span>)
</span>        </span>assert </span>r.status_code </span>== </span>404
</span>
</span>    </span>def </span>test_throws_404_for_users</span>(</span>self</span>):
</span>        get_user_model().objects.create_user(
</span>            </span>'ko'</span>, </span>'ko@test.com'</span>, </span>'pass'</span>, </span>is_superuser</span>=</span>False</span>)
</span>        self.client.login(</span>username</span>=</span>'ko'</span>, </span>password</span>=</span>'pass'</span>)
</span>        r </span>= </span>self.client.get(</span>'/admin/'</span>, </span>follow</span>=</span>True</span>)
</span>        </span>assert </span>r.status_code </span>== </span>404
</span>
</span>    </span>def </span>test_accessible_for_superusers</span>(</span>self</span>):
</span>        get_user_model().objects.create_user(
</span>            </span>'ko'</span>, </span>'ko@test.com'</span>, </span>'pass'</span>, </span>is_superuser</span>=</span>True</span>)
</span>        self.client.login(</span>username</span>=</span>'ko'</span>, </span>password</span>=</span>'pass'</span>)
</span>        r </span>= </span>self.client.get(</span>'/admin/'</span>, </span>follow</span>=</span>True</span>)
</span>        </span>assert </span>r.status_code </span>== </span>200
</span></code></pre>


Update a single field on a Django model
2021-05-19T00:00:00+00:00
Updating a single field in Django might have your preference over updating all model fields to the database. This is somewhat more beneficial in terms of performance for example. You specify the fields that should be updated by passing the update_fields</code> keyword argument to the .save()</code> method containing a list of field names.</p>
user.is_active </span>= </span>False
</span>user.save(</span>update_fields</span>=</span>[</span>'is_active])</span>
</span></code></pre>
Of course Django provides excellent docs</a> on this particular feature.</p>


Comments in bash scripts
2021-05-18T00:00:00+00:00
Comments in bash, or in other shells, start with a hashtag(#</code>). Everything after the hashtag is ignored, so you can have comments that span the entire line or use comments inline after a command.</p>
# Create a file if it doesn't exist
</span>if </span>[[ </span>! </span>-f </span>$file </span>]]</span>; then
</span>  touch $file </span># Create the file using the touch command
</span>fi
</span></code></pre>
Bash does not support multiline comments like many other languages. If you want comments that span multiple lines you should add a #</code> before each line.</p>
# Create a file if it doesn't exist
</span># if [[ ! -f $file ]]; then
</span>#   touch $file
</span># fi
</span></code></pre>
If you really want comments that span multiple lines you may misuse HEREDOC strings.</p>
<<COMMENT
</span>You may use HEREDOC to
</span>write multiline comments
</span>COMMENT
</span></code></pre>
Pro tip!</strong> you can use comments in your terminal as well. This way you can store them in your shell history without having to run them for example.</p>
$ # git rev-list --max-parents=0 HEAD | tail -n 1
</span></code></pre>


What are 'shells' in Linux
2021-05-17T00:00:00+00:00
You might have opened your terminal many times before. This program is more factually called a terminal emulator</em>. These terminal emulators are most often pre-installed and allow you to interact with your shell, I am writing this in the gnome-terminal</code> for example.</p>
A shell basically is the following two things:</p>

An interpreter for shell commands:</strong> A shell allows you to execute shell commands via both an interactive shell prompt and via shell scripts.</li>
A programming language:</strong> A shell provides basic programming capabilities to combine shell commands in a more complex manner, with features including variables and flow control structures.</li>
</ul>
Examples of shells on Linux, and other UNIX-like systems, include bash, zsh, fish and ksh.</p>
This page</a> at the GNU website describes the shell at is base as a "macro processor that executes commands". This term "marco processor" refers to the capability of shells to expand text and symbols into larger expressions.</p>


What is this shebang comment starting with #!
2021-05-16T00:00:00+00:00
If you have seen an executable script for a UNIX system good chance the first line started with #!</code>. This is a special comment called the "shebang" and it specifies the interpreter that should be used to execute the file with.</p>
So if you are looking at a bash script you may see #!/bin/bash</code>, if you are looking at a Python script you may see #!/usr/bin/python3</code> as shebang.</p>
The shebang comment uses the following structure:</p>
#![path to interpreter] [possible arguments]
</span></code></pre>
You may also encounter a shebang that is pointing to the interpreter /usr/bin/env</code>. This is useful in case you are not sure where your preferred interpreter is located on the system that might run the script, whether it is a server in the AWS cloud or the laptop of a colleague. It makes your script portable so to say since by using /usr/bin/env</code> PATH is searched for the command you pass as an argument. The following example shows how this shebang with the bash</code> interpreter.</p>
#!/usr/bin/env bash
</span></code></pre>
In case no shebang comment is present the default interpreter used depends on the shell you are using. Bash uses itself as a fallback when no shebang is specified. While Zsh uses /bin/sh</code> as a fallback on the other hand, what /bin/sh</code> actually refers to depends on your system.</p>
Also make sure your script has executable permissions before you execute it. You may do this with the chmod</code> command:</p>
$ chmod u+x ./script.sh
</span></code></pre>


Update a field for all objects in a Django QuerySet
2021-05-15T00:00:00+00:00
In some cases you may want to update a field, or multiple fields, for a collection of Django models in a QuerySet object. For those use-cases you may use the .update()</code> method on the QuerySet object.</p>
User.objects.filter(</span>last_login</span>=</span>None</span>).update(</span>is_active</span>=</span>False</span>)
</span></code></pre>
The .update()</code> method allows you to update fields for all the objects in your QuerySet. This is illustrated in the following example, which uses a .filter()</code> method to select the objects which should be updated. However, if you want to apply a change to all objects you can use .all()</code> instead.</p>
When you run this line in the Django shell you might be surprised by the return value of the statement. The .update()</code> method returns the number of rows matched by the query, which is not necessarily equal to the amount of rows updated.</p>
There is a gotcha when updating objects like this though. This method directly runs an SQL statement without calling the save()</code> method on your model and therefore not call any pre_save or post_save signals.</p>
Of course Django provides excellent docs</a> on this particular feature.</p>


Check for future posts in Hugo templates
2021-05-14T00:00:00+00:00
I have been happily running by blog using the Hugo static site generator. Hosted on Netlify, works like a charm. However, lately I has an issue where I, by accident, had set the publishing date for a post 10 years in the future. Not that big a deal, but in order to prevent this error in the future I did want to add a visual clue to future posts.</p>
I never really researched the Hugo templating language very well. I just picked a theme from Hugo Themes</a>, slightly modified some CSS and it just worked without any other effort.</p>
Using an example from the Hugo website</a> I was able to add a visual clue to future posts.</p>
Lets for example say that my markdown post has the following YAML Front Matter at the top of the posts.</p>
title</span>: </span>"Check for future posts in Hugo templates"
</span>date</span>: </span>2031-05-14
</span>lastmod</span>: </span>2031-05-14
</span>
</span>I have been happily running by blog...
</span></code></pre>
Now, in my templates I check check for that date</code> property which is set in the future. I did this with {{- if ge .Date.Unix now.Unix }}</code>. See the following snippet which adds some text after a title for future posts:</p>
<</span>h2</span>>
</span>  {{ .Title }} {{- if ge .Date.Unix now.Unix }}
</span>  <</span>sup</span>>[future]</</span>sup</span>>
</span>  {{- end }}
</span></</span>h2</span>>
</span></code></pre>


Defining constants in bash scripts
2021-05-13T00:00:00+00:00
If you are coming from a different programming language you are probably familiar to the concept of constants already. A constant is just like a variable except for the fact that its value does not change during the execution of your script.</p>
This makes sense in scripts for which you have to define the total amount of months in a year for example. This is a number that is not likely to change anytime soon.</p>
TOTAL_MONTHS</span>=</span>12
</span></code></pre>
As you might have noticed the TOTAL_MONTHS</code> constant is written in all caps, this is actually just a convention and nothing prevents you from changing its value. Using all caps does not enforce a readonly value in bash so if you would like to change TOTAL_MONTHS</code> to 11</code> you are free to do so:</p>
$ TOTAL_MONTHS=</span>"12"
</span>$ echo $TOTAL_MONTHS
</span>12
</span>$ TOTAL_MONTHS=</span>"11"
</span>$ echo $TOTAL_MONTHS
</span>11
</span></code></pre>
Your shell doesn't complain at all about this as you see.</p>
This all caps convention is consistent with how environment variables and shell variables are defined. An example of an environment variable would be $PATH</code>.</p>
Enforcing read only values</h2>
If you need to enforce a readonly value you may do so by using the declare</code> or readonly</code> commands. These two commands work very similar but differ in the default scope for which the variables are available. The readonly</code> command defaults to a global scope where declare</code> uses a local scope by default.</p>
The following snippet illustrates what happens when you try to reassign a readonly variable.</p>
$ declare</span> -r</span> TOTAL_MONTHS=</span>"12"
</span>$ echo $TOTAL_MONTHS
</span>12
</span>$ declare</span> -r</span> TOTAL_MONTHS=</span>"11"
</span>bash: declare: TOTAL_MONTHS: readonly variable
</span></code></pre>


See which environment variables are set with `printenv`
2021-05-12T00:00:00+00:00
Data in your shell environment is either stored as a shell variable or an environment variable. Shell variables are globally set and readable within bash. Environment variables on the other hand are available to all processes or programs on your system.</p>
You can use the printenv</code> command in order to print the environment variables with their values. This printenv</code> command will exclusively print environment variables.</p>
$ printenv
</span>COLORTERM=truecolor
</span>DBUS_SESSION_BUS_ADDRESS=unix:path=/run/user/1000/bus
</span>DEFAULTS_PATH=/usr/share/gconf/ubuntu.default.path
</span>DESKTOP_SESSION=ubuntu
</span>DISPLAY=:0
</span>EDITOR=vim
</span>...
</span></code></pre>
To print both the shell and environment variables you may use the set</code> builtin available in bash. You may use the set</code> builtin as well to change the value of shell attributes.</p>
$ set
</span>BASH=/usr/bin/bash
</span>BASHOPTS=checkwinsize:cmdhist:complete_fullquote:expand_aliases:extquote:force_fignore:globasciiranges:hostcomplete:interactive_comments:progcomp:promptvars:sourcepath
</span>BASH_ALIASES=()
</span>BASH_ARGC=([0]="0")
</span>BASH_ARGV=()
</span>BASH_CMDS=()
</span>BASH_LINENO=()
</span>BASH_SOURCE=()
</span>BASH_VERSINFO=([0]="5" [1]="0" [2]="17" [3]="1" [4]="release" [5]="x86_64-pc-linux-gnu")
</span>BASH_VERSION='5.0.17(1)-release'
</span>COLORTERM=truecolor
</span>...
</span></code></pre>


Data types in bash scripts
2021-05-11T00:00:00+00:00
Whether you pass data to a script as an argument or assign values to a variable. Bash is not that</strong> aware of data types, bash basically treats it all as strings. However, bash may allow arithmetic operations and comparisons on variables based on the context in which the variable is used.</p>
The fact that bash does not differentiate between strings and integers or floats allows you to be flexible in your shell scripts. Be aware of subtle errors though.</p>
In practice you can enforce an integer of you like by using the command declare</code> with -i</code> as an options. However, this isn't used that often in shell scripts.</p>
declare -i week
</span>week=7
</span></code></pre>
More effectively, if you need a numeric value you can test it in an if-statement.</p>
if ! </span>[[ </span>"$week" </span>=~ </span>^</span>[</span>0</span>-</span>9</span>]</span>+$ </span>]]</span>;</span>; then
</span>  </span>echo </span>"Week is not numeric"
</span>fi
</span></code></pre>


Solving `permission denied` error for shell scripts
2021-05-10T00:00:00+00:00
If try to run a script, whether it is written in Python, bash or something else, you may encounter an error saying Permission denied</code>.</p>
Lets say for example you have a file called script.sh</code> which runs perfectly fine when you run it using a interpreter like:</p>
$ bash ./script.sh
</span>Hello World
</span></code></pre>
However, you prefer to run it without the bash</code> and use just the file name. Or later even as a command instead by adding it to your PATH.</p>
In that case you may see the following error.</p>
$ ./script.sh
</span>bash: ./script.sh: Permission denied
</span></code></pre>
This error indicates that the execute</code> file permission is missing. In order to add this execute</code> permission you use the chmod</code> command, which is short for ch</strong></u>ange file mod</strong></u>e. By running the following command we can make the script executable.</p>
$ chmod u+x ./script.sh
</span></code></pre>
And as we now see this indeed did the trick. Make sure you have added the shebang comment though.</p>
$ ./script.sh
</span>Hello World
</span></code></pre>


Vertical align within flexboxes with Tailwind CSS
2021-05-09T00:00:00+00:00
In order to align contents vertically in a flexbox in Tailwind CSS you need to have align-items: center;</code> set on the flex container. You may add this by using the class items-center</code>.</p>
<</span>main </span>class</span>=</span>"flex items-center"</span>>
</span>  <</span>div</span>>...</</span>div</span>>
</span></</span>main</span>>
</span></code></pre>
Keep in mind that in order to see a visual difference the flex container needs a height bigger than its child element. So you may do this by adding the class min-h-screen</code>, which sets the minimal screen height to 100vh</code>. Other options like h-40</code>, just picking a random height here, work too for example.</p>
<</span>main </span>class</span>=</span>"flex items-center min-h-screen"</span>>
</span>  <</span>div</span>>...</</span>div</span>>
</span></</span>main</span>>
</span></code></pre>
In order to completely center the child element, so horizontally as well, you need to have justify-content: center</code> set as well on the flex container. To do so you use the justify-center</code> class in Tailwind. Now the same applies to width here as we had before with the height. In order to see a visual difference make sure that the width of the parent element is bigger than the width of the child element. You may do so by adding the class w-full</code>.</p>
<</span>main </span>class</span>=</span>"flex items-center justify-center min-h-screen w-full"</span>>
</span>  <</span>div</span>>...</</span>div</span>>
</span></</span>main</span>>
</span></code></pre>


Horizontally center `.container` in Tailwind CSS
2021-05-08T00:00:00+00:00
When coming from other CSS frameworks like Bootstrap or Bulma the container</code> class in Tailwind CSS might work a little different than expected. In Tailwind CSS the container element is not horizontally centered by default, in contrast to Bootstrap or Bulma.</p>
Frameworks like Bootstrap or Bulma center the container</code> by settings the left and right margin to auto</code>. You can do the same in Tailwind by using the mx-auto</code> class to set the horizontal margins of an element to auto</code>.</p>
<</span>main </span>class</span>=</span>"container mx-auto"</span>>...</</span>main</span>>
</span></code></pre>
Another option is to solve this in your tailwind.config.js</code> file. See the example below:</p>
module</span>.</span>exports </span>= </span>{
</span>  future: {},
</span>  purge: [],
</span>  theme: {
</span>    container: {
</span>      center: </span>true</span>,
</span>    },
</span>  },
</span>  variants: {},
</span>  plugins: [],
</span>};
</span></code></pre>


Find out where bash is installed
2021-05-07T00:00:00+00:00
To find out where bash</code>, or any other shell program, is installed on your system you may use the which</code> command. which</code> locates commands in your PATH.</p>
$ which bash
</span>/usr/bin/bash
</span></code></pre>
PATH is an environment variable in your system that defines a list of directories in which your shell looks for executable commands when you enter them. As you see from the output of our which</code> command, an occurrence of bash</code> is found in the directory /usr/bin</code>. In my case this is where the program bash</code> is located.</p>
Where command in zsh</h2>
If you are using the zsh shell instead of bash you have another option besides the which</code> command. The zsh shell comes with a where</code> shell builtin that you can use as alternative to which</code>.</p>
$ where bash
</span>/usr/bin/bash
</span>/bin/bash
</span></code></pre>


Find out what your default shell is
2021-05-06T00:00:00+00:00
In order to see what your default terminal shell is, you can best be in the terminal itself. To see your default shell go into the terminal and type:</p>
$ echo $SHELL
</span>/bin/bash
</span></code></pre>
This echo</code> command prints out the value of the $SHELL</code> environment variable. This $SHELL</code> variable holds the login shell of the current user logged in on the system. On linux systems the preferred shell by a user is stored in the file /etc/passwd</code>.</p>
See for example this snippet of my passwd</code> file. As you see the last section of the line is /bin/bash</code>, the login shell for my user.</p>
$ cat /etc/passwd
</span>...
</span>koen:x:1000:1000:,,,:/home/koen:/bin/bash
</span></code></pre>
You may find something odd when it comes to the file path to bash: /bin/bash</code>. When you use the which</code> command to find out where a program is located you may see a different path, in my case: /usr/bin/bash</code></p>
$ which bash
</span>/usr/bin/bash
</span></code></pre>
This is due to some legacy reasons. In older systems bash</code> was located in /bin</code>. To stay compliant with these older systems /bin</code> is actually a symlink to /usr/bin</code>. To validate this you run the command ls -l /bin</code> and you see in the output /bin -> usr/bin</code>. This arrow indicates that /bin</code> is a symlink to /usr/bin</code>.</p>
$ ls -l /bin
</span>lrwxrwxrwx 1 root root 7 Aug  4  2020 /bin -> usr/bin
</span></code></pre>
Change the default shell</h2>
If you prefer to use a different shell than bash you are free to do so. Lets for example change the default shell to zsh. In order to do so you use the command chsh</code>, short of ch</strong>ange sh</strong>ell?</p>
Keep in mind that you don't run this command with sudo</code>, since you want to change the shell for your current user not for the root user.</p>
If you have zsh</code> installed you can use it as your default shell with the following command.</p>
$ chsh -s $(which zsh)
</span></code></pre>
In order to have this command take effect you at least need to restart your terminal, and maybe even need to log out first.</p>


Check the version of bash
2021-05-05T00:00:00+00:00
To find your bash version go in your terminal and echo out the $BASH_VERSION</code> shell variable.</p>
$ echo $BASH_VERSION
</span>5.0.17(1)-release
</span></code></pre>
This $BASH_VERSION</code> shell variable is set as long as you are using bash as your shell variable. So if you are using zsh or fish as a shell environment this variable is not set. In that case you can use the --version</code> flag on the command:</p>
$ bash --version
</span>GNU bash, version 5.0.17(1)-release (x86_64-pc-linux-gnu)
</span>Copyright (C) 2019 Free Software Foundation, Inc.
</span>License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>
</span>
</span>This is free software; you are free to change and redistribute it.
</span>There is NO WARRANTY, to the extent permitted by law.
</span></code></pre>
You can invoke bash</code> as a command like this because bash actually is just another binary program on your system like e.g. cat</code>, nano</code>, tail</code>.</p>
The bash program is located in a folder on your operating system that is included in your PATH. To see where bash is installed you can run the following command:</p>
$ which bash
</span>/usr/bin/bash
</span></code></pre>
As you see, for me the bash program/command is located in a folder called bin</em>, which is inside a folder called usr</em> which is located at the root of my file system.</p>
Some programs show the version info with the flag -v</code>. If you add the -v</code> flag to the bash</code> command bash will run in verbose mode, in this mode bash will show you as much information as possible. You can safely test this out if you like, you will see another shell get launched showing your shell configuration at startup.</p>


Get the total amount of git commits via the command line
2021-05-04T00:00:00+00:00
When you browse GitHub repositories you nicely see some statistics about the repository including the total amount of commits made for a branch. This may give an indication on how actively a project is or was, this is definitely not always the case.</p>
You can get this total number of commits locally via the command line as well. You can get this number via the rev-list</code> subcommand.</p>
In order to get the total commits count of your currently active branch you may use HEAD</code> combined with the --count</code> flag.</p>
$ git rev-list HEAD --count
</span>1233
</span></code></pre>
Instead of HEAD</code> you can specify a branch name as well, whether it is your current branch or another one like main</code> in the example below.</p>
$ git rev-list main --count
</span>1202
</span></code></pre>
And it works with remotes as well. Keep in mind however that you may need to fetch</code> first before you see the correct number.</p>
$ git rev-list origin/main --count
</span>1237
</span></code></pre>
If you would like to get the count of unique commits on all branches combined you use the --all</code> flag instead of the branch name.</p>
$ git rev-list --all --count
</span>1868
</span></code></pre>


Using the terminal in ChromeOS
2021-05-03T00:00:00+00:00
I got myself a Chromebook lately and since it is based on Linux I couldn't help looking for a terminal, just for fun.</p>
And for sure, there is one. With the keycode CTRL+ALT+T</code> a Terminal app launches.</p>
</p>
However, when typing the help</code> command as suggested the result is somewhat disappointing.</p>
</p>
Is this all? And yes, when trying to launch vim</code> the disappointment increases.</p>
</p>
But after Googling around somewhat I found a Beta feature called "Linux development environment". Fingers crossed.</p>
</p>
After the installation a terminal launched that looks more promising.</p>
</p>
And indeed, this is more like it :).</p>
</p>


Group objects in a list by property value in Python
2021-05-02T00:00:00+00:00
Lately I came across a problem for which I had to group objects of a single list by the value of a property of these objects. After trying some things I settled on the groupby</code> function from the itertools</code> module.</p>
Lets consider the following example, we have a Letter class with two properties: a string to specify the character and a boolean to specify wether the letter is a vowel or not. We want to group Letter objects based on their vowel</code> property.</p>
This class looks as the following, the __repr__</code> is just there to have a neat string representation when we later print out the objects.</p>
class </span>Letter</span>:
</span>    </span>def </span>__init__</span>(</span>self</span>, </span>char</span>: </span>str</span>, </span>vowel</span>: </span>bool</span>) -> </span>None</span>:
</span>        self.char </span>= </span>char
</span>        self.vowel </span>= </span>vowel
</span>
</span>    </span>def </span>__repr__</span>(</span>self</span>) -> </span>str</span>:
</span>        </span>return </span>self.char
</span></code></pre>
Next we create a list with Letter objects. Not the entire alphabet, the first couple letters will do.</p>
letters </span>= </span>[
</span>    Letter(</span>'a'</span>, </span>True</span>),
</span>    Letter(</span>'b'</span>, </span>False</span>),
</span>    Letter(</span>'c'</span>, </span>False</span>),
</span>    Letter(</span>'d'</span>, </span>False</span>),
</span>    Letter(</span>'e'</span>, </span>True</span>),
</span>]
</span></code></pre>
Now we group our letters</code> list containing Letter</code> objects based on the value of their .vowel</code> property. This grouping is done by the key function we pass to groupby</code> as a second argument, the list itself being the first argument.</p>
from </span>itertools </span>import </span>groupby
</span>
</span>sorted_letters </span>= </span>sorted</span>(letters, </span>key</span>=</span>lambda </span>letter</span>: letter.vowel)
</span>grouped </span>= </span>[</span>list</span>(result) </span>for </span>key, result </span>in </span>groupby(
</span>    sorted_letters, </span>key</span>=</span>lambda </span>letter</span>: letter.vowel)]
</span>
</span>print</span>(grouped)
</span># => [[b, c, d], [a, e]]
</span></code></pre>
One gotcha is that the list, or any other iterable, needs to be sorted before passing it to the groupby</code> function. Otherwise your groups end up with a segmented result. To illustrate see the following example where the sorting is commented out. As you see the groupby</code> makes the groups consecutively.</p>
from </span>itertools </span>import </span>groupby
</span>
</span># letters = sorted(letters, key=lambda letter: letter.vowel)
</span>grouped </span>= </span>[</span>list</span>(result) </span>for </span>key, result </span>in </span>groupby(
</span>    letters, </span>key</span>=</span>lambda </span>letter</span>: letter.vowel)]
</span>
</span>print</span>(grouped)
</span># => [[a], [b, c, d], [e]]
</span></code></pre>
Our entire code sample looks like:</p>
from </span>itertools </span>import </span>groupby
</span>
</span>
</span>class </span>Letter</span>:
</span>    </span>def </span>__init__</span>(</span>self</span>, </span>char</span>: </span>str</span>, </span>vowel</span>: </span>bool</span>) -> </span>None</span>:
</span>        self.char </span>= </span>char
</span>        self.vowel </span>= </span>vowel
</span>
</span>    </span>def </span>__repr__</span>(</span>self</span>) -> </span>str</span>:
</span>        </span>return </span>self.char
</span>
</span>letters </span>= </span>[
</span>    Letter(</span>'a'</span>, </span>True</span>),
</span>    Letter(</span>'b'</span>, </span>False</span>),
</span>    Letter(</span>'c'</span>, </span>False</span>),
</span>    Letter(</span>'d'</span>, </span>False</span>),
</span>    Letter(</span>'e'</span>, </span>True</span>),
</span>]
</span>
</span>sorted_letters </span>= </span>sorted</span>(letters, </span>key</span>=</span>lambda </span>letter</span>: letter.vowel)
</span>grouped </span>= </span>[</span>list</span>(result) </span>for </span>key, result </span>in </span>groupby(
</span>    sorted_letters, </span>key</span>=</span>lambda </span>letter</span>: letter.vowel)]
</span>
</span>print</span>(grouped)
</span># => [[b, c, d], [a, e]]
</span></code></pre>


List installed PostgreSQL extensions with version
2021-05-01T00:00:00+00:00
With extensions you can add some extra functionality to your PostgreSQL database server. Which is a great but you generally don't want to have lots of extensions around which you are not using anymore. Therefore it is useful to clean them up once every while. To list the installed PostgreSQL extensions you need to run a SQL statement. For this you can login to the Postgres shell.</p>
Now, to show the installed PostgreSQL extensions with their version numbers you run the following SQL query:</p>
postgres</span>=</span># SELECT name, default_version, installed_version FROM pg_available_extensions WHERE installed_version IS NOT NULL;
</span>  name   | default_version | installed_version
</span>---------+-----------------+-------------------
</span> plpgsql | </span>1</span>.</span>0</span>             | </span>1</span>.</span>0
</span> postgis | </span>2</span>.</span>1</span>.</span>3</span>           | </span>2</span>.</span>1</span>.</span>3
</span>(</span>2</span> row)
</span></code></pre>


Timeout for a random amount of seconds in JavaScript
2021-04-30T00:00:00+00:00
Waiting is boring but with some randomness I might become a little more fun. In JavaScript you use the setTimeout</code> function to run some code in X amount of milliseconds.</p>
setTimeout</span>(() </span>=> </span>{
</span>  window.</span>alert</span>(</span>"Done waiting"</span>);
</span>}, </span>Math</span>.</span>floor</span>(</span>Math</span>.</span>random</span>() </span>* </span>10000</span>));
</span></code></pre>
With Math.random()</code> we get random floating point number between 0 and 1, including 0. On order to get from a floating point number between 0 and 1 to a proper amount of milliseconds we multiply by 10000</code>, which will give us a timeout in a range between 0 seconds and 10 seconds.</p>
When the timeout finished the callback function, passed as the first parameter to setTimeout</code>, is called.</p>


Create databases in PostgreSQL
2021-04-29T00:00:00+00:00
Creating a database in PostgreSQL is done via an SQL statement, and you need the CREATEDB</code> role to be able to do this. In its simplest form the SQL statement looks as follows:</p>
CREATE DATABASE </span>myproject</span>;
</span></code></pre>
Afterwards you may connect to the database</a> with the meta command: \c <database_name></code>.</p>
What creating a database in PostgreSQL actually does is making a copy from a template database. A template database is exactly what the name suggests it is, it serves as a template for a newly created database. PostgreSQL copies copies over the settings and data from the template to the database you create.</p>
PostgreSQL comes with two template databases: template0</code> and template1</code>, and uses template1</code> by default when you create a new database. The template0</code> is supposed to be a sort of safety net, if you mess something up while customizing template1</code> you can still recover it from template0</code>. Therefore it is advised to make all your customizations in template1</code> and never change template0</code>.</p>
When creating a database you can specify your preferred template database.</p>
CREATE DATABASE </span>myproject TEMPLATE </span>django_template</span>;
</span></code></pre>


Removing `li` elements from a list with JavaScript
2021-04-28T00:00:00+00:00
Without having to reach for jQuery, Vue, React or another fancy library you can easily remove the contents of a HTML list with just plain JavaScript. Lets assume that we have the following list in HTML.</p>
<</span>ul </span>id</span>=</span>"example"</span>>
</span>  <</span>li</span>>...</</span>li</span>>
</span>  <</span>li</span>>...</</span>li</span>>
</span></</span>ul</span>>
</span></code></pre>
There is a couple ways we can go about removing the li</code> elements, but we need to start with a selector to store our list in a variable. Since the list has the ID example</code> we can use that to find the list in the DOM.</p>
const </span>list </span>= </span>document.</span>getElementById</span>(</span>"example"</span>);
</span></code></pre>
Maybe the easiest way to empty the list is by setting its innerHTML. This will erase all the contents of the list.</p>
list.innerHTML </span>= </span>""</span>;
</span></code></pre>
This will leave you with an empty list, as follows:</p>
<</span>ul </span>id</span>=</span>"example"</span>></</span>ul</span>>
</span></code></pre>
While effective, this approach is somewhat rigorous too. As mentioned before, it will erase all the contents of the list. So if you had something else in your list, like a div</code> for example, it is removed as well.</p>
Of course there is a way to just remove the li</code> elements too. With a for</code> loop we can remove just remove the li</code> elements. We use a different selector here to get all the li</code>'s of the list instead of the list itself.</p>
var </span>listElements </span>= </span>document.</span>querySelectorAll</span>(</span>"#example li"</span>);
</span>
</span>for </span>(</span>var </span>i </span>= </span>0</span>; (li </span>= </span>listElements[i]); i</span>++</span>) {
</span>  li.parentNode.</span>removeChild</span>(li);
</span>}
</span></code></pre>


Reference Django settings from your code
2021-04-27T00:00:00+00:00
Accessing your application settings in Django can be useful for several reasons. You may want to check whether you are running in debug mode or you may want to access some keys specific to your current environment. To access your settings you import a settings</code> object from django.conf</code>, instead of importing the settings</code> module itself.</p>
Note that django.conf.settings</code> is an object and not a python module. Therefore you cannot import individual settings but you should access them via the settings object. This is shown in the example below.</p>
from </span>django.conf </span>import </span>settings
</span>
</span>credentials.update({
</span>  </span>'STRIPE_PUBLIC_KEY'</span>: settings.STRIPE_PUBLIC_KEY
</span>})
</span></code></pre>
In case you are defining your own settings, which you are free to do, make sure to define them using an all uppercase name.</p>
The settings object is only for reading settings, not for changing them. The only place where you should change your settings is in your Django settings module.</p>
from </span>django.conf </span>import </span>settings
</span>
</span># PLEASE DON'T
</span>settings.STRIPE_PUBLIC_KEY </span>= </span>''
</span></code></pre>


Convert negative number to positive in JavaScript
2021-04-26T00:00:00+00:00
Sometimes you may need to turn a negative number into a positive one. Of course there is the high(or elementary?) school mathematics approach: multiplying two negative numbers gives a positive.</p>
let </span>x </span>= -</span>5</span>;
</span>x </span>*= -</span>1</span>;
</span>console</span>.</span>log</span>(x); </span>// => 5
</span></code></pre>
But this only guarantees a positive number if you are sure that your variable is negative. Otherwise you will a negative and positive number which gives a negative obviously.</p>
In that case you may use the Math.abs()</code> function that comes with JavaScript to convert negative number to positive. The Math.abs()</code> function returns the absolute value of the number you pass it as a parameter.</p>
If you pass a negative number to Math.abs()</code> it returns the negation of that number. When you pass it a positive number it returns the number as is, and the same goes for when you pass the number zero.</p>
Math</span>.</span>abs</span>(</span>-</span>5</span>); </span>// => 5
</span>Math</span>.</span>abs</span>(</span>5</span>); </span>// => 5
</span>Math</span>.</span>abs</span>(</span>0</span>); </span>// => 0
</span></code></pre>
By using Math.abs()</code> you are ensured to have a positive number returned to you.</p>


Get the sum of all values in an array in JavaScript
2021-04-25T00:00:00+00:00
JavaScript unfortunately doesn't implement a method on Array's to sum up its values, not currently at least. This is in contrast to for example Python which has the sum()</code> function or the array_sum()</code> function in PHP. In the old school JavaScript days the way to go was by using a good old for-loop.</p>
Luckily we can sum up the values in an array rather quickly with the reduce()</code> method. The reduce()</code> method executes a callback function on all elements in the array except for the first element, unless you pass an initial value to reduce()</code> as a second argument. The first element in the array is used as the initial value(accumulator</code>) if you don't specify one yourself.</p>
If you need to sum up the values in an array you can use the following callback function in the reduce()</code> method.</p>
const </span>values </span>= </span>[</span>10</span>, </span>9</span>, </span>8</span>, </span>7</span>, </span>6</span>];
</span>const </span>sum </span>= </span>values.</span>reduce</span>((</span>accumulator</span>, </span>current</span>) </span>=> </span>accumulator </span>+ </span>current);
</span>console</span>.</span>log</span>(sum); </span>// => 40
</span></code></pre>
To understand the accumulator and current parameters better you may read along with the following example which logs both in each iteration.</p>
const </span>values </span>= </span>[</span>4</span>, </span>3</span>, </span>2</span>, </span>1</span>];
</span>console</span>.</span>log</span>(</span>"Before reduce"</span>);
</span>const </span>sum </span>= </span>values.</span>reduce</span>((</span>accumulator</span>, </span>current</span>) </span>=> </span>{
</span>  </span>const </span>result </span>= </span>accumulator </span>+ </span>current;
</span>  </span>console</span>.</span>log</span>(
</span>    </span>`accumulator: ${accumulator}, current: ${current}, result: ${result}`
</span>  );
</span>  </span>return </span>result;
</span>});
</span>console</span>.</span>log</span>(</span>"After reduce"</span>);
</span>
</span>// Before reduce
</span>// accumulator: 4, current: 3, result: 7
</span>// accumulator: 7, current: 2, result: 9
</span>// accumulator: 9, current: 1, result: 10
</span>// After reduce
</span>
</span>console</span>.</span>log</span>(sum); </span>// => 10
</span></code></pre>
As you see above the elements in the are iterated through from the second element, with the first element being the accumulator in the first iteration. And the result, or better the return value, of each iteration is used as accumulator for the next iteration and eventually as the return value of reduce()</code> itself.</p>
Reduce on empty arrays</h2>
You may encounter a situation where you cannot be certain that you call reduce on an array with elements. If you call .reduce()</code> on an empty array you will encounter the following TypeError</code>:</p>
[].</span>reduce</span>((</span>accumulator</span>, </span>current</span>) </span>=> </span>accumulator </span>+ </span>current);
</span>// Uncaught TypeError: Reduce of empty array with no initial value
</span></code></pre>
Possibly you can prevent this by checking the array length first. But a cleaner solution, in my opinion, is to provide a initial value to reduce()</code> as a second argument which is a valid accumulator too. So in the case of summing up values it is safe to use 0</code> as initial value, since it won't affect the value of the sum if the array does contain values.</p>
[].</span>reduce</span>((</span>accumulator</span>, </span>current</span>) </span>=> </span>accumulator </span>+ </span>current, </span>0</span>); </span>// 0
</span></code></pre>
Be aware with different types</h2>
Of course, be aware with the usual gotcha's when summing up values in JavaScript. Consider the following variation for example where the last element of the array is not an integer but a string. In this case JavaScript sums up 10, 9, 8 and 7 to a value of 34, when the string 6 is encountered will execute a string concatenation instead of summing up 6 as an integer. Resulting in the value of sum</code> being equal to the string 346</code>.</p>
const </span>values </span>= </span>[</span>10</span>, </span>9</span>, </span>8</span>, </span>7</span>, </span>"6"</span>];
</span>const </span>sum </span>= </span>values.</span>reduce</span>((</span>accumulator</span>, </span>current</span>) </span>=> </span>accumulator </span>+ </span>current);
</span>console</span>.</span>log</span>(sum); </span>// => 346
</span>console</span>.</span>log</span>(</span>typeof </span>sum);
</span></code></pre>


List all remotes in a git repository
2021-04-24T00:00:00+00:00
You may have multiple git remotes configured for you repository. Like me in my forked Django repository on GitHub, where I have set the original Django repository as a second remote. You can easily list git remotes on the command line with the git remote</code> command. This command just shows the local names of the remote repositories. As you can see in the following example:</p>
$ git remote
</span>origin
</span>upstream
</span></code></pre>
You can get more information out of the command. By adding -v</code> you get information about the remote urls as well, -v</code> being short for --verbose</code>. The following lists git remotes with urls:</p>
$ git remote -v
</span>origin  git@github.com:koenwoortman/django.git (fetch)
</span>origin  git@github.com:koenwoortman/django.git (push)
</span>upstream        git@github.com:django/django.git (fetch)
</span>upstream        git@github.com:django/django.git (push)
</span></code></pre>


Django: generic detail view must be called with either an object pk or a slug in the URLconf
2021-04-23T00:00:00+00:00
There is great magic involved in Django its class-based views, the good kind of magic. The kind of magic that saves me lots of time and lines of code. However, using them requires you to follow some conventions.</p>
Such a conventions in Django is using properly named url variables when using detail views. View classes like DetailView</code>, DeleteView</code>, UpdateView</code> rely on the presence of either a url variable with the name pk</code> or slug</code>. These classes inherit a method called get_object</code> from the SingleObjectMixin</code> class. This get_object</code> method is used to find the right model instance to be displayed in the view.</p>
So lets consider the following example: a detail view for a blog post model.</p>
# blog/views.py
</span>from </span>django.views </span>import </span>generic
</span>from </span>blog.models </span>import </span>Post
</span>
</span>
</span>class </span>DetailView</span>(</span>generic.DetailView</span>):
</span>    model </span>= </span>Post
</span>    template_name </span>= </span>'blog/detail.html'
</span></code></pre>
In order to comply with the requirements from the get_object</code> method we should add a url containing a variable named either pk</code> or slug</code>. Otherwise we would get an AttributeError</code> from Django with the message: Generic detail view DetailView must be called with either an object pk or a slug in the URLconf</code>.</p>
When using the path()</code> function you should keep the following format in mind when adding url variables: <variable type:variable name></code>.</p>
If you prefer to use the primary key for you DetailView you should add it in the urlpatterns</code> like:</p>
# urls.py
</span>from </span>django.urls </span>import </span>path
</span>from </span>blog </span>import </span>views
</span>
</span>urlpatterns </span>= </span>[
</span>    path(</span>'<int:pk>/'</span>, views.DetailView.as_view()),
</span>]
</span></code></pre>
If you prefer to use a slug for your DetailView you should first make sure your model implements a SlugField. Then add the slug as <slug:slug></code>, bit confusing maybe but both the variable type and name are supposed to be named slug</code>:</p>
# urls.py
</span>from </span>django.urls </span>import </span>path
</span>from </span>blog </span>import </span>views
</span>
</span>urlpatterns </span>= </span>[
</span>    path(</span>'<slug:slug>/'</span>, views.DetailView.as_view()),
</span>]
</span></code></pre>


List active SSH sessions via the command-line in Linux
2021-04-22T00:00:00+00:00
Your best bet to show the active SSH sessions on a system is probably to combine the netstat</code> command with grep</code>. The netstat</code> command is used to show statistics on network connections, not just limited to SSH. The netstat</code> command does require root privileges.</p>
By piping the output of netstat</code> to grep</code> you can filter connections properly to just list active SSH sessions. The command looks as follows:</p>
$ sudo netstat -tnpa | grep 'ESTABLISHED.*sshd'
</span></code></pre>
More generally, you can use the commands users</code>, who</code> and w</code> to list the currently logged in users on the system. Each displaying a different level of details.</p>
The users</code> commands just displays a list of usernames separated by spaces.</p>
$ users
</span>koen
</span></code></pre>
The who</code> command</p>
$ who
</span>koen     pts/0        Apr 18 16:28 (80.113.224.189)
</span></code></pre>
The w</code> command</p>
$ w
</span>16:28:47 up 21 days,  5:05,  1 user,  load average: 0.30, 0.13, 0.07
</span>USER     TTY      FROM             LOGIN@   IDLE   JCPU   PCPU WHAT
</span>koen     pts/0    80.113.224.189   16:28    7.00s  0.19s  0.01s w
</span></code></pre>


Stop tracking a remote git branch
2021-04-21T00:00:00+00:00
Setting an upstream branch can be useful, it tracks if you are commits behind or ahead and you can run git push</code> without the need to specify a remote and branch. However, there might be a place and time where you rather undo this branch tracking. The branch</code> subcommand in git has an option to unset the upstream branch, which you use to stop tracking the remote branch. The command is used as follows:</p>
$ git branch --unset-upstream [<branchname>]
</span></code></pre>
In practice that would look like the following:</p>
$ git branch --unset-upstream main
</span></code></pre>
Keep in mind that you specify the local branch and not the remote branch, so in this case main</code> instead of origin/main</code>. Which makes sense because we are detaching the local branch from its remote, not the remote branch from our local branch. The remote repository is completely unaware of the fact that you are locally tracking some of its branches.</p>
You can run the command without specifying a branch name as well. In that case git assumes that you want to stop tracking a remote for your currently active branch.</p>
$ git branch --unset-upstream
</span></code></pre>


Set the upstream branch for an existing branch in git
2021-04-20T00:00:00+00:00
Probably the most convenient way to set an upstream branch is to do so when you push the branch. You do so by adding the -u</code> option to the push</code> command, with -u</code> being the short option for --set-upstream</code>.</p>
$ git push -u <remote> <branch>
</span></code></pre>
For an existing branch you might want to set the upstream branch without having to push at the same time. You can set the upstream branch as well using the command:</p>
$ git branch (--set-upstream-to=<upstream> | -u <upstream>) [<branchname>]
</span></code></pre>
In practice that would look like the following:</p>
$ git branch -u origin/dev
</span></code></pre>


Delete multiple git branches at once
2021-04-19T00:00:00+00:00
Cleaning up your local branches is one of my, somewhat boring, recurring tasks. Especially for projects with multiple developers(and running git fetch</code> often) my list of local branches gets quite large.</p>
To remove a git branch you use the git branch -D <branch_names></code> command. You can pass multiple branch names to this command, separated by a space. Unfortunately git branch -D</code> doesn't allow globbing patterns, unlike the rm</code> command for example.</p>
The tab completion in Zsh already goes a long way in making deleting multiple branches faster. But we can do better. With git branch --format "%(refname:short)" | grep "<pattern>" | xargs git branch -D</code> we can use the grep</code> command to specify a pattern for the branch names.</p>
Look at the following for example, which removes git branches with names starting with fix/</code>.</p>
$ git branch --format "%(refname:short)" | grep "^fix/*" | xargs git branch -D
</span></code></pre>
If you rather have some security first you can run the following command first, which displays the list of branches without deleting them.</p>
$ git branch --format "%(refname:short)" | grep "^fix/*"
</span></code></pre>
Removing local branch with prune</h2>
Another option would be to use prune</code>. With prune</code> you prune away the branches that don't exist on the remote anymore. So the local branches that are not present on the remote repository anymore will be deleted.</p>
$ git remote prune origin
</span></code></pre>


List packages that can be upgraded in Ubuntu
2021-04-18T00:00:00+00:00
Whether it is your local machine or a production server, it is good practice to keep the packages on your system up-to-date. To just see which packages can be updated you can use the commands apt upgrade --dry-run</code> and apt list --upgradable</code>. The former shows which packages should have been upgraded once you run apt upgrade</code>. The latter lists all the packages that can be upgraded.</p>
You can do a dry-run as follows:</p>
$ apt upgrade --dry-run
</span>Reading package lists... Done
</span>Building dependency tree
</span>Reading state information... Done
</span>Calculating upgrade... Done
</span>The following packages have been kept back:
</span>  mysql-client mysql-server
</span>The following packages will be upgraded:
</span>  google-chrome-stable libjs-underscore libpci3 pciutils
</span>4 upgraded, 0 newly installed, 0 to remove and 2 not upgraded.
</span>Inst google-chrome-stable [89.0.4389.114-1] (89.0.4389.128-1 Google:1.0/stable [amd64])
</span>Inst pciutils [1:3.6.4-1] (1:3.6.4-1ubuntu0.20.04.1 Ubuntu:20.04/focal-updates [amd64]) []
</span>Inst libpci3 [1:3.6.4-1] (1:3.6.4-1ubuntu0.20.04.1 Ubuntu:20.04/focal-updates [amd64])
</span>Inst libjs-underscore [1.9.1~dfsg-1] (1.9.1~dfsg-1ubuntu0.20.04.1 Ubuntu:20.04/focal-security [all])
</span>Conf google-chrome-stable (89.0.4389.128-1 Google:1.0/stable [amd64])
</span>Conf pciutils (1:3.6.4-1ubuntu0.20.04.1 Ubuntu:20.04/focal-updates [amd64])
</span>Conf libpci3 (1:3.6.4-1ubuntu0.20.04.1 Ubuntu:20.04/focal-updates [amd64])
</span>Conf libjs-underscore (1.9.1~dfsg-1ubuntu0.20.04.1 Ubuntu:20.04/focal-security [all])
</span></code></pre>
And list the upgradable packages like:</p>
$ apt list --upgradable
</span>Listing... Done
</span>google-chrome-stable/stable 89.0.4389.128-1 amd64 [upgradable from: 89.0.4389.114-1]
</span>libjs-underscore/focal-security,focal-security 1.9.1~dfsg-1ubuntu0.20.04.1 all [upgradable from: 1.9.1~dfsg-1]
</span>libpci3/focal-updates 1:3.6.4-1ubuntu0.20.04.1 amd64 [upgradable from: 1:3.6.4-1]
</span>mysql-client/focal-updates,focal-updates,focal-security,focal-security 8.0.23-0ubuntu0.20.04.1 amd64 [upgradable from: 5.7.30-1ubuntu18.04]
</span>mysql-server/focal-updates,focal-updates,focal-security,focal-security 8.0.23-0ubuntu0.20.04.1 amd64 [upgradable from: 5.7.30-1ubuntu18.04]
</span>pciutils/focal-updates 1:3.6.4-1ubuntu0.20.04.1 amd64 [upgradable from: 1:3.6.4-1]
</span></code></pre>
If you are looking for a specific package you can pipe the output to the grep</code> command.</p>
apt list --upgradable | grep "mysql"
</span>
</span>WARNING: apt does not have a stable CLI interface. Use with caution in scripts.
</span>
</span>mysql-client/focal-updates,focal-updates,focal-security,focal-security 8.0.23-0ubuntu0.20.04.1 amd64 [upgradable from: 5.7.30-1ubuntu18.04]
</span>mysql-server/focal-updates,focal-updates,focal-security,focal-security 8.0.23-0ubuntu0.20.04.1 amd64 [upgradable from: 5.7.30-1ubuntu18.04]
</span></code></pre>
No need to pay too much attention to the warning in this case :-).</p>


Use one directory for HTML templates in Django
2021-04-17T00:00:00+00:00
From which directory Django loads HTML templates is configured with the TEMPLATES</code> variable in settings.py</code>. When you create a fresh Django application TEMPLATES</code> is configured to look for a templates</code> folder in the apps you create to load HTML templates from.</p>
Where Django apps are supposed to be pretty self-containing, my experience is that I have quite some overlap in HTML components on the template side between apps. Think of some shared layouts or generic partials for lists for example.</p>
Therefore I prefer a templates</code> directory outside my apps for some projects. You can configure this by settings 'DIRS'</code> in the TEMPLATES</code> setting. The following example shows how to configure Django so that it will look for templates in a templates</code> directory in the project root.</p>
The example sets 'APP_DIRS'</code> to False</code> so Django won't look for templates in apps. You can keep this set to True</code> as well if you prefer.</p>
# settings.py
</span>
</span>TEMPLATES </span>= </span>[
</span>    {
</span>        </span>'BACKEND'</span>: </span>'django.template.backends.django.DjangoTemplates'</span>,
</span>        </span>'DIRS'</span>: [
</span>            os.path.join(BASE_DIR, </span>'templates'</span>)
</span>        ],
</span>        </span>'APP_DIRS'</span>: </span>False</span>,
</span>        </span>'OPTIONS'</span>: {
</span>            </span>'context_processors'</span>: [
</span>                </span>'django.template.context_processors.debug'</span>,
</span>                </span>'django.template.context_processors.request'</span>,
</span>                </span>'django.contrib.auth.context_processors.auth'</span>,
</span>                </span>'django.contrib.messages.context_processors.messages'</span>,
</span>            ],
</span>        },
</span>    },
</span>]
</span></code></pre>


Installing Python packages from a GitHub repo with Pipenv
2021-04-16T00:00:00+00:00
Besides installing packages from PyPI you can directly install packages from, for example, GitHub. This feature is not exclusive to Pipenv, pip can do the same just as well.</p>
For side-projects I use (mostly) just by myself I feel pretty save running on the development branch of the Django web framework. To install Django its development branch, called main</code> for Django, you need the location of the git repository.</p>

Besides Git Pipenv should work with the version control systems Bazaar, Subversion and Mercurial as well.</em></p>
</blockquote>
The location of the Django git repository is https://github.com/django/django.git</code> for HTTP and git@github.com:django/django.git</code> for SSH. The pipenv install</code> command expects the following format: <vcs_type>+<scheme>://<repository>@<branch_or_tag>#egg=<package_name</code>. Pipenv recommends you to add the -e</code> option to the install command to install as an editable dependency.</p>
Following the above format the Django install command will look like:</p>
$ pipenv install -e git+https://github.com/django/django.git@main#egg=Django
</span></code></pre>
Installing Django using SSH looks like:</p>
$ pipenv install -e git+ssh://git@github.com/django/django.git@main#egg=Django
</span></code></pre>
If you don't specify the egg</code> the installation fails with the warning: "pipenv requires an #egg fragment for version controlled dependencies."</p>
For more information on this topic you can read the docs</a> :-).</p>


Uninstalling packages on Ubuntu with `apt`
2021-04-15T00:00:00+00:00
Everyone in a while it doesn't hurt to remove some of the clutter on your Linux system. With the command apt remove <package, ...></code> you can remove packages from your system. Besides remove</code> you have the apt purge <package, ...></code> command available to you as well, which removes configuration settings for that package as well.</p>
Removing a package from the command line with apt</code> goes as follows:</p>
$ sudo apt remove pipenv
</span>Reading package lists... Done
</span>Building dependency tree
</span>Reading state information... Done
</span>The following packages were automatically installed and are no longer required:
</span>  ipset libipset13 python3-appdirs python3-distlib python3-filelock python3-importlib-metadata python3-more-itertools python3-virtualenv python3-virtualenv-clone python3-zipp xsltproc
</span>Use 'sudo apt autoremove' to remove them.
</span>The following packages will be REMOVED:
</span>  pipenv
</span>0 upgraded, 0 newly installed, 1 to remove and 24 not upgraded.
</span>After this operation, 12,8 MB disk space will be freed.
</span>Do you want to continue? [Y/n]
</span>(Reading database ... 267202 files and directories currently installed.)
</span>Removing pipenv (11.9.0-1) ...
</span>Processing triggers for man-db (2.9.1-1) ...
</span></code></pre>
One interesting line you may see in the commands output is "The following packages were automatically installed and are no longer required". The packages that are listed below are packages which were installed as a dependency of the package we removed which are no longer necessary now. They are orphaned so to say.</p>
To remove these former dependencies you run the command that is suggested in the output as well:</p>
$ sudo apt autoremove
</span></code></pre>


Solving `command not found: pipenv`
2021-04-14T00:00:00+00:00
It may that you installed pipenv</code> and when you try to run it you see a message saying something like: command not found: pipenv</code>.</p>
Most likely you installed pipenv with pip(pip install pipenv</code>) without having the directory where pip</code> installs local dependencies in your PATH. PATH is a shell variable that defines the folders where your shell environment looks for commands. In Linux pip probably installs the pipenv</code> command in ~/.local/bin</code>.</p>
One way around this that would probably work is to run pip install pipenv</code> with sudo</code>. However, if you do so for all packages you run arbitrary python code with superuser rights. With pipenv</code> I am kinda assuming this is safeish. But you are better off solving this issue for good by adding ~/.local/bin</code> to your PATH.</p>
The file where you need to update your PATH depends on whether you use Bash, ZSH or anything else as a shell.</p>
For bash open the file ~/.bashrc</code> and add the following:</p>
export </span>PATH</span>=</span>"$HOME/.local/bin:$PATH"
</span></code></pre>
For Zsh open the file ~/.zshrc</code> and add the following:</p>
path</span>+=</span>(</span>"$HOME/.local/bin"</span>)
</span>export </span>PATH
</span></code></pre>


List tables in Postgres database
2021-04-13T00:00:00+00:00
To list the tables in a Postgres database you use the \dt</code> meta-command, short for "display tables"? First things first, in order to get a list of tables in your database you first login to the Postgres shell and connect to the database you're interested in. You login to the Postgres shell with the psql</code> command. Afterwards, you can connect to a database</a> with \c</code>.</p>
$ psql
</span>psql (12.6 (Ubuntu 12.6-0ubuntu0.20.04.1))
</span>Type "help" for help.
</span>
</span>postgres=# \c myproject
</span>You are now connected to database "myproject" as user "postgres".
</span>myproject=#
</span></code></pre>
Now that we are connected to the right database we can show the tables with the \dt</code> command:</p>
myproject=# \dt
</span>         List of relations
</span> Schema |  Name  | Type  |  Owner
</span>--------+--------+-------+----------
</span> public | users  | table | postgres
</span> public | pizzas | table | postgres
</span>(2 rows)
</span>
</span>myproject=#
</span></code></pre>
When you run this meta-command you might see a message saying "Did not find any relations". You get this message when you have a database for which there aren't any tables yet.</p>
myproject=# \dt
</span>Did not find any relations.
</span></code></pre>


Switch databases in PostgreSQL with `\connect`
2021-04-12T00:00:00+00:00
With good ol' MySQL I was used to switch database with use <db_name>;</code>. Postgres has a different way to switch databases, you do so using one of its meta-commands. Once you are in the Postgres terminal, you enter using the psql</code> command, you can switch databases with \connect <db_name></code> command or with the shorter \c <db_name></code>.</p>
postgres=# \c myproject
</span>You are now connected to database "myproject" as user "postgres".
</span>myproject=#
</span></code></pre>
postgres=# \connect myproject
</span>You are now connected to database "myproject" as user "postgres".
</span>myproject=#
</span></code></pre>
In order to list the available databases</a> you use the \l</code> or \list</code> meta-command.</p>


List databases in PostgreSQL
2021-04-11T00:00:00+00:00
To list the databases in Postgres we are going to use the interactive terminal. To do so you might need to switch to the Postgres user with sudo su postgres</code>. You can enter the Postgres terminal with the psql</code> command.</p>
$ psql
</span>psql (12.6 (Ubuntu 12.6-0ubuntu0.20.04.1))
</span>Type "help" for help.
</span>
</span>postgres=#
</span></code></pre>
Now that we are in the shell we can use one of Postgres meta-commands to list the databases. The one we need in this case is \l</code>, which is short for \list</code>.</p>
postgres=# \l
</span>                                       List of databases
</span>     Name     |  Owner   | Encoding |   Collate   |    Ctype    |       Access privileges
</span>--------------+----------+----------+-------------+-------------+-------------------------------
</span> myproject    | postgres | UTF8     | en_US.UTF-8 | en_US.UTF-8 |
</span> postgres     | postgres | UTF8     | en_US.UTF-8 | en_US.UTF-8 |
</span> template0    | postgres | UTF8     | en_US.UTF-8 | en_US.UTF-8 | =c/postgres                  +
</span>              |          |          |             |             | postgres=CTc/postgres
</span> template1    | postgres | UTF8     | en_US.UTF-8 | en_US.UTF-8 | =c/postgres                  +
</span>              |          |          |             |             | postgres=CTc/postgres
</span>(4 rows)
</span>
</span></code></pre>


List users in PostgreSQL
2021-04-10T00:00:00+00:00
Listing all the users of a PostgreSQL database is easiest via the interactive terminal. You can start the interactive PostgreSQL terminal with the psql</code> on the command line. If this throws an error with the message psql: error: FATAL: role "..." does not exist</code> you probably haven't yet created a database role for the operating system user you are logged in as. You might want to fix that too. In the mean time you can probably switch to the postgres user with a command like sudo su postgres</code>.</p>
Once you get in the Postgres shell you can use the \du</code> meta-command to show the existing PostgreSQL users. With du</code> being short for "display users" I imagine.</p>
postgres=# \du
</span>                                       List of roles
</span>    Role name |                         Attributes                         | Member of
</span>--------------+------------------------------------------------------------+-----------
</span> postgres     | Superuser, Create role, Create DB, Replication, Bypass RLS | {}
</span> sitetemplate |                                                            | {}
</span>
</span>postgres=#
</span></code></pre>
If you're just interested in information about a single user you can filter this list on the username.</p>
postgres=# \du postgres
</span>                                   List of roles
</span> Role name |                         Attributes                         | Member of
</span>-----------+------------------------------------------------------------+-----------
</span> postgres  | Superuser, Create role, Create DB, Replication, Bypass RLS | {}
</span>
</span>postgres=#
</span></code></pre>
Listing Postgres users with SQL</h2>
If you rather take the SQL route over the meta-command there is an option too. If you have rights to query from pg_catalog</code> at least, which shouldn't be a problem if you use the default postgres</code> user.</p>
postgres</span>=</span># SELECT usename FROM pg_catalog.pg_user;
</span>     usename
</span>------------------
</span> postgres
</span> sitetemplate
</span>(</span>2</span> rows)
</span>
</span>postgres</span>=</span>#
</span></code></pre>


The Python walrus operator
2021-04-09T00:00:00+00:00
Since the release</a> of Python 3.8 we can assign values to variables within an expression using the walrus operator(:=</code>), also more formally known as the assignment expressions.</p>
An advantage of being able to assign a variable in an if-statement that you only use within the scope of that if statement. This often allows you to write shorter code. For example you could write:</p>
if </span>(exit_code </span>:= </span>command.run()) </span>> </span>0</span>:
</span>    </span>print</span>(</span>f</span>'exited with non-zero status (</span>{exit_code}</span>)'</span>)
</span></code></pre>
Instead of this:</p>
exit_code </span>= </span>command.run()
</span>if </span>exit_code </span>> </span>0</span>:
</span>    </span>print</span>(</span>f</span>'exited with non-zero status (</span>{exit_code}</span>)'</span>)
</span></code></pre>
The same logic can be useful in while structures too. The following for example is a while loop that requires user input, and quits the while loop when "exit" is entered.</p>
while </span>(line </span>:= </span>input</span>()) </span>!= </span>'exit'</span>:
</span>    f.write(line)
</span></code></pre>


Relative line numbers in Visual Studio Code
2021-04-08T00:00:00+00:00
The Vim extension in Visual Studio Code is one of the extension I use most pleasurably. Especially in with the Neovim Integration enabled. However, in (neo)vim I prefer to use relative line numbers</a>. It makes jumping and using commands that span multiple lines much easier.</p>
Luckily, using relative line numbers in Visual Studio Code doesn't require you to install another extension. It is supported in VS Code itself.</p>
Open up the settings with Ctrl+,</code> or via Preferences > Settings</code>. In here look for the setting called "Editor: Line Numbers" and set it to "relative" for relative line numbers.</p>
</p>
If your prefer to change the settings in the settings.json</code> you can do so by adding the following line.</p>
{
</span>  </span>...</span>
</span>  </span>"editor.lineNumbers"</span>: </span>"relative"</span>,
</span>  </span>...</span>
</span>}
</span></code></pre>
That is all :).</p>


Solving Django warning `Auto-created primary key used when not defining a primary key type`
2021-04-07T00:00:00+00:00
While playing around with the newly released Django 3.2 I noticed a warning I didn't see before in a website I migrated from Django 3.1 (Warning models.W042</code>).</p>
System check identified some issues:
</span>
</span>WARNINGS:
</span>users.User: (models.W042) Auto-created primary key used when not defining a primary key type, by default 'django.db.models.AutoField'.
</span>HINT: Configure the DEFAULT_AUTO_FIELD setting or the UsersConfig.default_auto_field attribute to point to a subclass of AutoField, e.g. 'django.db.models.BigAutoField'.
</span></code></pre>
The warning is introduced with a new feature</a> in Django 3.2 which allows to change the default field of primary which are automatically added by Django if you don't explicitly define one.</p>
You can explicitly define a primary key by adding primary_key=True</code> to a model field. If you don't, Django adds a primary key itself called id</code>. Before Django 3.2, the primary key field that Django would add was of type 'django.db.models.AutoField'</code>. Since Django 3.2 the default has been changed to 'django.db.models.BigAutoField'</code>.</p>
The BigAutoField</code> probably represents a 64-bit positive integer in your database. Where the AutoField</code> most likely a 32-bit positive integer. This change in Django implies that you will be able to store a whole lot more rows in the database table of the model.</p>
Solution</h2>
In order to get rid of the warning you need to set the DEFAULT_AUTO_FIELD</code> in the settings to the field you prefer for primary keys. If you rather keep the Django 3.1 default you should set the auto-field value to 'django.db.models.AutoField'</code>. This can also prevent some unwanted migrations in the future. You can either set the value in your settings:</p>
DEFAULT_AUTO_FIELD </span>= </span>'django.db.models.AutoField'
</span></code></pre>
Or set it per app in the apps.py</code> file:</p>
from </span>django.apps </span>import </span>AppConfig
</span>
</span>
</span>class </span>UsersConfig</span>(</span>AppConfig</span>):
</span>    default_auto_field </span>= </span>'django.db.models.AutoField'
</span>    name </span>= </span>'users'
</span></code></pre>
You can of course also explicitly set the primary on the model itself.</p>


`Class has no 'objects' member` error with Pylint
2021-04-06T00:00:00+00:00
When you're using Pylint with Django you may encounter warnings like Class ‘Question’ has no ‘objects’ member pylint(no-member)</code>. Pylint helps you to find possible problems with your code, in this case it doesn't mean there is an error per se.</p>
In order to use Pylint effectively with Django make sure that you have the Django plugin for Pylint installed. Since that is just a Python package you can install it with pip</code>.</p>
$ pip install pylint-django
</span></code></pre>
If you're using a Pylint extension in your editor you might need to add some config settings.</p>
With Visual Studio Code you can add the following snippet to your editor settings.json. To open these settings with the shortcut ctrl-shift-p</code> (or cmd-shift-p</code> on Mac) for the Command Palette and run the command: Preferences: Open Settings (JSON)</strong>.</p>
</p>
This opens up the settings JSON file. Here you should either look for the python.linting.pylintArgs</code> or add it yourself and make sure that --load-plugins=pylint_django</code> is passed as an argument.</p>
{
</span>  </span>...</span>
</span>  </span>"python.linting.pylintArgs"</span>: [
</span>    </span>"--load-plugins=pylint_django"
</span>  ],
</span>  </span>...</span>
</span>}
</span></code></pre>
Another possible issue with Visual Studio Code can be Python interpreter that is used. This should be same Python for which you installed pylint-django</code>. This is especially something you want to pay attention to if you're using a virtual environment. If so, make sure that you select the Python interpreter in your virtual environment. You can do this by running the Python: Select Interpreter</strong> command that can be found in the VS Code Command Palette as well.</p>


Running sudo commands without a password
2021-04-05T00:00:00+00:00
The fact that a password is required to run a command with sudo is a useful safety mechanism, which I definitely value on production environments. On my local development machine however, I manage well without the password. You can do so by adding a line like %koen ALL=(ALL:ALL) NOPASSWD: ALL</code> to the sudoers config file, where you swap out my username of course.</p>

First a word on sudo</code> itself, sudo</code> stands for "superuser do" and it is a program that allows you, if you have the permissions, to run commands as a different user. Most often it is used to run commands as the root user.</p>
</blockquote>
sudo</code> is just another program that comes installed on your UNIX machine that is configured in the config file located at /etc/sudoers</code>.</p>

Do not</u> edit this file with normal text editor because it can break the sudo command.</strong></p>
</blockquote>
You should use the special visudo</code> command/editor to edit the /etc/sudoers</code> config file since it validates whether you have no syntax errors.</p>
$ sudo visudo
</span></code></pre>
This opens up the /etc/sudoers</code> with your preferred editor, and I guess it defaults to vi(m) since the command is visudo</code> :). If you rather use a different editor to edit the sudoers file you can do so by setting the EDITOR</code> environment variable. For example, the following opens the sudoers file with nano</code>.</p>
$ sudo EDITOR=nano visudo
</span></code></pre>
Whether you use vim, nano or something else. The command opens a config file looking somewhat like the following.</p>
# User privilege specification
</span>root    ALL=(ALL:ALL) ALL
</span>
</span># Members of the admin group may gain root privileges
</span>%admin ALL=(ALL) ALL
</span>
</span># Allow members of group sudo to execute any command
</span>%sudo   ALL=(ALL:ALL) ALL
</span></code></pre>
In order to be able to run sudo</code> without a password you need to add the line %koen ALL=(ALL:ALL) NOPASSWD: ALL</code> to this sudoers file. Where you swap koen</code> for your own username of course. You can get your username by using the command id -un</code>.</p>
So adding that line for your current user leaves the config file something like the following.</p>
# User privilege specification
</span>root    ALL=(ALL:ALL) ALL
</span>
</span># Members of the admin group may gain root privileges
</span>%admin ALL=(ALL) ALL
</span>
</span># Allow members of group sudo to execute any command
</span>%sudo   ALL=(ALL:ALL) ALL
</span>%koen   ALL=(ALL:ALL) NOPASSWD: ALL
</span></code></pre>


Count the amount of child nodes of an HTML element with JavaScript
2021-04-04T00:00:00+00:00
It is quite simple to count the amount of direct child nodes of an HTML element with regular JavaScript without jQuery or any other fancy stuff.</p>
You can call the .childElementCount</a> property on the element to get the amount of child nodes. Take the following snippets for example.</p>
<</span>ul </span>id</span>=</span>"example"</span>>
</span>  <</span>li</span>>...</</span>li</span>>
</span>  <</span>li</span>>...</</span>li</span>>
</span></</span>ul</span>>
</span></code></pre>
document.</span>getElementById</span>(</span>"example"</span>).childElementCount;
</span>// => 2
</span></code></pre>
document.getElementById('example')</code> returns a parent node, on which we call the childElementCount</code> returning the amount of child nodes.</p>


Resolving `ModuleNotFoundError: No module named 'numpy'`
2021-04-03T00:00:00+00:00
When you encounter the error ModuleNotFoundError: No module named 'numpy'</code> you most likely have not, or not correctly, installed numpy.</p>
If you haven't installed it yet you can do so by running:</p>
$ python3</span> -m</span> pip install numpy
</span></code></pre>
Assuming that python</code> still refers to a version of python 2 on your machine. Otherwise there is no need to run the install with python3</code>.</p>
The problem lies somewhere else if the above install command displays a line like:</p>
Requirement already satisfied: numpy in /home/koen/.local/lib/python3.8/site-packages (1.20.2)
</span></code></pre>
In that case numpy</code> is actually installed but python just cannot seem to find it. Possible causes can be:</p>

that you run your python code with a different python version for which you installed numpy.</li>
that not yet activated your python virtual environment yet.</li>
not yet select the right python interpreter in your code editor</li>
</ul>


Start the Windows Terminal in the WSL home directory
2021-04-02T00:00:00+00:00
I have bought myself a cheap Windows laptop lately. Mostly because it comes in handy to have an installation of Microsoft Word. But the Windows Subsystem for Linux (WSL) caught my interest too. Without too much of a hassle you can get yourself a Linux distro to run in Linux. Next, the very first thing you should do is get the Windows Terminal</a> from the Microsoft Store. It just works some much nicer than cmd.</p>
One thing that really annoys me when opening up my WSL in the Windows Terminal is the fact that it does not open in the home directory of the Linux installation. This flaw can luckily be fixed in the settings.json</code> file of the Windows Terminal. You should be able to open this settings file by using the <CTRL>+,</code> shortcut in the Windows Terminal.</p>
By adding "commandline" : "wsl.exe ~"</code> to the WSL profile you can get your WSL to open in the home directory. This makes the settings file looks something like:</p>
{
</span>    </span>"$schema"</span>: </span>"https://aka.ms/terminal-profiles-schema"</span>,
</span>
</span>    </span>"defaultProfile"</span>: </span>"{07b52e3e-de2c-5db4-bd2d-ba144ed6c273}"</span>,
</span>
</span>    </span>"profiles"</span>:
</span>    {
</span>        </span>"defaults"</span>:
</span>        {
</span>            </span>// Put settings here that you want to apply to all profiles.
</span>        },
</span>        </span>"list"</span>:
</span>        [
</span>            {
</span>                </span>"guid"</span>: </span>"{07b52e3e-de2c-5db4-bd2d-ba144ed6c273}"</span>,
</span>                </span>"hidden"</span>: </span>false</span>,
</span>                </span>"name"</span>: </span>"Ubuntu-20.04"</span>,
</span>                </span>"source"</span>: </span>"Windows.Terminal.Wsl"</span>,
</span>                </span>"colorScheme"</span>: </span>"Tango Light"</span>,
</span>                </span>"commandline" </span>: </span>"wsl.exe ~"
</span>            },
</span>            </span>...</span>
</span>        ]
</span>    },
</span>    </span>...</span>
</span>}
</span></code></pre>


Clear the contents of a file from the command line
2021-04-01T00:00:00+00:00
From the command-line you can empty a file without opening an editor and removing all the lines. This can be useful when you have a bulky log file you don't need to keep for example.</p>
With the truncate</code> command you can shrink the file to a specified size. If you specify a size of 0</code> you effectively end up with an empty file. This even works when the file is currently being written to.</p>
$ truncate -s 0 huge.log
</span></code></pre>
A second option is to use the output redirection operator(></code>). You use the output redirection operator to write standard output to a file, and overwrite the file if it already exists.</p>
$ > huge.log
</span></code></pre>


Split the zshrc file into multiple files
2021-03-31T00:00:00+00:00
When you get a long way with configuring ZSH your ~/.zshrc</code> can get a bit bulky, filled with aliases and more.</p>
At some point you might prefer to split up your .zshrc</code> file into multiple files. You can easily do so by creating a config directory with files that you source from your .zshrc</code>.</p>
I chose the location "$HOME/.config/zsh/config.d/"</code> to store separated config files, here I have the following files for example: aliases.zsh</code>, history.zsh</code>, fzf.zsh</code>.</p>
From my .zshrc</code> I loop over all the files in "$HOME/.config/zsh/config.d/</code> with a .zsh</code> file extension and source them.</p>
# ~/.zshrc
</span>
</span># Load seperated config files
</span>for</span> conf </span>in </span>"$HOME/.config/zsh/config.d/"</span>*</span>.zsh</span>; do
</span>  </span>source </span>"${conf}"
</span>done
</span>unset</span> conf
</span></code></pre>


Command history in ZSH
2021-03-30T00:00:00+00:00
If you're a user of oh-my-zsh most of the history are taken care of already. However, when you're setting up ZSH from scratch yourself you need to configure some settings before the command history is up and running.</p>
First, the file where the history will be stored. Unlike Bash, Zsh doesn't provide a default location for where to store command history. So you need to set it yourself in your ~/.zshrc</code> config file. I went for the file name .zsh_history</code> but feel free to set this to whatever you prefer, it also doesn't need be located in your home director.</p>
# ~/.zshrc
</span>
</span># The file where the history is stored
</span>export </span>HISTFILE</span>=</span>"$HOME/.zsh_history"
</span></code></pre>
Second is related to the length of the history file; how much command you will keep in history. There are two environment variables that relate to this. First is the HISTSIZE</code> variable, which defines how many commands are loaded into memory from the history file. Second is the SAVEHIST</code> variable, which defines how many commands are stored in the history file.</p>
# ~/.zshrc
</span>
</span># Number of events loaded into memory
</span>export </span>HISTSIZE</span>=</span>10000
</span>
</span># Number of events stored in the zsh history file
</span>export </span>SAVEHIST</span>=</span>10000
</span></code></pre>
That covers at least the basics. Next are a couple options I personally prefer as well.</p>
# ~/.zshrc
</span>
</span># Do not save duplicate commands to history
</span>setopt HIST_IGNORE_ALL_DUPS
</span>
</span># Do not find duplicate command when searching
</span>setopt HIST_FIND_NO_DUPS
</span></code></pre>
Clear history</h2>
Since the ZSH history is just kept in a file, clearing the history is just clearing the file. You can easily clear the contents of a file with a single command:</p>
$ truncate</span> -s</span> 0 </span>"${HISTFILE}"
</span></code></pre>
Show all historic commands</h2>
To show the entire ZSH history you can open the history file with your preferred pager:</p>
$ less </span>"${HISTFILE}"
</span></code></pre>


Quick cd'ing in ZSH by setting a `cdpath`
2021-03-29T00:00:00+00:00
There are directories I am cd</code>'ing to more often than others. When my early Linux days when I was using the Bash shell I often used cd</code> commands like: cd ../../../Code/blog</code>. For me, ~/Code</code> is where all my development projects are located, so I often switch to subdirectories of this ~/Code</code> directory. The ZSH shell allows you to add other directories to the search path of the cd</code>, by doing this you can cd</code> into subdirectories of ~/Code</code> (in my case) from any location.</p>
In order to add directories to the search path of the cd</code> command you should set cdpath</code> in your ~/.zshrc</code>.</p>
# ~/.zshrc
</span>setopt auto_cd
</span>cdpath</span>=</span>($HOME/Code)
</span></code></pre>
By adding the above, you are able to directly change to a subdirectory of ~/Code</code> from any location. You should see these subdirectories too in your autosuggestion and get tabcompletion as well.</p>
You can add as many directories to the cdpath</code> array as you would like:</p>
# ~/.zshrc
</span>setopt auto_cd
</span>cdpath</span>=</span>($HOME/Code $HOME/.config)
</span></code></pre>


Available data types in SQLite databases
2021-03-28T00:00:00+00:00
SQLite databases come with just five primitive data types, which are called storage classes. Which, to be fair, is enough to do the basics :). These five storage classes in SQLite are: INTEGER</code>, REAL</code>, TEXT</code>, NULL</code> and BLOB</code>.</p>
So all values you store in SQLite belong to one of these storage classes:</p>
Storage class</div></th> Description</th></tr></thead>

INTEGER</code></td> Whole numbers both positive and negative. With a size of 1, 2, 3, 4, 6, or 8 bytes. SQLite manages the sizing automatically based on the value you store.</td></tr>
REAL</code></td> 8-byte decimal floating point numbers</td></tr>
TEXT</code></td> Unlimited storage of text characters (strings)</td></tr>
NULL</code></td> Null values, representing missing or unknown information.</td></tr>
BLOB</code></td> Binary objects of unlimited size.</td></tr>
</tbody></table>
Typing in SQLite works a little different than most other relational database systems like MySQL and PostgreSQL. Where MySQL and PostgreSQL use static typing on a column basis, SQLite uses a dynamic typing approach where columns have just a type affinity</em>. In SQLite the actual types are defined on cell, or value, basis instead of on a column basis.</p>

You can thing of the "type affinity" of a column in SQLite as the recommended data type you store in that column. But do keep in mind that SQLite may cast data before storing based on a columns type affinity.</em></p>
</blockquote>
The "type affinities" that SQLite uses are: NUMERIC</code>, INTEGER</code>, REAL</code>, TEXT</code> and NONE</code>. As which storage class your data ends up in SQLite does depend the type affinity a column has. To learn more about the rules SQLite uses to cast data based on type affinities you can best read the SQLite docs</a>.</p>


Open a SQLite database in the terminal
2021-03-27T00:00:00+00:00
SQLite databases are quite convenient in web development, when prototyping a simple website for example. It comes as the default database for a couple big web frameworks like Ruby on Rails and Django. Mind that none of them also encourage you to use SQLite in production.</p>
There are graphical database browsers available for SQLite, but you can open a SQLite database in the terminal as well. To open a SQLite database in shell mode you enter the sqlite3</code> command followed by the path to your database file.</p>
$ sqlite3 db.sqlite3
</span>SQLite version 3.31.1 2020-01-27 19:55:54
</span>Enter ".help" for usage hints.
</span>sqlite>
</span></code></pre>
You can now run SQL queries from the SQLite shell. Besides that there are many commands available, all starting with a period(.</code>). One of those commands is actually mentioned when you open the shell: .help</code>. When you run this .help</code> command you will see a list of available commands in the SQLite shell.</p>
A couple useful SQLite shell commands are:</p>
Command</th> Description</th></tr></thead>

.databases</code></td> List names and files of attached databases</td></tr>
.dump</code></td> Dump the database in a SQL text format</td></tr>
.excel</code></td> Display the output of next command in spreadsheet</td></tr>
.exit</code></td> Exit this program</td></tr>
.help</code></td> Show a list of available commands</td></tr>
.save FILE</code></td> Write in-memory database into FILE</td></tr>
.schema</code></td> Show the CREATE statements</td></tr>
.tables</code></td> List names of tables</td></tr>
</tbody></table>


Filter lists in Python
2021-03-26T00:00:00+00:00
If you need to filter a list in Python than the built-in filter()</code> function is probably what you're looking for. The filter()</code> function takes a function as its first argument and an iterable as its second argument.</p>

An iterable is basically an object you can iterate through. Like in a for-loop for example.</em></p>
</blockquote>
The filter()</code> function does return a filter object, which is iterable as well. So you can directly use the result in a for loop for example. It isn't a list however, so list slicing on filter results will break your code.</p>
The function that filter()</code> takes as its first argument is used to evaluate whether elements should be present in the filtered result. If you use None</code> instead of a filter function that all elements that evaluate to False</code> are filtered out. As the example below shows.</p>
things </span>= </span>[</span>''</span>, </span>False</span>, </span>0</span>, </span>None</span>, </span>5</span>, </span>'Dog'</span>, </span>True</span>]
</span>
</span># Remove Falsy values from list
</span>true_things </span>= </span>list</span>(</span>filter</span>(</span>None</span>, things))
</span>
</span>print</span>(true_things)
</span># => [5, 'Dog', True]
</span></code></pre>

The filter()</code> function keeps the original list intact, it doesn't actually remove values from the list you pass it.</em></p>
</blockquote>
But most often you want to be a little more specific when filtering a list. You can do this by writing your own function that returns True</code> for elements that you want to keep and False</code> for elements that can be filtered out.</p>
numbers </span>= </span>[</span>-</span>2</span>, </span>-</span>1</span>, </span>0</span>, </span>1</span>, </span>2</span>]
</span>
</span>def </span>is_positive</span>(</span>number</span>):
</span>    </span>return </span>number </span>> </span>0
</span>
</span>result </span>= </span>filter</span>(is_positive, numbers)
</span>
</span>print</span>(</span>list</span>(result))
</span># => [1, 2]
</span></code></pre>
Filter using a lambda function</h2>
Filtering using a lambda function can be a way to achieve the same result more concisely. Lambda functions are actually expressions, therefore you can create them at their point of use. In our case that would be directly as the first argument of the filter()</code> function.</p>
numbers </span>= </span>[</span>-</span>2</span>, </span>-</span>1</span>, </span>0</span>, </span>1</span>, </span>2</span>]
</span>
</span>result </span>= </span>filter</span>(</span>lambda </span>n</span>: n </span>> </span>0</span>, numbers)
</span>
</span>print</span>(</span>list</span>(result))
</span># => [1, 2]
</span></code></pre>
Filter list by dict value</h2>
With a custom filter function we can basically filter on anything. Just as such you can filter dictionaries in a list by on of its values.</p>
particles </span>= </span>[
</span>    {
</span>        </span>'name'</span>: </span>'neutron'</span>,
</span>        </span>'charge'</span>: </span>0
</span>    },
</span>    {
</span>        </span>'name'</span>: </span>'proton'</span>,
</span>        </span>'charge'</span>: </span>1
</span>    },
</span>    {
</span>        </span>'name'</span>: </span>'electron'</span>,
</span>        </span>'charge'</span>: </span>-</span>1
</span>    },
</span>]
</span>
</span>def </span>is_positive</span>(</span>particle</span>):
</span>    </span>return </span>particle[</span>'charge'</span>] </span>> </span>0
</span>
</span>result </span>= </span>filter</span>(is_positive, particles)
</span>
</span>print</span>(</span>list</span>(result))
</span># => [{'name': 'proton', 'charge': 1}]
</span></code></pre>
Filter list by object property</h2>
The example of the previous section can easily be translated to work with objects too. Where we in this case filter on a property of the object.</p>
class </span>Particle</span>:
</span>    </span>def </span>__init__</span>(</span>self</span>, </span>name</span>, </span>charge</span>):
</span>        self.name </span>= </span>name
</span>        self.charge </span>= </span>charge
</span>
</span>    </span>def </span>__repr__</span>(</span>self</span>):
</span>        </span>return </span>f</span>'<Particle: </span>{self.name}</span>>'
</span>
</span>particles </span>= </span>[
</span>    Particle(</span>'neutron'</span>, </span>0</span>),
</span>    Particle(</span>'proton'</span>, </span>1</span>),
</span>    Particle(</span>'electron'</span>, </span>-</span>1</span>),
</span>]
</span>
</span>def </span>is_positive</span>(</span>particle</span>):
</span>    </span>return </span>particle.charge </span>> </span>0
</span>
</span>result </span>= </span>filter</span>(is_positive, particles)
</span>
</span>print</span>(</span>list</span>(result))
</span># => [<Particle: proton>]
</span></code></pre>
Filter with list comprehension</h2>
Using list comprehensions is ofter considered to be the more Pythonic way of doing things. And filtering a list using list comprehension works fine too.</p>
Reusing one of the examples above using list comprehension looks as follows.</p>
numbers </span>= </span>[</span>-</span>2</span>, </span>-</span>1</span>, </span>0</span>, </span>1</span>, </span>2</span>]
</span>
</span>result </span>= </span>[n </span>for </span>n </span>in </span>numbers </span>if </span>n  </span>> </span>0</span>]
</span>
</span>print</span>(result)
</span></code></pre>
In contrary to the filter()</code> function, list comprehension obviously returns a list. So there is no need to wrap the result in a list()</code>.</p>


Return JSON response from a Django view
2021-03-25T00:00:00+00:00
When making an API with Django I go straight to Django REST framework</a>. However, you don't need it at all to just return a JSON response from Django.</p>
When you are rendering a template in Django your view probably returns an instance of the HttpResponse</code> class. It is a common way to print some text on a webpage:</p>
from </span>django.http </span>import </span>HttpResponse
</span>
</span>
</span>def </span>index</span>(</span>request</span>):
</span>    </span>return </span>HttpResponse(</span>'Just rendering a string :)'</span>)
</span></code></pre>
If you invoke the render</code> shortcut function you are actually returning a HttpResponse</code> too. The render</code> function renders the template file to a string and returns a HttpResponse</code> with the rendered template as its content.</p>
from </span>django.shortcuts </span>import </span>render
</span>
</span>
</span>def </span>index</span>(</span>request</span>):
</span>    </span>return </span>render(request, </span>'blog/index.html'</span>)
</span></code></pre>
Besides HttpResponse</code> Django comes with a JsonResponse</code> class as well. This JsonResponse</code> is actually a subclass of HttpResponse</code>. The JsonResponse</code> transforms the data you pass to it to a JSON string and sets the content type HTTP header to application/json</code>.</p>
To return JSON data from a Django view you swap out the HttpResponse</code> for JsonResponse</code> and pass it the data that needs to be transformed to JSON.</p>
from </span>django.http </span>import </span>JsonResponse
</span>
</span>
</span>def </span>index</span>(</span>request</span>):
</span>    </span>return </span>JsonResponse({</span>'text'</span>: </span>'Just rendering some JSON :)'</span>})
</span></code></pre>


Use the email field as username in Django
2021-03-24T00:00:00+00:00
Django comes with its own user model</a> which plays a part in the authentication system of Django. By default these Django users require a unique username for authentication. If you prefer to use the email instead of the username to login you can do so by implementing a custom user model.</p>

Adding this custom user model is something you preferably do before you create migrations for the first time.</em></p>
</blockquote>
1. Create a custom user model</h2>
The first step is creating a custom user model. I often prefer to create a users</code> app in my Django projects when I need a custom user model. But feel free to pick another name for this app, something like auth</code> makes sense too. Anyway, you can create an app with the following command, I will stick to an app named users</code> in this post:</p>
$ python manage.py startapp users
</span></code></pre>
Next, we need to add the newly created users</code> app to our INSTALLED_APPS</code> in settings.py</code>. You can add the app as both users</code> or 'users.apps.UsersConfig'</code>, there is a slight functional difference</a> though. But that's not relevant for now.</p>
# settings.py
</span>
</span>INSTALLED_APPS </span>= </span>[
</span>    </span>'django.contrib.admin'</span>,
</span>    </span>'django.contrib.auth'</span>,
</span>    </span>'django.contrib.contenttypes'</span>,
</span>    </span>'django.contrib.sessions'</span>,
</span>    </span>'django.contrib.messages'</span>,
</span>    </span>'django.contrib.staticfiles'</span>,
</span>
</span>    </span># Local apps
</span>    </span>'users.apps.UsersConfig'</span>,
</span>]
</span></code></pre>
With our new users</code> app added to the INSTALLED_APPS</code> we can create the a custom user model. In users/models.py</code> we will make a new class called User</code> which is a subclass of django.contrib.auth.models.AbstractUser</code>. In our User</code> class we will set the username</code> property to None</code>, so that we don't get it from AbstractUser</code>. Next we add the email</code> property as a unique EmailField</code> to the user model.</p>
By setting the USERNAME_FIELD</code> you let Django know which field to use to uniquely identify users</a>. The REQUIRED_FIELDS</code> are the required fields which you will be prompted for</a> when you create a user via the createsuperuser</code> command, but you exclude the USERNAME_FIELD</code> ans password from this list. We set because for AbstractUser</code> the field email</code> is part of this list, which is now our USERNAME_FIELD</code> :).</p>
from </span>django.db </span>import </span>models
</span>from </span>django.contrib.auth.models </span>import </span>AbstractUser
</span>from </span>django.utils.translation </span>import </span>gettext_lazy </span>as </span>_
</span>
</span>
</span>class </span>User</span>(</span>AbstractUser</span>):
</span>    username </span>= </span>None
</span>    email </span>= </span>models.EmailField(_(</span>'email address'</span>), </span>unique</span>=</span>True</span>)
</span>
</span>    USERNAME_FIELD </span>= </span>'email'
</span>    REQUIRED_FIELDS </span>= </span>[]
</span></code></pre>
Before we can make our migrations we need to go back to settings.py</code> and set AUTH_USER_MODEL</code> to the new user model class we just made. If you picked different names, make sure to use the following format: <APP_NAME>.<CUSTOM_USER_MODEL_CLASS></code>.</p>
# settings.py
</span>AUTH_USER_MODEL </span>= </span>'users.User'
</span></code></pre>
With that we should be good to go to make migrations.</p>
$ python manage.py makemigrations
</span>Migrations for 'users':
</span>  users/migrations/0001_initial.py
</span>    - Create model User
</span></code></pre>
...and run them:</p>
$ python manage.py migrate
</span>Operations to perform:
</span>  Apply all migrations: admin, auth, contenttypes, sessions, users
</span>Running migrations:
</span>  Applying contenttypes.0001_initial... OK
</span>  Applying contenttypes.0002_remove_content_type_name... OK
</span>  Applying auth.0001_initial... OK
</span>  Applying auth.0002_alter_permission_name_max_length... OK
</span>  Applying auth.0003_alter_user_email_max_length... OK
</span>  Applying auth.0004_alter_user_username_opts... OK
</span>  Applying auth.0005_alter_user_last_login_null... OK
</span>  Applying auth.0006_require_contenttypes_0002... OK
</span>  Applying auth.0007_alter_validators_add_error_messages... OK
</span>  Applying auth.0008_alter_user_username_max_length... OK
</span>  Applying auth.0009_alter_user_last_name_max_length... OK
</span>  Applying auth.0010_alter_group_name_max_length... OK
</span>  Applying auth.0011_update_proxy_permissions... OK
</span>  Applying auth.0012_alter_user_first_name_max_length... OK
</span>  Applying users.0001_initial... OK
</span>  Applying admin.0001_initial... OK
</span>  Applying admin.0002_logentry_remove_auto_add... OK
</span>  Applying admin.0003_logentry_add_action_flag_choices... OK
</span>  Applying sessions.0001_initial... OK
</span></code></pre>
2. Adjust the user manager</h2>
We created a custom user model, but need to make a change to the UserManager</code> as well. If you would run the createsuperuser</code> command now it would exit with the error:TypeError: create_superuser() missing 1 required positional argument: 'username'</code>.</p>
You might want to create a separate file for this in your app, but for convenience I am adding the manager to models.py</code>. The Django docs have a fine example</a> on this too.</p>
For our custom user manager we will first extend the BaseUserManager</code> class from Django. Secondly,</strong> we add the line objects = UserManager()</code> to our custom user model.</p>
from </span>django.db </span>import </span>models
</span>from </span>django.contrib.auth.models </span>import </span>AbstractUser
</span>from </span>django.utils.translation </span>import </span>gettext_lazy </span>as </span>_
</span>from </span>django.contrib.auth.base_user </span>import </span>BaseUserManager
</span>
</span>
</span>class </span>UserManager</span>(</span>BaseUserManager</span>):
</span>    use_in_migrations </span>= </span>True
</span>
</span>    </span>def </span>_create_user</span>(</span>self</span>, </span>email</span>, </span>password</span>, </span>**</span>extra_fields</span>):
</span>        </span>if not </span>email:
</span>            </span>raise </span>ValueError</span>(</span>'Users require an email field'</span>)
</span>        email </span>= </span>self.normalize_email(email)
</span>        user </span>= </span>self.model(</span>email</span>=</span>email, </span>**</span>extra_fields)
</span>        user.set_password(password)
</span>        user.save(</span>using</span>=</span>self._db)
</span>        </span>return </span>user
</span>
</span>    </span>def </span>create_user</span>(</span>self</span>, </span>email</span>, </span>password</span>=</span>None</span>, </span>**</span>extra_fields</span>):
</span>        extra_fields.setdefault(</span>'is_staff'</span>, </span>False</span>)
</span>        extra_fields.setdefault(</span>'is_superuser'</span>, </span>False</span>)
</span>        </span>return </span>self._create_user(email, password, </span>**</span>extra_fields)
</span>
</span>    </span>def </span>create_superuser</span>(</span>self</span>, </span>email</span>, </span>password</span>, </span>**</span>extra_fields</span>):
</span>        extra_fields.setdefault(</span>'is_staff'</span>, </span>True</span>)
</span>        extra_fields.setdefault(</span>'is_superuser'</span>, </span>True</span>)
</span>
</span>        </span>if </span>extra_fields.get(</span>'is_staff'</span>) </span>is not </span>True</span>:
</span>            </span>raise </span>ValueError</span>(</span>'Superuser must have is_staff=True.'</span>)
</span>        </span>if </span>extra_fields.get(</span>'is_superuser'</span>) </span>is not </span>True</span>:
</span>            </span>raise </span>ValueError</span>(</span>'Superuser must have is_superuser=True.'</span>)
</span>
</span>        </span>return </span>self._create_user(email, password, </span>**</span>extra_fields)
</span>
</span>
</span>
</span>class </span>User</span>(</span>AbstractUser</span>):
</span>    username </span>= </span>None
</span>    email </span>= </span>models.EmailField(_(</span>'email address'</span>), </span>unique</span>=</span>True</span>)
</span>
</span>    objects </span>= </span>UserManager()
</span>
</span>    USERNAME_FIELD </span>= </span>'email'
</span>    REQUIRED_FIELDS </span>= </span>[]
</span></code></pre>
With that you should be able to run python manage.py createsuperuser</code> again.</p>
3. User admin</h2>
Now, to confirm that the email field is used as a username field we can open-up the Django admin. If you see the field "Email address" instead of "Username" you should be fine.</p>
</p>
But once you log in however, the user admin isn't available since we are using a custom user model now. To fix this we'll make changes to users/admin.py</code>.</p>
from </span>django.contrib </span>import </span>admin
</span>from </span>users.models </span>import </span>User
</span>
</span>@admin.register(User)
</span>class </span>UserAdmin</span>(</span>admin.ModelAdmin</span>):
</span>    </span>pass
</span>
</span></code></pre>


Register apps by package name vs dotted path in Django
2021-03-23T00:00:00+00:00
When you create a new app in Django with python manage.py startapp <app name></code> you need to register it by adding it to the INSTALLED_APPS</code> in the settings.py</code> file. I often forget the last step :).</p>
You can add an app in two ways to INSTALLED_APPS</code>, either by adding the package name or the dotted path to a subclass of AppConfig</code>. According to the Django docs</a> the latter is preferred.</p>
The following shows both ways of registering a Django app.</p>
INSTALLED_APPS </span>= </span>[
</span>
</span>    </span># ...
</span>
</span>    </span>'blog'</span>,
</span>    </span>'posts.apps.PostsConfig'</span>,
</span>]
</span></code></pre>
So what is the difference between the two? The latter option, with dotted path, allows you to add configuration options to your app. For example, you can override the ready</code> method where you can registering signals. The first, just the package name, will use the configuration from the class django.apps.AppConfig</code>. You might not need to change the app config right away but using the dotted path allows you to be more flexible in the future.</p>


Reload Postgres config from psql
2021-03-22T00:00:00+00:00
After you've made a change in the Postgres settings you may need to restart the postgres service. The command you would use for this depends on your init system, if you're using systemd the command sudo service postgresql restart</code> will probably do.</p>
If your change doesn't require a full restart but just a reload, there is a convenient command available in psql</code>:</p>
postgres=# SELECT pg_reload_conf();
</span> pg_reload_conf
</span>----------------
</span> t
</span>(1 row)
</span></code></pre>


Set the EDITOR environment variable in ZSH
2021-03-21T00:00:00+00:00
When you start to use the command line more often you notice that quite some shell programs launch a text editor like nano or vim for you to edit a file or something in that regard. Most often these shell programs check for the shell environment variable EDITOR</code> to see your preferred text editor for these type of tasks.</p>
To see to what value EDITOR</code> is set you just echo</code> it out. Mind the $</code> sign before EDITOR</code> when you reference a variable in the shell.</p>
$ echo $EDITOR
</span>vim
</span></code></pre>
You can set the EDITOR</code> variable per command like this:</p>
$ EDITOR=nano git commit
</span></code></pre>
What is unfortunate about setting it per command is that it doesn't persist. In order to make this setting permanent you can set the default editor in the ~/.zshrc</code> config file. This config file is specific for the ZSH shell so if you were to use bash for example you need to configure it somewhere else.</p>
To make the EDITOR setting permanent you need to export</code> it in your ~/.zshrc</code> config file.</p>
# ~/.zshrc
</span>
</span>export </span>EDITOR</span>=</span>nano
</span></code></pre>
Afterwards the setting doesn't take immediate effect. You can either close and reopen your terminal or source ~/.zshrc</code>:</p>
$ source ~/.zshrc
</span></code></pre>


Change the default git editor
2021-03-20T00:00:00+00:00
Many git commands can launch a text editor, for example the git commmit</code> command will launch one for you to enter the commit message. Git uses the editor that one of the environment variables VISUAL</code> or EDITOR</code> are set to in your shell. If none of them are set git will default to the vi</code> editor.</p>
Of course you can set one of the VISUAL</code> or EDITOR</code> environment variables in your shell. But you can define your preferred editor also directly in the git config. You can change the git config file or via a command:</p>
$ git config --global core.editor nvim
</span></code></pre>
The git config file is either located in your home directory, named as: ~/.gitconfig</code>. Or you can use the location $XDG_CONFIG_HOME/git/config</code>, which most likely is ~/git/config</code>. This config file uses the TOML configuration language. You can add a default editor as follows:</p>
# ~/git/config or ~/.gitconfig
</span>
</span>[user]
</span>  </span>email </span>= </span>koen@ko.en</span>
</span>  </span>name </span>= </span>Koen Woortman</span>
</span>[core]
</span>  </span>editor </span>= </span>nvim</span>
</span></code></pre>
The value you set editor</code> to is actually the shell command used to launch the editor. So you are not just bound to terminal editors, you can for example use visual studio code as git editor</a> as well.</p>
Editor</th> Config value</th></tr></thead>

nano</td> nano</td></tr>
vim</td> vim</td></tr>
neovim</td> nvim</td></tr>
emacs</td> emacs</td></tr>
sublime text</td> subl -n -w</td></tr>
atom</td> atom --wait</td></tr>
vscode</td> code --wait</td></tr>
</tbody></table>


Install a specific version of a package with pip
2021-03-19T00:00:00+00:00
Most often installing the latest version of a package will do. For some cases you require an older version of a package, for example when the newest version of the package you'd like to install isn't compatible with the Python version you're running.</p>
If you don't specify a version when installing a package than pip will go for the latest version available.</p>
$ pip install httpie
</span></code></pre>
To specify the version of the package you like you use the same scheme as you might be familiar with from the requirements.txt</code> file.</p>
$ pip install httpie==2.3.0
</span></code></pre>
You install the specific version with <package name>==<version></code>.</p>


Get the SQL query from a Django queryset object
2021-03-18T00:00:00+00:00
The Django ORM abstracts away most of the database stuff. But while debugging or profiling it can be useful to see how Django executes a query.</p>
You can easily get the raw SQL query by accessing the .query</code> property of a queryset object.</p>
>>> </span>users </span>= </span>User.objects.all()
</span>>>> </span>str</span>(users.query)
</span>'</span>SELECT </span>"users_user"."id", "users_user"."password", "users_user"."last_login", "users_user"."is_superuser", "users_user"."first_name", "users_user"."last_name", "users_user"."is_staff", "users_user"."is_active", "users_user"."date_joined", "users_user"."email" </span>FROM </span>"users_user"'
</span></code></pre>
The example above displays this in the Django shell, for a query that gets all the users.</p>


Using the Zsh shell in Vim mode
2021-03-17T00:00:00+00:00
Whenever available I love to reach to the Vim keybindings. The Zsh line editor not being an exception. Vim all the things!</em></strong></p>
Enabling the Vim keybindings is a one-liner in the ~/.zshrc</code> config file. But to get it working somewhat more smoothy some other tweaks are necessary too in my opinion. I'm sure there are some oh-my-zsh</code> plugins available for this too if you use that.</p>
First off, let's indeed add that one-liner to the ~/.zshrc</code> config file.</p>
# ~/.zshrc
</span>
</span># Use vi mode
</span>bindkey</span> -v
</span></code></pre>
The next time you open your shell you are using vi mode. You can exit insert mode with ESC</code> and enter it again with i</code>, and other keybindings you're expecting are available too.</p>
There is somewhat of a delay between pressing a key combination and the actual effect. For me this timeout takes a bit too long. You can change it by setting the KEYTIMEOUT</code> environment variable in your ~/.zshrc</code> file too.</p>
# ~/.zshrc
</span>
</span># Use vi mode
</span>bindkey</span> -v
</span>export </span>KEYTIMEOUT</span>=</span>1
</span></code></pre>
What is missing for me is a proper mode indicator. I've moved the code for the indicator to a separate zsh theme</a>.</p>
The code that did the trick for me is pasted in bellow.</p>
## Init
</span>setopt PROMPT_SUBST
</span>
</span>## Options
</span>THEME_PROMPT_PREFIX</span>=</span>${THEME_PROMPT_PREFIX</span>:-</span>''}
</span>THEME_VI_INS_MODE_SYMBOL</span>=</span>${THEME_VI_INS_MODE_SYMBOL</span>:-</span>'λ'}
</span>THEME_VI_CMD_MODE_SYMBOL</span>=</span>${THEME_VI_CMD_MODE_SYMBOL</span>:-</span>'ᐅ'}
</span>
</span>## Set symbol for the initial mode
</span>THEME_VI_MODE_SYMBOL</span>=</span>"${THEME_VI_INS_MODE_SYMBOL}"
</span>
</span># on keymap change, define the mode and redraw prompt
</span>zle-keymap-select</span>() {
</span>  </span>if </span>[ </span>"${KEYMAP}" </span>= </span>'vicmd' </span>]</span>; then
</span>    THEME_VI_MODE_SYMBOL</span>=</span>"${THEME_VI_CMD_MODE_SYMBOL}"
</span>  </span>else
</span>    THEME_VI_MODE_SYMBOL</span>=</span>"${THEME_VI_INS_MODE_SYMBOL}"
</span>  </span>fi
</span>  zle reset-prompt
</span>}
</span>zle</span> -N</span> zle-keymap-select
</span>
</span># reset to default mode at the end of line input reading
</span>zle-line-finish</span>() {
</span>  THEME_VI_MODE_SYMBOL</span>=</span>"${THEME_VI_INS_MODE_SYMBOL}"
</span>}
</span>zle</span> -N</span> zle-line-finish
</span>
</span># Fix a bug when you C-c in CMD mode, you'd be prompted with CMD mode indicator
</span># while in fact you would be in INS mode.
</span># Fixed by catching SIGINT (C-c), set mode to INS and repropagate the SIGINT,
</span># so if anything else depends on it, we will not break it.
</span>TRAPINT</span>() {
</span>  THEME_VI_MODE_SYMBOL</span>=</span>"${THEME_VI_INS_MODE_SYMBOL}"
</span>  </span>return </span>$(( </span>128 </span>+ </span>$1 ))
</span>}
</span>
</span>PROMPT</span>=</span>'$THEME_PROMPT_PREFIX%f%B%F{240}%1~%f%b %(?.%F{green}$THEME_VI_MODE_SYMBOL.%F{red}$THEME_VI_MODE_SYMBOL) '
</span></code></pre>


Confirmation when running rm in Zsh
2021-03-16T00:00:00+00:00
Better safe than sorry right? To prevent yourself from stupid mistakes when removing files you can add the -i</code> option to the rm</code> command. This will ask for a confirmation before removing the file.</p>
$ rm</span> -i</span> secrets.txt
</span>rm: remove regular file </span>'secrets.txt'</span>?
</span></code></pre>
You can now press y</code> to indeed remove the file. For directories this works the same.</p>
$ mkdir secrets
</span>$ vim secrets/dirty.txt
</span>$ rm</span> -ir</span> secrets
</span>rm: descend into directory </span>'secrets'</span>?</span> y
</span>rm: remove regular file </span>'secrets/dirty.txt'</span>?</span> y
</span>rm: remove directory </span>'secrets'</span>?</span> y
</span></code></pre>
Right, it works, but a confirmation for each individual directory and file is a bit overkill if you'd ask me. Using the capital I</code> option instead fixes this.</p>
$ mkdir secrets
</span>$ vim secrets/dirty.txt
</span>$ rm</span> -Ir</span> secrets
</span>rm: remove 1 argument recursively</span>?</span> y
</span></code></pre>
Typing out this -I</code> is something that I'd probably forget at some point. So instead I decided to make it an alias for the rm</code> command.</p>
To do this open up the ~/.zshrc</code> config file, or wherever you add your aliases, and add the following:</p>
# ~/.zshrc
</span>
</span>alias </span>rm</span>=</span>'rm -I'
</span></code></pre>
Somewhat more trivial but maybe useful too is that the cp</code> and mv</code> commands both accept this -i</code> option too.</p>
Now what if you unintentionally removed a file anyway? Then I hope you checked the file in to version control.</p>


Running commands in Zsh without having to wait
2021-03-15T00:00:00+00:00
In Zsh, and for Bash this works the same, you can send commands to the background. This unblocks your terminal for other commands you'd like to run. For example in the case of a slow command or a process that keeps running like a development server.</p>
You can send a command to the background by appending an &</code> at the end of the command. So like this for example.</p>
$ hugo server </span>&
</span>[1] 96545
</span></code></pre>
This sends the hugo development server to the background and shows the process ID. If you'd like you can use this process ID to lookup information about the process.</p>
$ ps</span> -p</span> 96545
</span>    PID TTY          TIME CMD
</span>  96545 pts/8    00:00:01 hugo
</span></code></pre>
Or more practically kill the process.</p>
$ kill 96545
</span>[1]  + done       hugo server
</span></code></pre>
To bring back the process to the foreground you just use the fg</code> command. This brings up the last process you ran in the background.</p>
You might have noticed that the background process does write to the terminal while being in the background. Which has a useful purpose obviously. This way you get possible warnings and other information about the running process that might require your attention.</p>
However, if you would rather have the process running quietly you can redirecting the output of the command to /dev/null</code>. As is shown in the example below. Just be aware that you might miss useful information about the running process when you do this.</p>
$ hugo server </span>></span> /dev/null </span>&
</span></code></pre>


Check if string contains substring in PHP
2021-03-14T00:00:00+00:00
In order to check if a string contains a word, letter (any kind of substring) you use the strpos()</code> function. Which looks for the first occurrence of the substring in the string you want to search. It returns the position of the first occurrence in the string and false</code> if the substring couldn't be found.</p>
<?php
</span>
</span>if</span>(</span>strpos</span>(</span>'Graphpaper'</span>, </span>'php'</span>) </span>!== </span>false</span>)
</span>{
</span>    </span>echo </span>'Word contains "php"'</span>;
</span>}
</span>else
</span>{
</span>    </span>echo </span>'Word does not contains "php"'</span>;
</span>}
</span>
</span># => Word contains "php"
</span></code></pre>
Since PHP 8 you have some new sugar to check for substrings, the str_contains()</code> which was introduced in PHP 8.</p>
<?php
</span>
</span>if</span>(str_contains(</span>'Graphpaper'</span>, </span>'php'</span>))
</span>{
</span>    </span>echo </span>'Word contains "php"'</span>;
</span>}
</span>else
</span>{
</span>    </span>echo </span>'Word does not contains "php"'</span>;
</span>}
</span>
</span># => Word contains "php"
</span></code></pre>


Get the length of a string in PHP
2021-03-13T00:00:00+00:00
This might be one of the easiest things you'll ever do, in PHP to be precise. To get the length of a string in PHP you use the strlen()</code> function. It takes a string as its argument and returns the length of the string, the amount of individual characters with spaces, tabs, line breaks, etc. included.</p>
<?php
</span>
</span>echo strlen</span>(</span>'four'</span>);
</span># => 4
</span></code></pre>
Easy peasy.</p>
In case you want to check if a string is empty you could better use the empty()</code> function. Which checks whether a variable is empty.</p>


Get the last element of an array in PHP
2021-03-12T00:00:00+00:00
For getting the last element of an array in PHP you have multiple options, which function slightly differently. The most obvious ones are end()</code>, array_slice()</code> and array_pop()</code>.</p>
Getting the last element with end()</h2>
The end()</code> function sets the internal pointer of the array to its last element and returns it's value. It works pretty straight forward, after this function call the array is still intact and you can do with the return value what you'd like; assign it to a variable, print it, e.g.</p>
<?php
</span>
</span>$dogs </span>= </span>[</span>'Lassie'</span>, </span>'Hachi'</span>, </span>'Bolt'</span>];
</span>
</span>echo end</span>($dogs);
</span># => 'Bolt'
</span></code></pre>
Getting the last element with array_slice()</h2>
With the array_slice()</code> function you extract slices from an existing array. You can use -1</code> as offset to get just the last item of the array you pass as the first argument. A side note</p>
Be aware that array_slice()</code> returns a new array. So in order to actually get the last element of the original array you need to get the value at index 0 of the return value from array_slice()</code>.</p>
<?php
</span>
</span>$dogs </span>= </span>[</span>'Lassie'</span>, </span>'Hachi'</span>, </span>'Bolt'</span>];
</span>
</span>echo array_slice</span>($dogs, </span>-</span>1</span>)[</span>0</span>];
</span># => 'Bolt'
</span></code></pre>
Getting the last element with array_pop()</h2>
This one functions slightly differently. The array_pop()</code> function removes the last element from an array and returns it. So it works perfectly fine to get the last element of the array, just make sure you also actually meant to remove it from the array.</p>
<?php
</span>
</span>$dogs </span>= </span>[</span>'Lassie'</span>, </span>'Hachi'</span>, </span>'Bolt'</span>];
</span>
</span>echo array_pop</span>($dogs);
</span># => 'Bolt'
</span>
</span>print_r</span>($dogs);
</span># => Array
</span>#    (
</span>#        [0] => Lassie
</span>#        [1] => Hachi
</span>#    )
</span>
</span></code></pre>


Removing unused node modules with yarn
2021-03-11T00:00:00+00:00
Every now and then I install a node module to test something out. Or haven't decided which package to use for a certain use-case and install multiple packages that do the same thing.</p>
You can remove those packages from the dependencies section in your package.json, but that doesn't remove the package from the node_modules</code> folder. Yarn has an autoclean command that removes unnecessary dependencies.</p>
$ yarn autoclean
</span></code></pre>
What about npm?</h2>
npm</code> offers a similar command to remove unnecessary dependencies; prune</code>.</p>
$ npm prune
</span></code></pre>


Installing Lua on Ubuntu 20.04
2021-03-10T00:00:00+00:00
The programming language Lua is somewhat lesser known. Though, it has been around since 1993. What got me interested in learning some Lua is that Neovim allows you to use it as a substitute for VimL in your config file.</p>
By default Lua isn't available on Ubuntu. Luckily it's available in the repositories and therefore easy installable via apt</code>. Currently, the latest available version of Lua on Ubuntu 20.04 is version 5.3. You can install it using the following command.</p>
$ sudo apt install lua5.3
</span></code></pre>
If all went well you can now start the Lua shell with the lua</code> command in your terminal.</p>
$ lua
</span>Lua 5.3.3  Copyright (C) 1994-2016 Lua.org, PUC-Rio
</span>>
</span></code></pre>
Feel free to enter print('Hello World')</code> in this terminal, if that makes the tutorial feel more complete ;).</p>
Once you're done you can exit out the Lua shell by pressing CTRL+C</code>.</p>
Building Lua from source</h2>
You can easily build Lua from source. The [https://www.lua.org/download.html](download page on the Lua website) contains more information on this.</p>
$ curl</span> -R -O</span> http://www.lua.org/ftp/lua-5.4.2.tar.gz
</span>$ tar zxf lua-5.4.2.tar.gz
</span>$ cd lua-5.4.2
</span>$ make all test
</span></code></pre>


Ruby Ternary Operator
2021-03-09T00:00:00+00:00
The ternary operator in Ruby is a C-style conditional expression that allows you to quickly define a conditional.</p>
You only need one line and it comes in handy when you need to do a variable assignment based on a condition.</p>
The expression takes the form of: <condition> ? <value if true> : <value if false></code>.</p>
Let's for example say that we want to assign the name of a bird based on the trait that it flies.</p>
Instead of writing an if/else like this.</p>
name </span>= if</span> bird.can_fly
</span>         </span>'Pidgin'
</span>       </span>else
</span>         </span>'Ostrich'
</span>       </span>end
</span></code></pre>
You can write it as follows with the ternary operator.</p>
name </span>=</span> bird.can_fly </span>? </span>'Pidgin' </span>: </span>'Ostrich'
</span></code></pre>
Nested Ternary Operator</h2>
If you want to go crazy you can nest a ternary operator as well, since it's just an expression.</p>
name </span>=</span> bird.can_fly </span>? </span>'Pidgin' </span>: </span>(bird.can_swin </span>? </span>'Penguin' </span>: </span>'Ostrich'</span>)
</span></code></pre>


Comparisons with the Ruby spaceship operator
2021-03-08T00:00:00+00:00
The spaceship operator (<=></code>) is a comparison operator that is implemented by Ruby's Comparable</code> mixin. With the spaceship operator you can do a three-way comparison, to do the comparisons <</code>, ==</code>, and ></code> in a single operation. It returns either -1, 0 or 1 depending on if the other object is respectively; less than, equal to, or greater than the other object.</p>
With strings, where the string length is used for the comparison, it gives the following results for example.</p>
puts </span>'a' </span><=> </span>'ab'   </span># => -1
</span>puts </span>'ab' </span><=> </span>'ab'  </span># =>  0
</span>puts </span>'ab' </span><=> </span>'a'   </span># =>  1
</span></code></pre>
This is internally used by Ruby for sorting arrays. Ruby will swap the places of two adjacent elements in an array if the <=></code> comparison has a result of 1. If the result is either -1 or 0 it will leave the elements in place.</p>
letters </span>= </span>[</span>'ab'</span>, </span>'a'</span>, </span>'abc'</span>]
</span>puts</span> letters.sort!.</span>inspect
</span># => ["a", "ab", "abc"]
</span></code></pre>
Implementing the Comparable mixin</h2>
You can include the Comparable</code> mixin in your own classes too. If you do so you get the implementation for the conventional comparison operators (<</code>, <=</code>, ==</code>, >=</code>, and ></code>) and the method between?</code> for free, since these make use of the <=></code> operator. Unless you overwrite them.</p>
class </span>Book
</span>  </span>include </span>Comparable
</span>  </span>attr </span>:pages
</span>
</span>  </span>def </span><=></span>(</span>other</span>)
</span>    pages </span><=></span> other.pages
</span>  </span>end
</span>
</span>  </span>def </span>initialize</span>(</span>str</span>)
</span>    @str </span>=</span> str
</span>  </span>end
</span>end
</span></code></pre>
You should return nil</code> if the objects are not comparable using the <=></code> operator.</p>


Using relative line numbers in vim
2020-12-31T00:00:00+00:00
Writing code in an editor without line numbers is like fries without salt. It's not that I'm using line numbers that often, but it just doesn't look right.</p>
Enabling them in VIM can be done in the .vimrc</code> by adding the following line.</p>
" ~/.vimrc
</span>
</span>set</span> number </span>" Enable line numbers
</span></code></pre>
Or you can run it as an command like :set number</code> to enable it in your current vim session. Changing the setting like this just won't persist. So when you close and open vim again the line numbers are gone again.</p>
Either way, the result this has is the following. Line numbers are shown in our .vimrc</code> file and any other file we open.</p>
  </span>1 </span>" ~/.vimrc
</span>  </span>2
</span>  </span>3 </span>set</span> number </span>" Enable line numbers
</span></code></pre>
Since VIM version 7.3, and in Neovim too, we can show relative line numbers. Which helps for commands that strike multiple lines. We can enable this by adding set relativenumber</code> to our .vimrc</code>. As with regular line number this works as a command too.</p>
  </span>1 </span>" ~/.vimrc
</span>  </span>2
</span>  </span>3 </span>set</span> number          </span>" Enable line numbers
</span>  </span>4 </span>set</span> relativenumber  </span>" Enable relative line numbers
</span></code></pre>
Now that we added the setting for relative line numbers, our line numbers as shown as below. For the current line we are at we see the actual line number, for other lines we see the distance from our current line.</p>
  </span>2 </span>" ~/.vimrc
</span>  </span>1
</span>3   </span>set</span> number          </span>" Enable line numbers
</span>  </span>1 </span>set</span> relativenumber  </span>" Enable relative line numbers
</span></code></pre>
Pay attention to the set number</code> setting as well, without it only the relative numbers are shown. So the current line would otherwise be numbered 0</code>.</p>
Jeff Kreeftmeijer wrote more extensively about line numbers in vim</a> and open-sourced a sweet vim plugin</a> for automatically switching between absolute and relative line numbers.</p>


Show all databases in your MySQL database
2020-12-30T00:00:00+00:00
The most common way to show the databases on your system is by using the SHOW DATABASES</code> statement. This shows a list of all databases that your database user has access to.</p>
So in my case there are databases showing up which MySQL uses for internal use. Like for managing users and privileges for example.</p>
mysql> SHOW DATABASES;
</span>+--------------------+
</span>| Database           |
</span>+--------------------+
</span>| information_schema |
</span>| mysql              |
</span>| performance_schema |
</span>| production         |
</span>| staging            |
</span>| sys                |
</span>+--------------------+
</span>6 rows in set
</span>Time: 0.029s
</span></code></pre>
The SHOW SCHEMAS</code> statement is a synonym for SHOW DATABASES</code>. So you might as well use that, it is shorter to type :).</p>
You can if you need to pass a pattern to this query as well. To filter out some of the resulting rows you'll get.</p>
SHOW DATABASES LIKE '%schema';
</span>+--------------------+
</span>| Database (%schema) |
</span>+--------------------+
</span>| information_schema |
</span>| performance_schema |
</span>+--------------------+
</span>2 rows in set
</span>Time: 0.018s
</span></code></pre>


Remove a MySQL user
2020-12-29T00:00:00+00:00
To remove a user and its privileges from a MySQL database you use the DROP USER</code> statement. With MySQL you can create multiple users and assign different permissions. But it's a good idea to not keep unused accounts around.</p>
You can delete a user in MySQL with the following statement.</p>
mysql</span>> DROP USER </span>'morty'</span>@</span>'localhost'</span>;
</span></code></pre>
This would have dropped the user morty</code> from the host localhost</code>.</p>

Keep in mind that this change takes effect after the sessions of the deleted user is closed. If the dropped user has an open session, the user isn't dropped until its session is closed.</em></p>
</blockquote>
Ofcourse you can't just go dropping users left and right. In order to do so you at least need either the global CREATE USER</code> or DELETE</code> privilege in mysql system schema.</p>
You can list your user privileges in MySQL as well.</a> For this you need the SHOW GRANTS</code> statement.</p>
This shows the grants of the currently logged in user.</p>
mysql> SHOW GRANTS;
</span>+---------------------------------------------------+
</span>| Grants for koen@localhost                         |
</span>+---------------------------------------------------+
</span>| GRANT ALL PRIVILEGES ON *.* TO 'koen'@'localhost' |
</span>+---------------------------------------------------+
</span>1 row in set (0,00 sec)
</span></code></pre>
If the user doesn't have the sufficient rights to drop a user you should be able to drop it as the root</code> user.</p>
One thing that might comes in handy is a query to show the users which are currently present. In order to do so you can query the mysql.user</code> table.</p>
mysql</span>> SELECT</span> User, Host </span>FROM </span>mysql</span>.</span>user</span>;
</span>+</span>---------------+-----------+
</span>| User          | Host      |
</span>+</span>---------------+-----------+
</span>| koen          | localhost |
</span>| </span>mysql</span>.</span>session</span> | localhost |
</span>| </span>mysql</span>.</span>sys</span>     | localhost |
</span>| root          | localhost |
</span>+</span>---------------+-----------+
</span></code></pre>


Check if a file exists with Bash
2020-12-28T00:00:00+00:00
In your Bash script you'll have to deal with files at some point. So knowing for sure whether a file exists or not comes in handy at some point. You can test for these conditions in an if statement luckily.</p>
Normally, in Bash, the preferred way to test this condition is by using double square brackets([[ … ]]</code>), which is the improved version of the single square brackets ([ … ]</code>). Do keep in mind however that the double square brackets might not be available in other shells. So for portability you might want to prefer single square brackets over the double ones.</p>
To test for the existence of a file we can use the -f</code> file test operator. The -f</code> operator returns true if the file for the specified path exists and is a actual file, so not a directory.</p>
In the script below an example is shown, in which a file is created first and secondly the existence is validated.</p>
#!/bin/bash
</span>
</span># 1. We create a file
</span>touch ~/dirty_secrets.txt
</span>
</span># 2. Check whether the file exist
</span>if </span>[[ </span>-f </span>"$HOME/dirty_secrets.txt" </span>]]</span>; then
</span>  </span>echo </span>"You have dirty secrets"
</span>fi
</span></code></pre>
And now run the script.</p>
$ ./dirty-secrets
</span>You have dirty secrets
</span></code></pre>
There are a couple things that the -f</code> operator does and doesn’t take into account. It does check if the specified file is actually a file. So if the specified path is an existing directory it still returns false. It doesn't check whether the file is a symlink or not. So if the specified path is a path to a symlink, it does return true.</p>
Test if a file doesn't exist</h2>
For checking if a file is not existing we can do something similar. In order to check whether a file doesn’t exist we negate the condition with an exclamation mark.</p>
#!/bin/bash
</span>
</span># 1. Now we remove the file
</span>rm ~/dirty_secrets.txt
</span>
</span># 2. And check whether the file exist
</span>if </span>[[ </span>! </span>-f </span>"$HOME/dirty_secrets.txt" </span>]]</span>; then
</span>  </span>echo </span>"Good boy, no dirty secrets"
</span>fi
</span></code></pre>
Lets see the result of the updated version of the script now.</p>
$ ./dirty-secrets
</span>Good boy, no dirty secrets
</span></code></pre>
Create file if it doesn't exist</h2>
A more likely use-case is that you want to create a file if it doesn’t exist yet. With a small modification we can do just that.</p>
We can create the file by using the touch</code> command.</p>
#!/bin/bash
</span>
</span># 1. Store the files path in a variable
</span>file</span>=</span>"$HOME/dirty_secrets.txt"
</span>
</span># 2. Create a file if it doesn't exist
</span>if </span>[[ </span>! </span>-f </span>$file </span>]]</span>; then
</span>  touch $file
</span>  </span>echo </span>"Created file '$file'"
</span>fi
</span></code></pre>
Lets see what happens when we run this version of the script.</p>
$ ./dirty-secrets
</span>Created file </span>'/home/koen/dirty_secrets.txt'
</span></code></pre>
Test if a folder exist</h2>
Testing for the existence of a directory is the same but uses a different operator. Where we used -f</code> to check for the existence of a file, we use -d</code> for directories.</p>
#!/bin/bash
</span>
</span># 1. We create a file
</span>mkdir ~/dirty_secrets
</span>
</span># 2. Check whether the directory exist
</span>if </span>[[ </span>-d </span>"$HOME/dirty_secrets" </span>]]</span>; then
</span>  </span>echo </span>"You have dirty secrets"
</span>fi
</span></code></pre>
When we run the script we get the following output.</p>
$ ./dirty-secrets
</span>You have dirty secrets
</span></code></pre>
Check multiple files at once</h2>
Checking for multiple files at once can be done as well. In order to do so you combine the conditions with &&</code>.</p>
if </span>[[ </span>-f </span>"$HOME/dirty_secrets/mine.txt" </span>]] </span>&& </span>[[ </span>-f </span>"$HOME/dirty_secrets/ours.txt" </span>]]</span>; then
</span>  </span>echo </span>"You have dirty secrets"
</span>fi
</span></code></pre>
File test operators</h2>
In the above examples we used only the -f</code> and -d</code> operators. But there are a couple other useful operators for dealing with files. They are summed up in the table below.</p>
Operator</th> Returns true when</th></tr></thead>

-f</code></td> file exists and is a regular file</td></tr>
-d</code></td> file exists and is a directory</td></tr>
-e</code></td> file exists</td></tr>
-s</code></td> file is not zero size</td></tr>
-L</code></td> file is a symbolic link</td></tr>
-S</code></td> file is a socket</td></tr>
-x</code></td> file has execute permissions</td></tr>
</tbody></table>
Learning more</h2>
The best way to learn more is to use Bash. A lot. Don't forget that Google is your friend.</p>
In case you learn well from books I would recommend these.</p>

The Linux Command Line: A Complete Introduction</a></li>
Learning the bash Shell: Unix Shell Programming</a></li>
</ul>


Add a directory to PATH in ZSH
2020-12-27T00:00:00+00:00
The place where you want to add directories to your PATH is in the .zshrc</code> file. Since this file gets loaded once you enter the shell, you make sure your settings don’t disappear when restarting the shell.</p>
The more generic way to add a directory to the path is to export a PATH variable in your .zshrc</code> file. This approach works just as well in the Bash shell. You set this PATH variable equal to a string of paths separated by a colon(:</code>). Often you want to include the current value of PATH in this string as well, by doing this you add paths instead of overwriting PATH.</p>
For example, if you would like to add the paths ~/bin</code> and /home/koen/.local/bin</code> to your PATH you would add the following to your .zshrc</code>. You can make use of tilde expansion here, as a shortcut for your home directory.</p>
export </span>PATH</span>=</span>~/bin:/home/koen/.local/bin:$PATH
</span></code></pre>
ZSH does also offer another way to add paths to the PATH variable, like it is a list of some sort.</p>
path</span>+=</span>(</span>'~/bin'</span>)
</span>path</span>+=</span>(</span>'/home/koen/.local/bin'</span>)
</span>export </span>PATH
</span></code></pre>
So what exactly is this $PATH?</h2>
PATH is an environment variable where you tell your system to look for executables when you enter a command in the shell.</p>
You can inspect the value of the PATH variable by running the following.</p>
$ echo $PATH
</span></code></pre>
This outputs a string with locations like /usr/bin</code> and /bin</code>. When you install a program like git, the executable program for git is placed in one of these directories. So that your system can actually find the commands you run.</p>


Show user privileges in MySQL
2020-12-23T00:00:00+00:00
First off make sure you're logged in to MySQL. You can do this via a GUI, like MySQL Workbench, or via the MySQL shell:</p>
$ mysql -u <user>
</span></code></pre>
Now that you're logged in to MySQL you can simply show the grants of the current user by running one of the following query.</p>
mysql> SHOW GRANTS;
</span>+---------------------------------------------------+
</span>| Grants for koen@localhost                         |
</span>+---------------------------------------------------+
</span>| GRANT ALL PRIVILEGES ON *.* TO 'koen'@'localhost' |
</span>+---------------------------------------------------+
</span>1 row in set (0,00 sec)
</span></code></pre>
In order to find the grants given to another user you need to pass that user and the host to SHOW GRANTS</code>.</p>
mysql> SHOW GRANTS FOR 'root'@'localhost';
</span>+---------------------------------------------------------------------+
</span>| Grants for root@localhost                                           |
</span>+---------------------------------------------------------------------+
</span>| GRANT ALL PRIVILEGES ON *.* TO 'root'@'localhost' WITH GRANT OPTION |
</span>| GRANT PROXY ON ''@'' TO 'root'@'localhost' WITH GRANT OPTION        |
</span>+---------------------------------------------------------------------+
</span>2 rows in set (0,00 sec)
</span></code></pre>
By the way, if you need inspiration for querying users you can query the mysql.user</code> table.</p>
mysql> SELECT Host, User FROM mysql.user;
</span>+-----------+---------------+
</span>| Host      | User          |
</span>+-----------+---------------+
</span>| localhost | koen          |
</span>| localhost | mysql.session |
</span>| localhost | mysql.sys     |
</span>| localhost | root          |
</span>+-----------+---------------+
</span>4 rows in set (0,00 sec)
</span></code></pre>
Unfortunately getting all grants for a specific user isn't as easy passing just the user and not the host :(.</p>
mysql> SHOW GRANTS FOR 'root';
</span>ERROR 1141 (42000): There is no such grant defined for user 'root' on host '%'
</span></code></pre>
The closest thing I came across to showing all the grants for a user is the query SELECT * FROM information_schema.user_privileges;</code>. This does show the grants per privilege.</p>
mysql> SELECT * FROM information_schema.user_privileges;
</span>+-----------------------------+---------------+-------------------------+--------------+
</span>| GRANTEE                     | TABLE_CATALOG | PRIVILEGE_TYPE          | IS_GRANTABLE |
</span>+-----------------------------+---------------+-------------------------+--------------+
</span>| 'root'@'localhost'          | def           | SELECT                  | YES          |
</span>| 'root'@'localhost'          | def           | INSERT                  | YES          |
</span>...
</span>| 'koen'@'localhost'          | def           | CREATE TABLESPACE       | NO           |
</span>+-----------------------------+---------------+-------------------------+--------------+
</span>86 rows in set (0,00 sec)
</span></code></pre>


Join two Python tuples
2020-12-22T00:00:00+00:00
Tuples in Python are immutable, meaning they can't be modified once they are created. Adding elements or reordering elements is a no-no. So methods like .append()</code> or .sort()</code> which you can use on lists are not available on tuples.</p>
Meaning that in order to add elements to a tuple you need to merge two tuples together by using the +=</code> operator.</p>
toppings </span>= </span>(</span>'tuna'</span>, </span>'cheese'</span>, </span>'salami'</span>, </span>'pepper'</span>)
</span>toppings </span>+= </span>(</span>'tomato'</span>,)
</span>
</span>print</span>(toppings)
</span># => ('tuna', 'cheese', 'salami', 'pepper', 'tomato')
</span></code></pre>
Pay attention to the trailing comma in ('tomato',)</code>, without the comma this would be evaluated as a string.</p>


6 Non-Programming Books for Programmers
2020-12-21T00:00:00+00:00
Over the years I've collected a pretty extensive library of books. With the majority of them being about software development or a closely related topic. But once every while I find myself reading something totally different. The following is an updated list of non-programming books that made me a better programmer.</p>
Health</h2>
Why We Sleep</h3>
</a></p>
Amazon</a></p>
For as long as I've been in software development there have always been developers around me who seem to have their brightest moments during the night. There is always that</strong> guy making commits at 2 AM. Granted, working at night does have its advantages. There are a lot less distractions and the bright screen seems to keep you awake pretty well, besides the caffeine I mean. Whether it is beneficial to your code or not, not needing a lot of sleep somehow seemed to be a cool thing as well.</p>
But oh boy, bad things happen to your body when you're getting less than 7 hours of sleep a night. Neuroscientist Matthew Walker describes in a very approachable manner the effects that sleep has on our creativity, memory, decision making, eating habits and more. Even scarier is the increased chance for Alzheimer’s disease.</p>
In the long term good work doesn’t come from working till late at night, for me it comes from a well rested mind. After sticking to a more regular sleeping schedule I noticed that good sleep was the one thing that influences about everything. I had more energy, it was easier to focus, my mood became better and I got way more done while being less stressed.</p>
Learnings</strong></p>

There is nothing lazy</em> about getting enough sleep and not getting up early. Genetically there is actually such a thing as morning and evening people.</li>
Not getting enough sleep is terrible for your immune system. It also more than doubled your chances of getting cancer.</li>
</ul>
Productivity</h2>
Eat That Frog</h3>
</a></p>
Amazon</a></p>
Whatever your definition is of time management, you’ll likely need to do some of it. There is quite some dry material out there with regard to time management. But in my opinion this book does a great job in cutting out the unnecessary stuff and delivers practical advice on just a couple pages per subject.</p>
Procrastination was kind of my thing and I took some pride in it too. But doing things last minute mostly leads to stress. While that stress can give you a great rush, at some point it just gets exhausting. In the book are 21 tools to help you become more productive. You’ll likely don’t need all of them but some will certainly help you on a daily basis.</p>
Learnings</strong></p>

Do the most important task early in the day. You will feel great for the rest of the day, instead of anxiously looking forward to something big.</li>
Don't try to do too much important task on a day. Stick to a maximum of two important tasks.</li>
</ul>
The 4-Hour Workweek</h3>
</a></p>
Amazon</a></p>
Despite the title, if you like your job and aren’t necessary looking to work 4 hours a week this book is still a good read. Out of all the books this is the one that might have influenced me the most and I revisit it for a re-read every now and then. This book covers a wide range of topics, you can use the tips and tricks to retire early and travel around the world. But for me the most important takeaway was the notion of effectiveness. Instead of increasing the input hours focus on your per-hour output.</p>
Efficiency is important, but what</em> you’re doing is always more important than how</em> you do it. Most of the people who get more done than you don’t work harder or more, they work on the right things.</p>
Another key concept of the book is automation. As a developer this was hard not to get excited about. From scripts that write boring statistics to spreadsheets to this blog article being automatically deployed by webhook to Netlify. There is just a feeling of satisfaction you get when you can just blindly ignore something knowing it gets done.</p>
Learnings</strong></p>

Put your energy and efforts in the things that actually matter.</li>
</ul>
Psychology</h2>
Power of Habit</h3>
</a></p>
Amazon</a></p>
Since starting my first full-time job as a developer I picked up a couple bad habits along the way, and I am talking about everything from debugging with console.logs/print statements to having a terrible diet. Phasing-out the bad habits overtime can be challenging. You can start off great, but before you know it you fall back in your old patterns.</p>
Turns out there is a science to this. And often it is easier to trick your mind into taking on a better habit than trying to fight it off.</p>
Learnings</strong></p>

Meaningful goals are achieved by discipline and consistency. Turning things into a habit makes the hard work maintainable.</li>
</ul>
Collaboration</h2>
How to Win Friends and Influence People</h3>
</a></p>
Amazon</a></p>
The title was a bit off putting for me before buying the book. But since it seemed to be somewhat of a classic I gave it a try anyway and wasn’t disappointed. I did have the feeling it was written more with a management type of person in mind as its reader. However, since you will work together with others at some point, getting advice on relations with others can’t hurt. Although all principles in the book are not ones you couldn’t have come up with yourself, it is nice to get them in a comprehensive list form.</p>
A lot of issues and frustrations that come from code are personal opinions. While the actual code has been someone else his or her hard work. So the general advice here is; don’t let pull requests drag you into a hostile place.</p>
Learnings</strong></p>

Don’t criticize or complain as a first response.</li>
Give sincere appreciation.</li>
</ul>
Business</h2>
It Doesn't Have to Be Crazy at Work</h3>
</a></p>
Amazon</a></p>
For way too long I thought that if you’re not doing stand-ups and two week sprints you’re doing software development wrong. It so happens that the people at Basecamp have a totally different view on software development and seem to get an incredible amount of work done. Lucky for us they wrote a book about how they do it.</p>
They have a clear stance on what they think work should be. Instead of the two week rushes they opt for sanity and calmness in the office. Emphasizing that you should be protective of your time. Working 8-hours of work a day is plenty to get a whole lot done. That is, if you’re not spending half of it in irrelevant meetings and answering Slack messages.</p>
Whether it is or isn’t crazy at your work. It is good to know there are multiple ways to approach software development and be successfully doing so.</p>
Learnings</strong></p>

You will likely get the most done when you have long stretches of uninterrupted time to work.</li>
</ul>


Remap the ctrl+b tmux prefix to ctrl+a
2020-12-20T00:00:00+00:00
When coming from GNU screen the ctrl+b</code> tmux uses by default is somewhat hard to get used to. Besides that it isn't as nicely reachable as the ctrl+a</code> prefix used by GNU screen.</p>
Adjusting this prefix takes a couple lines of configuration in the ~/.tmux.conf</code> config file. Following the example in the tmux man pages, we make the following addition in the tmux config.</p>
# ~/.tmux.conf
</span>
</span>unbind-key C-b
</span>
</span>set-option -g prefix C-a
</span>
</span>bind-key C-a send-prefix
</span></code></pre>


Create a custom Django manage.py command
2020-12-19T00:00:00+00:00
When you used Django before you undoubtedly used a subcommand of manage.py</code>, such as runserver</code> and migrate</code>. You can also create custom django commands that can be invoked via manage.py</code>. This can be useful for administrative tasks in your application. Like running a background job for example.</p>
Create a command</h2>
Django looks for custom management commands in the folder management/commands</code> of the apps you registered in the INSTALLED_APPS</code> setting. The command itself is just a python file in the commands</code> folder.</p>
If we would have a plants app in our Django application that should have a waterplants</code> command, to water the plants, we add a waterplants.py</code> file to the commands</code> folder.</p>
So that our plants app has the following files. Just an fyi, files starting with a underscore(_</code>) are not registered as custom management command.</p>
$ tree plants
</span>plants
</span>├── admin.py
</span>├── apps.py
</span>├── __init__.py
</span>├── management
</span>│   └── commands
</span>│       └── waterplants.py
</span>├── migrations
</span>│   └── __init__.py
</span>├── models.py
</span>├── tests.py
</span>└── views.py
</span></code></pre>

$ tree plants</code> lol :)</em></p>
</blockquote>
If you run python manage.py help</code> you should see your new command as available subcommand.</p>
$ python manage.py help
</span>
</span>Type 'manage.py help <subcommand>' for help on a specific subcommand.
</span>
</span>Available subcommands:
</span>
</span>...
</span>
</span>[plants]
</span>    waterplants
</span>
</span>...
</span></code></pre>
However, running the command at this state doesn't do a whole lot. Actually, it throws an exception:</p>
AttributeError: module 'plants.management.commands.waterplants' has no attribute 'Command'</code>.</p>
What Django expects a class Command</code> which is a subclass of BaseCommand</code> in this waterplants.py</code> we just created. To get rid of this exception can past in the following piece of code.</p>
# ./plants/management/commands/waterplants.py
</span>from </span>django.core.management.base </span>import </span>BaseCommand
</span>
</span>
</span>class </span>Command</span>(</span>BaseCommand</span>):
</span>    </span>help </span>= </span>'Water the plants'
</span>
</span>    </span>def </span>handle</span>(</span>self</span>, </span>*</span>args</span>, </span>**</span>options</span>):
</span>        </span>pass
</span></code></pre>
The handle</code> method is the entry point of the command. When the command is invoked by Django the handle</code> method will be called.</p>
As you see we have set a help</code> property for the Command class. This string is used in the help message for the management command if we pass the --help</code> flag. We see that we get some optional arguments for free from the BaseCommand class.</p>
$ python manage.py waterplants --help
</span>usage: manage.py waterplants [-h] [--version] [-v {0,1,2,3}]
</span>                             [--settings SETTINGS] [--pythonpath PYTHONPATH]
</span>                             [--traceback] [--no-color] [--force-color]
</span>                             [--skip-checks]
</span>
</span>Water the plants
</span>
</span>optional arguments:
</span>  -h, --help            show this help message and exit
</span>  --version             show program's version number and exit
</span>  -v {0,1,2,3}, --verbosity {0,1,2,3}
</span>                        Verbosity level; 0=minimal output, 1=normal output,
</span>                        2=verbose output, 3=very verbose output
</span>  --settings SETTINGS   The Python path to a settings module, e.g.
</span>                        "myproject.settings.main". If this isn't provided, the
</span>                        DJANGO_SETTINGS_MODULE environment variable will be
</span>                        used.
</span>  --pythonpath PYTHONPATH
</span>                        A directory to add to the Python path, e.g.
</span>                        "/home/djangoprojects/myproject".
</span>  --traceback           Raise on CommandError exceptions
</span>  --no-color            Don't colorize the command output.
</span>  --force-color         Force colorization of the command output.
</span>  --skip-checks         Skip system checks.
</span></code></pre>
Accessing models</h2>
Since you're not gonna make management commands for the sake of it. You probably want them to interact with your models in some way.</p>
There is not much special about doing this from a command compared to any other place in your Django application. You can just import the model class in your command file and interact with it as you would normally do from a view for example.</p>
from </span>django.core.management.base </span>import </span>BaseCommand
</span>from </span>plants.models </span>import </span>Plant
</span>
</span>
</span>class </span>Command</span>(</span>BaseCommand</span>):
</span>    </span>help </span>= </span>'Water the plants'
</span>
</span>    </span>def </span>handle</span>(</span>self</span>, </span>*</span>args</span>, </span>**</span>options</span>):
</span>        plants </span>= </span>Plant.objects.all()
</span>
</span>        </span>for </span>plant </span>is</span> plants</span>:</span>
</span>            plant.water()
</span></code></pre>
Writing output</h2>
A simple print()</code> will work. But the BaseCommand comes with two other options as well. The BaseCommand sets the stdout</code> and stderr</code> output streams as its properties and we can write to them by calling a write</code> function.</p>
from </span>django.core.management.base </span>import </span>BaseCommand
</span>from </span>plants.models </span>import </span>Plant
</span>
</span>
</span>class </span>Command</span>(</span>BaseCommand</span>):
</span>    </span>help </span>= </span>'Water the plants'
</span>
</span>    </span>def </span>handle</span>(</span>self</span>, </span>*</span>args</span>, </span>**</span>options</span>):
</span>        plants </span>= </span>Plant.objects.all()
</span>
</span>        </span>for </span>plant </span>in </span>plants:
</span>            plant.water()
</span>            self.stdout.write(</span>f</span>'watered plant "</span>{plant}</span>"'</span>)
</span></code></pre>
Now that we added that to our command we actually see some output when we run the custom management command.</p>
$ python manage.py waterplants
</span>watered plant "Monstera"
</span>watered plant "Ficus"
</span>watered plant "Cactus"
</span></code></pre>
If you like you can also add some colors to the output. If we were to change the line that writes to stdout to:</p>
self.stdout.write(self.style.SUCCESS(</span>f</span>'watered plant "</span>{plant}</span>"'</span>))
</span></code></pre>
We would see the output having green text when rerunning the command.</p>
Some useful style options you get for writing output are:</p>

Success: self.style.SUCCESS('...')</code></li>
Notice: self.style.NOTICE('...')</code></li>
Warning: self.style.WARNING('...')</code></li>
Error: self.style.ERROR('...')</code></li>
</ul>
Command errors</h2>
When throwing exceptions in your command class you normally want to use the CommandError</code> class that is provided by Django. Since Django will intercept it and write the error message to stderr</code>, besides that it exits the command with a non-zero return code as well.</p>
from </span>django.core.management.base </span>import </span>BaseCommand, CommandError
</span>from </span>plants.models </span>import </span>Plant
</span>
</span>
</span>class </span>Command</span>(</span>BaseCommand</span>):
</span>    </span>help </span>= </span>'Water the plants'
</span>
</span>    </span>def </span>handle</span>(</span>self</span>, </span>*</span>args</span>, </span>**</span>options</span>):
</span>        plants </span>= </span>Plant.objects.all()
</span>
</span>        </span>if not </span>plants:
</span>            </span>raise </span>CommandError(</span>'No plants to water'</span>)
</span>
</span>        </span>for </span>plant </span>in </span>plants:
</span>            plant.water()
</span>            self.stdout.write(self.style.SUCCESS(</span>f</span>'watered plant "</span>{plant}</span>"'</span>))
</span></code></pre>
Custom return codes</h3>
As said above, the CommandError</code> class exits the script with a non-zero return code. It returns 1</code> to be precise. Using a different return code might be useful in some cases.</p>
To do so you can easily pass the returncode</code> keyword argument when throwing the exception.</p>
from </span>django.core.management.base </span>import </span>BaseCommand, CommandError
</span>from </span>plants.models </span>import </span>Plant
</span>
</span>
</span>class </span>Command</span>(</span>BaseCommand</span>):
</span>    </span>help </span>= </span>'Water the plants'
</span>
</span>    </span>def </span>handle</span>(</span>self</span>, </span>*</span>args</span>, </span>**</span>options</span>):
</span>        plants </span>= </span>Plant.objects.all()
</span>
</span>        </span>if not </span>plants:
</span>            </span>raise </span>CommandError(</span>'No plants to water'</span>, </span>returncode</span>=</span>2</span>)
</span>
</span>        </span>for </span>plant </span>in </span>plants:
</span>            plant.water()
</span>            self.stdout.write(self.style.SUCCESS(</span>f</span>'watered plant "</span>{plant}</span>"'</span>))
</span></code></pre>


Get the current directory in a Bash script
2020-10-31T00:00:00+00:00
When scripting together a bash script you might need to know your current working directory at some point.</p>
The current working directory is conveniently stored in the variable $PWD</code> which is available in all POSIX compliant shells. Another option to get the current working directory is by using the pwd</code> command. That pwd</code> command is a shell builtin and available in all POSIX compliant shells as well.</p>
#!/bin/bash
</span>
</span># Option 1
</span>cd</span> /home/koen
</span>echo </span>$PWD
</span>
</span># Option 2
</span>cd</span> /home/koen/Test
</span>CWD</span>=</span>$(pwd)
</span>echo </span>$CWD
</span></code></pre>
When we run this script it produced the following output. The first output being the value of $PWD</code>. The second line being the output of $(pwd)</code>.</p>
$ bash print_cwd
</span>/home/koen
</span>/home/koen/Test
</span></code></pre>
What about symlinks?</h3>
The example shown before doesn't take into account symlinks. So if you run pwd</code> or $PWD</code> in a folder that is symlinked it doesn't show you the physical location but the location of the symlink.</p>
If you need the actual physical location of the directory in your script you can use the -P</code> option on the pwd</code> command.</p>
That /home/koen/Test</code> folder was actually a symlink to another location. Lets alter the script to take symlinks into account.</p>
#!/bin/bash
</span>
</span># In a symlinked folder
</span>cd</span> /home/koen/Test
</span>CWD</span>=</span>$(pwd)
</span>echo </span>$CWD
</span>
</span># Also in a symlinked folder
</span>cd</span> /home/koen/Test
</span>CWD</span>=</span>$(</span>pwd </span>-P</span>)
</span>echo </span>$CWD
</span></code></pre>
And lets run it.</p>
$ bash print_cwd
</span>/home/koen/Test
</span>/home/koen/Documents/Test
</span></code></pre>
Now as you see, the pwd -P</code> command outputs the physical location of the Test</code> folder.</p>
Learning more</h2>
The best way to learn more is to use Bash. A lot. Don't forget that Google is your friend.</p>
In case you learn well from books I would recommend these.</p>

The Linux Command Line: A Complete Introduction</a></li>
Learning the bash Shell: Unix Shell Programming</a></li>
</ul>


Swapping list items in Python
2020-10-30T00:00:00+00:00
Suppose you have a list in Python, and you want to swap the positions of items in the list.</p>
Lets take the following list for example. In which the items are clearly out of order.</p>
meals </span>= </span>[</span>'breakfast'</span>, </span>'dinner'</span>, </span>'lunch'</span>]
</span></code></pre>
In order to the swap the positions of items in a list we need to find the indexes</a> of the items we'd like to swap. We can easily do so in this case by using the index()</code> function available for lists.</p>
i, j </span>= </span>meals.index(</span>'dinner'</span>), meals.index(</span>'lunch'</span>)
</span></code></pre>
In this case we want to swap 'dinner'</code> at index 1 with 'lunch'</code> at index 2. These indexes are now stored in the variables i</code> and j</code>.</p>
In Python a sweet one-liner will suffice to swap the items in the list.</p>
meals[i], meals[j] </span>= </span>meals[j], meals[i]
</span></code></pre>
This puts the list meals</code> in the proper order.</p>
meals </span>= </span>[</span>'breakfast'</span>, </span>'dinner'</span>, </span>'lunch'</span>]
</span>i, j </span>= </span>meals.index(</span>'dinner'</span>), meals.index(</span>'lunch'</span>)
</span>meals[i], meals[j] </span>= </span>meals[j], meals[i]
</span>
</span>print</span>(meals)
</span># => ['breakfast', 'lunch', 'dinner']
</span></code></pre>
Be aware that this works for lists, and not tuples. Since tuples are not mutable and lists are.</p>


Go to the end of the file in vim
2020-10-29T00:00:00+00:00
Let's jump!</p>
To the end of a file.</p>
In Vim!</p>
Before you can jump to the end if a file in Vim you need to make sure you are in NORMAL mode first. So if you're not yet, quit out of your current mode first. Most likely you need to quit our of INSERT mode first by pressing Esc</code>.</p>
If you did so you can jump all the way to the end of the file with:</p>
Shift</code>+G</code></p>
If you rather just move to the bottom of the screen, your friend is:</p>
Shift</code>+L</code></p>


How to write a good user story
2020-10-28T00:00:00+00:00
If you're in software development these days you probably come across user stories at some point. In case you do, what makes a good one?</p>
But first off, some background on what a user stories actually are and why people use them.</p>
The Story Of User Stories</strong></p>
The story of user stories is basically a story about miscommunications on software requirements. When you're building a software system that fills the needs of others, you base requirements of that system on those needs. To do so you need information. If that information is encapsulated in tech speak requirements start to look like; "Just call endpoint X and parse to Y".</p>
That's not what you want, if</strong></u> someone not understanding your tech speak is reading along. Going too far to the other direction is just as worse and causing developers to not understand what they are building.</p>
So became the user story. Which describes the value of a functionality for the system from the perspective of someone who interacts with the system. This someone is typically categorized, like for example customer, gymnast and developer.</em></p>
An example of a user story would be: as a customer I can pay with my credit card.</em></p>
So what do you gain with this? Not much per se. There are alternatives available that are just as good. The value comes from a common structure. If done properly you can rely on the fact that each user story has a similar amount of information in a known format.</p>
So what makes a good user story?</h3>
Now that we have a grasp of what a user story is. What makes a good one? So generally you want user stories to be:</p>

Written from the perspective of one user.</li>
Describing a function (not a solution).</li>
Scoped to one function.</li>
Describing a purpose of the function.</li>
Not overlapping with other stories.</li>
Contained, necessary information for developers and non-developers is present in the user story.</li>
</ul>
Learn more</h2>
If you can't get enough of user stories... there are some books I can recommend:</p>

User Stories Applied</a></li>
User Story Mapping</a></li>
Software Estimation: Demystifying the Black Art</a></li>
</ul>


Get the Python version number from code
2020-10-27T00:00:00+00:00
Outputting the Python version on the shell is straightforward, and you do it just like how you get the version of other programs.</p>
$ python --version
</span>Python 3.8.5
</span></code></pre>
Getting this version number in a script can be useful as well. But you have multiple options there.</p>
One coming close to the one we saw above is by using the python_version()</code> function from the platform</code> module.</p>
from </span>platform </span>import </span>python_version
</span>
</span>print</span>(python_version())
</span># => 3.8.5
</span></code></pre>
More detailed ones are found in the sys</code> module.</p>
from </span>sys </span>import </span>version
</span>
</span>print</span>(version)
</span># => 3.8.5 (default, Jul 28 2020, 12:59:40)
</span># => [GCC 9.3.0]
</span></code></pre>
This shows a more detailed string containing version info. Together with the compiler that was used.</p>
If you programmatically want to do something with the version number you can better use something other than sys.version()</code>.</p>
That something else might be sys.version_info</code>. It returns always five components of the version number. Nicely in a tuple.</p>
from </span>sys </span>import </span>version_info
</span>
</span>print</span>(version_info)
</span># => sys.version_info(major=3, minor=8, micro=5, releaselevel='final', serial=0)
</span></code></pre>
Checking for python version 2 or 3</h3>
If checking for Python version 2 is still a thing, you can easily do it with the version_info</code> function.</p>
from </span>sys </span>import </span>version_info
</span>
</span>if </span>version_info.major </span>== </span>3</span>:
</span>    </span>print</span>(</span>'Running Python 3'</span>)
</span>elif </span>version_info.major </span>== </span>2</span>:
</span>    </span>print</span>(</span>'Running Python 2'</span>)
</span></code></pre>


Returning JSON responses with Flask
2020-10-26T00:00:00+00:00
My most common use case for Flask is making APIs. And I like my APIs to respond with JSON. Flask comes with a jsonify()</code> function that returns JSON as a Flask Response object.</p>
The reason to use jsonify()</code> over a regular json.dumps()</code> is that jsonify()</code> sets the Content-Type</code> HTTP header to application/json</code>. Whereas the output of json.dumps()</code> is just plain text.</p>
An example of responding with JSON is shown below. You can pass a dict or a list to the jsonify()</code> function. This is then transformed to a JSON string.</p>
from </span>flask </span>import </span>Flask, jsonify
</span>
</span>app </span>= </span>Flask(__name__)
</span>
</span>
</span>@app.route(</span>'/chopstick/'</span>)
</span>def </span>chopstick</span>():
</span>    chopstick </span>= </span>{
</span>        </span>'color'</span>: </span>'bamboo'</span>,
</span>        </span>'left_handed'</span>: </span>True
</span>    }
</span>
</span>    </span>return </span>jsonify(chopstick)
</span>
</span>
</span>if </span>__name__ </span>== </span>'__main__'</span>:
</span>    app.run()
</span></code></pre>
The above example returns the following JSON object if we call the /chopstick/</code> endpoint.</p>
$ curl localhost:5000/chopstick/
</span>{
</span>  "color": "bamboo",
</span>  "left_handed": true
</span>}
</span></code></pre>
Alternatively you can use keyword arguments as well with jsonify()</code>. So the following produces the same end result.</p>
@app.route(</span>'/chopstick/'</span>)
</span>def </span>chopstick</span>():
</span>    </span>return </span>jsonify(
</span>        </span>color</span>=</span>'bamboo'</span>,
</span>        </span>left_handed</span>=</span>True
</span>    )
</span></code></pre>
Adding status codes to a JSON response</h2>
This jsonify()</code> is nice and all, but it doesn't give us the opportunity the set a status code for the response we are returning.</p>
Lets say for example that we want the /chopstick/</code> endpoint to work with a chopstick id. In case the id isn't found in the URI we want to return a 400 status for a bad request.</p>
So to illustrate, let say the chopstick function is responsible for handling both the /chopstick/</code> and /chopstick/<id></code> routes. If the chopstick_id</code> is None</code>, so not present in the URI, we return a 400 status with a appropriate error message.</p>
@app.route(</span>'/chopstick/'</span>)
</span>@app.route(</span>'/chopstick/<int:chopstick_id>'</span>)
</span>def </span>chopstick</span>(</span>chopstick_id</span>=</span>None</span>):
</span>    </span>if not </span>chopstick_id:
</span>        </span>return </span># status 400 - bad request
</span>
</span>    </span>return </span>jsonify(
</span>        </span>id</span>=</span>chopstick_id,
</span>        </span>color</span>=</span>'bamboo'</span>,
</span>        </span>left_handed</span>=</span>True</span>,
</span>    )
</span></code></pre>
To do so we can use the make_response()</code> function in Flask. We still make use of jsonify()</code> in combination with this make_response()</code> so that the error message is a correct JSON string.</p>
from </span>flask </span>import </span>Flask, jsonify, make_response
</span>
</span>app </span>= </span>Flask(__name__)
</span>
</span>
</span>@app.route(</span>'/chopstick/'</span>)
</span>@app.route(</span>'/chopstick/<int:chopstick_id>'</span>)
</span>def </span>chopstick</span>(</span>chopstick_id</span>=</span>None</span>):
</span>    </span>if not </span>chopstick_id:
</span>        message </span>= </span>jsonify(</span>message</span>=</span>'"chopstick_id" missing'</span>)
</span>        </span>return </span>make_response(message, </span>400</span>)
</span>
</span>    </span>return </span>jsonify(
</span>        </span>id</span>=</span>chopstick_id,
</span>        </span>color</span>=</span>'bamboo'</span>,
</span>        </span>left_handed</span>=</span>True</span>,
</span>    )
</span>
</span>
</span>if </span>__name__ </span>== </span>'__main__'</span>:
</span>    app.run()
</span>
</span></code></pre>
If we now curl the endpoint without an ID we see the error message with the 400 status code as response.</p>
$ curl</span> -i</span> localhost:5000/chopstick/
</span>HTTP/1.0 400 BAD REQUEST
</span>Content-Type: application/json
</span>Content-Length: 44
</span>Server: Werkzeug/1.0.1 Python/3.8.5
</span>Date: Sun, 25 Oct 2020 09:04:22 GMT
</span>
</span>{
</span>  </span>"message"</span>: </span>"</span>\"</span>chopstick_id</span>\"</span> missing"
</span>}
</span>
</span></code></pre>
And ofcourse, the chopstick itself is returned with status 200 if we do specify an ID in the URI.</p>
$ curl</span> -i</span> localhost:5000/chopstick/5
</span>HTTP/1.0 200 OK
</span>Content-Type: application/json
</span>Content-Length: 60
</span>Server: Werkzeug/1.0.1 Python/3.8.5
</span>Date: Sun, 25 Oct 2020 09:05:57 GMT
</span>
</span>{
</span>  </span>"color"</span>: </span>"bamboo"</span>,
</span>  </span>"id"</span>: 5,
</span>  </span>"left_handed"</span>: true
</span>}
</span></code></pre>
Flask Version</strong></p>
$ flask</span> --version
</span>Python 3.8.5
</span>Flask 1.1.2
</span>Werkzeug 1.0.1
</span></code></pre>


Check if a list is empty in Python
2020-10-25T00:00:00+00:00
Testing whether a list is empty is quite straightforward in Python. In the context of a if</code> or while</code> statement an empty list will be evaluated as False</code>. Like how empty strings or empty dicts are evaluated as False</code> as well.</p>
glass </span>= </span>[]
</span>
</span>if not </span>glass:
</span>    </span>print</span>(</span>'Glass is empty'</span>)
</span>
</span># => Glass is empty
</span></code></pre>
The PEP8 style guide</a> prefers the option as shown above. But in case you rather do a more explicit check the following will do. By comparing with []</code> we know for sure that glass</code> is a list.</p>
glass </span>= </span>[]
</span>
</span>if </span>glass </span>== </span>[]:
</span>    </span>print</span>(</span>'Glass is empty'</span>)
</span>
</span># => Glass is empty
</span></code></pre>
Another option is using the len()</code> function in case you rather be somewhat explicit. This way we validate that glass</code> is at least a sequence(str, list, tuple, ...).</p>
glass </span>= </span>[]
</span>
</span>if </span>len</span>(glass) </span>== </span>0</span>:
</span>    </span>print</span>(</span>'Glass is empty'</span>)
</span>
</span># => Glass is empty
</span></code></pre>


Print the name of the running Bash script
2020-10-24T00:00:00+00:00
When writing a Bash script you might be wanting to get the file name of the script. For outputting an error message this is useful for example. As is shown below.</p>
$ ls --pizza
</span>ls: unrecognized option '--pizza'
</span>Try 'ls --help' for more information.
</span></code></pre>
The full name of the script is stored in $0</code>. So the following script would work.</p>
#!/bin/bash
</span>
</span>script_name</span>=</span>$0
</span>echo </span>$script_name
</span></code></pre>
$ ./bin/h4ckerman
</span>./bin/h4ckerman
</span></code></pre>
However it gives you the full path as shown above. For me, I am mostly interested in just the file name of the script. This is where basename</code> comes in. basename</code> is a shell program available, and it gives you the base name... duh.</p>
#!/bin/bash
</span>
</span>script_name</span>=</span>$(basename $0)
</span>echo </span>$script_name
</span></code></pre>
$ ./bin/h4ckerman
</span>h4ckerman
</span></code></pre>
That's more like it.</p>
Another option that produces the same result as above is by using ${0##*/}</code>. ${0##*/}</code> makes use of parameter expansion in Bash. With ${0##*/}</code> you drop the longest substring (match) till the last /</code> for parameter $0</code>.</p>
#!/bin/bash
</span>
</span>script_name</span>=</span>${0</span>##*</span>/}
</span>echo </span>$script_name
</span></code></pre>
$ ./bin/h4ckerman
</span>h4ckerman
</span></code></pre>
Another option would be to use the $BASH_SOURCE</code> variable instead of $0</code>. However, as the name implies, this is functional in Bash and not POSIX compliant. So it wouldn't function per se in a shell that isn't Bash.</p>
But as long you know for sure the script is only to run in Bash, you might as well use it.</p>
Also be aware that $0</code> stores the name of how the script was called. Which isn't the same as the path of the actual script file, in case the script was symlinked.</p>
In case that matters for your use case you can use the following:</p>
echo </span>$(basename $(readlink</span> -nf </span>$0))
</span></code></pre>
Learning more</h2>
The best way to learn more is to use Bash. A lot. Don't forget that Google is your friend.</p>
In case you learn well from books I would recommend these.</p>

The Linux Command Line: A Complete Introduction</a></li>
Learning the bash Shell: Unix Shell Programming</a></li>
</ul>


Replication using a Django database router
2020-10-23T00:00:00+00:00
In Django it is perfectly fine to interact with multiple databases in your project. Django uses the concepts database routers to determine which database should be used for which model.</p>
These database routers can be leveraged to in a master-replica database setup.</p>

Be aware that this setup doesn't take replication lag into account.</p>
</blockquote>
To get starter lets first add multiple databases to the settings. A master database set to default</code> and the replica using the replica</code> key.</p>
DATABASES </span>= </span>{
</span>    </span>'default'</span>: {
</span>        </span>'NAME'</span>: </span>'django'</span>,
</span>        </span>'ENGINE'</span>: </span>'django.db.backends.mysql'</span>,
</span>    },
</span>    </span>'replica'</span>: {
</span>        </span>'NAME'</span>: </span>'django'</span>,
</span>        </span>'ENGINE'</span>: </span>'django.db.backends.mysql'</span>,
</span>    },
</span>}
</span></code></pre>
You could use master</code> instead of default</code> as well. But Django requires that a database entry be defined with the default</code> key is defined. If you prefer to do so you can set default</code> to an emply dict.</p>
Now we can move on to the database router itself. The database router should be a class that implements the methods: db_for_read</code>, db_for_write</code>, allow_relation</code>, allow_migrate</code>.</p>
A database router that supports replication might look as follows.</p>
import </span>random
</span>from </span>django.conf </span>import </span>settings
</span>
</span>class </span>ReplicationRouter</span>:
</span>    </span>def </span>db_for_read</span>(</span>self</span>, </span>model</span>, </span>**</span>hints</span>):
</span>        </span>"""
</span>        Randomly pick a database to read from
</span>        """
</span>        </span>return </span>random.choice([key </span>for </span>key </span>in </span>settings.DATABASES])
</span>
</span>    </span>def </span>db_for_write</span>(</span>self</span>, </span>model</span>, </span>**</span>hints</span>):
</span>        </span>"""
</span>        Always send write queries to the master database.
</span>        """
</span>        </span>return </span>'default'</span>;
</span>
</span>    </span>def </span>allow_relation</span>(</span>self</span>, </span>obj1</span>, </span>obj2</span>, </span>**</span>hints</span>):
</span>        </span>"""
</span>        This isn't really applicable for this use-case.
</span>        """
</span>        </span>return </span>True
</span>
</span>    </span>def </span>allow_migrate</span>(</span>self</span>, </span>db</span>, </span>app_label</span>, </span>model_name</span>=</span>None</span>, </span>**</span>hints</span>):
</span>        </span>"""
</span>        Only allow migration operations on the master database, just in case.
</span>        """
</span>        </span>if </span>db </span>== </span>'default'</span>:
</span>            </span>return </span>True
</span>        </span>return </span>None
</span>
</span></code></pre>
The allow_relation</code> and allow_migrate</code> aren't really applicable for replication. Those have a use-case for when you use different databases for different Django apps.</p>
Important for our use-case of replication are db_for_read</code> and db_for_write</code>. The db_for_read</code> method should return the database that should be used for a read operation. While db_for_write</code> specifies the database that should be used for a write operation.</p>
First off the database for write operations. In case Django needs to execute a write operation we want this query to end up at the master database. Because we should never write to the replica!</p>
We simply specify the key in the DATABASES</code> dict of the master database. This way only the master database will receive write queries.</p>
def </span>db_for_write</span>(</span>self</span>, </span>model</span>, </span>**</span>hints</span>):
</span>    </span>return </span>'default'</span>;
</span></code></pre>
Second is specifying the database read operations can be propagated to. For this we randomly select a database that is set in DATABASES</code>. This way read queries should be evenly distributed between the master and the replica.</p>
def </span>db_for_read</span>(</span>self</span>, </span>model</span>, </span>**</span>hints</span>):
</span>    </span>return </span>random.choice([key </span>for </span>key </span>in </span>settings.DATABASES])
</span></code></pre>
This does assume that all databases are used for replication though.</p>
The last thing we need to do is specifying the database router in the settings. You can add a database router by setting DATABASE_ROUTERS</code>.</p>
DATABASE_ROUTERS </span>= </span>[</span>'path.to.ReplicationRouter'</span>]
</span></code></pre>


Run the Django server on a different port
2020-10-22T00:00:00+00:00
If you start your Django development server it runs on port 8000 by default.</p>
$ python manage.py runserver
</span>Watching for file changes with StatReloader
</span>Performing system checks...
</span>
</span>System check identified no issues (0 silenced)</span>.
</span>October 19, 2020 - 12:19:16
</span>Django version 3.1.1, using settings </span>'api.settings'
</span>Starting development server at http://127.0.0.1:8000/
</span>Quit the server with CONTROL-C.
</span></code></pre>
To start the development server on a different port number you pass it as an argument after runserver</code>. To run the development server on port 8001 that would make the command python manage.py runserver 8001</code>.</p>
$ python manage.py runserver 8001
</span>Watching for file changes with StatReloader
</span>Performing system checks...
</span>
</span>System check identified no issues (0 silenced)</span>.
</span>October 19, 2020 - 12:20:38
</span>Django version 3.1.1, using settings </span>'api.settings'
</span>Starting development server at http://127.0.0.1:8001/
</span>Quit the server with CONTROL-C.
</span></code></pre>
You can even run multiple development servers simultaneously this way if you'd like to do so.</p>
Run on port 80</h2>
Running on port 80 can be done with some special treatment. A disclaimer first, there are probably better ways to make you site available via port 80, with a reversed proxy for example.</p>
You most likely have to use sudo</code> in order to run the server via port 80. This is where other problems may arise. If you run the command using sudo</code> the virtualenv isn't taken into account. So just running sudo python manage.py runserver 80</code> won't work if you're using virtualenv. Since the python</code> command references a different binary. One way to work around that is by using the full path to the python in your virtualenv.</p>
$ sudo /home/../venv/bin/python manage.py runserver 80
</span></code></pre>
This might have done the trick, but there is a chance you got stuck at a next problem. If you have NGINX or Apache installed on your system than port 80 is probably in use already. Giving you the following error message.</p>
Error: That port is already in use
</span></code></pre>
If that's the case you need to stop those services first. In case you're running Apache you can most likely stop it using the following command, but it may be different depending on your operating system.</p>
$ sudo service apache2 stop
</span></code></pre>
For NGINX the command would be.</p>
$ sudo service nginx stop
</span></code></pre>
Now you should be all set to run the Django development server on port 80. But again, look into reversed proxies.</p>
$ sudo /home/../venv/bin/python manage.py runserver 80
</span>Watching for file changes with StatReloader
</span>Performing system checks...
</span>
</span>System check identified no issues (0 silenced)</span>.
</span>October 19, 2020 - 12:42:55
</span>Django version 3.1.1, using settings </span>'api.settings'
</span>Starting development server at http://127.0.0.1:80/
</span>Quit the server with CONTROL-C.
</span></code></pre>
More options</h3>
For more options you can use the help option as well.</p>
$ python manage.py runserver --help
</span></code></pre>


Abort a git merge on conflicts
2020-10-21T00:00:00+00:00
When you pull in changes from your remote there is a chance you run into merge conflicts. If a merge can't be resolved using auto-merging your terminal can gets swamped with messages like:</p>
CONFLICT (content): Merge conflict in ...
</span></code></pre>
Ofcourse one option is to resolve the merge conflicts. However sometimes it is easier to just abort.</p>
You can abort a git merge with conflicts with the following command.</p>
$ git merge</span> --abort
</span></code></pre>
Now, to circumvent the merge conflicts you can use fetch</code>. If going down the road of resolving merge conflicts isn't an option.</p>
Before you do this make sure that your changes are stashed.</p>
You can fetch the latest changes from the remote, in this case called origin</code>, with the following command.</p>
$ git fetch origin </span><</span>branch</span>>
</span></code></pre>
To get these changes in your active branch you can do a hard reset which gives you the latest code from the remote you just fetched.</p>
$ git reset</span> --hard</span> origin/</span><</span>branch</span>>
</span></code></pre>


Make multiple subdirectories at once with mkdir
2020-10-20T00:00:00+00:00
The linux shell command to make a new directory. If works pretty pretty straightforward: you want to make a directory, you give the name as an argument, and you get a directory. If you want to make some subdirectories as well however mkdir</code> isn't as friendly.</p>
Lets say you want to make a directory called sub</code>, which should have a directory in it called way</code>, which in its turn should have a subdirectory called sandwich</code>.</p>
If you try it like this, mkdir starts to complain. It expects both the sub</code> and way</code> directories to exists and plans on just making the sandwich</code> directory.</p>
$ mkdir sub/way/sandwich
</span>mkdir: cannot create directory ‘sub/way/sandwich’: No such file or directory
</span></code></pre>
The boring option is to make this command into a three-parter. Make the first, second and third directory separately.</p>
$ mkdir sub
</span>$ mkdir sub/way
</span>$ mkdir sub/way/sandwich
</span></code></pre>
A faster way is to use the -p</code> option with the first command. The -p</code> option makes sure that parent directories are created as well if necessary.</p>
$ mkdir</span> -p</span> sub/way/sandwich
</span></code></pre>
And there you go.</p>
$ tree sub
</span>sub
</span>└── way
</span>    └── sandwich
</span>
</span>2 directories, 0 files
</span>
</span></code></pre>
Create multiple subdirectories with mkdir</h2>
By using braces({}</code>) you can create multiple subdirectories at once. This is actually called "Brace Expansion" and useful in other commands as well.</p>
$ mkdir</span> -p</span>  sub/{way,system}/sandwich
</span>$ tree sub
</span>sub
</span>├── system
</span>│   └── sandwich
</span>└── way
</span>    └── sandwich
</span>
</span>4 directories, 0 files
</span></code></pre>


Create a new app in a Django project
2020-10-19T00:00:00+00:00
To create a new app in Django we utilize the startapp</code> command. This creates a Django app directory with a specified app name.</p>
The app is created in by going in the root folder of your Django project and run the following command. The root folder is where the manage.py file is by the way.</p>
$ python manage.py startapp plebapp
</span></code></pre>
This results in a new directory being created named plebapp</code> with the file structure as shown below.</p>
$ tree plebapp
</span>plebapp
</span>├── admin.py
</span>├── apps.py
</span>├── __init__.py
</span>├── migrations
</span>│   └── __init__.py
</span>├── models.py
</span>├── tests.py
</span>└── views.py
</span></code></pre>
In order to use this app we are almost set. To actually include the app in our projects it has to be added to INSTALLED_APPS</code> in the settings. You can reference the new app by its name.</p>
INSTALLED_APPS </span>= </span>[
</span>    </span>...
</span>    </span>'plebapp'</span>,
</span>]
</span></code></pre>
Or by referencing the Config class you find in ./plebapp/apps.py</code>.</p>
INSTALLED_APPS </span>= </span>[
</span>    </span>...
</span>    </span>'plebapp.apps.PlebappConfig'</span>,
</span>]
</span></code></pre>


Remove None values from a list in Python
2020-10-18T00:00:00+00:00
With Python you have multiple options to remove None</code> values from a list. Those options include a basic for loop or by using list comprehension.</p>
A more readable option, by personal opinion, is to use the filter</code> function.</p>
cocktails </span>= </span>[</span>'Mojito'</span>, </span>None</span>, </span>'Pina Colada'</span>]
</span>
</span># Remove None values in list
</span>drinks </span>= </span>list</span>(</span>filter</span>(</span>None</span>, cocktails))
</span>
</span>print</span>(drinks)
</span># => ['Mojito', 'Pina Colada']
</span></code></pre>
The filter</code> function takes a function and iterable as parameters, giving it the following signature: filter(function, iterable)</code>. And the filter</code> function returns a filter object, so depending on your use-case you might want to cast it to a list again with list()</code>.</p>
All elements that in the iterable are passed to the function. If the function returns True</code> for that specific element, that element is kept present. If it returns False</code>, it is filtered out.</p>
If you pass None</code> as the function, the identity function is used instead. This causes all elements that are evaluated as False</code> to be filtered out, so besides None</code> empty strings, 0 and False</code> are too. Which can cause unwanted behavior.</p>
true_and_false </span>= </span>[</span>True</span>, </span>False</span>, </span>None</span>, </span>False</span>, </span>False</span>, </span>True</span>]
</span>true_and_false </span>= </span>list</span>(</span>filter</span>(</span>None</span>, true_and_false))
</span>
</span>print</span>(true_and_false)
</span># => [True, True]
</span></code></pre>
Thus, in the first example passing None</code> as a filter function does suffice. But in our cases you might need to be more explicit when you filter a list</a>, to do you can use list comprehension or write your own callback function.</p>
So the following example uses a lambda function to filter out None</code> values, but it keeps the False</code>'s in there as well.</p>
true_and_false </span>= </span>[</span>True</span>, </span>False</span>, </span>None</span>, </span>False</span>, </span>False</span>, </span>True</span>]
</span>
</span># Filter out values with a lambda function
</span>true_and_false </span>= </span>list</span>(</span>filter</span>(</span>lambda </span>x</span>: x </span>is not </span>None</span>, true_and_false))
</span>
</span>print</span>(true_and_false)
</span># => [True, False, False, False, True]
</span></code></pre>
And to include an example using list comprehension as well.</p>
true_and_false </span>= </span>[</span>True</span>, </span>False</span>, </span>None</span>, </span>False</span>, </span>False</span>, </span>True</span>]
</span>
</span># Filter out values with list comprehension
</span>true_and_false </span>= </span>[x </span>for </span>x </span>in </span>true_and_false </span>if </span>x </span>is not </span>None</span>]
</span>
</span>print</span>(true_and_false)
</span># => [True, False, False, False, True]
</span></code></pre>


Create a super user in Django
2020-10-17T00:00:00+00:00
If you want to login to the Django admin site you need a user with is_staff</code> or is_superuser</code> set to true. You can create a user with the super user permissions by utilizing the createsuperuser</code> command. This will prompt you for the required inputs for a user.</p>
$ python manage.py createsuperuser
</span>Username (leave blank to use </span>'koen'</span>)</span>:</span> admin
</span>Email address: admin@koenwoortman.com
</span>Password: </span>*********
</span>Password (again)</span>: </span>*********
</span>Superuser created successfully
</span></code></pre>
Using this user account you should able to login to the Django admin site. It also acts like a general user account in a normal Django project. So you're also able to use it as a login on your self-made website.</p>


Append lines to the end of a file with Bash
2020-10-16T00:00:00+00:00
At some point it is gonna be useful to write to a file with Bash. You can do so in a Bash script or directly via the command-line. To do so you use the append operator(>></code>).</p>
#!/bin/bash
</span>
</span># 1. Set the file to write to
</span>file</span>=</span>'log.txt'
</span>
</span># 2. Append text with '>>'
</span>echo </span>"[INFO] caught a bass" </span>>> </span>$file
</span></code></pre>
The >></code> appends to a file or creates the file if it doesn't exist. Don't confuse >></code> with ></code>, the latter completely overwrites a file erasing all current lines.</p>
Append command output to a file</h2>
So technically this is what we did with echo</code> as well. Where the output of the echo</code> command was appended to a file. You can use the output of other commands as well in combination with the append operator. Like the ls</code> command for example.</p>
#!/bin/bash
</span>
</span># 1. Set the file to write to
</span>file</span>=</span>'files_and_directories.txt'
</span>
</span># 2. Append text with '>>'
</span>ls </span>>> </span>$file
</span></code></pre>
Append multiple lines at once</h2>
Until so far we only appended single lines. But you might as well want to write multiple lines to a file at once. Tis a bit more cryptic however. But you can use cat</code> for this.</p>
#!/bin/bash
</span>
</span># 1. set the file to write to
</span>file</span>=</span>'log.txt'
</span>
</span># 2. Append multiple lines with '>>' and 'cat'
</span>cat </span><< EOT >> </span>$file
</span>[INFO] caught a bass
</span>[INFO] and released the bass
</span>EOT
</span></code></pre>
Learning more</h2>
The best way to learn more is to use Bash. A lot. Don't forget that Google is your friend.</p>
In case you learn well from books I would recommend these.</p>

The Linux Command Line: A Complete Introduction</a></li>
Learning the bash Shell: Unix Shell Programming</a></li>
</ul>


Tmux sessions should be nested with care, unset $TMUX to force
2020-10-15T00:00:00+00:00
If you try to start a new tmux session from within a tmux session you get the error message sessions should be nested with care, unset $TMUX to force</code>. So what does this mean?</p>
It basically means that tmux doesn't like it if you nest a tmux session in an already active tmux session. Doesn't mean it is impossible to do so. You can nest a tmux session by unsetting $TMUX, helpful error message right. You do this as follows:</p>
$ TMUX=</span>''</span> tmux
</span></code></pre>
This gets you a new tmux session inside your currently active tmux window.</p>
More likely the way to go is to detach from your current session</a> first with tmux detach</code>.</p>
Create and attach to tmux session in shell script</h3>
If you're writing a shell script that switches or attaches to a tmux session depending on whether you're in tmux or not you can do that as follows.</p>

First you check if a tmux session exists with a given name.</li>
Create the session if it doesn't exists.</li>
Attach if outside of tmux, switch if you're in tmux.</li>
</ol>
#!/bin/bash
</span>
</span>session_name</span>=</span>"sesh"
</span>
</span># 1. First you check if a tmux session exists with a given name.
</span>tmux has-session</span> -t</span>=</span>$session_name </span>2</span>></span> /dev/null
</span>
</span># 2. Create the session if it doesn't exists.
</span>if </span>[[ </span>$? </span>-ne</span> 0 </span>]]</span>; then
</span>  TMUX</span>=</span>'' </span>tmux new-session</span> -d -s </span>"$session_name"
</span>fi
</span>
</span># 3. Attach if outside of tmux, switch if you're in tmux.
</span>if </span>[[ </span>-z </span>"$TMUX" </span>]]</span>; then
</span>  tmux attach</span> -t </span>"$session_name"
</span>else
</span>  tmux switch-client</span> -t </span>"$session_name"
</span>fi
</span>
</span></code></pre>
A logical improvement to make based on this script is to get the session name from an argument to your script. So instead of hardcoding the tmux session name to "sesh" you would use the value in $1</code> for example.</p>


Start tmux session with specified name
2020-10-14T00:00:00+00:00
When you start a new tmux session, by default tmux starts naming sessions with a number. So your sessions will be names 0, 1, 3,...</p>
Often I'd like to name my accordingly, related to the project and/or environment that I'm working on. The tmux session I have running now is called blog</code> for example.</p>
You can control the name of the session by starting a new session as follows.</p>
$ tmux new</span> -s</span> blog
</span></code></pre>
The tmux session that will be created is named blog</code> in this case. The -s</code> option is for session, I hope that is easy enough to remember :).</p>
Renaming a tmux sessions is pretty straightforward as well. You can read here</a> how to do so.</p>


Start numbering tmux windows from index one
2020-10-13T00:00:00+00:00
With tmux the windows you create start counting from 0. I know this is kind of the default for programming related things. However in this case it doesn't feel really intuitive to me. Mostly because I'm using these indices to move to a specific window.</p>
You can let tmux know that you rather start numbering windows and panes from one instead of zero by putting the following in your ~/.tmux.conf</code> file.</p>
# ~/.tmux.conf
</span>
</span># Start numbering windows from index 1
</span>set -g base-index 1
</span>
</span># Start numbering panes from index 1
</span>setw -g pane-base-index 1
</span>
</span></code></pre>


Show current git branch in tmux status bar
2020-10-12T00:00:00+00:00
For a while I had my current git branch name showing in my ZSH prompt. Which you can pretty easily do if you use something like oh-my-zsh for example. But it became a bit too cluttering for me after some time. Both the width of the prompt and seeing the branch for each command bother me a bit.</p>
Since I am practically always in a tmux session anyway I wanted to see if I could show the current git branch in the tmux status bar. The following was inspired by an answer on StackExchange</a>.</p>
By adding the following lines to your ~/.tmux.conf</code> file you get the current git branch in the right corner of my tmux status bar.</p>
# ~/.tmux.conf
</span>
</span>set -g status-right "#(cd #{pane_current_path}; git rev-parse --abbrev-ref HEAD)"
</span>set -g status-right-length 200
</span></code></pre>
For one project we use very long branch names, generated by bitbucket based on a JIRA issue title... ugg. So I had to increase the length of status-right</code> for the branch name not to be cut off somewhere in the middle. The number 200 is taken somewhat out of the air.</p>


Switching tmux windows faster with alt+number
2020-10-11T00:00:00+00:00
I'm switching quite often. So the default tmux binding of <prefix> <number></code> starts to feel a bit expensive. I therefor decided that I wanted to switch tmux windows with alt+<number></code> instead.</p>
This is pretty similar to how I switch workspaces in i3, my window manager (I should checkout sway once, heard it was nice). And the same as in Google Chrome actually.</p>
You can add these alt+number keybindings by putting the following in your ~/.tmux.conf</code> file.</p>
# ~/.tmux.conf
</span>
</span># Switch windows alt+number
</span>bind-key -n M-1 select-window -t 1
</span>bind-key -n M-2 select-window -t 2
</span>bind-key -n M-3 select-window -t 3
</span>bind-key -n M-4 select-window -t 4
</span>bind-key -n M-5 select-window -t 5
</span>bind-key -n M-6 select-window -t 6
</span>bind-key -n M-7 select-window -t 7
</span>bind-key -n M-8 select-window -t 8
</span>bind-key -n M-9 select-window -t 9
</span></code></pre>


Remapping the split window keys in tmux
2020-10-10T00:00:00+00:00
In tmux you can split your panes horizontally with <prefix> "</code> and vertically with <prefix> %</code> by default. I quite often forgot these keybindings so wanted to remap them to something more meaningful.</p>
I decided on <prefix> -</code> to split vertically and on <prefix> \</code> to split horizontally. I would prefer |</code> over \</code>, but it requires me to press an extra key.</p>
This seems counterintuitive, because well, a hyphen(-</code>) is horizontal and a backslash(\</code>) is vertical. But if you see how tmux splits windows it makes more sense.</p>
A tmux window that is split horizontally looks as follows. It is split from left to right, with a pane border in the middle. Hence the backslash.</p>
+–––––––––+–––––––––+
</span>|         |         |
</span>|         |         |
</span>|         |         |
</span>|         |         |
</span>|         |         |
</span>+–––––––––+–––––––––+
</span></code></pre>
You can add the bindings for <prefix> -</code> and <prefix> \</code> by putting the following in your ~/.tmux.conf</code> file. I unbind the default bindings as well, so I can reuse them for something else if I need to.</p>
# ~/.tmux.conf
</span>
</span># Split panes with \ and -
</span>bind \\ split-window -h -c "#{pane_current_path}"
</span>bind - split-window -v -c "#{pane_current_path}"
</span>unbind '"'
</span>unbind %
</span></code></pre>
Take notice that you need to escape the backslash, that's where the bind \\</code> comes from.</p>
In most cases I like the new split to be in the directory as I am currently in. So I added the option -c "#{pane_current_path}"</code> to do so. If you don't prefer this you're set with the following configuration.</p>
# ~/.tmux.conf
</span>
</span># Split panes with \ and -
</span>bind \\ split-window -h
</span>bind - split-window -v
</span>unbind '"'
</span>unbind %
</span></code></pre>
Learn more</h2>
A great resource for learning more about tmux are its man pages. You can read them online here</a> or from the command-line using the following command:</p>
$ man tmux
</span></code></pre>
Or take a look at this book:</p>

Tmux 2: Productive Mouse-Free Development</a></li>
</ul>


Adding parameters to routes in Flask
2020-10-09T00:00:00+00:00
Parameters in Flask routes are surrounded by <</code> and ></code>. The name you use for the parameter it is passed to the routing function as keyword argument.</p>
@app.route(</span>'/<resource>'</span>)
</span>def </span>list_view</span>(</span>resource</span>):
</span>    </span>return </span>"</span>{}</span>"</span>.format(resource)
</span></code></pre>
Converter types</h2>
You can constrain parameters using converter types. The options for converter types are string</code>, int</code>, float</code>, path</code> and uuid</code>. You include them as follows.</p>
@app.route(</span>'/<string:resource>'</span>)
</span>def </span>list_view</span>(</span>resource</span>):
</span>    </span>return </span>"</span>{}</span>"</span>.format(resource)
</span></code></pre>
Flask Version</strong></p>
$ flask</span> --version
</span>Python 3.8.5
</span>Flask 1.1.2
</span>Werkzeug 1.0.1
</span></code></pre>


Multiple Flask routes to same function
2020-10-08T00:00:00+00:00
In some cases you can reuse a Flask route function for multiple URLs. Or you want the same page/response available via multiple URLs. In that case you can add a second route to the function by stacking a second route decorator to the function.</p>
The code below shows how you use the a function for multiple URLs. In case you're using parameters in one of your routes</a> make sure to provide a default value of the function argument.</p>
@app.route(</span>'/chopsticks/'</span>)
</span>@app.route(</span>'/chopsticks/<int:chopstick_id>'</span>)
</span>def </span>chopsticks_view</span>(</span>chopstick_id</span>=</span>None</span>):
</span>    </span>if </span>chopstick_id:
</span>        </span>return </span>"Chopstick </span>{}</span>"</span>.format(chopstick_id)
</span>    </span>return </span>"Chopstick list"
</span></code></pre>
Flask Version</strong></p>
$ flask</span> --version
</span>Python 3.8.5
</span>Flask 1.1.2
</span>Werkzeug 1.0.1
</span></code></pre>


Checkout git branches faster with fzf
2020-10-07T00:00:00+00:00
In large git repo's I find myself sometimes lost in switching branches. For this project I work on using Bitbucket we use branch names starting with a JIRA issue number. This makes relying on Tab-completion harder. I ain't got time to remember JIRA issue numbers.</p>
This is where fzf</code> comes in, a fuzzy finder for the command-line. You can find the GitHub repo here</a>.</p>
You can pipe lines to fzf</code> and it gives you an interactive input prompt you can use to filter.</p>
$ git branch </span>| </span>fzf
</span>></span> juice
</span>  29/29
</span>></span>   XY-8435-create-juice-model
</span>    XY-5193-fix-juice-form-fields
</span></code></pre>
The above example just outputs the branch name you select. In this case it filtered the branches that were listed using git branch</code> on the keyword juice</code>.</p>
In order for this to be somewhat useful you need to combine it with a git checkout</code>. In order to do so you can use the following. Where the output of $(git branch | fzf)</code> is used as argument to the checkout</code> subcommand.</p>
$ git checkout $(git branch </span>| </span>fzf)
</span>Switched to branch </span>'master'
</span></code></pre>
So this already does the job. As you see above you can switch branches like this. There is a problem with this however and is has to do with the outputs of git branch</code>.</p>
$ git branch
</span>  develop
</span>* master
</span></code></pre>
As you see the current branch is marked with an asterisk(*</code>). Eventhough it is unlikely I would want to try to switch my current branch. Actually I would never want that. But just to make it prone to typo's, lets fix it.</p>
$ git checkout $(git branch </span>| </span>fzf)
</span>error: pathspec </span>'master'</span> did not match any file(s) known to git
</span></code></pre>
If I would select master</code>, my current branch, in fzf</code> it would give me the error shown above. Since the output of fzf</code> contains the asterisk too. See the snippet bellow. Where I selected master in fzf</code>.</p>
$ git branch </span>| </span>fzf
</span>* master
</span></code></pre>
So we have to get the branch names in some other way to not have the asterisk showing up. In git we can use a lesser known, for-each-ref</code> command and format the output as follows.</p>
$ git for-each-ref refs/heads/</span> --format</span>=</span>'%(refname:short)'
</span>master
</span>develop
</span></code></pre>
I can use that command as a substitute for git branch</code>. If I now try to switch to my current branch I get a more appropriate message.</p>
$ git checkout $(git for-each-ref refs/heads/</span> --format</span>=</span>'%(refname:short)' </span>| </span>fzf)
</span>Already on </span>'master'
</span>Your branch is up to date with </span>'origin/master'
</span></code></pre>
Cool, that works too! So we are finished but it turned into one hell of a command which I don't plan on typing out ever. Instead I created a separate script.</p>
For me this script is at ~/Code/bin/interactive-checkout</code>, this works for me because I have the directory ~/Code/bin</code> added to my path.</p>
The script interactive-checkout</code> has the following contents.</p>
#!/bin/bash
</span>
</span>git checkout $(git for-each-ref refs/heads/</span> --format</span>=</span>'%(refname:short)' </span>| </span>fzf)
</span></code></pre>
Now I can use interactive-checkout</code> as a command instead of git checkout $(git for-each-ref refs/heads/ --format='%(refname:short)' | fzf)</code> and I can potentially bind it to an alias as well.</p>
Don't forget to make the script executable with chmod</code> :-).</p>


How to add an item at the beginning of a list in Python
2020-10-06T00:00:00+00:00
Where you add an item to the end of a list with append()</code>. You can use insert()</code> to insert an item at the beginning of a list in Python.</p>
The insert function takes two arguments. First the index of where the item should be inserted and second the actual item that should be inserted.</p>
So the signature of the insert()</code> function is as follows:</p>
list.insert(index, item)</code></p>
You use the insert()</code> function actually to insert an item at any position, depending on the index you pass to it.</p>
Since we want to add an item at the first position of the list we pass 0</code> as the first argument.</p>
pizza_toppings </span>= </span>[</span>'cheese'</span>, </span>'tuna'</span>]
</span>
</span>pizza_toppings.insert(</span>0</span>, </span>'tomato sauce'</span>)
</span>
</span>print</span>(pizza_toppings)
</span># => ['tomato sauce', 'cheese', 'tuna']
</span></code></pre>
The above example added "tomato sauce"</code> in the first position of the pizza_topping</code> list. Now the list makes sense.</p>


How to get the index of an item in a Python list
2020-10-05T00:00:00+00:00
Suppose you want to find the index of an item in a list in Python. You can use the built-in index()</code> function to do so. The index()</code> function takes the item you want to search for as its first argument.</p>
So the signature of the index()</code> function is as follows:</p>
list.index(key [, start[, end]])</code></p>
The start</code> and end</code> arguments are optional actually. You use those to specify the range of the list you want to search. By default the index()</code> function searches the whole lists.</p>
pizza_toppings </span>= </span>[</span>'tomato sauce'</span>, </span>'cheese'</span>, </span>'tuna'</span>]
</span>
</span>index </span>= </span>pizza_toppings.index(</span>'cheese'</span>)
</span>
</span>print</span>(index)
</span># => 1
</span></code></pre>


Merge multiple Python lists into one
2020-10-04T00:00:00+00:00
Merging Python lists together is as easy as using the +</code>.</p>
orders </span>= </span>[</span>'cheeseburger'</span>] </span>+ </span>[</span>'soda'</span>]
</span>
</span>print</span>(orders)
</span># => ['cheeseburger', 'soda']
</span></code></pre>
You can leverage the extend()</code> function for this purpose as well. You call it on the list you want to extend and pass it a list.</p>
orders.extend([</span>'fries'</span>])
</span>
</span>print</span>(orders)
</span># => ['cheeseburger', 'soda', 'fries']
</span></code></pre>
Be aware that you pass it a list, not just a string. If you pass it just a string all the characters get inserted individually.</p>
orders.extend(</span>'fries'</span>)
</span>
</span>print</span>(orders)
</span># => ['cheeseburger', 'soda', 'f', 'r', 'i', 'e', 's']
</span></code></pre>


Change a commit message in git
2020-04-06T00:00:00+00:00
Messing up your commit message is something that happens every now and then. Git allows you to make changes to your last commit by using the --amend</code> option.</p>
$ git commit --amend
</span></code></pre>
This will open the default editor that you configured with the message of your previous commit. In here you just change the message and exit out your editor. And voilà, commit message changed.</p>
You can use the -m</code> option as well, to set the message directly from the command line.</p>
$ git commit --amend -m "Hold your horses, bugfix incoming"
</span></code></pre>
Be aware</strong> that --amend</code> adds the changes you staged to the commit. So if this is not desired you need to either unstage the changes or stash them for the time being.</p>
If you have pushed the commit to a remote before and try to push again, Git will reject</strong> your push. In that case you need to use git push --force</code>. You need to be careful with this. Using --force</code> overwrites the history of your remote. Also, if others already based their work on your commit they might not be happy.</p>
You might have noticed that the timestamp of the commit didn't change. If you want to update the timestamp too, you can set the GIT_COMMITTER_DATE</code> environment variable before running the command.</p>
GIT_COMMITTER_DATE="Wed Apr 03 15:00 2020 +0100" git commit --amend
</span></code></pre>
If the commit message you want to change isn't from the last commit things get more tricky. The easiest way I found is using an interactive rebase. Find the commit hash of the commit before</strong> the one you'd like to change.</p>
git rebase -i 9bef4f8
</span></code></pre>
In the editor that opens, change the pick</code> command for edit</code> for the commit you want to change.</p>
edit 9e48a07 %$#^$%
</span>pick 2142d46 Perfect...
</span>pick 10da46d Hacky code, might be buggy
</span>pick 5ba932b Hold your horses, bugfix incoming
</span>
</span># Rebase 9bef4f8..5ba932b onto 5ba932b (4 commands)
</span>#
</span># Commands:
</span># ...
</span></code></pre>
You are now in the past. You can make changes on top of commit 9e48a07</code>. Or... just change the commit message. We will do that for now.</p>
$ git commit --amend -m "Enjoy your code, Sir"
</span></code></pre>
Now that we changed the message we need to rebase the commits that came next on this new change.</p>
$ git rebase --continue
</span></code></pre>
So, did that work? Lets find out.</p>
$ git log --abbrev-commit --pretty=oneline
</span>5ba932b (HEAD -> master) Hold your horses, bugfix incoming
</span>10da46d Hacky code, might be buggy
</span>2142d46 Perfect...
</span>9e48a07 Enjoy your code, Sir
</span>9bef4f8 We will need to rebase from here
</span></code></pre>
As you can see, the commit message has changed. As well as the commit hash. If you find yourself amending more ofter, consider adding an alias in your gitconfig.</p>
[alias]
</span>    amend = commit --amend
</span></code></pre>


Reload the tmux config
2020-04-03T00:00:00+00:00
Testing out settings in your tmux.conf file would be a pain if you had to kill and restart tmux each time.</p>
You see the changes you made by sourcing ~/.tmux.conf</code>. To source the fie you need to be in command mode. To start the command mode use <prefix> :</code>. Now type in :source-file ~/.tmux.conf</code> and hit enter. This should affect all your tmux sessions. Restarting the tmux server shouldn't be necessary.</p>
Reload config with key binding</h3>
If you do this frequently you might want to bind the source-file</code> command to a key combination.</p>
By adding the following binding to the ~/.tmux.conf</code> file you can reload the configuration with <prefix> r</code>.</p>
bind r source-file ~/.tmux.conf; display-message "Reloaded config"
</span></code></pre>


Change the tmux prefix to ctrl+space
2020-04-01T00:00:00+00:00
Tmux uses ctrl+b as default prefix. I rather have it set to ctrl+Space. The space bar is hard to miss. And I use it as leader in VIM, so I like the consistency.</p>
To configure the prefix we need to make a change in the ~/.tmux.conf</code> file. Following the example in the tmux man pages, we make the following addition in the tmux config.</p>
# ~/.tmux.conf
</span>
</span>unbind-key C-b
</span>
</span>set-option -g prefix C-Space
</span>
</span>bind-key C-Space send-prefix
</span></code></pre>


Reattach to tmux sessions
2020-03-30T00:00:00+00:00
When you detached from tmux and want to reattach to it again you use the tmux attach</code> command. Without any argument this command reattaches tmux session that was the latest one to be detached.</p>
$ tmux attach
</span></code></pre>
attach</code> is a shorthand actually for attach-session</code>, but both do the same thing so you can use them interchangeably.</p>
When attaching to the latest detached session isn't enough you need to specify a target session to attach to. For this you need to know the session name. The session name is either a number that tmux automatically assigned to it or the name you gave with when creating the session with tmux new -s <session></code></p>
If you don't know the session ID you can find a session by listing</a> all the sessions with the tmux list-sessions</code> command.</p>
$ tmux list-sessions
</span>first_project: 4 windows (created Wed Mar  4 18:17:14 2020)
</span>second_project: 2 windows (created Wed Mar  4 19:00:55 2020)
</span></code></pre>
Now, to reattach to the session called first_project</code> use the attach</code> command with the -t</code> option.</p>
$ tmux attach</span> -t</span> first_project
</span></code></pre>
Attaching to a session while you're in tmux doesn't work. If you try it you will see the following error message: sessions should be nested with care, unset $TMUX to force</code>. Inside of tmux you can switch between sessions with tmux choose-tree</code> for example.</p>


Rename tmux sessions
2020-03-27T00:00:00+00:00
When you start a new tmux session, by default tmux uses a numerical value to name the session. This isn't all too clear, especially when we're working with multiple tmux sessions at the same time. Ofcourse you can start a named tmux session with tmux new -s sesh</code>. But the ability to rename either the default name the provided name is convenient once every while.</p>
To rename a tmux session you can use the tmux rename-session</code> command. With the argument for the -t</code> option you specify which session is the target to rename. And the second argument is the new name for the session.</p>
$ tmux rename-session</span> -t</span> old_name new_name
</span></code></pre>
The alias for rename-session</code> is simply rename</code>. Meaning that you get the same results as above with tmux rename -t old_name new_name</code>.</p>
When you are in currently in the session you want to rename you can omit the current sessions name. Tmux will assume that your current session needs to be renamed if you don't specify a target with -t</code>.</p>
$ tmux rename-session new_name
</span></code></pre>
This command works outside of tmux too. In that case the most recently used tmux session is renamed.</p>
The rename functionality can be used in the tmux command mode too. To start the command mode use <prefix> :</code>. Now enter :rename-window new_name</code> and your current tmux session is renamed to "new_name".</p>
To do the above more quickly you can use a keybinding. By default :rename-window</code> is binded to the key combination <prefix> $</code></p>


Check if a file is a symlink with Bash
2020-03-25T00:00:00+00:00
Your Bash script might need to determine if a file is a symlink or not. In Bash you can test this with the -L</code> operator that returns true if the file exists and is a symlink. Lets find out how this works by making a symchecker</code> script.</p>
#!/bin/bash
</span>
</span># 1. We create a file.
</span>touch ~/script
</span>
</span># 2. Link the created file above to the ~/bin directory.
</span>ln</span> -s </span>~/script ~/bin/script
</span>
</span># 3. Check if ~/bin/script is a symlink.
</span>if </span>[[ </span>-L </span>"$HOME/bin/script" </span>]]</span>; then
</span>  </span>echo </span>"It's a link!"
</span>fi
</span></code></pre>
$ bash symchecker
</span>It</span>'s a link!
</span></code></pre>
So we see that works. But the script isn't perfect yet. Even though we checked for an existing symlink, this doesn't guarantee that the symlink isn't broken. Meaning the file that was symlinked might not exist anymore.</p>
Before we proceed, lets clean up the symlink we created. Otherwise ln</code> will show an error message the next time we run the script. Because the link already exist.</p>
$ unlink ~/bin/script
</span></code></pre>
Lets see what I mean with broken links. We'll add a step to the symchecker script that removes the initial file but doesn't touch the symlink.</p>
#!/bin/bash
</span>
</span># 1. We create a file.
</span>touch ~/script
</span>
</span># 2. Link the created file above to the ~/bin directory.
</span>ln</span> -s </span>~/script ~/bin/script
</span>
</span># 3. Remove the initial file.
</span>rm ~/script
</span>
</span># 4. Check if ~/bin/script is a symlink.
</span>if </span>[[ </span>-L </span>"$HOME/bin/script" </span>]]</span>; then
</span>  </span>echo </span>"It's a link!"
</span>fi
</span></code></pre>
$ bash symchecker
</span>It's a link!
</span></code></pre>
And what do you know. The file where the symlink links to is removed but the test still succeeds. To include this check we use the -e</code> operator which checks if a file exist.</p>
#!/bin/bash
</span>
</span># 1. We create a file.
</span>touch ~/script
</span>
</span># 2. Link the created file above to the ~/bin directory.
</span>ln</span> -s </span>~/script ~/bin/script
</span>
</span># 3. Remove the initial file.
</span>rm ~/script
</span>
</span># 4. Check if ~/bin/script is a symlink.
</span>if </span>[[ </span>-L </span>"$HOME/bin/script" </span>&& </span>-e </span>"$HOME/bin/script" </span>]]</span>; then
</span>  </span>echo </span>"It's a link!"
</span>else
</span>  </span>echo </span>"Might be a link, but it doesn't exist!"
</span>fi
</span></code></pre>
$ bash symchecker
</span>ln: failed to create symbolic link '/home/koen/bin/script': File exists
</span>Might be a link, but it doesn't exist!
</span></code></pre>
So that did the trick. But uh oh, we didn't unbind the symlink before. Now that we have a check for valid symlinks, we might as well safe us some time and clean up a broken link if we find one.</p>
#!/bin/bash
</span>
</span># 1. We create a file.
</span>touch ~/script
</span>
</span># 2. Link the created file above to the ~/bin directory.
</span>ln</span> -s </span>~/script ~/bin/script
</span>
</span># 3. Remove the initial file.
</span>rm ~/script
</span>
</span># 4. Check if ~/bin/script is a symlink.
</span>if </span>[[ </span>-L </span>"$HOME/bin/script" </span>]]</span>; then
</span>  </span>if </span>[[ </span>-e </span>"$HOME/bin/script" </span>]]</span>; then
</span>    </span>echo </span>"It's a link!"
</span>  </span>else
</span>    unlink ~/bin/script
</span>    </span>echo </span>"Link was broken, I cleaned it up!"
</span>  </span>fi
</span>else
</span>  </span>echo </span>"Not a link!"
</span>fi
</span></code></pre>
$ bash symchecker
</span>ln: failed to create symbolic link '/home/koen/bin/script': File exists
</span>Link was broken, I cleaned it up!
</span></code></pre>
So it look liked it worked! But we still see the error message from ln</code>. Actually this is because the first time we run the script, it was still there from the previous version from the symchecker script. In which we didn't clean up. To double check, we can it a second try.</p>
$ bash symchecker
</span>Link was broken, I cleaned it up!
</span></code></pre>
Yup, that looks better. But... all what we have now is a script that:</p>

Creates a file</li>
Creates a symlink to that file</li>
Removes that file</li>
Removes the symlink</li>
</ol>
So the end result is basically nothing.</p>
Lets make the script sort of usable by letting it expect a file path as parameter. So we will end up with a script that checks if the specified file is a symlink or not and clean it up if it happens to be broken.</p>
#!/bin/bash
</span>
</span># 1. Store the first parameter to the script in a variable.
</span>path</span>=</span>"$1"
</span>
</span># 2. Now that we expect a parameter, lets check if it was provided.
</span>if </span>[[ </span>-z </span>"$path" </span>]]</span>; then
</span>  </span>echo </span>"Script expects a parameter"
</span>  </span>exit</span> 1
</span>fi
</span>
</span># 3. Check if the parameter is a symlink.
</span>if </span>[[ </span>-L </span>"$path" </span>]]</span>; then
</span>  </span># 4. Check if it links to a valid path.
</span>  </span>if </span>[[ </span>-e </span>"$path" </span>]]</span>; then
</span>    </span>echo </span>"$path is a valid link!"
</span>  </span>else
</span>    unlink </span>"$path"
</span>    </span>echo </span>"Cleaned up broken link: $path"
</span>  </span>fi
</span>else
</span>  </span>echo </span>"$path is not a symlink."
</span>fi
</span></code></pre>
$ bash symchecker ~/brokenlink
</span>Cleaned up broken link: ~/brokenlink
</span></code></pre>
There you go. An advanced symlink checker and broken link cleaner in one. All that's left is putting the script in your PATH and make is executable with chmod.</p>
Learning more</h2>
The best way to learn more is to use Bash. A lot. Don't forget that Google is your friend.</p>
In case you learn well from books I would recommend these.</p>

The Linux Command Line: A Complete Introduction</a></li>
Learning the bash Shell: Unix Shell Programming</a></li>
</ul>


Detach from tmux sessions
2020-03-23T00:00:00+00:00
In case you are in tmux and want to return back to you terminal you need to detach</strong> tmux. Doing this in the most convenient way is with the keybinding <prefix> d</code>.</p>
This will return you to your terminal and keep the tmux session running. So you can attach to it later with tmux attach</code>. If you don't want to keep the session running, than kill-session</a> is what you're looking for.</p>
If necessary, for example when you're scripting against tmux, you can use the command to detach as well. Running the command will detach your current tmux session. Optionally you can pass a different target session to the -s</code> option to detach another actively running session.</p>
$ tmux detach-client
</span></code></pre>
Tmux provides a shorter notation for the above command as well. Which is just simply detach</code>.</p>
$ tmux detach
</span></code></pre>


Counting files and directories in Linux
2020-03-20T00:00:00+00:00
The wc</code> command is one of the GNU coreutils available on Linux. wc</code> is meant to get the amount of newlines, words, bytes and characters in a file. By combining wc</code> with ls</code> or find</code> you can easily get the amount of files or directories in a directory.</p>
Counting all files and directories</h3>
We can count all the files and directories in a directory by passing the output of ls</code> to wc</code> using a pipe(|</code>). To list one file per line we use the -1</code> option for ls</code>.</p>
koen@opensuse:~</span>></span> ls</span> -1 </span>| </span>wc</span> -l
</span>18
</span></code></pre>
The example above only counts the visible directories and files. In order to include hidden files or directories we have to pass the -a</code> option to the ls</code> command.</p>
koen@opensuse:~</span>></span> ls</span> -1a </span>| </span>wc</span> -l
</span>24
</span></code></pre>
Count files only</h3>
To just count the amount of files we can't just use the ls</code> command, since it doesn't make a distinction between files and directories. We can solve this with the find</code> command. The find</code> command is meant to, well.. find directories and files.</p>
The find</code> command looks less straightforward than ls</code>. You need to specify a path, we use .</code> to find in our current working directory. Second we specify the maximum depth find</code> searches, we use 1 as an argument so find</code> will only list the contents of the current directory. To only search for files we have to specify the type f</code>. And finally, to exclude hidden files we filter out files starting with a dot.</p>
To get the amount of files we pipe the output of the find</code> command to wc</code> and we get the amount of files in the current directory.</p>
koen@opensuse:~</span>></span> find .</span> -maxdepth</span> 1</span> -type</span> f</span> -name </span>"[!.]*" </span>| </span>wc</span> -l
</span>14
</span></code></pre>
Count directories only</h3>
The same trick as the example above can be used to count the directories. We have to change the argument for -type</code> to d</code> and it works.</p>
koen@opensuse:~</span>></span> find .</span> -maxdepth</span> 1</span> -type</span> d</span> -name </span>"[!.]*" </span>| </span>wc</span> -l
</span>4
</span></code></pre>


Kill tmux sessions
2020-03-18T00:00:00+00:00
When you detach from a tmux session it keeps running, so you can reattach to it later again. However, if you don't need the session again you might as well close it for good. You can do this by killing the session.</p>
To kill a tmux sessions you use the tmux kill-session</code> command. If you don't specify a session tmux will kill the current or last active session. Depending on if you're currently in an active tmux session or not.</p>
$ tmux kill-session
</span></code></pre>
A session to kill can be specified by using the -t</code> option and use the session name as its argument.</p>
$ tmux kill-session</span> -t</span> session_one
</span></code></pre>
Kill all tmux sessions</h3>
The easiest way to kill all tmux sessions isn't with the kill-session</code> command. To kill all tmux sessions at once you can use the kill-server</code> command. This command will besides killing all the sessions also shut down the tmux server.</p>
$ tmux kill-server
</span></code></pre>
Kill all other tmux sessions</h3>
The kill-session</code> command has the option to kill all session except a specified one. For this you'll need to use the -a</code> option.</p>
In case you want to kill all tmux sessions except the current one you don't need to specify a session name. Or if you're outside of tmux, tmux will assume you want to kill the last active session. See the command below to kill all other tmux sessions.</p>
$ tmux kill-session</span> -a
</span></code></pre>
If that isn't what you want you can specify the session name yourself. For this you'll have to use the same -t</code> option as before.</p>
$ tmux kill-session</span> -at</span> pumpkin_session
</span></code></pre>


Use Visual Studio Code as git editor
2020-03-16T00:00:00+00:00
Most of the time the Git integration of Visual Studio Code will do fine. But for other functions of Git the command-line seems more efficient. Once you use git over the command-line you'll find yourself sometimes using a terminal text editor. Which might be fine for you. But if you're the integrated terminal in Visual Studio Code it might feel a bit awkward. In this case you can set Visual Studio Code as the default editor for git.</p>
During this example we will change the global git configuration. You can change the configuration on a repository level too. To do this; make sure you're in the git repository and lose the --global</code> option.</p>
Set Visual Studio code as git editor</h3>
To set Visual Studio Code as default editor you have to run the following command.</p>
$ git config</span> --global</span> core.editor </span>"code --wait"
</span></code></pre>
This adds the following configuration to your global git config.</p>
[core]
</span>    </span>editor </span>=</span> code </span>--</span>wait
</span></code></pre>
By passing the --wait</code> to the code command you tell Visual Studio Code to wait for you to close the file before returning to the terminal.</p>
Set Visual Studio code as git mergetool</h3>
Besides an editor you can set a merge tool. Ofcourse you can use Visual Studio Code for this too. This is a two step process. First you have to define a new merge tool and secondly you need to set it as the default merge tool.</p>
$ git config</span> --global</span> mergetool.vscode.cmd </span>"code --wait $MERGED"
</span>$ git config</span> --global</span> merge.tool vscode
</span></code></pre>
This adds the following configuration to your global git config.</p>
[merge]
</span>    </span>tool </span>=</span> vscode
</span>[mergetool "vscode"]
</span>    </span>cmd </span>=</span> code </span>--</span>wait </span>$MERGED
</span></code></pre>
Set Visual Studio code as git difftool</h3>
The same goes for setting the git difftool. You will have to run the following two commands.</p>
$ git config</span> --global</span> mergetool.vscode.cmd </span>"code --wait $MERGED"
</span>$ git config</span> --global</span> merge.tool vscode
</span></code></pre>
This adds the following configuration to your global git config.</p>
[diff]
</span>    </span>tool </span>=</span> vscode
</span>[difftool "vscode"]
</span>    </span>cmd </span>=</span> code </span>--</span>wait </span>--</span>diff </span>$LOCAL $REMOTE
</span></code></pre>
Summary</h2>
You can change the git config to use Visual Studio Code instead of a terminal text editor. To do this in one step you can paste the following snippet in your git config file.</p>
[core]
</span>    </span>editor </span>=</span> code </span>--</span>wait
</span>[merge]
</span>    </span>tool </span>=</span> vscode
</span>[mergetool "vscode"]
</span>    </span>cmd </span>=</span> code </span>--</span>wait </span>$MERGED
</span>[diff]
</span>    </span>tool </span>=</span> vscode
</span>[difftool "vscode"]
</span>    </span>cmd </span>=</span> code </span>--</span>wait </span>--</span>diff </span>$LOCAL $REMOTE
</span></code></pre>
For more information read the Visual Studio Code docs</a>.</p>


Create a file of specific size in Linux
2020-03-13T00:00:00+00:00
While testing an upload service for example you probably need to test it with a large file. On the Linux command-line you can create such a file with the dd</code> command.</p>
To generate a file of 10MB you can run the following command. This will create a file called largefile.txt</code> in your current directory filled with zeros. If you prefer random data instead of zeros you will have to replace /dev/zero</code> by /dev/urandom</code>.</p>
$ dd if=/dev/zero of=largefile.txt bs=1M count=10.
</span></code></pre>


4 ways to clean up your Laravel routes files
2020-03-11T00:00:00+00:00
As your Laravel application grows, your routes file grows with it. And most often it doesn't just grow with it, it becomes messy and hard to read. So cleaning it up once every while can be time well spend.</p>
1. Use resource routes</h2>
The first route definition you see in your web.php</code> routes file after starting a new Laravel project is:</p>
<?php
</span>
</span>Route</span>::get(</span>'/'</span>, </span>function </span>() {
</span>    </span>return </span>view(</span>'welcome'</span>);
</span>});
</span></code></pre>
If you're running PHP 7.4 or higher, locally and on your server, you can clean this one up a little with an arrow function. The following is equivalent to the route definition above, but using an arrow function.</p>
<?php
</span>
</span>Route</span>::get(</span>'/'</span>, </span>fn</span>() => view(</span>'welcome'</span>));
</span></code></pre>
But if you'd ask me routes using closures cause quite some visual noise. So I rather use controllers over closures unless it really makes no sense to make a controller for a view.</p>
Another pro for using controllers for your routes is that you can leverage resource routes. When you define a resource route you get routes for all the CRUD actions you'll probably need.</p>
<?php
</span>
</span>Route</span>::resource(</span>'users'</span>, </span>'UsersController'</span>);
</span></code></pre>
Just that one line generated the following routes for you.</p>
$ php artisan route:list --compact --name user
</span>+-----------+-------------------+----------------------------------------------+
</span>| Method    | URI               | Action                                       |
</span>+-----------+-------------------+----------------------------------------------+
</span>| GET|HEAD  | users             | App\Http\Controllers\UsersController@index   |
</span>| POST      | users             | App\Http\Controllers\UsersController@store   |
</span>| GET|HEAD  | users/create      | App\Http\Controllers\UsersController@create  |
</span>| GET|HEAD  | users/{user}      | App\Http\Controllers\UsersController@show    |
</span>| PUT|PATCH | users/{user}      | App\Http\Controllers\UsersController@update  |
</span>| DELETE    | users/{user}      | App\Http\Controllers\UsersController@destroy |
</span>| GET|HEAD  | users/{user}/edit | App\Http\Controllers\UsersController@edit    |
</span>+-----------+-------------------+----------------------------------------------+
</span></code></pre>
Which is super nice ofcourse, but it also means you need a controller with those same actions. That's a low effort task luckily. By running the following artisan command you get a new controller with all seven actions.</p>
$ php make:controller UsersController --resource
</span></code></pre>
There is a chance however that you don't need all of the actions. If that's the case you can chain the route definition with ->only([...])</code> or ->except([...])</code> to get a subset of all the resource routes.</p>
<?php
</span>
</span>Route</span>::resource(</span>'users'</span>, </span>'UsersController'</span>)->only([</span>'index'</span>, </span>'show'</span>]);
</span></code></pre>
This will limit the user routes to only an index and a show action. Even if you just have a couple of actions this quickly saves you lines of code.</p>
$ php artisan route:list --compact --name user
</span>+----------+--------------+--------------------------------------------+
</span>| Method   | URI          | Action                                     |
</span>+----------+--------------+--------------------------------------------+
</span>| GET|HEAD | users        | App\Http\Controllers\UsersController@index |
</span>| GET|HEAD | users/{user} | App\Http\Controllers\UsersController@show  |
</span>+----------+--------------+--------------------------------------------+
</span></code></pre>
2. Register routes in tuples</h2>
Since Laravel 5.6</a> we can use arrays instead of strings to define the controller and action of a route. This tuple syntax looks like the following.</p>
<?php
</span>
</span>Route</span>::get(</span>'users'</span>, [\App\Http\Controllers\</span>UsersController</span>::class, </span>'index'</span>]);
</span></code></pre>
You can clean this up by adding a use</code> statement for the UsersController</code>. Check if your editor can hide these, because these will start to add up pretty quick when your application grows.</p>
<?php
</span>
</span>use </span>App\Http\Controllers\</span>UsersController</span>;
</span>
</span>Route</span>::get(</span>'users'</span>, [</span>UsersController</span>::class, </span>'index'</span>]);
</span></code></pre>
Or you can set the namespace of the routes file to the same namespace of your controllers. What falls in the category hacky if you'd ask me, but being a little creative can be fun sometimes :-).</p>
<?php
</span>
</span>namespace </span>App\Http\Controllers;
</span>
</span>Route</span>::get(</span>'users'</span>, [</span>UsersController</span>::class, </span>'index'</span>]);
</span></code></pre>
Using the tuple syntax might allow you to use the "Go to Definition" and "Refactor" functions of your IDE. Which are nice benefits in (at least) my workflow compared to the string syntax which feels a bit magical.</p>
One thing that is a bit of a bummer is that it doesn't work with resource routes at the moment.</p>
For more information about tuple routes, Freek.dev</a> has a great opinion about them.</p>
3. Split up the routes file</h2>
Larger applications have easily dozens of route definitions divided in multipe route groups. Lets say your application has a public section, a section that requires authentication and a section that requires admin access. In that case the routes file has a structure similar to something like this:</p>
<?php
</span>
</span>// routes/web.php
</span>
</span>use </span>Illuminate\Support\Facades\</span>Route</span>;
</span>
</span>Route</span>::get(</span>'/'</span>, </span>function </span>() {
</span>    </span>return </span>view(</span>'welcome'</span>);
</span>});
</span>
</span>Route</span>::group([</span>'middleware' </span>=> </span>'auth'</span>, </span>'prefix' </span>=> </span>'app'</span>], </span>function </span>() {
</span>    </span>Route</span>::resource(</span>'users'</span>, </span>'UsersController'</span>)->only([</span>'index'</span>, </span>'show'</span>]);
</span>
</span>    </span>Route</span>::group([</span>'middleware' </span>=> </span>'admin'</span>], </span>function </span>() {
</span>        </span>Route</span>::get(</span>'dashboard'</span>, </span>'DashboardController@index'</span>);
</span>    });
</span>});
</span></code></pre>
I personally find it hard to follow what is happening with all the groupings and the level of indent. Imagine managing an application with hundreds of routes. We can solve this by splitting the routes file up in three files: routes/web.php</code>, routes/app.php</code> and routes/admin.php</code>.</p>
So we end up with the following three files:</p>
<?php
</span>
</span>// routes/web.php
</span>
</span>use </span>Illuminate\Support\Facades\</span>Route</span>;
</span>
</span>Route</span>::get(</span>'/'</span>, </span>function </span>() {
</span>    </span>return </span>view(</span>'welcome'</span>);
</span>});
</span></code></pre>
<?php
</span>
</span>// routes/app.php
</span>
</span>use </span>Illuminate\Support\Facades\</span>Route</span>;
</span>
</span>Route</span>::resource(</span>'users'</span>, </span>'UsersController'</span>)->only([</span>'index'</span>, </span>'show'</span>]);
</span></code></pre>
<?php
</span>
</span>// routes/admin.php
</span>
</span>use </span>Illuminate\Support\Facades\</span>Route</span>;
</span>
</span>Route</span>::get(</span>'dashboard'</span>, </span>'DashboardController@index'</span>);
</span></code></pre>
But this doesn't work correctly just like that. If we check our available routes now we that only the one from routes/web.php</code> is still available.</p>
$ php artisan route:list
</span>+--------+----------+----------+------+---------+--------------+
</span>| Domain | Method   | URI      | Name | Action  | Middleware   |
</span>+--------+----------+----------+------+---------+--------------+
</span>|        | GET|HEAD | /        |      | Closure | web          |
</span>+--------+----------+----------+------+---------+--------------+
</span></code></pre>
Also notice that we got rid of all the middleware in the routes/app.php</code> and routes/admin.php</code> files. We fix that later on ;-)</p>
For this to work we need to add the newly created routes files to the RouteServiceProvider. And in the RouteServiceProvider class you want to look for the map()</code> function. Which, if you haven't touched it before, should look like this:</p>
<?php
</span>
</span>public </span>function </span>map</span>()
</span>{
</span>    $this->mapApiRoutes();
</span>
</span>    $this->mapWebRoutes();
</span>
</span>    </span>//
</span>}
</span></code></pre>
We will add calls mapAppRoutes</code> and mapAdminRoutes</code> to this function in which we will register the other two routes files.</p>
<?php
</span>
</span>public </span>function </span>map</span>()
</span>{
</span>    $this->mapApiRoutes();
</span>
</span>    $this->mapWebRoutes();
</span>
</span>    $this->mapAppRoutes();
</span>
</span>    $this->mapAdminRoutes();
</span>}
</span></code></pre>
So now we need to write those two new functions. Both should be very similar to the mapWebRoutes</code> function that did already exist. But we need to change the file path and add back the middleware.</p>
<?php
</span>
</span>protected </span>function </span>mapWebRoutes</span>()
</span>{
</span>    </span>Route</span>::middleware(</span>'web'</span>)
</span>            ->namespace($this->namespace)
</span>            ->group(base_path(</span>'routes/web.php'</span>));
</span>}
</span>
</span>protected </span>function </span>mapAppRoutes</span>()
</span>{
</span>    </span>Route</span>::middleware(</span>'web'</span>)
</span>            ->middleware(</span>'auth'</span>)
</span>            ->namespace($this->namespace)
</span>            ->group(base_path(</span>'routes/app.php'</span>));
</span>}
</span>
</span>protected </span>function </span>mapAdminRoutes</span>()
</span>{
</span>    </span>Route</span>::middleware(</span>'web'</span>)
</span>            ->middleware(</span>'auth'</span>)
</span>            ->middleware(</span>'admin'</span>)
</span>            ->namespace($this->namespace)
</span>            ->group(base_path(</span>'routes/admin.php'</span>));
</span>}
</span></code></pre>
And voila, our route definitions are back as we had them before. Only now in clean separated files.</p>
$ php artisan route:list
</span>+--------+----------+--------------+-------------+------------------------------------------------+--------------+
</span>| Domain | Method   | URI          | Name        | Action                                         | Middleware   |
</span>+--------+----------+--------------+-------------+------------------------------------------------+--------------+
</span>|        | GET|HEAD | /            |             | Closure                                        | web          |
</span>|        | GET|HEAD | dashboard    |             | App\Http\Controllers\DashboardController@index | web          |
</span>|        | GET|HEAD | users        | users.index | App\Http\Controllers\UsersController@index     | auth         |
</span>|        | GET|HEAD | users/{user} | users.show  | App\Http\Controllers\UsersController@show      | auth         |
</span>+--------+----------+--------------+-------------+------------------------------------------------+--------------+
</span></code></pre>
4. Routes macros</h2>
The Marcroable trait is something you might have seen before. With macros you can basically "add" functions to the interface of a class. This is useful when you want to extend one of Laravels core classes with a function that's really specific to your application for example.</p>
Luckily for us, the Laravel router implements the Macroable</code> trait. So what this allows us to do is to bundle a set of routes in a macro and register them at once in our routes file.</p>
Lets say your application implements a service that expects data to be pushed to it from another service. An incoming webhook from GitHub for example. In that case you can bundle the route definitions with your service, and define them using a single line in your routes file.</p>
You can define the route macro in the service provider of your GitHub service. It requires a name and an closure. And within the closure you can add route definitions as you would normally do in your routes file. Just make sure you add a use</code> statement for the Route facade.</p>
<?php
</span>
</span>public </span>function </span>boot</span>()
</span>{
</span>    </span>Route</span>::macro(</span>'githubServiceRoutes'</span>, </span>function </span>() {
</span>        </span>Route</span>::group([ </span>'middleware' </span>=> </span>'validate_github_secret'</span>], </span>function </span>() {
</span>            </span>Route</span>::post(</span>'github/webhook'</span>, </span>'GithubController@handle'</span>);
</span>        });
</span>    });
</span>}
</span></code></pre>
In your routes file you can now use the name you gave the macro as a static function for the Route facade.</p>
<?php
</span>
</span>// routes/admin.php
</span>
</span>use </span>Illuminate\Support\Facades\</span>Route</span>;
</span>
</span>Route</span>::githubServiceRoutes();
</span></code></pre>
Lets double check with the artisan routes command. And yup, the route that we registered in the Github ServiceProvider is now available.</p>
$ php artisan route:list
</span>+--------+----------+----------------+------+----------------------------------------------+----------------------------+
</span>| Domain | Method   | URI            | Name | Action                                       | Middleware                 |
</span>+--------+----------+----------------+------+----------------------------------------------+----------------------------+
</span>|        | GET|HEAD | /              |      | Closure                                      | web                        |
</span>|        | POST     | github/webhook |      | App\Http\Controllers\GithubController@handle | web,validate_github_secret |
</span>+--------+----------+----------------+------+----------------------------------------------+----------------------------+
</span></code></pre>


Using tail to follow log files
2020-03-09T00:00:00+00:00
Log files are created for a reason. They come in handy when you're debugging an unexpected HTTP response for example. But keep refreshing a log file is not an efficient way of working. To automatically see additions to a file you can use the tail</code> command in follow mode.</p>
Using tail in follow mode</h3>
The tail</code> command is used to print the last lines in a file. By default it will show only the last 10 lines.</p>
$ tail /var/log/nginx/access.log
</span>::1 - - </span>[</span>27/Feb/2020:19:17:08 +0100</span>] </span>"GET / HTTP/1.1"</span> 200 17 </span>"-" "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.90 Safari/537.36"
</span>...
</span>$
</span></code></pre>
The example above showed that the command finished after printing the last 10 lines. To keep the command running we need to use the -f</code> option to follow additions added to the file.</p>
When you pass the -f</code> option you will see that the command keeps running and that lines get added when you make another request to NGINX.</p>
$ tail</span> -f</span> /var/log/nginx/access.log
</span>::1 - - </span>[</span>27/Feb/2020:19:19:28 +0100</span>] </span>"GET / HTTP/1.1"</span> 200 17 </span>"-" "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.90 Safari/537.36"
</span>...
</span></code></pre>
Tail multiple files</h3>
When necessary you can tail multiple files at the same time. To do this you add a second file path as an argument. This will show the file name as a header above new entries.</p>
$ tail</span> -f</span> /var/log/nginx/access.log /var/log/nginx/error.log
</span>...
</span>=</span>=</span>></span> /var/log/nginx/access.log </span><==
</span>::1 - - </span>[</span>27/Feb/2020:19:24:38 +0100</span>] </span>"GET / HTTP/1.1"</span> 200 17 </span>"-" "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.90 Safari/537.36"
</span>...
</span></code></pre>
Filter tail results with grep</h3>
If you know what you're looking for you can combine tail</code> with grep</code>. To search for a specific HTTP status for example. This way you'll only see lines containing the string "404".</p>
$ sudo tail</span> -f</span> /var/log/nginx/access.log </span>| </span>grep </span>"404"
</span>::1 - - </span>[</span>27/Feb/2020:13:13:24 +0100</span>] </span>"GET /favicon.ico HTTP/1.1"</span> 404 548 </span>"http://example.me/" "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.90 Safari/537.36"
</span></code></pre>


List tmux sessions
2020-03-05T00:00:00+00:00
Tmux has the concepts of sessions, you can look at a session as a workspace for your terminal. This is convenient when you're working on a project, creating panes and windows, but have to switch to something different in between. In this case you can just keep this specific session running so you can come back to it later. When you're working with multiple sessions it can be useful to list the ones that are active at the moment.</p>
To list all the sessions that are currently managed by the tmux server you can use the tmux list-sessions</code> command. The command shows by default the name of the sessions, the amount of windows per session, when the session was created and whether the session is currently attached to a terminal.</p>
$ tmux list-sessions
</span>first_project: 4 windows (created Wed Mar  4 18:17:14 2020)
</span>second_project: 2 windows (created Wed Mar  4 19:00:55 2020) (attached)
</span></code></pre>
Like many tmux commands list-sessions</code> has the shorthand too, tmux ls</code> shows you the same information.</p>
$ tmux ls
</span>first_project: 4 windows (created Wed Mar  4 18:17:14 2020)
</span>second_project: 2 windows (created Wed Mar  4 19:00:55 2020) (attached)
</span></code></pre>
Both of the examples above have an equivalent in the command mode of tmux. To start the command mode use <prefix> :</code>. Now you can enter :list-sessions</code> or :ls</code> to see a list of active tmux sessions.</p>
You can use these to make a custom keybinding in your .tmux.conf</code> file. An example would be:</p>
bind <key> list-sessions
</span></code></pre>
By default, list-sessions</code> is binded to the key combination <prefix> s</code>. You can navigate the session list with j</code> and k</code> and activate one by pressing enter</code>. If your main purpose is to switch session you can try out choose-session</code>, it is more verbose and gives you the possibility to switch to a specific window too.</p>
Format the output</h3>
You can specify the format of the session list with the -F</code> option. When you're scripting with tmux this can be a useful feature. For example, if your script requires the session names you can use the following command.</p>
$ tmux ls</span> -F </span>"#{session_name}"
</span>first_project
</span>second_project
</span></code></pre>
You can ofcourse use multiple variables in the format string. The output below shows the name of the active window in each session.</p>
$ tmux ls</span> -F </span>"#{session_name}:#{window_name}"
</span>first_project:database
</span>second_project:server
</span></code></pre>
The FORMAT section in the man pages lists a whole lot more options for formatting the output of list-sessions</code>.</p>


Type subsets with TypeScript Partials
2020-03-02T00:00:00+00:00
The Partial type is one of the utility types</a> in TypeScript. You can use the Partial type to represent a subsets of the type variable you pass to it.</p>
In an application that communicates with a REST API you ofter find yourself writing interfaces to represent a resource you want to create. If you're about to create a new user your interface might look similar to the one below.</p>
interface </span>User {
</span>  firstName</span>: </span>string</span>;
</span>  lastName</span>: </span>string</span>;
</span>  email</span>: </span>string</span>;
</span>}
</span></code></pre>
If you have all the required properties and pass them in a function that expects a User TypeScript is happy and won't complain.</p>
function </span>createUser</span>(</span>user</span>: </span>User) {
</span>  </span>// ...
</span>}
</span>
</span>const </span>user</span>: </span>User </span>= </span>{
</span>  firstName: </span>"Winston"</span>,
</span>  lastName: </span>"Tortoise"</span>,
</span>  email: </span>"w.tortoise@example.com"</span>,
</span>};
</span>
</span>createUser</span>(user);
</span></code></pre>
But now that you have sir Winston in your database and he decides to change his email address. You can't just pass the update for a single property into a function that expects a parameter of type User. TypeScript won't be happy and will complain.</p>
function </span>updateUser</span>(</span>user</span>: </span>User) {
</span>  </span>// ...
</span>}
</span>
</span>const </span>newMail </span>= </span>"winston.tortoise@example.com"</span>;
</span>
</span>updateUser</span>({ email: newMail }); </span>// TypeScript says NO!
</span></code></pre>
So how to solve this. Instead of creating a second interface to represent a specific user update you could give Partial a try. With the Partial utility type you create a new type from an already existing one but makes all the properties optional. To make this a bit more visual, see the snipper below of how the Partial type is defined in TypeScript.</p>
/**
</span> * Make all properties in T optional
</span> */
</span>type </span>Partial<T> </span>= </span>{
</span>  [P </span>in keyof </span>T]</span>?: </span>T[P];
</span>};
</span></code></pre>
So to make TypeScript happy we use the Partial utility type with User</code> as its generic. By doing this the updateUser</code> will only accept an object with properties in the User</code> type. Take note that all the properties are made optional, so even an empty object will be fine in this case.</p>
function </span>updateUser</span>(</span>user</span>: </span>Partial<User>) {
</span>  </span>// ...
</span>}
</span>
</span>const </span>newMail </span>= </span>"winston.tortoise@example.com"</span>;
</span>
</span>updateUser</span>({ email: newMail }); </span>// TypeScript is happy
</span></code></pre>
Require one property in partial</h3>
Having all the fields optional is in some cases not what you want. For example, sometimes all the fields can be optional expect for an unique identifier you need to identify a specific user. This might not not be the most elegant solution but you could solve this by combining a partial with the Pick utility type. The Pick</code> type requires a subset of properties in a type. See the snippet below of how the Pick</code> type is implemented in TypeScript.</p>
/**
</span> * From T, pick a set of properties whose keys are in the union K
</span> */
</span>type </span>Pick<T, K </span>extends keyof </span>T> </span>= </span>{
</span>  [P </span>in </span>K]</span>: </span>T[P];
</span>};
</span></code></pre>
In the example below shows how to combine Pick with Partial to make all properties of User</code> optional except for the email</code> property.</p>
function </span>updateUser</span>(</span>user</span>: </span>Pick<Partial<User>, </span>"email"</span>>) {
</span>  </span>// ...
</span>}
</span>
</span>// TypeScript says NO :(
</span>updateUser</span>({ firstName: </span>"Hannah" </span>});
</span>
</span>// TypeScript says Yes! :)
</span>updateUser</span>({ firstName: </span>"Hannah"</span>, email: </span>"hannah@example.com" </span>});
</span></code></pre>
List of partials</h3>
Partials can be used with as a list too. By adding a []</code> after the Partial type TypeScript will expect an array of partials. The items in the array of partials don't need to have the same properties. So TypeScript is 100% fine with the example below.</p>
const </span>users</span>: </span>Partial<User>[] </span>= </span>[
</span>  { firstName: </span>"John" </span>}, </span>// First user
</span>  { lastName: </span>"James" </span>}, </span>// Second user
</span>];
</span></code></pre>


Tagging git commits
2020-02-25T00:00:00+00:00
Git provides the functionality to mark a point in your repository’s history with a "tag". These tags are typically used to indicate the release of a version. With Git you can create two types of tags: Annotated and Lightweight. These two types differ in how they are stored in the Git repository and the amount of meta data they contain.</p>
Annotated Tags</h3>
Annotated tags are normally what you want when tagging a release. You want this because they have more meta-data attached to them, much like regular commits. They contain a checksum, name, email, date and have a tagging message. Optionally you can sign annotated tags with your GPG key.</p>
Lightweight Tags</h3>
Lightweight tags point to a commit in a similar way as branches do. The difference being that a branch points to the next commit as soon as you add a commit. Lightweight tags will keep pointing to the commit that was tagged. Lightweight are useful for private use. You can use them like a bookmark for yourself.</p>
Manage tags</h2>
Git comes with a whole set of commands to deal with tags. We'll go over all the commands you need to manage the tags in your repository.</p>
Create tags</h3>
You can create a Lightweight</strong> tag by using the git tag</code> command and provide a name for the tag. This creates a lightweight tag to the last commit it your currently active branch.</p>
$ git tag lw-bookmark
</span></code></pre>
Creating Annotated</strong> tags is similar to creating lightweight tags. You use the same git tag</code> command but have to add the -a</code> option. Since annotated tags require a message Git will launch an editor for you to enter one. If you prefer you can also use the -m</code> option to specify the message directly.</p>
$ git tag</span> -a</span> v0.2-annotated
</span># or
</span>$ git tag</span> -a</span> v0.2-annotated</span> -m </span>"Release v0.2"
</span></code></pre>
Both examples tag the current place in time of your Git repository. You can ofcourse also tag previous commits. This can be done by adding the commit hash after the name of the tag.</p>
$ git tag</span> -a</span> v0.1-annotated</span> -m </span>"Release v0.1"</span> 3f18d02
</span></code></pre>
List tags</h3>
To list the tags we just created we can use the git tag</code> command without any arguments. This lists all the lightweight and annotated tags in your repository in alphabetical order.</p>
$ git tag
</span>lw-bookmark
</span>v0.1-annotated
</span>v0.2-annotated
</span></code></pre>
This listing tags gets quickly out of hand in a large Git repository. So it might be useful to list tags with a pattern. For example, if you’re only interested in seeing tags for the v0 releases you can run the following command.</p>
$ git tag</span> -l </span>"v0.*"
</span>v0.1-annotated
</span>v0.2-annotated
</span></code></pre>
Tag details</h3>
Listing the tags doesn’t provide a whole lot of details. It is just a list of what is available in your repository. To show more details of a tag you use the git show</code> command.</p>
$ git show v0.2-annotated
</span>tag v0.2-annotated
</span>Tagger: John Developer </span><</span>john.developer@example.com</span>>
</span>Date:   Tue Feb 24 20:56:07 2020 +0100
</span>
</span>Release v0.2
</span>
</span>commit 321f7dde2c3bc5458c030ee6e9ee3825d91514ca (HEAD -</span>></span> master, tag: v0.2-annotated)
</span>Author: John Developer </span><</span>john.developer@example.com</span>>
</span>Date:   Tue Feb 24 20:55:36 2020 +0100
</span>
</span>    Add an awesome feature
</span></code></pre>
As you can see above you can see quite some details of annotated tags. You see details about the tag created and the commit that was tagged. Lightweight tags are a lot less detailed. As you can see below they just show details of the commit that was tagged.</p>
$ git show lw-bookmark
</span>commit c773c5822b253b6f483e6c63ba73ec55f61faf8f (tag: lw-bookmark)
</span>Author: John Developer </span><</span>john.developer@example.com</span>>
</span>Date:   Tue Feb 24 20:51:18 2020 +0100
</span>
</span>    Tiny bug fix
</span></code></pre>
Push tags</h3>
When you push changes to a remote server Git doesn't include tags by default. If you want to push your tags you have to do this explicitly. To push a single tag to a remote server you run the command git push [remote] [tagname]</code>.</p>
$ git push origin v0.2-annotated
</span></code></pre>
In case you have multiple tags to push you can use the --tags</code> option instead. But keep in mind that this will push all your tags, lightweight and annotated.</p>
$ git push origin</span> --tags
</span></code></pre>
Delete tags</h3>
Deleting a tag from just your local repository is straight forward. It works the same for annotated and lightweight tags and you do it by running the command git tag -d [tagname]</code>.</p>
See the example below where we delete the lightweight tag that we created before.</p>
$ git tag</span> -d</span> lw-bookmark
</span>Deleted tag </span>'lw-bookmark'</span> (was c773c58)
</span></code></pre>
In case you pushed the tag to a remote server before you can delete by passing the --delete</code> option to the Git push command.</p>
$ git push</span> --delete</span> origin lw-bookmark
</span></code></pre>


Becoming productive in the Ruby IRB console
2020-02-24T00:00:00+00:00
With the release of Ruby 2.7 the IRB shell got somewhat of a make over. It now includes syntax highlighting, multiline editing, tab completion and RDoc integration. And with some tweaks in the .irbrc</code> file we can improve the overall experience even more.</p>
Since Ruby 2.7 the IRB history is by default written to a history file in your home directory. If you're on an older version of Ruby you can enable the same behavior using the following snippet. This saves the last 1000 entries in the IRB shell.</p>
# ~/.irbrc
</span>IRB</span>.conf[</span>:SAVE_HISTORY</span>] </span>= </span>1000
</span></code></pre>
Ruby versions older than 2.7 also don't enable indentation by default. You can change this in the irbrc as well. However, this doesn't set the indent correctly for closing end</code>s. Which does work out of the box in Ruby 2.7.</p>
# ~/.irbrc
</span>IRB</span>.conf[</span>:AUTO_INDENT</span>] </span>= </span>true
</span></code></pre>
Loading gems</h2>
Some gems come in handy to have available in your shell. You can require them interactively during your IRB session. But if you find yourself doing this with the same gems you can require them in the irbrc file as well.</p>
# ~/.irbrc
</span>require </span>'faraday'
</span></code></pre>
This works nice until you start using different Ruby versions with a tool like rbenv</code>. These different Ruby versions share the same .irbrc</code> but don't necessarily have the same gems available. If this happens, getting some notice would be nice. We can do this by using the following snippet in your .irbrc</code>.</p>
# ~/.irbrc
</span>%w{faraday faker}</span>.each </span>do </span>|</span>lib</span>|
</span>  </span>begin
</span>    </span>require</span> lib
</span>  </span>rescue </span>LoadError => err
</span>    $stderr.</span>puts</span> err
</span>  </span>end
</span>end
</span></code></pre>
This will give the following message when you start the IRB console.</p>
$ irb
</span>cannot load such file</span> --</span> faker
</span>irb(main):001:0</span>>
</span></code></pre>
Helper functions</h2>
Since the irbrc file is interpreted as a Ruby file you are free to define all the functions you want. Say for example you get annoyed by typing exit</code> all the time when exiting IRB. You can define a function called q</code> that saves you three characters of your time.</p>
# ~/.irbrc
</span>def </span>q
</span>  </span>puts </span>'👋 See you later alligator'
</span>  </span>exit
</span>end
</span></code></pre>
To use this new time saving function you can just call it from IRB.</p>
$ irb
</span>irb(main):001:0</span>></span> q
</span>👋 See you later alligator
</span></code></pre>
Changing the prompt</h2>
The IRB console comes with multiple prompt modes built-in, namely :NULL</code>, :DEFAULT</code>, :CLASSIC</code>, :SIMPLE</code>, :INF_RUBY</code> and :XMP</code>. You can try them out and set your preferred one as follows:</p>
# ~/.irbrc
</span>IRB</span>.conf[</span>:PROMPT_MODE</span>] </span>= </span>:SIMPLE
</span></code></pre>
You can easily create your own prompt mode definition.</p>
# ~/.irbrc
</span>IRB</span>.conf[</span>:PROMPT</span>][</span>:CUSTOM_PROMPT</span>] </span>= </span>{
</span>  </span>:AUTO_INDENT </span>=> </span>false</span>,          </span># disables auto-indent mode
</span>  </span>:PROMPT_I </span>=>  </span>">> "</span>,            </span># simple prompt
</span>  </span>:PROMPT_S </span>=> </span>nil</span>,               </span># prompt for continuated strings
</span>  </span>:PROMPT_C </span>=> </span>nil</span>,               </span># prompt for continuated statement
</span>  </span>:RETURN </span>=> </span>"    ==></span>%s\n</span>"        </span># format to return value
</span>}
</span>
</span>IRB</span>.conf[</span>:PROMPT_MODE</span>] </span>= </span>:CUSTOM_PROMPT
</span></code></pre>
For more information about changing the prompt you can read the docs here</a>.</p>


Command-line interfaces with Ruby OptionParser
2020-02-18T00:00:00+00:00
The Ruby standard library ships with the OptionParser class for parsing command-line options. Besides just parsing options it can take care of help messages and usage information too. This makes building command-line interfaces a breeze compared to using the ARGV constant.</p>
To access the OptionParser class you need to require optparse</code> at the top of you Ruby file. Don't confuse it with a gem. It comes with Ruby, there is no need to install it separately.</p>
require </span>'optparse'
</span></code></pre>
You get started by creating an instance of the OptionParser class, pass it a block and call parse!</code> on it.</p>
require </span>'optparse'
</span>
</span>OptionParser</span>.</span>new do
</span>  </span>puts </span>'I found a goldfish'
</span>end</span>.parse!
</span>
</span>#=> $ ruby fish_finder.rb
</span>#=> I found a goldfish
</span></code></pre>
Okay, that was pretty useless, a single line of puts</code> would have had the same result. Lets start with adding an option to this fish finder CLI. We can store the option values in a hash by passing in into the parse method.</p>
require </span>'optparse'
</span>
</span>params </span>= </span>{}
</span>
</span>OptionParser</span>.</span>new do </span>|</span>parser</span>|
</span>  parser.on(</span>'-w'</span>, </span>'--water TYPE'</span>)
</span>  parser.on(</span>'-h'</span>, </span>'--help'</span>)
</span>  parser.on(</span>'-v'</span>, </span>'--verbose'</span>)
</span>end</span>.parse!(</span>into:</span> params)
</span>
</span>puts</span> params
</span>
</span>#=> $ ruby fish_finder.rb -v --water salt
</span>#=> {:verbose=>true, :water=>"salt"}
</span></code></pre>
You can note a couple things from the above example already:</p>

You can require options to have an argument by adding a argument name to the option specification. See the --water TYPE</code> specification. If you want an optional argument you would use --water [TYPE]</code> in this case.</li>
Options you don't pass to the script are not present in the params</code> hash. Note the absence of :help</code>.</li>
The long option name is used as a symbol in the params</code> hash.</li>
</ul>
Now before we continue lets wrap this in a fancy FishFinder class.</p>
require </span>'optparse'
</span>
</span>class </span>FishFinder
</span>  </span>def </span>fish
</span>    </span>'I found a goldfish'
</span>  </span>end
</span>
</span>  </span>def </span>parse
</span>    </span>OptionParser</span>.</span>new do </span>|</span>parser</span>|
</span>      parser.on(</span>'--water TYPE'</span>)
</span>      parser.on(</span>'-h'</span>, </span>'--help'</span>)
</span>      parser.on(</span>'-v'</span>, </span>'--verbose'</span>)
</span>    </span>end</span>.parse!
</span>  </span>end
</span>end
</span>
</span>finder </span>= </span>FishFinder</span>.</span>new
</span>finder.parse
</span>puts</span> finder.fish
</span></code></pre>
Print usage information</h2>
The OptionParser class provides methods out of the box to help you create usage information messages. We do this by setting a banner for the parser, which is the first line in the usage output. With the seperator method you can add extra lines of text, or a blank line in this case. In the block that is passed for the --help</code> option you see that puts parser</code> is enough to print the usage information. We exit here as well so we don't search for a goldfish while we only want to see the usage information.</p>
require </span>'optparse'
</span>
</span>class </span>FishFinder
</span>  </span>def </span>fish
</span>    </span>'I found a goldfish'
</span>  </span>end
</span>
</span>  </span>def </span>parse
</span>    </span>OptionParser</span>.</span>new do </span>|</span>parser</span>|
</span>      parser.banner </span>= </span>'Usage: fish_finder.rb [options]'
</span>      parser.separator </span>''
</span>
</span>      parser.on(</span>'--water TYPE'</span>, </span>'Pick "fresh" or "salt"'</span>)
</span>
</span>      parser.on(</span>'-h'</span>, </span>'--help'</span>, </span>'Show this message'</span>) </span>do
</span>        </span>puts</span> parser
</span>        </span>exit
</span>      </span>end
</span>
</span>      parser.on(</span>'-v'</span>, </span>'--verbose'</span>, </span>'Show fancy fish'</span>)
</span>    </span>end</span>.parse!
</span>  </span>end
</span>end
</span>
</span>finder </span>= </span>FishFinder</span>.</span>new
</span>finder.parse
</span>puts</span> finder.fish
</span>
</span>#=> $ ruby fish_finder.rb --help
</span>#=> Usage: fish_finder.rb [options]
</span>#=>     --water TYPE                 Pick "fresh" or "salt"
</span>#=> -h, --help                       Show this message
</span>#=> -v, --verbose                    Show extra fish
</span></code></pre>
Boolean switch options</h2>
We can use the --verbose</code> flag to overwrite a default configuration. This way we can change the behavior of this fish finder by passing an option. If the --verbose</code> of -v</code> option is passed to the script we reward you with a fancy fish emoji.</p>
require </span>'optparse'
</span>
</span>class </span>FishFinder
</span>  </span>attr_accessor </span>:verbose
</span>
</span>  </span>def </span>initialize
</span>    self.verbose </span>= </span>false
</span>  </span>end
</span>
</span>  </span>def </span>fish
</span>    fish </span>= </span>self.verbose </span>? </span>'🐠' </span>: </span>'goldfish'
</span>    </span>"I found a </span>#{fish}</span>"
</span>  </span>end
</span>
</span>  </span>def </span>parse
</span>    </span>OptionParser</span>.</span>new do </span>|</span>parser</span>|
</span>      parser.banner </span>= </span>"Usage: fish_finder.rb [options]"
</span>      parser.separator </span>""
</span>
</span>      parser.on(</span>'--water TYPE'</span>, </span>'Pick "fresh" or "salt"'</span>)
</span>
</span>      parser.on(</span>'-h'</span>, </span>'--help'</span>, </span>'Show this message'</span>) </span>do
</span>        </span>puts</span> parser
</span>        </span>exit
</span>      </span>end
</span>
</span>      parser.on(</span>'-v'</span>, </span>'--verbose'</span>, </span>'Show fancy fish'</span>) </span>do </span>|</span>verbose</span>|
</span>        self.verbose </span>=</span> verbose
</span>      </span>end
</span>    </span>end</span>.parse!
</span>  </span>end
</span>end
</span>
</span>finder </span>= </span>FishFinder</span>.</span>new
</span>finder.parse
</span>puts</span> finder.fish
</span>
</span>#=> $ ruby fish_finder.rb
</span>#=> I found a goldfish
</span>
</span>#=> $ ruby fish_finder.rb --verbose
</span>#=> I found a 🐠
</span></code></pre>
Options with required arguments</h2>
By adding an all caps name to the option definition you can define a required argument for an option. This means that an OptionParser::MissingArgument</code> exception is raised when the option is missing. You probably want to catch this and give a nice feedback message.</p>
Now, a second issue might be that you receive an argument that you don't expect. In our case we allow for the water types "fresh" and "salt". We could use the build-in type coercion. So an OptionParser::InvalidArgument</code> exception in thrown when an invalid argument is passed.</p>
parser.on(</span>'--water TYPE'</span>, </span>String</span>, </span>'Pick "fresh" or "salt"'</span>)
</span></code></pre>
In the above example you see how that would look. We require the TYPE</code> argument to be a non-empty string. You can take a look at the docs</a> for more type coercion options.</p>
Since our argument values are rather specific we can check for a pattern too. See the final example for a check on salt or fresh water.</p>
require </span>'optparse'
</span>
</span>class </span>FishFinder
</span>  </span>attr_accessor </span>:verbose</span>, </span>:filter
</span>
</span>  </span>def </span>initialize
</span>    self.verbose </span>= </span>false
</span>  </span>end
</span>
</span>  </span>def </span>fish
</span>    fish </span>= </span>self.verbose </span>? </span>'🐠' </span>: </span>self.find_fish
</span>    </span>"I found a </span>#{fish}</span>"
</span>  </span>end
</span>
</span>  </span>def </span>find_fish
</span>    </span>if </span>self.filter </span>== </span>'fresh'
</span>      </span>'goldfish'
</span>    </span>elsif </span>self.filter </span>== </span>'salt'
</span>      </span>'tuna'
</span>    </span>else
</span>      </span>'sturgeon'
</span>    </span>end
</span>  </span>end
</span>
</span>  </span>def </span>parse
</span>    </span>OptionParser</span>.</span>new do </span>|</span>parser</span>|
</span>      parser.banner </span>= </span>"Usage: fish_finder.rb [options]"
</span>      parser.separator </span>""
</span>
</span>      parser.on(</span>'--water TYPE'</span>, </span>/fresh|salt/</span>, </span>'Pick "fresh" or "salt"'</span>) </span>do </span>|</span>water</span>|
</span>        self.filter </span>=</span> water
</span>      </span>end
</span>
</span>      parser.on(</span>'-h'</span>, </span>'--help'</span>, </span>'Show this message'</span>) </span>do
</span>        </span>puts</span> parser
</span>        </span>exit
</span>      </span>end
</span>
</span>      parser.on(</span>'-v'</span>, </span>'--verbose'</span>, </span>'Show extra fish'</span>) </span>do </span>|</span>v</span>|
</span>        self.verbose </span>=</span> v
</span>      </span>end
</span>    </span>end</span>.parse!
</span>  </span>end
</span>end
</span>
</span>finder </span>= </span>FishFinder</span>.</span>new
</span>finder.parse
</span>puts</span> finder.fish
</span>
</span>#=> $ ruby fish_finder.rb --water salt
</span>#=> I found a tuna
</span>
</span>#=> $ ruby fish_finder.rb --water fresh
</span>#=> I found a goldfish
</span>
</span>#=> $ ruby fish_finder.rb
</span>#=> I found a sturgeon
</span></code></pre>


Bash Tutorial - Starting with Bash shell basics
2020-02-15T00:00:00+00:00
The command-line can seem quite daunting at first. There is no holding hands as provided by a graphical file browser for example. But when you get up to speed with it, there is no looking back.</p>
On most Unix systems the the program that act as the command-line is the Bash shell. On the command-line you feed commands to Bash, and Bash makes sure the related program runs.</p>
You can best view the shell as an interface to your operating system. It is a program that translates your input to instructions for the operating system.</p>
Bash is common but not your only choice for a command-line shell. These days Zsh and Fish</a> are popular as well. But those shells will not be covered here.</p>
This tutorial goes into the basics of interacting with the command-line. After reading you should feel comfortable enough to use it for basic operations. Lets get started.</p>
Content</strong></p>

The command prompt</a></li>
Navigate through the file system</a></li>
Files and directories</a></li>
Permissions</a></li>
</ul>
The command prompt</h2>
The command prompt is the first notable thing you see when you open your terminal or console application. It will probably look somewhat like this:</p>
koen@helios:~$
</span></code></pre>
You can customize this to all your likings, so it is not guaranteed to look like this. But most likely it shows:</p>

Your username on the system, koen</code> in my case.</li>
The name that is given to your system, this is called the hostname.</li>
The current directory shown as a ~</code> in this example, we get into that later.</li>
</ul>
Now that we dissected that. Lets start with what the command-line is for: running commands.</p>
koen@helios:~$ echo </span>"How Do Fish Breathe Underwater?"
</span></code></pre>
The echo</code> command we ran here is builtin to Bash. Its basic usage is to print out text that you supplied it as argument. You see this happening when you press Enter. The argument, between quotes, was written back to you by Bash on the next line.</p>
koen@helios:~$ echo </span>"How Do Fish Breathe Underwater?"
</span>How Do Fish Breathe Underwater</span>?
</span>koen@helios:~$
</span></code></pre>
Now that we covered running commands. Lets take a look at what that ~</code> meant.</p>
Navigate through the file system</h2>
When you open your terminal you are likely in the "Home" directory of your user. It is practically the same as opening a graphical file browser. But with text just text instead of icons for folders and files.</p>
To see what the actual location on the file system is that you're at you use the pwd</code> command. Easily to remember as P</u>rint the name of my current W</u>orking D</u>irectory.</p>
koen@helios:~$ pwd
</span>/home/koen
</span></code></pre>
What this shows is that I am in a folder called koen</code>, which is in a folder called home</code>, which is in de root of the file system. The root of the file system is indicated with a /</code> at the beginning of the path.</p>
Listing files and directories</h3>
It is nice to have a sense of where we are. It is even nicer to known what is actually there. For that use-case we have the ls</code> command to l</u>is</u>t files and directories.</p>
koen@helios:~$ ls
</span>Desktop  Documents  Downloads  Music  Pictures  Public  Templates  Videos
</span></code></pre>
This displayed all the contents that are in the directory /home/koen</code>, which are in this case only folders and not files.</p>
Command options</h3>
With the use of "options" the ls</code> command can come in many forms. Like most commands actually. You can modify the output or behavior of commands by appending these options. By passing the option -l</code> for example you get more detailed information about files and folders.</p>
Options come as words or as single letters. Single letter options use a single -</code> to indicate an option, -l</code> in this case. If you don't use a -</code> it is interpreted as a argument. Options that are full words use --</code>, an example would be ls --version</code>.</p>
In this case the -l</code> option of the ls</code> command causes the file list to be more "list like" and it shows some scary things as well. Like drwxr-xr-x</code>, these are file permissions which we will cover later.</p>
koen@helios:~$ ls</span> -l
</span>total 48
</span>drwxrwxr-x 43 koen koen  4096 sep 22 10:37 Code
</span>drwxr-xr-x  2 koen koen  4096 aug 22 09:32 Desktop
</span>drwxr-xr-x  8 koen koen  4096 okt 18 12:35 Documents
</span>drwxr-xr-x  2 koen koen 12288 okt 18 12:35 Downloads
</span>drwxr-xr-x  2 koen koen  4096 mei 20 23:58 Music
</span>drwxr-xr-x  2 koen koen 12288 okt 14 13:31 Pictures
</span>drwxr-xr-x 19 koen koen  4096 sep 15 14:07 snap
</span>drwxr-xr-x  2 koen koen  4096 jun  1 19:42 Videos
</span></code></pre>
Listing files in a specific folder</h3>
Now that we have a sense of where we are. We are not just bound to exploring the contents of the current folder. By passing an argument to ls</code> we can just as well show the contents of other folders.</p>
To see what is hiding in the Downloads folder we pass Downloads</code> as an argument to ls</code>. Keep in mind here that Bash is case-sensitive. So ls downloads</code> is not</strong> the same as ls Downloads</code>.</p>
koen@helios:~$ ls Downloads
</span>'Pizza: A Global History.pdf'
</span></code></pre>
Right that is a must-read indeed.</p>
You should have TAB completion for this. So as soon as you typed ls Dow</code> you should be able to press TAB, and Bash will autocomplete. This TAB completion works if there is one unique match for your argument. So if you would type ls Do</code> and press TAB Bash nothing happens. Since both "Downloads" and "Documents" start with "Do". If you press TAB twice though Bash will show the matching suggestions.</p>
koen@helios:~$ ls Do
</span>Documents/ Downloads/
</span></code></pre>
Moving around</h3>
That listing the files in the Downloads</code> folder could have been done in a two-step process as well. By moving into that folder and list the files and directories from there.</p>
To move around we use cd</code> to c</u>hange d</u>irectory.</p>
koen@helios:~$ cd Downloads
</span>koen@helios:~/Downloads$ ls
</span>'Pizza: A Global History.pdf'
</span></code></pre>
Notice that for the first time the command didn't output anything. In many cases in Bash, no output is good output. For commands like cd</code> you generally only see output when an error occurs. Like when you try to move into a non-existing directory for example.</p>
You might have noticed that the prompt changed as well. Instead of ~</code> now ~/Downloads</code> is shown. As mentioned earlier the prompt shows the current working directory. That tilde(~</code>) character is an abbreviation for your "Home" directory, so /home/koen</code> is my case.</p>
Absolute and relative paths</h3>
To move back to the "Home" directly you can use cd /home/koen</code>, if your user is called "koen" at least. The /home/koen</code> part is what is called an absolute path</strong> because starts from the root of the file system(/</code>) till where you want to end up. This is in contrary to navigation with relative paths</strong> like the double dots we saw earlier. Where you navigate relative from your current working directory or relative from your home directory.</p>
Going up a directory</h3>
To get back in our home directory again for the "Downloads" we have to go one directory "up". Therefor we use cd ..</code>, the ..</code> reference the parent directory of the current directory. So cd ..</code> would translate to: change directory to the parent directory of my current working directory</em>.</p>
Going from /home/koen/Downloads</code> to /home/koen</code> again.</p>
koen@helios:~/Downloads$ cd ..
</span>koen@helios:~$
</span></code></pre>
Returning home</h3>
Since going to your home directory is quite common this is the default for cd</code> if you don't provide it an argument. So instead of the cd ..</code> from above you could actually achieve the same with just cd</code> in this case.</p>
More on cd</code></h3>
Since you're gonna use cd</code> lots of times. Here is a little overview of useful commands. They are assumed to be ran from the home directory for this example.</p>
Command</th> Where you end up</th> Explanation</th></tr></thead>

cd</code></td> /home/koen</code></td> Your home directory is the default for cd</code>, so wherever you run this you return home.</td></tr>
cd ~</code></td> /home/koen</code></td> The ~</code> is a shortcut for your home directory, you can use it in commands as well.</td></tr>
cd ..</code></td> /home</code></td> You go one directory up in the file system tree.</td></tr>
cd ../koen</code></td> /home/koen</code></td> You go one directory up in the file system tree and from here you go in the directory koen</code>.</td></tr>
cd Downloads</code></td> /home/koen/Downloads</code></td> Go into the Downloads</code> folder from your current directory.</td></tr>
cd ~/Downloads</code></td> /home/koen/Downloads</code></td> Go into the Downloads</code> folder from your home directory.</td></tr>
cd /home/koen</code></td> /home/koen</code></td> Go to your home directory by using an absolute path.</td></tr>
</tbody></table>
Files and directories</h2>
In the previous section we moved around in directories that were already there. In this section we learn to make our own directories and files using the shell and manipulate them.</p>
Creating files and directories</h3>
To make a new directory you use mkdir</code>.</p>
koen@helios:~$ mkdir juice
</span>koen@helios:~$
</span></code></pre>
As mentioned before, ofter no news is good news with Bash. We don't actually get feedback that the directory is created but it is there, as we check with ls</code>.</p>
koen@helios:~$ ls
</span>Code  Desktop  Documents  Downloads  juice  Music  Pictures  snap  Videos
</span></code></pre>
To give an example if bad news. You can move one directory up, outside of your home directory. If you try to make a directory here you normally see an error message. We get into permissions</a> later, but as the message says your user does not have permissions to create a directory here.</p>
koen@helios:~$ cd ..
</span>koen@helios:/home$ mkdir lemonjuice
</span>mkdir: cannot create directory ‘lemonjuice’: Permission denied
</span></code></pre>
Lets get back to the safety of our home folder before we continue.</p>
koen@helios:/home$ cd
</span>koen@helios:~$
</span></code></pre>
Directories are pretty useless when they are empty. So lets fill one we created earlier with some juice recipes. For creating files we can use the touch</code> command.</p>
koen@helios:~$ touch juice/apple-juice.txt
</span>koen@helios:~$
</span></code></pre>
Again no news is good news. We can speed things up a bit and create multiple files at once by passing multiple arguments.</p>
koen@helios:~$ touch juice/tomato-juiec.txt juice/banana-smoothie.txt
</span>koen@helios:~$
</span></code></pre>
If we now list the contents of the juice folder with ls</code> we see the files we created with touch</code>.</p>
koen@helios:~$ ls juice/
</span>apple-juice.txt  banana-smoothie.txt  tomato-juiec.txt
</span></code></pre>
Moving files</h3>
The command to move files and directories is mv</code>. You use it to move files and directories around. Like how you would drag files and folders around in a graphical file browser.</p>
To move a file or directory you pass two arguments to the mv</code> command. First you specify what you want to move and second where you want to move it to.</p>
Another practical use-case is renaming files so lets use the mv</code> command to fix that typo I made before.</p>
koen@helios:~$ mv juice/tomato-juiec.txt juice/tomato-juice.txt
</span>koen@helios:~$ ls juice/
</span>apple-juice.txt  banana-smoothie.txt  tomato-juice.txt
</span></code></pre>
Lets say that we want to categorize a bit more. We have a smoothie in there which is sorta juice but also sorta not. To do this we'll add a subdirectory to the juice folder and move the banana-smoothie.txt</code> file in there.</p>
koen@helios:~$ mkdir juice/smoothie
</span>koen@helios:~$ mv juice/banana-smoothie.txt juice/smoothie/
</span></code></pre>
Where before we had to specify the file name to move it. Here the destination we passed to the mv</code> is a directory. To check whether this worked we can use the tree</code> command. This command lists directory structures. By default it is might not available though.</p>
To check the files and folders in the juice folder we pass it as an argument to the tree</code> command and see for yourself. In the juice folder there now is a smoothie folder containing the banana-smoothie.txt</code> file.</p>
koen@helios:~$ tree juice/
</span>juice/
</span>├── apple-juice.txt
</span>├── smoothie
</span>│   └── banana-smoothie.txt
</span>└── tomato-juice.txt
</span>
</span>1 directory, 3 files
</span></code></pre>
Copying files and directories</h3>
Lets say I want to make banana-kiwi smoothies too. Which are pretty similar to banana smoothies so it would be a waste of time to rewrite the whole file. This is where to cp</code> command comes in handy.</p>
koen@helios:~$ cd juice/smoothie/
</span>koen@helios:~/juice/smoothie$ cp banana-smoothie.txt banana-kiwi-smoothie.txt
</span>koen@helios:~/juice/smoothie$ ls
</span>banana-kiwi-smoothie.txt  banana-smoothie.txt
</span></code></pre>
Look at that, super easy. And it works for directories too. However, when you want to copy a directory you need to use the -r</code> option which stands for recursively. Which basically means, copy the folder and its contents to a new location.</p>
koen@helios:~/juice$ cp</span> -r</span> smoothie/ healthy
</span>koen@helios:~/juice$ tree
</span>.
</span>├── apple-juice.txt
</span>├── healthy
</span>│   ├── banana-kiwi-smoothie.txt
</span>│   └── banana-smoothie.txt
</span>├── smoothie
</span>│   ├── banana-kiwi-smoothie.txt
</span>│   └── banana-smoothie.txt
</span>└── tomato-juice.txt
</span>
</span>2 directories, 6 files
</span></code></pre>
Removing, danger!</h3>
Okay lets face it. I am not gonna keep the juice folder and its files. So time to learn about removing files with the rm</code> command. Some caution is necessary here. In Bash you don't have the safety net of a Thrash folder. Once it's gone it's gone.</p>
Lets start with tomato juice since it turns out to be not very tasty. So it deserves a special treatment.</p>
koen@helios:~/juice$ rm tomato-juice.txt
</span>koen@helios:~/juice$ ls
</span>apple-juice.txt  healthy  smoothie
</span></code></pre>
You can't remove the directory you are currently in. Lets go back to your "Home" directory and remove the juices folder all together. Since we are now dealing with a directory we need to use the same -r</code> option as for copying.</p>
koen@helios:~/juice$ cd
</span>koen@helios:~$ rm</span> -r</span> juice/
</span></code></pre>
So the juices folder is gone now and there is no way to get it back unless we had a backup.</p>
Hidden files</h3>
A special kind of files and directories are hidden ones. Since they are hidden you might not have noticed them. Hidden files start with a .</code>. Mostly these files are created or used by program to store data or configurations.</p>
Bash creates these files as well, for example the .bash_history</code> file in which your latest commands are stored. You can make these hidden files appear by adding the -a</code> option to the ls</code> command.</p>
koen@helios:~$ ls -al
</span>total 1040
</span>drwxr-xr-x 35 koen koen   4096 okt 18 13:58 .
</span>drwxr-xr-x  3 root root   4096 mei 31 12:44 ..
</span>-rw-------  1 koen koen     11 jun 12 16:42 .bash_history
</span>-rw-------  1 koen koen     11 jun 12 16:42 .bashrc
</span>drwxr-xr-x 30 koen koen   4096 okt 18 09:44 .cache
</span>drwxrwxr-x 43 koen koen   4096 sep 22 10:37 Code
</span>drwxr-xr-x 45 koen koen   4096 sep 29 14:15 .config
</span>...
</span>drwxr-xr-x  2 koen koen   4096 jun  1 19:42 Videos
</span></code></pre>
Permissions</h2>
Linux and pretty much all other operating systems are set up to support multiple users. So for security reasons it makes sense that not all users can access all files.</p>
Users and groups</h3>
As we saw before, in the output of the ls -l</code> command my name was in there twice. The first appearance on koen</code> indicates that the file is owned by a user called koen</code>. The second appearance is the name of a user group, in my case the group has the same name as my user.</p>
koen@helios:~$ ls</span> -l
</span>total 52
</span>drwxrwxr-x 43 koen koen  4096 sep 22 10:37 Code
</span>...
</span></code></pre>
File permissions</h3>
Why those user groups are useful have to do with file permissions. The permissions as shown using the somewhat cryptic drwxrwxr-x</code>.</p>
The first character in drwxrwxr-x</code> indicates whether we are looking at a file or directory. In this case the first character is a d</code>, for directory. For files a hyphen(-</code>) is used.</p>
The other characters are actually a repetition of three times three characters that specify the permissions. The characters are r</code>, w</code> and x</code> and they mean the following:</p>

Read (r) permissions for the file or directory. This means you can view the file contents if it is a file or list the contents of the directory if it is a directory.</li>
Write (w) permissions to the file or directory. Meaning you can change the content of the file. Or in case of a directory, you can modify its content like deleting files.</li>
Execute (x) permissions. Meaning you can execute the file, like using it as a command. Or cd</code> into it if it's a directory.</li>
</ul>
This sequence of three characters is repeated three times to indicate the permissions for the owner, user group and the others. Seeing the character means the permission is applicable, if you see a hyphen it means you don't have that permission.</p>
So to use drwxrwxr-x</code> as an example. We covered d</code> already. Next is rwx</code> for the file owner. This means that the file owner has read, write and executable permissions for this directory. Next is again rwx</code>, meaning that all users belonging to the group have read, write and executable permissions as well. At last is r-x</code>, these are permissions for all users that are not the file owner and do not belong to the user group. In this case all other users have permissions to read and execute. Not</strong> to write because at the position of the w</code> a hyphen is shown.</p>
Root user</h3>
There is one special user which is called root</code>. This user is a superuser account which have more access rights. You use this user mostly to do administrative tasks, like installing a new package for example.</p>
Most commonly to do so is by using a program called sudo</code>. Which allow you to do something as super user. You put this in front of the command you would like to execute. Like this for example, you are most likely prompted for you password when you run it.</p>
koen@helios:~$ sudo mkdir /home/test
</span></code></pre>


Zypper cheat sheet
2020-02-11T00:00:00+00:00
Zypper is the package manager of OpenSUSE and SUSE Linux. The basics are pretty easy to remember but sometimes a cheat sheet is just handy.</p>
Package Management</h2>
zypper install (in)</h3>
Install a new package, if the specified package is already installed it will be updated.</p>
$ zypper install php7
</span></code></pre>
The same, but using the shorthand in</code> notation.</p>
$ zypper in php7
</span></code></pre>
In case you need a specific version of a package you can add preferred version number right after the package name followed by an equal sign.</p>
$ zypper in zypper=1.14.30
</span></code></pre>
In OpenSUSE packages can be installed as pattern too. Patterns in OpenSUSE are basically a group of related packages that are required to run a specific piece of software. Like installing the desktop environment xfce</code> for example, which requires other packages such as the X Window System.</p>
Instead of installing these packages individually, all of these packages can all be easily installed as a pattern by the following command.</p>
$ zypper in</span> -t</span> pattern xfce
</span></code></pre>
zypper remove (rm)</h3>
Uninstall the specified package and their, possible, dependent packages.</p>
$ zypper rm php7
</span></code></pre>
The same, but using the shorthand rm</code> notation.</p>
$ zypper rm php7
</span></code></pre>
zypper info (if)</h3>
Displays detailed information about the specified packages.</p>
$ zypper if php7
</span></code></pre>
Show symbols the package requires.</p>
$ zypper if</span> --requires</span> php7
</span></code></pre>
zypper verify (ve)</h3>
Check whether the dependencies of installed packages on your system are satisfied and possibly installing missing dependencies.</p>
$ zypper ve
</span></code></pre>
Update Management</h2>
zypper update (up)</h3>
Update installed packages with newer versions.</p>
$ zypper up
</span></code></pre>
Update a specific package with a newer version.</p>
$ zypper up php7
</span></code></pre>
zypper list-updates (lu)</h3>
List installable updates.</p>
$ zypper lu
</span></code></pre>
zypper dist-upgrade (dup)</h3>
Perform a distribution upgrade.</p>
$ zypper dup
</span></code></pre>
Query Commands</h2>
zypper search (se)</h3>
Search for packages matching any of the given search strings.</p>
$ zypper se mysql
</span></code></pre>
Search using a wildcard.</p>
$ zypper se </span>'yast*'
</span></code></pre>
Search for packages that provide a specific binary.</p>
$ zypper se</span> --provides --match-exact</span> npm
</span></code></pre>
zypper packages (pa)</h3>
Show packages which are orphaned (without repository).</p>
$ zypper pa</span> --orphaned
</span></code></pre>
Show packages which are unneeded.</p>
$ zypper pa</span> --unneeded
</span></code></pre>
zypper patterns (pt)</h3>
List all available patterns or all patterns from specified repositories.</p>
$ zypper pt
</span></code></pre>
Repository Management</h2>
zypper addrepo (ar)</h3>
Add a new repository specified.</p>
$ zypper ar
</span></code></pre>
zypper removerepo (rr)</h3>
Delete repositories specified.</p>
$ zypper rr
</span></code></pre>
zypper repos (lr)</h3>
List all defined repositories.</p>
$ zypper lr
</span></code></pre>
zypper refresh (ref)</h3>
Refresh repositories specified by their alias, name, number, or URI.</p>
$ zypper ref
</span></code></pre>
zypper clean (cc)</h3>
Clean the local caches for all known or specified repositories.</p>
$ zypper cc
</span></code></pre>
Package Locks</h2>
zypper locks (ll)</h3>
List currently active package locks.</p>
$ zypper ll
</span></code></pre>
zypper addlock (al)</h3>
Add a package lock.</p>
$ zypper al php7
</span></code></pre>
zypper removelock (rl)</h3>
Remove specified package lock.</p>
$ zypper rm php7
</span></code></pre>

Create a type alias in Rust

Fix `character literal may only contain one codepoint` error in Rust

Parse a file in Rust

Parse integer from string in Rust

Split string by whitespace in Ruby

Clone objects in Ruby: dup vs. clone

Filter JavaScript array by object property

PHP Arrow Functions

Remove an element from an array in Ruby

Add item to hash in Ruby

Ruby: search for value in hash

Iterate through a hash in Ruby

Merge hashes in Ruby

Split a string in Rust

Update a Ruby gem with bundler

Connect to NordVPN on login in Linux

Join an array of strings by a comma in Ruby

Remove an installed Ruby gem

Base64 encode a Ruby hash

Ruby: Check if string contains substring

String interpolation in Ruby

Custom CLI commands in Ruby on Rails

Vue.js: Specify multiple types for component props

Rename a column in a Laravel migration

PHP: Sum values in a multidimensional array

Remove a foreign key constraint in a Laravel migration

Remove duplicate values from a JavaScript array

Return Laravel validation errors as JSON

Use Bootstrap for pagination links in Laravel

Bitwise AND operator in PHP (&)

PHP: Get the class name of an object without namespace

Create a Zip file using PHP

Remove a key from the request input in Laravel

Fix the `403 This Action Is Unauthorized` error in Laravel

Laravel: Apply validation rules only if the field is present

Bash: Assign default value for a positional parameter

Difference between web and api routes in Laravel

Check if a variable exists in Laravel Blade templates

PHP: How to check whether a key exists in an array

How to raise custom exceptions in Ruby

Laravel: hot-reload Blade templates with Vite

Laravel: Set the Content-Type header to application/json

Iterate over the keys in an object using Object.keys()

Check the type of a variable in JavaScript using `typeof`

Remove duplicate values from an array in PHP

PHP - Check if array contains a value

Check if a number is an integer in JavaScript

Reverse a string in JavaScript

Git worktree workflow with release branches

Fix `Configure your bundler to alias 'vue'` in Vite.js

Module aliases in Vite.js

Bash: loop over arguments passed to script

How to use environment variables in Vite

JavaScript: Split a string on a character

Check if any arguments are passed to a bash script

Run the Vite dev server on a custom port

Set the required PHP version with composer

Fix 'No database selected' error in MySQL

Redirect to a different route in Laravel

Render HTML safe content in Laravel Blade

Return a 404 response in Laravel

Delete all Laravel models in a table

Removing packages with pipenv

Create custom error classes in JavaScript

Update installed packages on Ubuntu

Get a random item from an array in PHP

Check if PHP array is empty using count()

PHP: Check if a variable exists

Enums in TypeScript

What create mode 100644 means in git

Get the length of an array in PHP

HTTP Redirects with plain PHP

Check if PHP script is served over HTTP or HTTPS

Fix `zsh: permission denied: ..` going up one directory

Alternative to the ternary operator in Rust

MySQL: Show the tables in your database

Make Laravel model with migration, controller and factory

PHP Spaceship Operator (<=>)

Remove leading whitespaces from a JavaScript string

Disable beep/bell in tmux