hjertnes.blog

What I expect from an A5 notebook

22.10.2017 02:00

```text This is just a short list of what a A5 notebook should be like in order to be the most useful to me ```

```text
  • Lined or grid
  • I prefer lined for long form writing and dot grid for tasks.
  • Hardcover; because it is much more convenient when I write somewhere I don’t have a flat surface available.
  • At least two markers
  • I prefer three
  • The paper should be good; Leuchtturm1917 or Rhodia quality is the standard I expect.
  • And then I mean both paper quality and shorter dry time.
  • ```

    Understanding ForEach

    20.10.2017 02:00

    ForEach is the second of two different methods that exists in the Array prototype for looping over a array. The difference between the two is that map does not mutate the original array, while forEach does. Let’s take a look at the example below:

    It looks and works <em>kind of</em> the same. The big difference is that forEach will <em>mutate</em> the orignal array, but it will not return a new array. This means that it will <em>change</em> it according to the code you write, but it will replace it with undefined if you try to do something like <code>myList = myList.forEach(...)</code> </div>
    

    Understanding Map

    19.10.2017 02:00

    Map is one of two functions in the Array prototype that let you iterate over an array. Just like reduce, filter and fine it takes either a expression or a function as its first parameter. Look at the example below:

    ```text The way map works is that it runs the function you define in the first parameter once per element in the array you run it on. A map should always return something, and it never mutates the data you run it on.
    This means that row three of our example will not do anything, because map will produce a new array, that you need to replace your first one with, if that’s what you want.
    To work with array in this way is less error prone and have less if not zero side affects, than to mutate it using for example a for loop. But it might be slower; I personally think that most people that run into this kinde of performance trouble probably have some other "issues" in their code.
    I jumped in with both feet as soon as I discovered map, and never looked back. ```

    Understanding filter

    18.10.2017 02:00

    There are three javascript methods I use more than anything else: map, find and filter. Find and filter are kind of two sides of the same coin. The only difference is that find returns either the element it matched with or undefined while filter returns either an array with all the matches or an empty array. The way a filter works, is that you give it either a function or a simple expression as its only parameter, and all the elements that return true is included while everything that return false is not. Look at the example below:

    ```text Remember: filter will not mutate your original array, so you need to replace it if that is what you intended to do.
    The thing I love about filters is how easy it is to make a bunch of small filter expressions, instead of large and complex ones, and you’ll end up with code that is very easy to read and maintain.
    I don’t even want to think about how we did it before filter. Probably a bunch of for loops and adding stuff that matched to a new array and then replacing them. ```

    Understanding find

    17.10.2017 02:00

    Find is a method you can use on any array in Javascript. You use to find a single element in a array. It is very similar to for example filter(covered in a future post), the big difference between the two is that find returns a single element or undefined; while filter returns an array of matches or a empty array if none are found. For example like this:

    ```text You provide it with either a full function, arrow function or a simple expression, and it returns the first match or undefined; if you don’t have any matches.
    This is usually how I did it before I discovered .find: ```

    ```text Or even worse, some horrible for loop with a break. ```

    Understanding Reduce

    16.10.2017 02:00

    ```text Reduce is a in the Array.prototype; which means you can run it on any array or list. It is a method that lets you reduce a list or collection down to a value. ```

    ```text You have probably written something like this more times than you care to ```

    ```text The next time you’re about to do that, is the perfect time to figure out how reducers work. Because those four lines can be replaced by a single line using a reducer. ```

    ```text This is how it works. Reduce takes a function as its argument, and you can also provide an optional default value. I almost always do that. The function takes two arguments one accumulator and the currentValue. The accumulator is the result of what the reducer have done up to this point, and the currentValue is the value of the item in the array. ```

    ```text For example, the first time it is called in our simple example above the parameters will be (0, 1) and then it will be (1, 2) and so on. ```

    ```text I personally think that reducers is a great way to turn a array of values or objects into a single value. They produce less code than looping over them. And as a bonus: they have far fewer side affects. ```

    OS X

    15.10.2017 02:00

    ```text There are a few tasks I have to break down into small chunks. One of them are maintaining the “Audit” section of 1Password, another one is to manage Notifications on OS X. ```

    ```text The short version is: I don’t want any. ```

    ```text So. The way you disable notifications on OS X, is more or less the same as iOS. You have to you through every singe app and disable everything. And it is a major pain in the ass. ```

    ```text My problem with it is two fold. First of all, why not let me mark all of them and do what ever I want to do with either all or any selection of apps. Second, why do I have to click a million different things to just disable notifications? ```

    ```text This is one of the areas where the iOS influence on OS X was wrong. Not the inclusion of it, but rather that the interface are lacking every ability to work efficient. ```

    Something between the sample and a bottle.

    15.10.2017 02:00

    ```text When I want to test an ink, I have two options either I buy or trade a sample or I buy a full bottle. I would probably just get the bottle because it is not THAT expensive. ```

    ```text What I want is something bigger than a sample, but smaller than a 50ml bottle. 10 or 15 ml would be perfect. Because a small sample is never enough for me to do a proper test. I like to test it in many different pens in order to get the full picture of how a ink behaves. But the problem with the full bottle, is of course to get rid of it, if you don’t like it or don’t see yourself using it all. ```

    ```text The reason I try to always test a ink with as many pens as possible is because to use a ink with a finer nib versus a broader one or a dry pen vs wet pen is very different. The colours are different. And the dry time is different. ```

    ```text Some inks look better with a fine line, while others look much better with a big wet one. And some inks are just unusable with a wet nib because you have to take a nap while you wait for a page to dry ```

    Welcome

    11.10.2017 02:00

    Too many Javascript blogs isn’t possible, right?

    ```text The pitch for this blog is a collection of short and easy to understand explanation of something related to Javascript. I might sneak in some related topics here and there. But the core focus will be javascript; both as a front end and back end language. ```

    ```text I’ll publish one post per weekday. ```

    ```text Enjoy. ```

    Review

    08.10.2017 02:00

    ```text I received the [Code & Quill Origin](Code & Quill Origin Grey Dotted + Linjert A5 Hardcover Notatbok – Tudos) free of charge from Tudos for the purpose of reviewing it. ```

    ```text This is a A5-ish notebook with dot grid on the left side and lined on the right side – what I usually call dual layout. The paper is okay, but it bleeds through a little bit more than I’m used to. It’s not that bad, but a little bit worse than for example Leuchtturm1917. ```

    ```text The design of this notebook is not ugly, but it isn’t anything I like either. The only way to describe it is how iOS apps used to look before everything went “flat”. There are probably some people that love how it looks. But it isn’t my kind of thing. ```

    ```text My three big complaints of this notebook is: ```

    ```text
  • The paper quality makes something to be desired. Close, but no cigar.
  • The lack of felt page markers is really annoying.
  • The format of the book is similar to A5, but a little bit shorter. This drives me nuts. Why wouldn’t you follow an established standard? This is the kind of thing where I mumble “fucking Americans”, we have the metric system and various other systems for a reason.
  • ```

    ```text I have used dual layout notebooks before, mainly the Field Notes special edition from about three years ago, or something. And it never clicked with me. My opinion have been that people should get a Travelers Notebook and fill it with different refills if they just want multiple page layouts in their notebook. ```

    ```text The way I usually use notebooks are either long form writing or writing down lists. And to use a dual layout for something like that is either confusing or plain wasteful. So what I had to do in order to test out this notebook was find something I could use it for where it made sense to have one layout here and another one over there. ```

    ```text I decided to use it for creating “mockups” for app and web development stuff I do at work and for fun. This means I need to carry another notebook, and that was exactly what I needed… ```

    ```text The dual layout is good for some stuff. And my mock up notes are less messy and easier to understand when I use the grid for the mockups (crappy drawings) and the lined part for describing what it is. ```

    ```text Now. I’m not 100% sure if the improvement is big enough for me to justify carrying another notebook. I guess time will show. ```