DEV Community: Tom Deneire ⚡

It’s 2023: are we still fighting the editor war?

Tom Deneire ⚡ — Sat, 25 Feb 2023 15:04:53 +0000

Screenshot of my editor setup, using Neovim with gopls LSP, inside Tilix. See my configuration dotfiles.

The editor war

When Unix culture became popularized, the community quickly found itself entertaining fierce discussions. Put a bunch of programmers in a room and they’re bound to disagree about the merits of operating systems, programming languages, version control systems and even indent style. One of these “holy wars” was the rivalry between users of Emacs and vi(m), also known as the editor war, which — according to sources — has been going on at least since 1986!

Today, this so-called “editor war”, seems far from over. Channels like Reddit, HackerNews or Medium are ripe with people proclaiming (sometimes shouting) which tool is “best” (usually, their editor or IDE of course!), and I used to be very reluctant to get involved. When I first started working in software development I briefly used Komodo and Spyder, before joining a company that used SublimeText and, later on, VSCode. I was happy with all of these tools, and didn’t care for foul-mouthed fanboys of this or that editor du jour.

Recently, however, I have come to appreciate these discussions (if civil, of course) and especially the critical reflection of which tool is best for you. Because, let me be clear from the start, there is no such thing as “the best” editor.

The right tool for the job

Which editor is best for you, is a highly personal matter. It depends on a lot of factor, such as personal preference, but also the work you do. A Python developer might prefer PyCharm, because it arguably has the best tooling for Python development. A data scientist will be very comfortable using VSCode, which has excellent integrations for Jupyter Notebooks. A UNIX sysadmin might prefer Vim because it integrates seamlessly with a terminal workflow like tmux… And sometimes, like on a remote system, your only choice might be to fire up vi…

Only a fool never changes his mind

In other words, the editor or IDE you use should be a deliberate choice based on your development needs and a comparison of the available tools. This means that there are good reasons to at least consider switching editors once in a while. Just like a carpenter would not use the same tools throughout his career, software development tools constantly evolve. And so do the people who use them (which is why the tools change in the first place). Indeed, only a fool never changes his mind. Moreover, critically reflecting on how your develop and which tools you use can be a great way of introspection and learning.

Enjoy yourself!

When I recently switched from VSCode to Neovim, there were two main reasons. The first was, without a doubt, personal taste and enjoyment. This reason might seem whimsical or besides the point, but as software developers we spend the majority of our time in our editors, so I think it’s vital this should be a pleasant experience. If you’re working in a boring, frustrating or unattractive environment, it’s bound to have an effect on your disposition, and hence your work. So find something you like and enjoy using. It’s only going to make your work better not only because you’re in a better mental state, but also because you’ll enjoy learning how to get the most out of your tool.

Being in the driver’s seat

The second reason I prefer my current editor is control. Perhaps I just never understood VSCode as well as I should have, but with Neovim I feel in total control. I understand every bit of the configuration, including the more complicated stuff like language server integration, auto-completion with snippets and syntax coloring. I like that my primary tool only does what I want it to do, only changes what I can fix myself, only shows what I think is important, only updates when I think it is time, and so on.

Challenge what you know

Not only am I more in control, I am much more aware of the capabilities of my bread-and-butter tool. I’m sure VSCode or other editors have ways of doing this too, but (Neo)Vim’s powerful (regex) search and replace, repeating the last action (.), and scriptability (with Lua or just plain :! shell commands) were game changers for me. You see, if you’ve been using a tool for long enough, you adapt to its capabilities, never realizing that there might be a faster, better way out there. Ironically, this is probably the reason why many people are reluctant to consider changing their editor. What they know, is what they like. However, challenging what you know is an important skill both in life and in software development.

Think ahead

When I first considered migrating away from my previous setup, I actually thought it would be very hard to accomplish. You see, where I work, we use a set of bespoke file types, each with their own syntax, snippets and workflow, which was fully integrated in my development environment as VSCode extensions. Another vital extension offered a GUI wrapper to a custom CLI tool we use for deployment and version control, which is also indispensable for our work. So before I could use Neovim for work, I had to write my own syntax files and plugins to replace these. Not only was this very easy to accomplish with the builtin Lua interpreter, by doing so I now feel much more independent of my editor. It is never a good idea to be married to a piece of technology. You never know when you’ll want (or be forced) to change it for something else. So, you could say, paradoxically, that moving to Neovim has made it easier for me to move away from Neovim if I wanted to in the future!

Smooth like coconut oil

Most editors promote a specific type of workflow. Some integrate seamlessly with testing and debugging environments, others excel at editing and comparing several files side-by-side, possibly with previews for markup like Markdown or reStructuredText. Still others, like Neovim, are really well-suited for hopping between the terminal to the editor and back. Considering your typical development workflow and which editor is best for that, is also a worthwile learning experience. The most important areas you can look at for improvement, are the actions you perform hundreds of times a day. Things like file navigation, running unit tests, refactoring a piece of code, … If you can improve one of those, it’s going to have an enormous effect on your workflow, both saving you time and making your life easier. “You want to be smooth as coconut oil” — as one Netflix engineer and popular YouTuber would say …

Listen to your body

Something quite akin to development workflow is ergonomics. Again, if you’re going to use a tool for hours on end, you have got to feel physically comfortable with it. For me, being able to use keyboard-based editing, file navigation and version control (I use lazygit for this), had a surprising impact on the neck and shoulder issues I was experiencing when I used the mouse more often. For the record, Neo(Vim) is not the only keyboard-oriented editor out there. If your interested, you should checkout Helix and Lapce too, and of course, Emacs ;-)

Know thyself

I hope you will now agree that exploring editors is an exciting experience which will make you a better developer, even if you stay with your current setup. It’s a process of reflection, at the end of which you will have a better understanding of how you work and why you work the way you do! It’s 2023: the time of the editor wars of yore should be over. But in an era where programmers face increasing competition from AI code generation, self-critical reflection is an absolute must.

Hi! 👋 I’m Tom. I’m a software engineer, a technical writer and IT burnout coach. If you want to get in touch, check out https://tomdeneire.github.io

Battling impostor syndrome as a software engineer

Tom Deneire ⚡ — Sat, 25 Feb 2023 14:58:58 +0000

Battling impostor syndrome as a software engineer

Photo by Matheus Farias on Unsplash

Impostor syndrome

Impostor syndrome or “impostorism” is a psychological phenomenon in which an individual doubts their skills, talents, or accomplishments and has a persistent internalized fear of being exposed as a fraud. Despite external evidence of their competence, people experiencing impostorism do not believe they deserve their success or luck.

It has been estimated that nearly 70% of us will experience symptoms of impostor phenomenon at least once in our lives. It is spread equally among men and women and occurs in various settings, such as a new living environment, academia, social interactions and relationships, and — perhaps most of all — the workplace.

Impostorism in IT

In my experience, impostor syndrome is exceptionally present in IT. Almost all of the people I have worked with — engineers, analysts and designers alike — have at one time confessed feelings of being a fraud or a fake, or of feeling inadequate for their jobs.

This is only logical because of the nature of the IT sector.

For one, it actively promotes perfectionism. In software, things are either right or wrong — hence the culture of testing. This is, of course, excellent development practice, but with insecure people, you can see how it may stimulate fear of failure. Ask yourself, for instance, would you go to sleep easily on a day your tests keep failing and you don’t know why?

Secondly, the IT business is full of very intelligent people. Some experience this as a privilege or a stimulating work environment, but it can also lead people to compare themselves to the (perceived) standards of others. For instance, when your colleagues have computer science degrees and you are perhaps self-taught.

Thirdly, when things go wrong in IT — which they inevitably do sometimes — it is often very ease to put the blame on someone. While some companies are already actively promoting a zero-blame culture, others still analyse issues in terms of who messed up here? This mindset is even engrained in our tools. Just think of the psychology behind a command like git blame !

Finally, IT is a fast-paced work environment with lots of people coming and going. I know people who have walked away from great jobs because of impostor syndrome, only to end up in the same situation with the next job. And with the recent wave of lay-offs in the sector, I can only imagine what getting fired would do for someone who is already feeling like an impostor…

Fear of failure

Impostor syndrome is not recognized by “official” manuals like the DSM or ICD, and that’s fine by me. Impostorism is nothing but a particular example of a much more fundamental aspect of human emotion: fear. There are three basic forms of fear: fear of change (or death), fear of abandonment and fear of failure (the latter two being closely related).

With impostor syndrome, it’s obviously fear of failure, and fear of being abandoned because of that failure, that is underneath. This is perhaps the most human form of fear. You won’t see a tiger doubting its ability to climb a tree or a hawk in disbelief that it can soar the skies. Animals know their capabilities and rely on them. People are afraid to fail, even if they know their capabilities.

Another typically human trait that is related to and exacerbates this fear of failure, is what is our so-called inner storyteller. I’m talking about your inner monologue and how it can quickly turn towards the negative. Imagine you are about to deploy an important new feature and observe your train of thought. Are you excited about the customer feedback or are you dreading their response? How will your team lead react? Are you proud to show them your work or are you already thinking of potential flaws in your code? What will your colleagues say? Will they applaud your technical choices or are you already anticipation that one person who is always critical?

What can I do about it?

In all of the above, it is important to acknowledge that a small degree of fear of failure is natural. Anticipating problems (storytelling) and thinking twice before doing something (fear of failure) are indeed human traits, which can be beneficial if they lead to self-preservation or self-improvement. That’s why tigers sometimes fall from trees, while people use ropes when they go climbing…

With impostor syndrome, though, we are far from such “ecological” or normal fear. This is Fear with a capital F — crushing, debilitating fear, spells of anxiety, panic attacks, sleeplessness, heart palpitations, headaches, and so on. Symptoms you can’t handle by taking a scented bath or getting a massage, or indulging in a crazy night out with friends (although this is the stuff people try).

So what can you do about it? There are different strategies to handle impostor syndrome and while not all of them are as effective, you still need all of them to succeed.

Try this (but it’s not enough)

The first stage is mental. While many people with impostor syndrome know their capabilities, many are also truly convinced they do not have what it takes. So, be honest, how do you view yourself? Do you really believe in your skills and talents? Are you able to tell a co-worker or your boss that you’re good at your job? If you’re not, you need to work on your mindset and confidence. One concrete thing you can try, is writing up your CV. I have found it can help you realize your true potential and experience. In the vast world of software engineering it’s often easier to see what you can’t do than what can and have already done.

This helps (but it’s not easy)

The mental stage is only the tip of the iceberg, though. What you believe, is good start, but it is nowhere near enough. It’s what you feel, the emotional part, that counts. As said, many people know full well that they are competent engineers, but they still feel like an impostor! That’s why it’s vital to not only know what you’re worth with your head, but also with your gut. And that’s more than just a metaphor. As always with emotion, the answer is in your body. Think of a child being afraid in the dark. You can’t really convince it that there are no monsters under the bed. You can even go look, and it will still be afraid. But a warm hug, a soft reassuring voice and a night lamp will help. That’s because these things trigger a physical response, not a mental one, and fear is a physical phenomenon. So as an adult, you are emotionally responsible to help yourself turn this fear into self-love, and you can’t do this with your head.

This works (but it takes time)

Clearing out the fear of failure from your body is not easy. And even if you succeed in getting rid of the negative emotions when they occur, this is still not a permanent solution. The only thing that will really change impostor syndrome is a therapeutical approach. It takes a skilled therapist to help you recognize and manage the physical feelings of stress and anxiety, and to help you work on what lies beneath your fear of failure. Really dealing with impostor syndrome means opening up that can of worms that will take you to your absent dad, your hypercritical mom, your overachieving brother, your manipulative friend, your demeaning teacher, your failed driver’s test, …

It gets better

Of course, the last step is the most difficult one. Many people are afraid (again, fear of failure!) to take it, because they think that if they open up, things will get worse instead of better. And the truth is, they might, but only in the very short run.

When I was battling my own demons, my tech lead at the time once said that he believed that if someone was absent for mental reasons, they would never return to their previous level. At the time, this worried me, as I looked up to him and was afraid he might be right. Now, I know different.

Therapy has made me a much stronger person and, therefore, a much more capable software engineer. But it’s true, there are no shortcuts. It’s going to take time and it’s going to hurt.

But you can do it.

If you want to know more about the psycho-therapeutical approach behind this blog, developed by psychiatrist dr. Tom Herregodts, check out his YouTube video Physics of fear

Hi! 👋 I’m Tom. I’m a software engineer, a technical writer and IT burnout coach. If you want to get in touch, check out https://tomdeneire.github.io

Text versus bytes

Tom Deneire ⚡ — Sat, 11 Feb 2023 09:24:34 +0000

Photo by Hope House Press — Leather Diary Studio on Unsplash

TL;DR: There is no such thing as text, only collections of bytes which can be displayed as characters *based on an *encoding.

Ones and zeros

A computer is an electronic device, which really only "understands" on and off. Think of how the light goes on and off when you flip the switch. In a way, a computer is basically a giant collection of light switches.

This is why a computer's processor can only operate on 0 and 1, or bits, which can be combined to represent binary numbers, e.g. 100 = 4. It is these binary numbers that the processor uses as both data and instructions (a.k.a. "machine code").

It makes sense to group bits into units; otherwise, we would just end up with one long string of ones and zeros and no way to chop it up into meaningful parts. A group of eight binary digits is called a byte, but historically the size of the byte is not strictly defined. In general, though, modern computer architectures work with an 8-bit byte.

Bytes

This binary nature of computers means that on a fundamental level all data is just a collection of bytes. Take files, for instance. In essence, there's no difference between a text file, an image or an executable. So it's actually a bit (pun not intended) confusing when people talk about the "binary" files, i.e. not human-readable, as opposed to human-readable "text".

Let's look at an example myfile:

$ xxd -b myfile
00000000: 01101000 01100101 01101100 01101100 01101111 00100000
00000006: 01110111 01101111 01110010 01101100 01100100 00001010

The instruction xxd -b asks for a binary "dump" of myfile.

We see that it contains 12 eight-bit bytes. Because the binary representation is difficult on the eyes, bytes are often displayed as hexadecimal numbers:

$ xxd -g 1 myfile
00000000: 68 65 6c 6c 6f 20 77 6f 72 6c 64 0a

Or (less often) as decimal numbers:

$ od -t d1 myfile
0000000  104  101  108  108  111   32  119  111  114  108  100  10

In decimals, 8-bit bytes go up to 256, which makes sense as 2⁸ = 256, i.e. eight positions can hold either zero or one, which equals 256 combinations.

But how do we know what these bytes represent?

Character encoding

In order to interpret bytes in an meaningful way, for instance to display them as text or as an image, we need to give the computer additional information. This is done in several ways, one of which is predetermining the file structure with identifiable sequences of bytes.

Another is specifying an encoding, which you can think of as a lookup table connecting meaning to its corresponding digital representation. When it comes to text, we call this "character
encoding". Turning characters into code is referred to as "encoding", interpreting code as characters is "decoding".

One of the earliest character encoding standards was ASCII, which specifies that the character a is represented as byte 61 (hexadecimal) or 97 (decimal) or 01100001 (binary). However, since 8-bit bytes only give you 256 possibilities, today multibyte encodings are used. In the past, different areas of the world used different encodings, which was software's Tower of Babel, causing a bunch of communication problems to this day. Luckily, today UTF8 is more or less the international standard --- for instance, accounting for 97% of all web pages. UTF-8 is capable of encoding all 1,112,064 valid character code points in Unicode using one to four one-byte units.

Bytes as text

Going back to our file, we can now ask the computer to interpret these bytes as text. It is important to realize that any time we display bytes as text, be it in a terminal, a word processor, an editor or a browser, we need a character encoding. Often, we are unaware of encoding that is used, but there is always a choice to be made, whether by default settings or by some clever software that tries to identify the encoding.

Terminals, for instance, have a default character setting --- mine is set to UTF-8. So when we ask to print myfile we see this:

$ cat myfile
hello world

This means the bytes we discussed earlier are the UTF-8 representation of the string hello world. For this example, other character encodings, like ASCII or ISO-Latin-1 would yield the same result. But the difference quickly becomes clear when we look at another example.

Let's save the UTF-8 encoded text string El Niño as a file and then print it. We can do that in the terminal --- remember, it's set to UTF-8 display by default:

$ echo "El Niño" > myfile
$ cat myfile
El Niño

Now let's change the terminal's encoding to CP-1252 and see what happens when we print the same file:

$ cat myfile
El NiÃ±o

We call this Mojibake; the garbled text that I'm sure you've often seen under the form of the generic replacement �. But do you understand why this happens? Because myfile contains bytes entered as UTF-8 encoded text, displaying the same bytes in another encoding doesn't give the result we expect.

This is also explains why commands like cat don't work on so-called binary files, or opening them in an editor reveals only gibberish: they're not encoded as text.

Text as bytes

The example of El Niño shows that we can also take text --- a string typed in a terminal --- and use that as bytes. For instance, when we save text from an editor in a file. At first, this can be a tricky concept to wrap your head round. Bytes can be strings and strings are bytes. The important thing to remember is that whenever you handle text or characters, there is an (explicit or implicit) encoding at work.

When you think of it, code is text too, so some programming languages make certain encoding assumptions as well. Others just deal with text as bytes and leave the encoding up to other applications (such as a browser or a terminal).

Go, for instance, is natively UTF-8, for instance, which means you can do this:

package main

import "fmt"

func main() {
    fmt.Println("Hello, 世界")
}

Python 3 is UTF-8 too, but Python 2 used to be ASCII. So, regardless of whether your code editor is able to display such a string or not, the Python 2 will complain if you try to use the print function on it. Remember, print tells a device to display bytes. So if you put this in a file test.py

print "Hello, 世界"

and execute it with Python 2, it will throw the following error.

py2 test.py

File "test.py", line 1
SyntaxError: Non-ASCII character '\\xe4' in file test.py on line 1, but no encoding declared; see http://python.org/dev/peps/pep-0263/ for details

The bottom line is that you should always be careful when handling text and when in doubt use explicit encoding or decoding mechanisms.

Handling multibyte characters

There’s a lot more to say about character encodings, but I’ll wrap things up with an observation about multibyte characters that might prompt you to study the subject more in depth.

A popular question in code interviews is to ask the candidate to write (pseudo-)code to reverse a string. In Python, for instance, there is a nice oneliner for this, which uses a slice from end to start (::) that steps backward (-1):

>>> print("Hello World"[::-1])
dlroW olleH

Yet think about what happens under the hood. Apparently, there is a mechanism that iterates over the bytes that make up the string and reverses their order. But what happens when a character is represented by more than one byte? For instance, 界 , is four bytes in UTF-8 (e7 95 8c 0a in hex). The first of these is a leader byte, a byte reserved to start a specific multibyte sequence, the other three are continuation bytes, which are only valid when preceded by a leader. So when you reverse these bytes, you end up with a different byte sequence, which is actually invalid UTF-8!

Fortunately, Python (which is natively UTF-8, remember) is able to handle this:

>>> print("Hello, 世界"[::-1])
界世 ,olleH

In other programming languages, though, you would have to write a function that identifies byte units in the string and then reverse their order, not the bytes themselves. Which would imply knowledge of the string’s encoding…

Conclusion

Text versus bytes is a complex issue that even advanced programmers can struggle with, or have tried to avoid for most of their careers. However, it is a fascinating reminder of the very essence of computing and understanding it, or at least the fundamentals, is really indispensable for any software developer.

If you’re looking for another source to read up on the matter, you can start with The Absolute Minimum Every Software Developer Absolutely, Positively Must Know About Unicode and Character Sets (No Excuses!) by Joel Spolsky.

Hi! 👋 I’m Tom. I’m a software engineer, a technical writer and IT burnout coach. If you want to get in touch, check out https://tomdeneire.github.io

TIL: wrapping my head around Go’s “iota”

Tom Deneire ⚡ — Sat, 11 Feb 2023 09:15:45 +0000

TIL (“Today I learned”) are shorter, less-researched posts that I typically write to help organize my thoughts and solidify things I have learned while working. I post them here as a personal archive and of course for others to possibly benefit from.

Photo by Kelly Sikkema on Unsplash

Iota

A few days ago, I happened upon the iota identifier in Go.

I remembered seeing it before, but it’s still pretty rare, so I looked up the definition of iota in the documentation:

const iota = 0 // Untyped int.

iota is a predeclared identifier representing the untyped integer ordinal number of the current const specification in a (usually parenthesized) const declaration. It is zero-indexed.

¿Qué?

Upon reading this (several times over actually) I must confess I still didn’t really understand what iota was or did. And while the language specification is more explicit and has examples, it is not much clearer:

Within a constant declaration, the predeclared identifier iota represents successive untyped integer constants. Its value is the index of the respective ConstSpec in that constant declaration, starting at zero. It can be used to construct a set of related constants

Some additional browsing, in Golang by Example, for instance, reveals that iota can be used to implement enums in Go. Like so:

type Size uint8

const (
    small Size = iota
    medium
    large
    extraLarge
)

which is effectively the same as:

type Size uint8

const (
 small      Size = 0
 medium     Size = 1
 large      Size = 2
 extraLarge Size = 3
)

and, indeed, a cleaner solution than defining Size like so:

type Size string

const (
 small      Size = "small"
 medium     Size = "medium"
 large      Size = "large"
 extraLarge Size = "extraLarge"
)

The power of a great example

Even after these examples, I didn’t really see much benefit in iota, apart from its auto-increment function.

It was only when I read the example from Effective Go, that I realised the true power of iota:

type ByteSize float64

const (
    _           = iota // ignore first value by assigning to blank identifier
    KB ByteSize = 1 << (10 * iota)
    MB
    GB
    TB
    PB
    EB
    ZB
    YB
)

func (b ByteSize) String() string {
    switch {
    case b >= YB:
        return fmt.Sprintf("%.2fYB", b/YB)
    case b >= ZB:
        return fmt.Sprintf("%.2fZB", b/ZB)
    case b >= EB:
        return fmt.Sprintf("%.2fEB", b/EB)
    case b >= PB:
        return fmt.Sprintf("%.2fPB", b/PB)
    case b >= TB:
        return fmt.Sprintf("%.2fTB", b/TB)
    case b >= GB:
        return fmt.Sprintf("%.2fGB", b/GB)
    case b >= MB:
        return fmt.Sprintf("%.2fMB", b/MB)
    case b >= KB:
        return fmt.Sprintf("%.2fKB", b/KB)
    }
    return fmt.Sprintf("%.2fB", b)
}

You use iota to define constants, but that doesn’t mean the constant cannot apply arithmetic to an iota. So, through clever use of the bitwise shift operator <<, you can make iota do the heavy lifting for you in defining byte units!

What a great example to explain the concrete usage of an abstract notion! I only wish examples like this would be included in the official documentation instead of a document that describes itself as “tips for writing clear, idiomatic Go code”…

Hi! 👋 I’m Tom. I’m a software engineer, a technical writer and IT burnout coach. If you want to get in touch, check out https://tomdeneire.github.io

VSCode vs Neovim

Tom Deneire ⚡ — Sat, 11 Feb 2023 09:12:17 +0000

Photo by Christopher Robin Ebbinghaus on Unsplash

A while ago I wrote about the fact that I was using Vim motions in VSCode and that I was exploring Neovim.

Since then, I have really fallen in love with Neovim (although sometimes it was more of a love-hate relationship ;-) ) and I use it full-time now. In this post I want to explain why and critically compare my experiences with both tools.

(Before we start, just a quick word about Neovim vs Vim. I guess most of my observations will hold true for regular Vim as well, although there are some things that make Neovim a superior product, such as its builtin LSP (language server protocol) client, builtin terminal emulator, and embedding of the Lua programming language.)

Installation and setup

Proponents of VSCode will say that it’s much easier to install and setup, while proponents of Neovim will say that if you want to do VSCode right and if you know what you are doing in Neovim, there is really not much difference.

When I started with Neovim I was a complete newbie (still am, really), so I would have to agree that setting up Neovim is time-consuming and comes with a learning curve. LSP might be built in, but installing the language servers or getting autoformatting and autocompletion to work was not trivial. However, now that I’ve done it, it would be really easy to (re)do a vanilla install, because the setup is very portable. I’ve put my .dotfiles in a Git repository and that’s really all you need. Granted, VSCode does have a settings.json(which you can sync to GitHub, if I’m not mistaken), but it doesn’t hold nearly as much information as Neovim’s configuration files.

Performance / UX

As far as performance and user experience go, Neovim is the clear winner. It is really fast starting up, there is almost no lag, the application will not ask to you to reinstall plugins, and so on.

The editing itself also feels very snappy and responsive when typing or opening other files. Faster navigation between files and tabs is a clear win for me. Of course this partly due to the extensive use of mappings, but then again even with the best keybindings I don’t think you could get VSCode to do the same.

Extensions / plugins

There is no doubt that the VSCode/Typescript ecosystem for extensions is larger than the counterpart for (Neo)Vim/Vimscript/Lua plugins. One simple thing I miss, for instance, is a good (working) rainbow tags plugin. Another, more important perhaps, is Git integration, although to be fair, I haven’t explored the (Neo-)Vim options too much for that.

Moreover, VSCode, being Electron, i.e. browser software, can do things like Jupyter Notebooks, markdown rendering, which are perhaps not impossible in Neovim, but certainly more difficult to achieve. Of course, you ask the question whether you really want an editor to do that instead of using dedicated applications for that.

On the other hand, Neovim plugins are amazingly customizable. For instance, you can write Lua functions that have your statusline display exactly what you want it to say, or parametrize fuzzy file searching to your specific needs. This might seem like a small thing, but haven’t you ever wanted a certain extension to do you it slightly different so that it would be perfect for you?

Moreover, Neovim plugin development is much better than the VSCode counterpart, which involves installing a ton of software and a rather complicated build process.

Overall, Neovim is, as advertised, truly hyperextensible, it’s integrated Vimscript and Lua make it easy to get your editor to do more advanced things, like custom syntax colouring (at work, we work with quite a few bespoke filetypes), or just write a function to map a keystroke to an elaborate command or a Shell script.

Comfort

I first started using Vim motions because I was curious and because I have been struggling with a bad back and neck pain. Honestly, I didn’t think switching to Vim motions would have much of an impact, but in fact, I feel a clear difference. Of course, regular sittings breaks, good posture, and such are equally import, but I do feel that working with Vim motions is more ergonomic.

Aesthetics

This sort of depends on your personal preference, but to me, it’s a bit of a tie. You can make Neovim look really nice with patched fonts and it’s great you can git rid of all the clutter. On the other hand, you still feel in a terminal-based editor. (Which is not necessarily a bad thing). You can compare these two screenshots of the same file (with LSP diagnostics at work):

Conclusion

So, is Neovim worth it?

If you’re trying to answer this question for yourself, I would recommend watching “Does your editor matter?” by Primeagen on YouTube. I agree 100% that the important things is getting to know your editor and maximizing its potential to help your development process. Whether its VSCode, Neovim or anything else, get to know your tool!

I personally wouldn’t recommend Neovim for a starting developer, but for me, at this stage of my software engineering career, it’s clearly a superior tool.

(Disclaimer: you might find Neovim addictive! I’m not kidding, for the first few weeks I was in a real frenzy trying to get everything working and then to customize it exactly to my liking!)

Hi! 👋 I’m Tom. I’m a software engineer, a technical writer and IT burnout coach. If you want to get in touch, check out https://tomdeneire.github.io

Handling Common Data Formats in Go (TXT)

Tom Deneire ⚡ — Sat, 11 Feb 2023 09:08:09 +0000

Photo by Alina Grubnyak on Unsplash

Reading and writing data is one of the basic elements of programming. In Go, which is a compiled language with strong typing, this might seem somewhat more complicated than other languages like Python. Here’s how to handle the most common data formats like a true Gopher…

Text

“Data” does not necessarily have to be structured data. A plain .txt file (or any file format really) can be a legitimate source of data. Although opening a file and reading its contents may seem like a trivial enough task, there are still several ways to do this in Go.

Reading a whole file

One way is to read a complete file into memory, so this is only an option when you know a file is going to be limited in size (like configuration files and such).

The canonical way to do this, is to use os.ReadFile (before Go 1.16 there was also ioutil.ReadFile, which is now deprecated)

Output:

Hello
world

Reading a file bit by bit

When dealing with larger files, it is better to read them bit by bit, either as a limited number of bytes, or line by line, or even (in the case of text) word by word.

All of these options involve opening the file with os.Open and making sure it also gets closed. (In the previous example, os.ReadFile took care of that on its own). In Go, we do that using the defer keyword, which guarantees the execution of a function after the surrounding function ends, even if it panics.

Byte chunks

The first method first declares a bytes buffer of 4 bytes. It then reads the file in 4 byte chunks at a time until it reaches the end of the file, which is signaled by the Read() method by returning a specific error, namely io.EOF (end of file):

Output:

Hell = 4 bytes
o
wo = 4 bytes
rldo = 3 bytes

As you can see, this is not really optimal for handling text, as obviously the byte chunks split up words arbitrarily. To counter that, Go has several handy functions in the bufio package (which is dedicated to buffered I/O, as in the previous example) that allow more text-oriented buffering.

Line by line

The bufio package uses a special type for these operations, called a scanner. This type comes with a Scan() method, which allows to step through the ‘tokens’ of the input. The specification of a token is defined by a split function. Scanning stops when an error is encountered and only returns that error when the Errmethod is called.

Output:

Hello
world

Word by word

Scanning line by line is actually the default split for a scanner, so we could just leave out the line

scanner.Split(bufio.ScanLines)

If we want to user another splitter, like word by word, we can simply replace said line with:

scanner.Split(bufio.ScanWords)

Other input sources

In the above, we have been reading text from a file, but you can also apply the same techniques with different input sources. Reading in general is most often done in Go through the use of an io.Reader, which is an interface that wraps the basic Read method, meaning that it will accept any type that implements the Read method. As bufio.NewScanner takes an io.Reader as input, we can use all kinds of input sources.

For instance, you can read from standard input os.Stdin (which is also an io.Reader) like this:

scanner := bufio.NewScanner(os.Stdin)

or you can create an io.Reader from another variable, e.g. a string:

input := "Hello world"
scanner := bufio.NewScanner(strings.NewReader(input))

or bytes:

input := []byte("Hello world")
scanner := bufio.NewScanner(bytes.NewReader(input))

You will now understand that os.Open, which we discussed earlier, also returns an io.Reader (or similar types, i.e. that offer a Read method). And so do other I/O devices in Go, like a network connections or pipes.

In other words, these readers are everywhere in Go, so it is important to know how to handle them well.

Stay tuned for the rest of this mini-series which will discuss TXT, CSV, JSON, XML and SQLite!

Hi! 👋 I’m Tom. I’m a software engineer, a technical writer and IT burnout coach. If you want to get in touch, check out https://tomdeneire.github.io

TIL: Go typecasting with empty interfaces

Tom Deneire ⚡ — Sat, 11 Feb 2023 09:02:52 +0000

Photo by Suzanne D. Williams on Unsplash

Empty interfaces

Today I was working with Pigeon, a Go package which creates parsers based on a parsing expression grammar (PEG). As the documentation details, it is possible to use a labeled expression in the definition of the rules, like so:

LabeledExpr = value:[a-z]+ {
    fmt.Println(value)
    return value, nil
}

In the Go code between brackets value is typed as an empty interface (interface{}). When you match a sequence (as in the above with + ), the underlying type is a slice of empty interfaces.

Since an interface is just a set of methods — an empty interface having no methods — , you need to cast these empty interfaces to concrete types (syntax = interface.(type)) in order to access the underlying values.

Let’s illustrate this with some code. First, I define a function — for didactic purposes — that will turn any type into an empty interface.

func makeInterface(object interface{}) interface{} {
    return object
}

Then I make an object which is a slice of empty interfaces (following the example in the above):

object := make([]interface{}, 2)

Then I assign some values to that slice:

object[0] = []byte("hello")
object[1] = []byte("world")

Finally, we turn the whole thing into an empty interface:

test := makeInterface(object)

Now, since we have a slice of interfaces, I struggled a bit trying to figure out why this does not work:

for _, item := range test 
    fmt.Println(item)
}

./test.go:46:23: cannot range over test (variable of type interface{})

Type casting

Of course, it makes perfect sense. test is not a slice of empty interfaces, but an empty interface containing a slice of empty interfaces. In order to access those, we first need to cast the interface to a slice of interfaces:

testSlice := test.([]interface{})

Then we can range over this slice and do additional typecasting:

testSlice := test.([]interface{})
     for _, item := range testSlice {
          byteSlice := item.([]byte)
          fmt.Println(string(byteSlice))
     }

hello
world

Hi! 👋 I’m Tom. I’m a software engineer, a technical writer and IT burnout coach. If you want to get in touch, check out https://tomdeneire.github.io

10 Tips for Tackling Mental Health Issues as a Software Engineer (or Anyone Else, Really)

Tom Deneire ⚡ — Sat, 11 Feb 2023 08:57:49 +0000

Photo by Bekir Dönmez on Unsplash

Working as a professional software engineer can be a struggle — not only because of tight deadlines and steep learning curves, but also from a mental health standpoint. Many programmers experience high level of stress, have problems relaxing or sleeping, suffer from impostor syndrome, and ultimately end up battling anxiety, burnout or depression. Having experienced this downward spiral myself, people often ask me what was the key to my recovery. Obviously, there is no such thing as one easy fix for everyone, but I do have 10 tips that can certainly help to keep you healthy or get you back on the right track. And while I’m writing with software engineers in mind, I’m sure there’s something here for everyone…

1. Do What You Love

First of all, I’m a big believer in doing what you love professionally. From the school principle who would rather be a music producer, over the NGO activist who dreams of owning a small book shop, to the data analyst who actually wants to paint fine art — every profession has their share of people who are not happy at their jobs, but stay because of the money, the hours or the prestige. However, in the long run, this only causes frustration and mental exhaustion. So start your journey towards more mental well-being at work by asking yourself: “Do I really enjoy this?” If the answer is no, go do something else. Life’s too short. And if you find yourself thinking “Yes, but…”, read the excellent F**ck It. Do What You Love, by John C. Parkin. He’ll convince you you’ll never be happy if you’re not doing what you love.

2. Listen To Your Body

Many people who are stuck in an environment they don’t enjoy or under a lot of stress, don’t even realize this themselves. Whether it’s a sense of work ethic, personal pride or financial concern, they just keep going and ignore the alarm bells until it’s too late. At this point, health issues usually kick in. When we experience anxiety and stress, our bodies produce cortisol, adrenaline and noradrenaline. This is a healthy and natural response, but in the case of a chronic build up of such stress hormones, it leads to physical ailments like chronic pain (headaches, back pain), digestive problems (heartburn, constipation), inflammation (skin rashes, bowel problems) or even heart conditions. This is your body’s way of saying “I’ve had enough”, and sooner or later you’ll need to listen to it, because the health issues will only become worse. I’ve experienced it myself and have seen it in many others too. For instance, a former colleague of mine, who struggles with anxiety and fear of failure, went to a dozen doctors over the course of a few years with an ever-growing list of complaints. She tried a number of treatments, spent weeks on medical leave, until she literally couldn’t go on any further. And then she resigned. I hope it was the right decision. Personally, I think the physical stuff was just one side of the story.

3. Be Honest With Yourself

This dovetails nicely into a third important aspect. Sooner or later (but sooner is better), we all need to starting being honest with ourselves. Often, the truth of the matter is in plain sight. Maybe it’s our partner who has been saying for years that we work too much, maybe it’s that friend who keeps asking “Are you sure you’re alright?”. Tackling mental health problems starts with being completely, even brutally honest with yourself. Look into the mirror, lose the ego, and ask yourself: “Am I happy? Do I love my job? Do I love my life? ” The realization that the answer may be “no”, is often the moment when people “crack”, when they lose the facade and start being honest. It’s hard, mind you, because this is also the moment when things get worse (because now you’re much more aware of them) before they can start getting better. Still, the first important step towards change is admitting you need change.

4. Go To Therapy

When you need change, you also need help. You often see people’s sense of pride or duty that got them over-stressed in the first place, interfering with their recovery too. Admitting you need to change is one thing, admitting you need help, is quite another. But it’s such an important aspect. We’re all so caught up in our own unique contexts that we often can’t see the forest for the trees. Whether it’s a psychiatrist, a therapist, or just a good friend — they often see truths and solutions, when all you yourself can see are questions and difficulties. Help, and preferably professional help, is extremely valuable for all stages of mental issues, be it a vague sense of bore-out or a full-blown clinical depression.

5. Face Your Fears

When you start tackling mental issues, things get scary pretty quickly. Admitting you have a problem is scary, seeking out help is scary, talking about your emotions is scary — suddenly you feel very small. But that’s a good thing. If there’s one thing I’ve learned in my own process, it’s how much fear dominates our lives. There are three main types of fear: fear of abandonment fear of change and fear of failure — and together they are the root of many of our negative emotions and thoughts. Especially the last type seems very prominent in software engineering. I’m the first to admit that it was fear of failure that inspired my impostor syndrome, my anxiety, my debilitating perfectionism, my social communication issues, my sleep disorder, my lack of work-life balance. Facing these fears, understanding where they come from, realizing the impact they have on your physical and emotional well-being, and ultimately, learning how you can transform them into strength is the key to getting better.

6. Anger Management

A good indication of underlying fear, is anger — often also ignored or suppressed for years. This is clearly another area where many people cling to social expectations or the illusion of the moral highroad. People will tell you: “I’m not angry, I’m just (insert other emotion here)”. They’ll confess to being sad, disappointed, frustrated, and so on, but if you scratch the surface, you’ll soon see how much anger is there. Anger for that colleague who routinely criticizes their code, anger for that manager who has no idea of the complexity of a new feature, anger for themselves because they’ve been working on a problem all day without making any progress… And underneath that anger is fear: fear of the confrontation with said colleague, fear of losing your job, fear of failure. Admitting you’re angry and finding a suitable release for it, is another big step.

7. Learn To Say No

Recognizing your fears and your anger will soon lead to identifying a number of sore spots in your professional life. You’ll suddenly realize how much certain people, situations or decisions vex you, and once you do, there is no way back. Whereas in the past you’d just ignore colleague A or B as much as possible, you’ll slowly start confronting them. Or, where before you would just go along with the decision to adopt a new framework du jour, you’ll want to speak up. This is when you learn to say no, which is another thing that is surrounded with social and professional stigma nowadays. You’ll often read about how good employees are people with a Yes mentality, but for me, being able to say no at the right time is a vastly underrated skill. Saying no is about being assertive, about indicating your personal boundaries and about self-respect.

8. Eliminate Your Storyteller

People who work in software or other technical environments, are often highly rational. Many will have a strong inner monologue, analyzing weaknesses, questioning decisions, double-checking solutions, imagining worst-case scenarios, and so on. I call this your personal storyteller, and his voice is not always a pleasant one. For some people, myself included, this inner monologue can become relentless and debilitating, second-guessing ourselves every step of the way. Eliminating your storyteller is not an easy task for rational people operating in a rational environment. Getting out of your head involves getting into your body and your gut feelings. This may sound vague and spiritual, but it’s actually highly practical. It’s about stopping your thought process by focusing on the actual experience. For instance, instead of mentally reliving a failed debugging session (“What did I miss? Am I ever going to find the problem?”), you need to focus on that gnawing feeling in your stomach where all of this fear of failure is living. This is not pleasant either, but at least it gives you something concrete to work with. I’ve found that it’s much easier to try and work the fear out of my body, than to stop the creaking cartwheel of my thoughts…

9. Lose The Context

Once you’re aware of your storyteller, you’ll notice how much your life is dominated by words and ideas and scenarios. But if you strip all of that “context” away, things get really clear, really quickly. With context, you’ll think of a professional situation like this: “It’s true colleague A belittled me yesterday, but I did make a stupid mistake, didn’t I? Still, he can’t talk to me like that. I mean, okay, I know there’s no ill will involved and he’s had a tough year with COVID and all. So what should I do? If I go to the manager, I’m probably throwing oil on the fire. Maybe I’m overreacting?” And this goes on and on… Without context, the situation is like this: “I feel disrespected by colleague A. This needs to stop. I can’t account for his actions, but I can control mine. So next time I will speak up respectfully, and we’ll see where that gets us.”

10. Stop Reading Lists Like This One

At the very end of this list, I have a confession to make. I don’t actually believe in lists like this one, or in a bunch of tips and tricks for complex matters like improving mental health in a professional context. So my final advice is this. If you are experiencing mental issues (personal or professional), seek out help and start working on yourself. Books, podcasts or apps may all help along the way, but real change comes from real work. The kind that is not in a book, but comes for staring hard in the mirror and working on yourself. And while that’s hard work — probably one of the hardest things you’ll ever do — it’s worth it.

Hi! 👋 I’m Tom. I’m a software engineer, a technical writer and IT burnout coach. If you want to get in touch, check out https://tomdeneire.github.io

Get started with AWK

Tom Deneire ⚡ — Sat, 11 Feb 2023 08:54:56 +0000

Photo by Natalia Yakovleva on Unsplash

What is AWK?

AWK is a true GNU/Linux classic, designed by Alfred Aho, Peter Weinberger, and Brian Kernighan — three of the biggest names in UNIX development and computer science in general. It is a convenient and expressive programming language that can be applied to a wide variety of computing and data-manipulation tasks.

Of course this tutorial is only a brief overview of the basics of AWK. There are several more elaborated tutorials to be found online, as well as the original manual The AWK Programming Language written by the designers…

Workflow and structure

Starting out, we need to understand the workflow and program structure of AWK.

An AWK program follows this outline:

execute commands from BEGIN block
read a line from input stream
execute commands on a line or rather ‘record’
repeat if end of file has not been reached
execute commands from END block

Not all steps are necessary. For instance, a valid AWK instruction can be:

echo -e 'one\ntwo\nthree' | awk '/o/ {print}'

one
two

This only uses the middle or “body” block.

AWK commands take the form of pattern-action statements with the syntax pattern { action }.

If there is a match for the pattern, the action is performed. If there is no pattern, the action is performed for every input line, for instance:

echo -e 'one\ntwo\nthree' | awk '{print}'

one
two
three

Together with the BEGIN and END block, this becomes:

echo -e 'one\ntwo\nthree' | awk 'BEGIN{print "STARTING\n"} {print} END{print "READY"}'

STARTING
one
two
three
READY

By default, AWK separates input into ‘records’ using newlines, but this can be changed (see below).

Running an AWK program

There are several ways to run an AWK program.

We can use AWK as a command-line application, as in the examples above, but we can also provide AWK commands in a script file and use the -f flag:

cat input.txt | awk -f script.awk

We can use input that is piped to awk, like in the example above, or we can specify a source file (or several) for the text input, e.g.

awk '{print}' input.txt

Built-in variables

FS, $0, $1, …

As a text processing utility, AWK is designed to split lines into fields. To do this, it uses a built-in variable FS which defaults to space but which you can change with the -F flag, like so:

echo 'a b c' | awk '{print $1}'

a

echo 'a,b,c' | awk -F "," '{print $1}'

a

(Similarly, built-in variable RS, record separator, allows to change the default record separator, which defaults to newline).

AWK has many such variables, not only the above-mentioned $n (nth field) or $0 (the entire record), but also, for instance:

NF

This represents the number of fields in the current record, which can be used as a pattern to match the input to, for instance:

echo -e 'a b c\nd e' | awk 'NF > 2'

a b c

NR

This represents the index number of the ‘record’ (in this case, line) from the input:

echo -e 'a b c\nd e' | awk '{print NR}'

1
2

IGNORECASE

Some variables are specific for certain versions of AWK, such as GAWK (GNU AWK), which is the default awk on many Linux systems. One of those is IGNORECASE which can be used when matching records to certain patterns (note the / / syntax for patterns, see below):

echo -e 'a b c' | awk '{IGNORECASE = 1} /A/'

a b c

Operators

This overview is too short to discuss AWK operators in full, but let’s look at some examples.

Arithmetic

There are only two types of data in awk: strings of characters and numbers. Awk converts strings into numbers using a conversion format (which can be changed using built-in variable CONVFMT):

echo -e 'a 1 1' | awk '{print ($2 + $3)}'

2

Increment and decrement

echo -e '1 1 1' | awk '{print (++$1)}'

2

Relational

echo -e '1\n0\n7\n0\n3\n0\n4\n2\n3' | awk '$0 != 0'

1
7
3
4
2
3

Assignment

awk 'BEGIN { name = "Tom"; printf "My name is %s", name }'

My name is Tom

By the way, notice how this is an AWK instruction that does not have a body, only a BEGIN block. Hence it does not need an input to function either… It also uses formatted printing printf instead of the regular print.

Patterns and regular expressions

AWK’s bread and butter is pattern matching. Moreover, it is very powerful and efficient in handling regular expressions.

A basic example of this is:

echo -e 'one\ntwo\nthree' | awk '/one/ {print}'

one

which we can also write using a relational operator for the pattern:

echo -e 'one\ntwo\nthree' | awk '$0 == "one" {print}'

AWK uses the POSIX regular expression syntax (as do other UNIX utilities, like sed):

Patterns can be combined with parentheses and the logical operators &&, || and !, which stand for AND, OR, and NOT.

echo -e 'one\ntwo\nthree' | awk '(/one/) || (/two/) {print}'
one
two

Patterns are AWK’s true strength, even the keywords BEGIN and END mentioned above are, in fact, just patterns…

Computing with AWK

Besides text, AWK also handles numerical data well, and is a formidable tool for performing calculations, generating reports, and so on.

For computations it is often handy to make use of user-created variables, which you do not need to define, like so:

echo -e '1\n1\n1' | awk '{total+=$0} END {print total}'

3

Functions

Built-in functions

We have already seen that awk provides built-in variables. Similarly, there are built-in functions for computing useful values. There are several kinds of functions such as functions for arithmetic, time, bit manipulation and also text functions. One of these is length, which counts the number of characters in a string:

echo -e 'one\ntwo\nthree' | awk '{print length($0)}'

3
3
5

User-defined functions

You can also define your own functions with the following syntax:

function function_name(arg1, arg2, ...){function body}

Returning value with return is optional.

A basic example is a function that returns the minimum number:

echo -e '1 2\n4 3\n5 7' | awk 'function min(num1,num2){if (num1 < num2) return num1 else return num2}{print min($1,$2)}'
1
3
5

Of course, such an example would be more legible in an AWK script than a oneliner.

Control-flow

The previous example already showed that AWK is also capable of if-else statements for making decisions:

if (condition)
action-1
else
action-2

It also has the ability to create for loops:

for (initialization; condition; increment/decrement)
action

(Both are modeled on the syntax of the C programming language)

awk 'BEGIN { for (i = 1; i <= 5; ++i) print i }'

1
2
3
4
5

Arrays

Awk provides arrays for storing groups of related values. These are very powerful as they can even be multidimensional.

A simple example:

echo -e 'Tom 1\nHarry 2\nTom 3\nHarry 4\nJimmy 5' | awk '{total[$1]+=$2} END {print total["Tom"]}'

5

AWK as a scripting language

A more elaborate example shows how AWK can be a valid alternative for Python or other scripting languages. (Also keep in mind that in some programming environments (servers, for instance) you might not have access to Python or your favourite scripting language, or limited possibilities to upload source code files!)

Let’s count all .json, .xml and .csv files in my Dropbox folder.

Let’s first gather all files recursively into a source file:

find /home/tdeneire/Dropbox/. -not -type d > files.txt
wc -l files.txt 

132899 files.txt

This amounts to some 130K files.

In Python we could do something like this:

total = {}

with open("/home/tdeneire/Dropbox/files.txt", "r") as reader:
    for line in reader:
        line = line.strip()
        extension = line.split(".")[-1]
        total.setdefault(extension, 0)
        total[extension] += 1

for key in ["json", "xml", "csv"]:
    print(key, total[key])

In AWK:

awk -F "." '{extension=$(NF); total[extension]+=1} END {wanted["json"]; wanted["csv"]; wanted["xml"]; for (ext in wanted){print ext,total[ext]}}' /home/tdeneire/Dropbox/files.txt

In this particular example, AWK is much slower than Python (about 2.5 times slower), but if we play to AWK’s strengths, i.e. pattern matching, for instance, searching for ten consecutive digits, matters are quickly reversed.

In Python

import re

with open("/home/tdeneire/Dropbox/files.txt", "r") as reader:
    for line in reader:
        line = line.strip()
        if re.match('.*[0-9]{10}', line):
            print(line)

With AWK:

awk -F "." '/.*[0-9]{10}/' /home/tdeneire/Dropbox/files.txt

Difference:

time py3 test.py

real 0m1.296s
user 0m0.693s
sys  0m0.143s

time awk -F "." '/.*[0-9]{10}/' /home/tdeneire/Dropbox/files.txt

real 0m0.659s
user 0m0.105s
sys  0m0.113s

This just goes to show the importance of picking the right tool for the job for scripting.

But in some cases that tool might just be AWK, even if it’s over 40 years old!

Sources

https://www.tutorialspoint.com/awk
Aho, Alfred V.; Kernighan, Brian W.; Weinberger, Peter J., *The AWK programming language* (Reading, Mass.: 1988), ISBN-10 0-201-07981-X

Hi! 👋 I’m Tom. I’m a software engineer, a technical writer and IT burnout coach. If you want to get in touch, check out https://tomdeneire.github.io

Catching Go errors with errors.Is()

Tom Deneire ⚡ — Sat, 11 Feb 2023 08:46:03 +0000

Photo by David Pupaza on Unsplash

Go error handling

Anyone who has done some development in Go will be familiar with the Go philosophy on error handling and the following pattern:

result, err := myFunc(args)
 if err != nil {
  // do something
 }

Catching errors

As many Gophers, over time I have grown accustomed to the inevitability of Go’s errors and come to appreciate this explicit and sturdy way of handling errors. Up till recently, however, there was one aspect about Go errors that kept confusing me, namely how to catch *specific *errors.

Let’s look at the following example:

file, err := os.Open("myfile")
   if err != nil {
       // handle error
}

In a case like this, coming from a Python background, I would like to use try…catch… pattern, for instance, to create myfile should it not exist.

In idiomatic Go there are two solutions for this.

The first is to rewrite the code to first check whether the file exists (you can use os.Stat() for that) and, if not, create it — this is probably preferable in this case.

The second is to make use of errors.Is() — this can be used if there is no workaround (see below).

errors.Is()

Go’s error package has a function errors.Is()that enables you to test a certain error against a target, like so:

In this way, we are able to catch a specific case of the possible errors returned by os.Open() , namely “file does not exist”, as different from, for instance, “permission denied”.

However, it can be a bit tricky to find the correct target to test an error against. Whereas other languages like Python will print a specific code in the error output (in this case FileNotFoundError) which you can then use as an exception, Go will only print the string representation of the error:

open myfile: no such file or directory

In Go you can either test against errors you define yourself, or generic system errors, like the ones defined in package io/fs :

var (
    ErrInvalid    = errInvalid()    // "invalid argument"
    ErrPermission = errPermission() // "permission denied"
    ErrExist      = errExist()      // "file already exists"
    ErrNotExist   = errNotExist()   // "file does not exist"
    ErrClosed     = errClosed()     // "file already closed"
)

Another case where these predefined error variables are useful, is the sql package, as even “no rows found” is an error in Go:

var ErrNoRows = errors.New("sql: no rows in result set")

This is a clear example of where you cannot work around the error and would want to specifically test it, since you would like to catch “no rows”, but still have the software fail at something like a connection error! Just have a look at an an example from the documentation:

errors.As()

Finally, there is also another function, errors.As() ,which lets you use the error target:

Output:

Failed at path: non-existing

For more information on this advanced variation of the pattern, have a look at the documentation!

Hi! 👋 I’m Tom. I’m a software engineer, a technical writer and IT burnout coach. If you want to get in touch, check out https://tomdeneire.github.io

What every programmer should know about Alan Turing

Tom Deneire ⚡ — Sat, 11 Feb 2023 08:41:37 +0000

Enigma encryption-machine — Photo by Mauro Sbicego on Unsplash

Biography

Alan Turing (1912–1954) was a British mathematician, who was highly influential in the development of theoretical computer science. Turing formalized the concepts of algorithm and computation by describing the so-called Turing machine, which can be considered a model of a general-purpose computer. Turing is widely considered to be the father of computer science and artificial intelligence.

Outside the realm of computer science, Turing is especially remembered for the role he played in World War Two whilst working for Britain’s codebreaking centre. He was particularly instrumental in improving the Allied techniques for breaking the ciphers of the famous Enigma machine, which was used extensively by Nazi Germany to encipher even their most top-secret military messages.

Sadly, despite his accomplishments in both cryptanalysis and computer science, Turing — who often worked under the cover of secrecy — was never fully recognized in his home country. To boot, in 1952, Turing was prosecuted for homosexual acts. He accepted chemical castration, which rendered him impotent and caused him to grow breasts, as an alternative to prison. Turing died in 1954, at home, at only 41 years old, from eating an apple poisoned with cyanide. Although the circumstances of his death remain unclear, it appears most likely that he took his own life.

Turing machines

Computing

Turing first described his “computing” machine in 1936 with a strictly mathematical purpose. Without going into too much detail, Turing was basically looking for a way to prove that while it is possible to formulate a procedure to produce all rational numbers — numbers that can be expressed as a fraction, e.g. 1 (1/1), 0.5 (1/2) or 0.333… (1/3) — , it is impossible to formulate such a procedure for all real numbers, which include the irrational numbers, which cannot be expressed as a fraction, e.g. √2 or π.

The problem with the irrationals is that while they contain some numbers that are computable — i.e. numbers that can be computed to within any desired precision by a finite, terminating process, like the examples of √2 or π, the vast majority of the irrational numbers cannot be computed. They consist of a purely random, infinite progression of digits without a discernible pattern, such as 0.2896574609817847850521… There is no way to formally describe how to produce such numbers.

The notion “computability” is a good way to understand what a Turing machine is supposed to do. It is a machine that, given a set of instructions, is able to compute numbers, even if their decimal expansion goes on for ever. It is not the end result that counts, but the formal procedure required to produce that result. For instance, we can easily think of a set of instructions to produce 1/3:

0.33333333333333333333333333333333333333333333...

It could be something like (this is not how Turing does it, but that does not matter for now):

**A**: print "0"
**B**: print "."
**C**: print "3"
**D**: goto **C**

I’m using instructions here that will ring a bell for anyone familiar with computer science and although this is not exactly how Turing designed his machine, it is the logical consequence of it.

Turing machine

In actuality, a Turing machine is more like a typewriter, which can both print and read characters or “symbols”, with a head that can move both left and right, and working on an infinite one-dimensional tape divided into cells. The machine’s actions are not so much the result of “instructions” (that would imply that it can be programmed), but of “states” or “configurations”. In a certain state a machine will perform a certain action (Turing also allows series of actions) depending on which symbol it reads at the current position of the head. These actions can be:

print a symbol
erase a symbol
move to the right
move to the left
change to another state

Although difficult to believe at first, this unbelievably simple, even “slavish” (in Turing’s own words) machine, that in itself is not even able to do simple addition or multiplication, can be used to print every computable number. For instance, we can easily see that how the machine’s possibility for conditional logic means that we can construct a Turing machine that keeps repeating the sequence 0123456789:

0.01234567890123456789...

In his original 1936 paper, Turing gives even more difficult examples, such as this one (with increasingly larger sequences of 0):

0.01001000100001...

Any finite “algorithm” — a word I have carefully avoided so far, because it is of course anachronistic — one can think of to construct a number, can be formulated as a specific Turing machine. What’s more, it is possible to design a Universal Turing machine: one single machine (U) that can be fed as input the description of any other specific machine (M), and will consequently compute the same number as M.

When you consider what Turing is describing here — the notion of I/O, machine states or instructions implementing an algorithm’s logic, a stream of binary data (Turing used binary fractions exclusively), a way to “store” programs, and so on — it is easy to see how the Turing machine is widely considered a basic model for a general computer as we know it today.

Turing completeness

A system of data-manipulation rules, such as a computer’s instruction set or a programming language, is said to be Turing-complete, if it can be used to simulate any Turing machine. For example, an imperative language is Turing-complete if it has conditional branching and the ability to change an arbitrary amount of memory.

Of course, all well-known programming languages are Turing complete, and so are some lesser-known, esoteric ones like Whitespace, in which only spaces, linefeeds and tabs have meaning, or Piet, whose programs are bitmaps that look like abstract art. However, it might come as a surprise that even programs like Microsoft Excel or Powerpoint are Turing-complete. This means that, at least in theory, they are completely equivalent to any other Turing-complete language. Imagine writing an operating system in Powerpoint slides! And we can go further still: even video games like Minecraft, card games like Magic: The Gathering, and chemical reaction networks have been shown to be Turing-complete!

Notable examples of incomplete languages are markup languages such as HTML or XML, or query languages. Standard SQL, for instance, is not Turing-complete, although with some additions it can be made so. Regular expression languages and parsing languages are also not Turing-complete.

Turing test

In his writings, Turing often connected his computing machine to the way the human mind works. For instance, he likened the states of the machine to the state of mind of a person performing computations. Vice versa, it is possible that he modeled certain aspects of the Turing machine on the way humans calculate. This interest lead Turing to explore what we would now call “artificial intelligence”.

Beside the apparent resemblance of the human mind and his computing machine, it is not difficult to see how Turing would arrive at the notion of making machines “intelligent”. Let’s go back to the Universal Turing machine, which builds on the fact that it is possible to describe or encode any Turing machine as a string. Conversely, any string that can be produced by an algorithm can be formulated by a Turing machine. Hence, it is conceivable that we create an algorithm that produces the encoding of a Turing machine! In other words, software writing software.

When thinking about the problem of artificial intelligence, Turing proposed what he called the “imitation game” (hence the 2014 movie about Turing’s life), nowadays known as the Turing test. The test is designed to determine whether a machine is able to exhibit intelligent behaviour indistinguishable from that of a human. In the standard interpretation, it is a conversation between a human interrogator and two other parties, one of which is a machine. The “game” is to determine which one is human and which is not, using written communication only (to rule out factors like articulation, tone, etcetera).

While machines have been able to pass the Turing test since the 60s, it remains a highly influential, but also widely criticized way to approach artificial intelligence.

Want to know more?

A lot more can be said about Turing machines or Alan Turing’s influence on theoretical computer science in general, and this short blog cannot really do justice to the richness of his ideas.

For those who want to know more, I highly recommend reading *The Annotated Turing: A Guided Tour Through Alan Turing’s Historic Paper on Computability and the Turing Machine (2008) *by Charles Petzold (ISBN 978–0–470–22905–7). It is written as a commentary to Turing’s original paper “On Computable Numbers, with an Application to the Entscheidungsproblem” (doi:10.1112/plms/s2–42.1.230). However, it not only takes the reader sentence by sentence through Turing’s paper, but adds explanations, further examples, corrections, and biographical information. Also, it requires nothing but a general, high-school level of mathematics to start with.

In short, this is an invaluable source for those who want to explore Alan Turing’s groundbreaking insights on the power of mechanical computation, and — more importantly — its fundamental limitations.

Hi! 👋 I’m Tom. I’m a software engineer, a technical writer and IT burnout coach. If you want to get in touch, check out https://tomdeneire.github.io

Shell in a nutshell

Tom Deneire ⚡ — Sat, 11 Feb 2023 08:35:14 +0000

Photo by Jonas Dücker on Unsplash

In another blog, I explained the concept of the shell — a command language interpreter that executes commands read from standard input, a command line string, or a specified file.

This means that shell can be used either interactively via the terminal:

tdeneire@XPS-13-9370:~$ sh
$ echo "hello"
hello
$ exit
tdeneire@XPS-13-9370:~$

or as a CLI:

sh -c "echo $(date)"

or to execute Shell scripts, saved as .shfiles like this:

#!/bin/sh

echo "Hello world"

You can then execute them with sh myfile.sh.

Especially the last option is a fantastic tool for writing scripts for automation, installation, configuration, and so on.

Because knowing your way around Shell scripts is a vital tool for any developer working with UNIX systems, I will try to summarize Shell syntax below.

I’ve taken care to limit this summary to “pure” UNIX shell syntax, i.e. the Bourne shell or sh . Most Unix-like systems contain the file /bin/sh that is either the Bourne shell, or a symbolic link (or hard link) to a compatible shell (e.g. dash). The reason for sticking to sh is that different shell versions (bash, dash, ksh, zsh, …) all come with different features, although they are mostly sh-compatible. By sticking to sh syntax you allow your scripts to be executed by a variety of shells, which makes them dependable and robust.

Hello world

echo "Hello World!"

Comments

# This is a comment

Variable assignment

NAME_1="Tom"    # set

readonly NAME_1 # read-only

unset NAME_1    # unset

Quoting (strong vs weak)

Quoting variables prevents word splitting and glob expansion, and prevents the script from breaking when input contains spaces, line feeds, glob characters and such.

$ echo '$HOME'

$HOME

$ echo "$HOME"

/home/tdeneire

Arrays

# POSIX shell does not support array variables!

# dash, bash, ksh and others do, however

User input

echo "Enter user name: "

read -r FIRST_NAME

echo "Current user name is $FIRST_NAME"

Operators (arithmetic)

VAL=$((2 + 2))

# +  (Addition) 

# -  (Subtraction) 

# *  (Multiplication)

# /  (Division) 

# %  (Modulus) 

# =  (Assignment) 

# == (Equality) 

# != (Not Equality)

Operators (relational)

[ "$VAL" -eq 4 ]

# -eq (equal)

# -ne (not equal)

# -gt (greater than)

# -lt (less than)

# -ge (greater or equal)

# -le (less or equal)

Operators (boolean)

# && (AND)

# || (OR)

# !  (NOT)

Operators (string)

NAME="Tom"

[ "$NAME" = "Tom" ]

# =   (equal)


# !=  (not equal)

# -z  (zero length)


# -n  (non-zero length)

# str (not empty)

Conditional statements (if…elif…else)

NAME="Tom"

if [ "$NAME" = "Tom" ];

then

    echo "me"

elif [ "$NAME" = "Peter" ];

then

    echo "my cousin"

else

    echo "someone else"

fi

Conditional statements (case)

NAME="Tom"

case $NAME in

    "Tom")

        echo "me"

    ;;

    "Peter")

        echo "my cousin"

    ;;

    *)

        echo "someone else"

    ;;

esac

Loops

For

for NUMBER in 0 1 2 3 4 5 6 7 8 9

do

    echo $NUMBER

done

While

I=0

while [ $I -lt 10 ]

do

    echo $I

    I=$(($I + 1))

done

Until

I=0

until [ ! $I -lt 10 ]

do

    echo $I

    I=$(($I + 1))

done

Break

for VAR1 in 1 2 3

do

    for VAR2 in 0 5

    do

        if [ $VAR1 -eq 2 ] && [ $VAR2 -eq 0 ]

        then

            break 2

        else

            echo "$VAR1 $VAR2"

        fi

    done

done

Continue

NUMS="1 2 3 4 5 6 7"

for NUM in $NUMS

do

    Q=$(($NUM % 2))

    if [ $Q -eq 0 ]

    then

        echo "$NUM is an even number"

        continue

    fi

    echo "Found odd number: $NUM"

done

Command substitution

echo "Date is $(date)"

Functions

Hello () {

    echo "Hello, $1"

    return 0  # Can only return 0-255. Other data should be written


    to stdout

}

Hello "Tom"

RETURN=$?

echo "This command exited with code $RETURN"

Sources

POSIX Shell Tutorial
POSIX shell cheat sheet
GitHub - dylanaraps/pure-sh-bible: 📖 A collection of pure POSIX sh alternatives to external…
Shell Scripting Tutorial

Hi! 👋 I’m Tom. I’m a software engineer, a technical writer and IT burnout coach. If you want to get in touch, check out https://tomdeneire.github.io