arthofer.sh

Easy Is Not Simple

Fri, 17 Jan 2025 19:09:00 +0200

I’m faced with a lot of what is hip and bleeding-edge in IT in my professional work every day. And for some time now, i had this weird, subtle feeling that something is “off”. Things are supposed to be easy to work with and get a lot of shit done. But it doesn’t feel like it. All those supposed easy interfaces to get stuff done are putting a ton of mental load on you, even for tasks which should be very simple. And when something goes sideways there are suddenly a lot of flaming hoops to jump through to actually get to the point of debugging something.

And recently i realized my problem with all of this: none of those tools are simple anymore.

The tech stack which is required to run a stupid “hello world” on a given Kubernetes cluster is just gigantic. The amount of moving parts involved here are is staggering. And Kubernetes is just an example. It is the same nearly everywhere. On the way to “ease of use”, things have become unbelievably complicated under the hood. Another classic example is systemd on my beloved Linux. While i do understand some of the initial motives, it has grown into a gigantic pile of interwoven moving parts which are hard to really understand well. Sure, some things might be easier to do with it, but it definitly isn’t as simple as oldschool rc-scripts. Those have their problems, but they’re easier to understand.

There is (supposedly) easy to use. And there is easy to understand. I mean really understand how a given thing works. This is only possible if something is relatively simple.

Simplicity is hard to achieve. It is way easier to just throw stuff together until it kinda works in some way. But what is lost with that approach is actually understanding what the fuck is happening. Things become unmaintenable very fast. And this is not only a problem in IT. It is everywhere in this modern, “civilized” world we live in.

Can it be nice to stream music over the internet on your phone while it’s connected to your cars stereo via Bluetooth? Sure. Until you drive briefly through a narrow valley. Or the streaming app crashes/malfunctions for whatever reason. Or Bluetooth is acting up. Putting some kind of physical media (tape, CD, Minidisc…) into a dedicated device has always worked more reliably for me. And i don’t have to fucking re-pair the thing or wait a minute until it decides to maybe finally connect. Put the media in, it gets played. It’s simpler.

Or modern roadbikes. They tend to come with fully electronic shifting nowadays, most even wireless. It shifts very precise and very fast, which is great. Until you forget to charge the battery. One of the great things about bikes in general is, that they’re very simple machines. I honestly don’t understand why it is necessary to introduce complexity here. Cable-based shifting might need a tiny bit of maintenance from time to time. But it is very simple and probably everybody can do it themself.

This topic is bothering me for a while now and i’ll continue to spend time to think and research about this in general.

Thanks for Ruining the Internet

Sat, 13 Jul 2024 19:25:58 +0200

I admit I’m guilty. I had a Facebook account once. But i deleted that one years ago. I had an Instagram account once. also deleted that one years ago. I had a Twitter account once, deleted it once the crazy, spoiled idiot took over. I had a Reddit account once, deleted it when they went full-moron

The Shit shows

Facebook

I joined it after some “social pressure” after resisting for a while. It was kinda fun in the beginning, but commercialization made it worse and worse rather fast. At some point i stopped attending and didn’t even silently check on it anymore. A bit after that i deleted the account. Nothing of value was lost.

Instagram

Joined out of curiosity and because I’m into photography and wanted to share some pictures. Also was a bit of fun in the beginning, but at some point i noticed that i started to think idiotic thoughts like “if i post this, it could get some likes”. Which disgusted me. I’m not some influencer marketing slave zombie. A while after that i deleted my account and nothing of value was lost here as well.

Twitter

Had my first account on there rather in the beginning. It was fun. Lots of weird people from all over the world. Was nice to just blast out some random thoughts and sometimes getting a response on it from somebody. But i somehow got bored with it after a while and deleted the account. A few years ago i created an account there again. I think i wanted to follow some specific people and also stay up to date and “in the game” with what this IT business madness is. Actually connected with a small handful of local people there, which lead to attending a few very relaxed meetups with fellow nerdy people. Also gave some talks there. Rest in peace “Infrastructure as a Meetup”-meetup, you were a good one (more on that maybe in another post). Overall it was sometimes fun, but not as much as in ye olde days. Already thought a while about getting rid of the account and thanks to The Idiot taking over, the decision was very easy in the end.

Created my account there quite some while ago. When the “old” layout was still the only one. It was really fun for a long while. Having all those niche communities in one place made it very easy to discover new things. But in the end the turbo capitalists once more took over and shat into everyone’s soup. When they decided to basically block alternatives clients the fun was gone for me. I let the account alive for a little longer, but once they announced to feed all the Reddit content into some Artificial Imbecile i deleted it instantly. A little bit of value was lost for me, but nothing serious.

Back to the basics

All of this threw me back into the corners of the internet where i actually feel comfy. Mastodon is a so much nicer place to be than Twitter every was. Lemmy, while still rather small and missing some of the communities i liked on Reddit, is also so much better. Being on a platform that has not been created with the main goal of earning money with it really makes a gigantic difference. The instances are all just run by some random people for the fun of it. They sometimes ask for a little donation to keep the lights on, but that is obviously more than OK. I’m thankful that somebody is running the instances I’m on. Keeping stuff updated and online can be challenging, so it is really OK to ask to at least share the bill. It is very nice to be back in the weirder internet. Where people exchange knowledge because they’re interested in a topic. Where people actively mix computer stuff with occultism. Where i don’t have the feeling every second person is trying to sell me something.

So i guess i have to say “Thank you!” to all the nasty, idiotic, greedy tech bros for ruining the commercial social media platforms. This drove me back into the waters where i belong. Also probably a “Thank you!” for actively fucking up the rest of the internet. It keeps doing things like we did 20 years ago interesting and actually makes it necessary.

I really like the basic idea of the internet, but we must drive out the money.

Nested Maps in Go

Fri, 22 Apr 2022 20:00:15 +0200

I recently had to use a bunch of nested maps in Go and struggled way too long to get them “working”. And obviously there wasn’t a lot of good information to be found via $popular_search_engine. So i thought this might make a good blog post.

What gave me the proper nudge in the correct direction of thinking correctly was a Google Groups posting from 2012: https://groups.google.com/g/golang-nuts/c/PoRkoN84KKU/m/7330L9NulHQJ

TL;DR

You need to actually initialize every inner map seperatly if you want to use it! For more details you should read the rest ;-)

A simple example and the attempt of an explaination

Lets create a simple example to demonstrate the issue at hand:

$ go mod init nested_maps
go: creating new go.mod: module nested_maps

$ touch nested_maps.go

Now open nested_maps.go in your favorite editor and paste in the following piece of code:

package main

import (
	"log"
	"encoding/json"
)

type people struct {
	Group string
	Name string
	Age string
}

type groups struct {
	Groups []people
}

func main() {
	var a = []byte(`{"Groups":[
		{"Group": "first", "Name": "Stanislaus", "Age": "23"},
		{"Group": "second", "Name": "Mechthild", "Age": "13"},
		{"Group": "third",    "Name": "Gunhilde", "Age": "42"}
	]}`)

	var peopleA groups
	err := json.Unmarshal(a, &peopleA)
	if err != nil {
		log.Fatal(err)
	}

	// here we assume at first that we create our nested map
	jsonData := make(map[string]map[string]string)
	for _, v := range peopleA.Groups {
		jsonData[v.Group][v.Name] = v.Age
	}
}

What we try to do here:

	jsonData := make(map[string]map[string]string)
	for _, v := range peopleA.Groups {
		jsonData[v.Group][v.Name] = v.Age
	}

is to put a JSON array, where each array element contains three key-value pairs that define a group name, the persons name and their age, into a nested map. The intention for this might be that we think processing the data via a nested map is nice. Or whatever.

While this compiles perfectly fine, running the created binary will result in this runtime error:

$ ./nested_maps
panic: assignment to entry in nil map

goroutine 1 [running]:
main.main()
	/home/flart/temp/nested_maps/nested_maps.go:34 +0x1e8

My n00bish reaction at first was “WTF? I created the map with make(). It’s not nil!” But obviously i was terribly wrong.

What happens here is that Go creates the outer map but nothing else. And this makes perfect sense since it can’t possibly know how many inner maps we might want later on. It’s our job to take care of that.

A solution for that is extending our for loop like this:

	// here's our nested map
	jsonData := make(map[string]map[string]string)
	for _, v := range peopleA.Groups {
		// here we check if the inner map exists
		_, ok := jsonData[v.Group]
		if !ok {
			// if the inner map doesn't exist, we create it with make()
			jsonData[v.Group] = make(map[string]string)
		}
		// now we can safely fill up the nested map
		jsonData[v.Group][v.Name] = v.Age
	}

The comments hopefully speak for themselves, but anyways: What we added is a simple check if the inner map to which we want write data already exists. This is done with a simple map lookup, which in Go returns not only the potential value but also a boolean value on which we can do a simple check with if. So if we get a false back, we just create the inner map with a make() and all is good.

Here is the full example which executes without a runtime error:

package main

import (
	"log"
	"encoding/json"
)

type people struct {
	Group string
	Name string
	Age string
}

type groups struct {
	Groups []people
}

func main() {
	var a = []byte(`{"Groups":[
		{"Group": "first", "Name": "Stanislaus", "Age": "23"},
		{"Group": "second", "Name": "Mechthild", "Age": "13"},
		{"Group": "third",    "Name": "Gunhilde", "Age": "42"}
	]}`)

	var peopleA groups
	err := json.Unmarshal(a, &peopleA)
	if err != nil {
		log.Fatal(err)
	}

	// here's our nested map
	jsonData := make(map[string]map[string]string)
	for _, v := range peopleA.Groups {
		// here we check if the inner map exists
		_, ok := jsonData[v.Group]
		if !ok {
			// if the inner map doesn't exist, we create it with make()
			jsonData[v.Group] = make(map[string]string)
		}
		// now we can safely fill up the nested map
		jsonData[v.Group][v.Name] = v.Age
	}
}

Hope this helps somebody else at some point in the future :-)

TIL Memory Fragmentation

Sat, 22 Aug 2020 21:10:37 +0200

I was recently sent down a very nice rabbit hole of low-level operating system knowledge, which i would like to share here.

What the hell is happening?

We’re using Concourse as the main driver for pretty much all of our deployment automations in our team at my job. During some time frame in the end of 2019 and the beginning of 2020, we sometimes encountered rather strange errors in pipeline jobs, which then caused those jobs to fail. The pattern was always looking something like

iptables: vmalloc: allocation failure, allocated 0 of XXXX bytes

where the number at XXX was always different. But it was never something gigantic and the worker node where the job was running, definitely had enough memory available in total at this point in time, to serve that allocation request from iptables. And usually, the next run of that job went through just fine. So this was all very confusing and strange in the beginning.

Lets ask the internet

As it is common nowadays, we just put the error message from above into $search_engine and discovered, that we’re not the only ones with that problem. Somebody already opened and issue on the GitHub project of Concourse: https://github.com/concourse/concourse/issues/3127

As @circosta pointed out at https://github.com/concourse/concourse/issues/3127#issuecomment-484895481, this all seems to be caused by a bug in iptables: https://bugzilla.kernel.org/show_bug.cgi?id=200651 Basically, there was (at least for some time) a very restrictive flag set, when requesting memory via kmalloc (search for GFD_NORETRY on https://www.kernel.org/doc/htmldocs/kernel-api/API-kmalloc.html), which caused iptables to fail hard instantly. This was then fixed, as i understood it, by changing the flag to a bit less restrictive one.

OK, so memory was short and iptables decided to fail because it couldn’t get the amount it wanted. But wait… our monitoring did not show that the worker node was this much under memory pressure, that it couldn’t satisfy the request in question. Well, at this point in time, there was no good explanation for me. But we accepted that it’s basically a kernel bug, that was fixed in a later version. So we made sure our workers where running on a recent enough kernel version and where happy that those cryptic iptables errors disappeared. And i shoved all of this on some area in the backside of my brain.

…aaaand down the rabbit hole

Back then, i subscribed to the GitHub issue. Because i was majorly annoyed by the problem and i also have a weakness for such low-level issues :-) And recently i got an e-mail that somebody posted a new comment there: https://github.com/concourse/concourse/issues/3127#issuecomment-663520233

As @blairboy362 stated, this all seems to be a memory fragmentation problem. There was potentially enough total memory available on the host, but no big enough continuous chunk.

The mentioning of /proc/buddyinfo was the first step of this fall into the rabbit hole. Because i didn’t know it existed up until that moment. If you run cat on it, you’ll get a result that will look somehow like

$ cat /proc/buddyinfo
Node 0, zone      DMA      0      0      0      1      2      1      1      0      1      1      3
Node 0, zone    DMA32      7      8      7      7     13     10      9     10      3      8    419
Node 0, zone   Normal   1795  19012  11279   6581   5116   2335   1008    416    136     62   5294

…OK, what the fuck am i looking at? I did a quick search for /proc/buddyinfo in the interwebs, and stumbled upon this very nice explanation: https://www.uninformativ.de/blog/postings/2017-12-23/0/POSTING-en.html tl;dr: /proc/buddyinfo gives you information how fragmented your memory is. The Linux kernel allocates memory in chunks of 4KB, called pages. Each column shows how many units of pages of different sizes are available. The leftmost column being basic 4KB pages, the next column being 4^2KB pages….and so on. Meaning the last column shows the largest available continuous chunks of memory the kernel can allocate. Low or even none available blocks of memory on the right side are bad, indicating very fragmented RAM, which lead to failing larger allocation requests. Like with iptables in Concourse in the example above.

It’s pretty logical that memory can get fragmented, but i honestly never gave it a thought before. And i didn’t know i could check something in /proc for information about the state of fragmentation. Definitly makes sense to keep an eye on weird issues, because you most likely learn something new :-)

WTF is a Container?

Tue, 07 Jul 2020 19:22:36 +0200

Nowadays (and for quite some while now) everything seems to be somehow related to “containers”. Astonishingly, not a lot of people really know what a container actually is.

And it’s quite hard to find good technical information about this on the internet. Because if you search for it, you’ll find a shitload of crappy medium.com postings from some neighborhood startups, which are all talking about Docker and Kubernetes. But nobody explaining the underlying tech layer that makes all of this possible. Funnily, some of the most valuable information is in some man pages which you most likely have on your Linux machine.

Wrong

Most people seem to think that Docker images are containers, but this is wrong. A Docker image is just a compressed layered file system and some meta data, which can be used to spawn a container with.

Also, Kubernetes pods are not containers. They consist of at least one container, but there can be multiple bundled together in a pod. I’ll try to write something about that in the future.

And containers are not “some kind of virtualization”, it’s process- and resource isolation.

So what does this mean?

What everybody is calling a container, is actually just using a bunch of Linux kernel features to isolate a process (or more) from the rest of the system. Usually it also gets some resources like networking, disks and CPU shares assigned.

The two kernel features that enable this are namespaces and cgroups. Where namespaces define what a process can “see” and cgroups (short for “control groups”) define what a process is allowed to utilize.

There are currently namespaces for:

cgroups
IPC
network
mounts
PID
time
users
UTS

And cgroups for basically any resource a process would want to use.

I want more information!

Some people were already very nice and wrote a lot of information in man pages. So i will not copy that content onto my site to look smart. Good starting points are man namespaces and man cgroups. In there you’ll find pointers to more detailed information of the specific namespaces and cgroups.

Yes, i did just tell you to RTFM ;-)

Make Email Great Again

Sun, 05 Apr 2020 20:19:56 +0200

The situation

It’s the beginning of April 2020 and “COVID-19” happened. Nearly the whole world is in lock-down mode currently. Some more, some less. And most people are very worried.

I’m stupidly lucky to work at a company that reacted quite early and strict and went into full mandatory “work from home”-mode. And since it’s a very modern IT company, all of the work luckily can be done remotely. Because the internet exists and our whole infrastructure (at least the parts i know of) is available from every place in the world (with proper VPN of course).

Quite recently i got promoted to a team-lead position, which doesn’t mean “management” in our company, just that you’re the person that should take care about various organizational and operational topics. That means for example planning sprints and that I’m the main contact point for people outside of our team that need something from us.

Instant messaging is a problem, not a solution (at least at work)

So now I’m sitting at my cozy office at home and first was naively thinking “Well, at least I’ll get some actual development work done now. Because there will be less interruptions” ….Holy shit did i underestimate the interruptive power of instant messaging. In our case: Slack. And also Zoom meetings. Holy crap.

I’m about 3 weeks into government prescribed self-isolation and it feels like all i do during my working hours is constantly chatting and video-conferencing. Don’t get me wrong, those two can be quite valuable tools to keep up the social contact with my colleagues. But in my opinion, chatting is terrible for handling our “daily business”. You are confronted with a constant stream of tiny chunks of information. And not only from one source (person), but from multiple. At the same time. Usually about different topics. That’s like trying to watch 15 movies at the same time. Afterwards you’ve watched 15 movies, but you can’t barely remember any details. Of course this is a bit different with chatting. You might have the chance to stick with one conversation at a time, at least for a short time frame. But you’ll still jump around between conversations constantly. And it’s all for the greater good! You want to be a helpful colleague, you want to be responsive, you want to react quickly to whatever comes along…etc. And in the end, after your day of “work” is over, it will feel like you accomplished nothing. Sure, you answered lots of questions, helped others getting over some obstacle in their task, where a nice and overly helpful co-worker. But damn, I’m (more or less) a developer. I want to build something. Automate some annoying task, produce a piece of software for our customers, patch a bug….etc. But it’s impossible, because there’s always this nagging feeling that I’ve to answer somebody on Slack. Because that’s the expectation that comes with tools like that: instant feedback. But this is not how software development work. We deal with complex problems on complex systems and need to prioritize which of those problems we deal with in what order. That can’t be done with this kind of fragmented communication. It’s like I’m a server which gets bombarded with a constant flood of UDP packets on all ports. I need a firewall, a packet filter, a way to keep my communication-ports free and available. And also a way to reduce my own system-load to have resources free to get some actual work done.

E-Mail to the rescue?

This got me thinking. A lot. Back when i started working in IT,there was no instant messaging for “the masses” at work Sure, there was IRC, but it was only used by us nerds/geeks to keep in touch. And maybe sometimes to ask a quick technical question. But then you mostly got a pointer where to look for a solution to your problem (quite often the infamous RTFM). From what i experienced, most of the more serious technical discussions in the internet happened in mailing lists and the Usenet.

Maybe because an asynchronous medium is the better tool for the job? It’s just the modern version of writing a letter. When you write a letter, you (hopefully!) take your time to phrase the words for your objective properly. Because you want to make sure to get the whole idea to the other side of communication without going back and forth needlessly. You could say the limitations can be the main advantage here.

With instant messaging the conversation very often starts with a simple “hello”. Then nothing happens until you finally answer to find out what the person on the other side actually wants. This at least problematic enough that there is now a website which advocates against this exact behavior: nohello.com. I can only emphasize that even this small behavioral phenomenon can be quite a recurring problem during a typical day. And this is only the start of one single communication stream. Then you have to, quite often, pull it out of peoples noses what they actually want or need. Because they haven’t yet sat back for 5 minutes to think about it. They started a chat.

I do believe that this won’t happen as much with an asynchronous medium like e-mail. Nobody sends a mail with just “hello” in it (at least not in a professional environment). People tend to at least shortly think about what they want to tell or ask you. So this is the first part that’s better.

The second and at least evenly important part is: You can sift through your inbox in a way more structured manner. At the worst you do something like “from top to bottom” or “start with the oldest and work your way to the most recent”. But with every not completely crappy mail client you can apply some basic filtering. And the less crappy ones also have proper displaying of mail threads (no, the “threads” in Slack are not good enough), which helps understanding the flow of information quite a bit.

You ranted a lot, but what now?

I’ll try to move my communication more back to e-mails. That will definitely take some time since i got very used to Slack at this point of time. Ironically i was even annoyed by mails lately. Because it felt like it costs so much more time compared to just chatting. But as i rambled intensively above, the quality of information transported is potentially better with e-mails (at least that’s what i currently believe).

This will probably also take some understanding from my colleagues, since most things are communicated via Slack currently. I’m looking forward to some lengthy discussions here ;-)

I guess this will be some kind of experiment of going “back to the roots”. Maybe I’ll be posting some update to that later one. Assuming my co-workers haven’t chased my away with pitchforks and torches.

Vim with fancy code completion

Wed, 20 Nov 2019 21:26:00 +0100

I finally was annoyed enough to set up proper code-completion in Vim. This is mostly a highly condensed and simplified version of a great blog post from somebody else: https://octetz.com/posts/vim-as-go-ide

The main difference is that i’m not using Neovim. The reason being that i really like gvim and all the GUI options for Neovim are either bloated Electron abominations or just looking awkward.

Quick setup

Anyway, to replicate my setup you need:

Vim in at least version 8.0
The excellent vim-plug installed: https://github.com/junegunn/vim-plug
Go installed and properly configured (if you care about the Go integration)

Put this in your .vimrc:

" vim-plug config
call plug#begin('~/.vim/plugged')
Plug 'fatih/vim-go', { 'do': ':GoInstallBinaries', 'for': 'go' }
Plug 'tpope/vim-surround'
Plug 'scrooloose/nerdtree', { 'on':  'NERDTreeToggle' }
Plug 'neoclide/coc.nvim', {'branch': 'release'}
Plug 'sheerun/vim-polyglot'
Plug 'PProvost/vim-ps1'
call plug#end()

Then either open Vim and run :PlugInstall, or run it via your shell with vim +PlugInstall. The result will be the same. You’ll get some progress indicators and in the end a confirmation that all the wanted plugins are installed.

Explaination of the plugins from above:

vim-go: Go development plugin (https://github.com/fatih/vim-go)
vim-surround: nice helper for changing quotes, braces…etc (https://github.com/tpope/vim-surround)
nerdtree: file browser thingy (https://github.com/scrooloose/nerdtree)
CoC: code completion engine black magic (https://github.com/neoclide/coc.nvim)
vim-polyglot: language pack collection (https://github.com/sheerun/vim-polyglot)
vim-ps1: powershell plugin (yes, some of us have professionally deal with that) (https://github.com/PProvost/vim-ps1)

Install language servers

coc.nvim enables you to use the very nice concept of language servers (https://en.wikipedia.org/wiki/Language_Server_Protocol). So to use that, you need to install some of them. On Arch you’d do something like

$ pacman -S bash-language-server python-language-server

go-langserver can be installed with

$ go get -u github.com/sourcegraph/go-langserver

Configure language servers

To actually configure coc.nvim to make use of some language servers run :CocConfig in your Vim. Then configure it like:

{
      "powershell.integratedConsole.showOnStartup": false,
      "diagnostic.virtualText": true,
      "languageserver": {
      "golang": {
        "command": "go-langserver",
        "filetypes": ["go"],
        "initializationOptions": {
          "gocodeCompletionEnabled": true,
          "diagnosticsEnabled": true,
          "lintTool": "golint"
        }
      }
    },
      "languageserver": {
      "bash": {
        "command": "bash-language-server",
        "args": ["start"],
        "filetypes": ["sh"],
        "ignoredRootPaths": ["~"]
      }
    },
    "languageserver": {
      "terraform": {
        "command": "terraform-lsp",
        "filetypes": ["terraform"],
        "initializationOptions": {}
      }
    }
}

And then you want to make sure some coc.nvim extensions are installed if missing. You do that with adding this to your .vimrc:

" automatically install coc extensions if they're missing
let g:coc_global_extensions=[ 'coc-powershell', 'coc-python' , 'coc-yaml']

Overall coc.nvim config

Finally, you want to properly configure coc.nvim. Just put this into your .vimrc:

" -------------------------------------------------------------------------------------------------
" coc.nvim default settings
" -------------------------------------------------------------------------------------------------

" if hidden is not set, TextEdit might fail.
set hidden
" Better display for messages
set cmdheight=2
" Smaller updatetime for CursorHold & CursorHoldI
set updatetime=300
" don't give |ins-completion-menu| messages.
set shortmess+=c
" always show signcolumns
set signcolumn=yes

" Use tab for trigger completion with characters ahead and navigate.
" Use command ':verbose imap <tab>' to make sure tab is not mapped by other plugin.
inoremap <silent><expr> <TAB>
      \ pumvisible() ? "\<C-n>" :
      \ <SID>check_back_space() ? "\<TAB>" :
      \ coc#refresh()
inoremap <expr><S-TAB> pumvisible() ? "\<C-p>" : "\<C-h>"

function! s:check_back_space() abort
  let col = col('.') - 1
  return !col || getline('.')[col - 1]  =~# '\s'
endfunction

" Use <c-space> to trigger completion.
inoremap <silent><expr> <c-space> coc#refresh()

" Use `[c` and `]c` to navigate diagnostics
nmap <silent> [c <Plug>(coc-diagnostic-prev)
nmap <silent> ]c <Plug>(coc-diagnostic-next)

" Remap keys for gotos
nmap <silent> gd <Plug>(coc-definition)
nmap <silent> gy <Plug>(coc-type-definition)
nmap <silent> gi <Plug>(coc-implementation)
nmap <silent> gr <Plug>(coc-references)

" Use U to show documentation in preview window
nnoremap <silent> U :call <SID>show_documentation()<CR>

" Remap for rename current word
nmap <leader>rn <Plug>(coc-rename)

" Remap for format selected region
vmap <leader>f  <Plug>(coc-format-selected)
nmap <leader>f  <Plug>(coc-format-selected)
" Show all diagnostics
nnoremap <silent> <space>a  :<C-u>CocList diagnostics<cr>
" Manage extensions
nnoremap <silent> <space>e  :<C-u>CocList extensions<cr>
" Show commands
nnoremap <silent> <space>c  :<C-u>CocList commands<cr>
" Find symbol of current document
nnoremap <silent> <space>o  :<C-u>CocList outline<cr>
" Search workspace symbols
nnoremap <silent> <space>s  :<C-u>CocList -I symbols<cr>
" Do default action for next item.
nnoremap <silent> <space>j  :<C-u>CocNext<CR>
" Do default action for previous item.
nnoremap <silent> <space>k  :<C-u>CocPrev<CR>
" Resume latest coc list
nnoremap <silent> <space>p  :<C-u>CocListResume<CR>

This seemed to work fine for me. Have fun and enjoy your Vim on steroids :-)

Set up environment-modules

Sat, 05 Jan 2019 20:00:00 +0200

These instructions are valid for a current Arch Linux installation, since that’s what i’m using. Some details might differ on other distributions.

Installation

Install env-modules package from AUR:

(I use trizen to manage AUR packages, but that’s just personal preference)

trizen -S env-modules

There’s also env-modules-tcl, but i had some problems with that, so i stayed with env-modules.

Setup

Create $HOME/.modulefiles:

mkdir $HOME/modulefiles

Add this snippet to your .bashrc:

 #add own modules to modulepath
if [ -d $HOME/.modulefiles ]; then
    module use $HOME/.modulefiles
fi

Reload .bash

source .bashrc

Example module file

Create ‘hello’ module file:

touch $HOME/.modulefiles/hello

Open $HOME/.modulefiles/hello with your editor and insert this:

#%Module1.0######################################################################
##
## helllo modulefile
##
proc ModulesHelp { } {
    puts stderr "\t'hello world' for demo purposes"
}

module-whatis   "sets HELLO to 'hello world'"

You should see the new module file now when you run “module avail”:

$ module avail
------------------------------------- /home/flart/.modulefiles --------------------------------------
hello

(Other directories in your module path might also show up here)