Lately, I often find myself wondering about the "journey". "Journey Before Destination", as Brandon Sanderson wrote. I have to get it out of my head for it to take any form, I guess.

First of all, who am I on this journey? A software developer. A man who automates. Creator, modifier. That's why I view myself, at least - as someone whose sole purpose on this world is to adjust parts of it to make life easier for other people. Sometimes it means writing software for banks, sometimes holding the elevator door for someone who wants to get inside. I always said that the whole reason I got for writing software is to make life easier for other people, and it's still true. I'm just lost on anything between me and this purpose.

You see, lately I don't find myself caring about the code I'm paid to write. I have some fun on my side projects, but that's it. I feel distanced from it, and getting into the flow is increasingly difficult. And it's not just code either, it's everything. Cooking, cleaning, changing the towels on the rack of sheets on the bed - It's all something that needs actual effort, instead of being just "something I do". I know, it sounds depressive, but bear with me for a minute.

It all comes to a thought that maybe I'm in too much haste, much like all of this world. For some reason, be it either from Instagram or some Netflix shows, I find myself feeling like I should already be further down the road. Like I should already have more "goals" achieved, whatever they might be. Like I should be "more", get more, find more. Like some of the destinations should already be behind me. I've told my therapist that it's more about the journey and how I feel along the way, and she asked if I ever actually stop to think about where I am on this way and how I feel in this place. I couldn't find an answer.

What does stopping even mean, really? Is it this moment I feel the wind on my face when I step out of my apartment to go to the grocery shop? Is it this minute that I spend on my balcony, coffee in hand, looking at the gray city before returning to three screens and a mountain of tasks and tickets waiting for my attention? Maybe attention is the only thing that this is about, pointing it at something that doesn't actually wait for it. The world just... is, stays where and what it is. Modified, changed, altered by humans on our every step, still maintains it's identity as our home and place we can look at, full of air we can breathe and beauty we can observe.

I suppose that that's all there is to my mistake of how I spend my life. I convinced myself that I never cared what people want or think of me, and I still find myself chained to their attention and needs at work, university and major parts of life. I don't find myself looking at trees and flowers, even though there is nothing stopping me from going out and doing just that. There is just too much pressure to keep doing things, which gets transferred into procrastination anyway, because I can't handle it.

I'm just too fast and too tired for myself and this world, and yet I still ignore the simple solution of just slowing down and focusing more on my "now", then plans and wishes of others.

I suppose there is no real "point" or "end" to this text. I needed to get form something outside of myself, and if it helped you form something for yourself, it's great. I hope we both now go outside and breath whatever air we can, instead of canning ourselves inside and sighing full of frustration and anger.

Today I’ve watched a new video from CodeBullet: Channel that I found when I had a huge phase of watching everything AI - be it teaching a neural network to play a Mario game or drive a simple car... anything like that, and CodeBullet provided me with exactly such a material: simple or not so simple task with an interesting enough narration.

The video was about creating a simple program to cheat in “Clicker Heroes” game. While I don’t know this game, and didn’t want to download it, it reminded me a bit of an old in-browser clicker game called “Cookie Clicker”. There was a time when I spent too much time there, so I was happy to notice it’s still up and online as of writing this post.

What is this about, really?

After finding the game again, I realized that I’m curious about my ability to code something like this: simple clicker to cheat the game, as a fun project. 3 AM be damned, I took a laptop and started coding. Finding whether I was in a game, clicking a cookie, checking for upgrades and buying them... all of that in a language I didn’t touch in a long while: Python.

Two and a half hours later, and the code - as simple and unpolished as it is - is done and working. Cookies are clicked, upgrades are being bought, and I can watch and smile, as I see my code working without problems.

And then I remembered.

Coding used to be really fun for me. Such small projects, just to achieve a simple objective, overcome a simple challenge. For the last two and a half years of my professional career, I stopped coding just for fun. Projects like this weren’t really in my head, while I had to focus on building my independent life which I’ve then just begun and code I was working on at any company I was currently working at.

My point is, I forgot that I’ve got into coding to have fun; To overcome those little challenges, to see my work come to any kind of fruition. Of course, there were other sources of motivation, the biggest of which was my desire to make people’s lives easier using what I have learned, but this? This is where it all started. Simple pleasure from fulfilling a simple task using code.

Remember to code small, stupid things.

It’s just never boring. There is always something you can do to just... do a thing. Some stupid challenge, like making your computer react to you in some way. Or any kind of automation, like turning off your console at the specified time in case you left it in rest mode. Or anything else that will probably take you less than two hours, but will flood your brain with dopamine. My point is, remember that coding, like any other work, can be used both professionally and just for fun, for the simple pleasure of Doing The Thing. If you can make your life easier while you do that, it’s just gravy.

Just remember to have fun.

PS. For those curious, you can find the code I wrote here. Word of warning: It’s not pretty or polished, I’m not a daily Python developer. It was just the easiest language to quickly achieve this objective, and I like writing simple scripts of this kind in Python.

Or rather, bad configuration can do it.

See, I’ve just spent about an hour trying to figure this out, and for the life of me I couldn’t understand, what was happening.

I’ve recently fallen in love with the idea of adding new features to Vim using plugins. As I have four different machines running Linux in one way or another, I have decided to install the same two plugins (Ale and NerdTree) on all of them. Sounds simple enough, doesn’t it? And it was really simple!

On three out of four machines it worked perfectly. One command to install plug-vim on machine, copy the right section into my .vimrc… simple enough, it worked. Right until I tried to install it on my fourth, final and most important machine: Ubuntu in WSL2 on my personal laptop.

For reasons unknown to me at the time, every time I’ve tried to install plugins, I just got these errors:

Error detected while processing /home/hane/.vim/plugged/nerdtree/plugin/NERD_tree.vim:
line   15:
E492: Not an editor command: ^M
line   16:
E15: Invalid expression: exists('loaded_nerd_tree')^M
line  235:
E171: Missing :endif
Error detected while processing /home/hane/.vim/plugged/ale/plugin/ale.vim:
line    4:
E492: Not an editor command: ^M
line    6:
E492: Not an editor command: ^M
line    7:
E15: Invalid expression: exists('g:loaded_ale_dont_use_this_in_other_plugins_please')^M
line  353:
E171: Missing :endif
Press ENTER or type command to continue

They showed up every time I opened Vim, too, so nothing too pleasant.

The culprit was good ol’ Git.

It took me more than an hour to find the right way to google this, and kudos to this specific comment for helping me!

The fix was simple: Change git configuration and set property core.autocrlf to false.

One command:

git config --global core.autocrlf false

And after reinstalling plugins once again, all my problems were gone!

So what happened?

Vim-plug uses git to download plugins. When core.autocrlf was set to true, it automatically set line endings for every file to CRLF, while Vim, when processing .vim files on Linux, was expecting LF endings. That caused the problem above:

E492: Not an editor command: ^M

But what is an ^M, and what does it have to do with Line Endings?

^M is a CR in CRLF, which stands for Carriage Return. It’s a control character used to move a cursor to the beginning of the next line when reaching the end of a current line. As you can probably guess, it was not expected in this case, because only ^@ (Line Feed, LF in CRLF) was expected by Vim and the end of the line.

So Vim got one more character than expected and wasn’t ready to process it, effectively being unable to run installed plugins.

Of course, I could’ve spent much less time on fixing that, if I knew what ^M was beforehand, but hey - We’re all learning, right?

If you encountered this issue too, and this article helped you, please let me know!

For most of the last two years, My job has been mostly about writing another and another SQL query, be it to check what's happening with some data, debug a weird bug or develop a stored procedure as a part of a feature I'm working on. During that time, I've written dozens of different procedures consisting of multiple queries, even to the point of committing small heresy in the form of two thousand lines monster full of XML deserialization and business validations.

Bad times.

But every such experience had left me with some new knowledge to use in future projects, things I could use to further optimize my SQL code or make some debugging easier, so I decided to share them in form of this blog post

Easily commented out conditions

This one is very small and simple, but very useful when I need to write a query with multiple conditions. Let's take a look at the following example:

SELECT
	Id, 
	Name
FROM
	SomeTable
WHERE
	Field1 = "X"
	AND Field2 = "Y"

Now, here we already made our life easier by putting an AND keyword on new line, right before the second condition. It's a good practice when you're actively working on a query, because if you need to see what kind of result you'll achieve without the second condition, you can simply comment it out:

WHERE
	Field1 = "X"
	--AND Field2 = "Y"

See? Nice and easy, and in most SQL IDEs, like SSMS or DataGrip, you can comment out a single line with a simple shortcut.

But what if you want to see what would happen with the second condition, but without the first? If you leave AND keyword on its place, you'll just create an error, because there will be no condition preceding it:

--*SQL server won't let you do this, as there is no working condition before AND!*
WHERE
	--Field1 = "X" 
	AND Field2 = "Y"

Of course, you could move AND to the end of the first condition, but then it would trouble you if you need to comment out the second condition again. Or you could comment out AND like this: /AND/ and it would work, too. It's all fine and dandy, but what if there is another option?

WHERE 1=1
	AND Field1 = "X"
	AND Field2 = "Y"

Looks weird, but it could actually save you a lot of time. That way if you don't need any condition, you can simply comment it out, without breaking your whole query, which depending on size might be very difficult to find where did the error happened.  Adding this simple 1=1 will not affect your qery performance in any significant way, but instead will make it much easier to work on the query "right now".

Of course, it's not something I would leave in a production code, but for the sake of debugging, it can save you some precious seconds or even minutes, and most importantly, it will let you stay "in the flow", without being bothered by unexpected and irritating errors.

Instant insert into TempDB table from SELECT

Now, this is something I've picked up just recently, but it instantly made my life much easier. Consider following code:

CREATE TABLE #Sample (Id INT, Name NVARCHAR(100), Description NVARCHAR(500))

INSERT INTO #Sample (Id, Name, Description)
SELECT
	Id, 
	Name,
	Description
FROM
	SampleTable
WHERE
	Condition = true

This example is very simple:

1. We create a temporal table (which is marked by # character at the beginning of the name)
2. We write its columns and their types
3. We repeat both table name and columns in INSERT statement
4. We fill it with data from SELECT statement

It still made us write quite a lot of words, and any mistake in data type or in choosing columns in INSERT statement can lead to irritating errors, which could stop you for a long enough time that you'll lose your focus.

Instead, you could try this:

SELECT
	Id,
	Name,
	Description
INTO #Sample
FROM
	SampleTable
WHERE
	Condition = true

Yes: I just replaced both CREATE TABLE and INSERT INTO statements with single INTO between SELECT and FROM statements. What does it do? It creates a table with the same column names and types as the ones we just retrieved from the database using our SELECT statement, without writing a lot of unnecessary code, and making it more difficult to make a mistake in the list of columns or risking that one of the columns will have a wrong type.

Of course, there is a but: If you have to run this command multiple times, it won't just insert new data into our #Sample table, but instead it will throw an error saying that such a table already exists. We will deal with this in just a second:

Ensuring that an unnecessary temporal table doesn't already exist

When we use temporal tables, sometimes we also have to delete them, especially when we are actively developing our query. Of course, it's less important when we use #table in stored procedure, as it will get dropped when the procedure is finished, and it's scoped to this procedure, just as our #table will be scoped to our DB session - but if it exists when it shouldn't, it's still a problem.

An obvious choice would be to simply DROP #table at the end of our query, but there is a risk: If for any reason #table doesn't exist when DROP is called, it will throw an error. Similarly, if for any reason the DROP statement won't be called (for example, because there was an error before it) next time we run our query we will also run into a problem.

So what's the solution?

IF OBJECT_ID('tempdb..#app') IS NOT NULL DROP TABLE #app

This single line of code will do two things:

1. Check if table #app already exists in tempdb
2. If it exists, it will drop it.

Put this line at the beginning of your SQL script, change the name to whatever you like, and you're good to go. If a table doesn't exist yet, nothing will happen, but if it exists before it should, it will be dropped.

These lines do an excellent next to SELECT INTO statement, as it protects you against unnecessary errors while letting you use this statement easily.

For now, this will be all. If I remember (or find out) any other tips that can make my life a little easier, this post will have a part 2.

Summary

• You can make debugging SQL queries much simpler by adding "fake" 1=1 condition, and putting every "real" condition after AND or OR keywords.
• Creating and filling tempdb tables can be very simple in SQL Server
• There are a lot of possible errors while operating on tempdb tables, but you can avoid them if you remember that they are there

But what about You? Do You have any interesting tips or tricks you use in SQL Server that helps you get through the day? If you do, please share them in comments, I'd love to learn something new to use in my day-to-day SQL work.