Switched to LibreOffice.

At some point years ago I discovered StarOffice (an alternative to the Microsoft Office). I gave it a short try, don’t remember how long I played with it. I’m almost sure, however, that I remember its particularly impressing feature: a desktop-like start screen. Once You’ve opened the app, it presented You with a large (maybe full-screen) area, which resembled a desktop rather, than a regular window. What I mean by that is the StarOffice’s start screen looked similar to a Windows desktop itself – it had, for example, its own Start Button. It was surprising and I liked it – it brought some freshness into the matter of working with an ordinary office suite.

I don’t remember why I’ve switched back to the Microsoft Office, but now – many years after that – I am at a similar point, at which once more I decide to change my preference. But this time StarOffice does not exist anymore – being replaced by its successor: LibreOffice (and OpenOffice in between).

For me this is a significant part of my adventure with free software (is it called FLOSS today?). Before that I had exciting experiences with GNU/Linux (various distros), which is yet another subject to which I’ve recently returned.

Now, years after, my first impressions on both – GNU/Linux and LibreOffice – are positive. Watching several GNU/Linux reviews I’ve had the impression that average (i.e. non-technical) users are much more taken into consideration nowadays, as the OS target user base. I have the impression that not only more average users choose GNU/Linux, but also that its developers take the approach in which non-technical users’ perspective matters.

Back to LibreOffice, however, I feel good and comfortable using ethical software. It again brings some freshness, and even still has its own dedicated start window – a fantastic concept thanks to which You can see at one glimpse all Your recent documents, texts, spreadsheets, presentations, etc. I find it a much better idea than sole Windows 7 “jump lists” (link?).

This is a couple of reasons why I’ve decided to switch to the LibreOffice:

  • it is free software, therefore ethical,
  • it is developed in a model I find optimal: by community of its enthusiasts, driven often by the very idea – not by the money,
  • since it is free of charge, it’s much more available: You can always have “the newest and greatest” version, which is not so easy in case of proprietary office suits,
  • it allows You to customize its look&feel to a satisfactory (i.e. high) degree;

Customization alone is key in my case, due both to my love for aesthetics, and need to use dark-theme. I couldn’t do much to darken the Microsoft Word 2010: it hadn’t had a genuine dark mode, but a sole metallic-looking skin (which hadn’t even been really dark). Moreover, I couldn’t set its windows’ background to black (or anything dark), let alone to set the paper color – which wasn’t so easy to achieve.

Using LibreOFfice’s Word counterpart, Writer – You could be very surprised. It’s very easy to set Your Own colors not only to the paper (pages), but also all the background surrounding it, and many, many more elements (even such details like hyperlinks, lines signifying page header and footer, etc.). I am enchanted by how easily You can adjust LibreOffice’s many aspects to Your Own liking. For example, speaking of colors, You have all the LibreOffice’s apps colors gathered in one place for You to set – so You don’t need to do it separately per each app. Moreover, You can even create Your Own complete themes, if You’d like to.

LibreOffice - Application Colors

Under Windows 7 those themes are stored within the registrymodifications.xcu file (C:\Users\YourUserName\AppData\Roaming\LibreOffice\4\user).

Similarly You can set the language: no more flicking and thoroughly searching through app’s settings – all the language-related aspects are, again, present in one place.

LibreOffice - Language Settings

And then, in the same mold You will find font-related settings within Writer.

LibreOffice Writer - Basic Fonts

As far as professional software is concerned, the ability to set things up easily and quickly is crucial.

Keeping all of this in mind I’ve realized that this is yet another subject worth to cover on this blog: whenever I find particular knowledge tangibly useful both for myself and probably also for You, I’ll publish a related how-to or a more in-depth article on the matter. Similarly like in case of Git, which has fascinated me and inspired to write several posts, uncovering my “non-technical approach” to it (so to speak).

So in case You are considering to give the LibreOffice a try – or maybe You’ve recently joined its users community – either way there is a chance You’ll find something interesting here, under the LibreOffice tag. 🙂

I’m not gonna write complex and elaborate manuals – instead, I’m going to focus on anything which I find crucial in my everyday work. Usually these are smaller and more particular-task-oriented bits and pieces of knowledge – indeed, I find over the years, that to master something You don’t necessarily need to learn so much stuff. Instead of such a labor it often turns out that You may only need to master a couple of more-or-less simple topics, which will be just fine to achieve Your goals, on a satisfactory level.

This realization alone may be life-changing 🙂 – I still remember how little did it take to gain a certainty that some particular app could meet (at least most of) my needs:

  1. Point out the essence of Your work, i.e. to what key actions it may be boiled down.
  2. Check out if how to perform those actions within a new app.

For example, the only thing I needed to obtain such certainty in case of Macromedia Flash (Macromedia’s at the time) was to find out if I could figure out how to design an animated baner (because it involves the same key characteristics like in case of a genuine Flash-driven, interactive website). In case of Photoshop I needed to check how easily could I learn how to master various ways of applying transparency as well as layer blending.

A Meaningful, Successful Life is One You Lead Being Yourself.

Not so long after finishing my experiment with meditating daily I realized that spontaneous irregular sessions do not work well in my case. It is challenging to meet even habitual activities – let alone anything “in between”. I was concerned with pretty rare occurrences of meditation – because of the important benefits one can get out of this activity, given it is often practiced. On the other hand, however, I’ve learned that forcing myself to fulfill the habit (i.e. to meditate on a daily basis) results in low genuineness of the outcome (the quality of sessions). So the big question turned out to be

how to reconcile the quality with efficiency?

My first hope was to take “a blogging approach” by labelling and sharing each undertaken session via Meditation Assistant Android app – but it didn’t turn out to be enough of a help. Now I still don’t know what such a thing could be – but today I was inspired by Cynthia Sue Larson (Whom blog archive I’m currently studying):

“Meditation is actually the most important thing you can do.” (source)

“(…) people increasingly experience more reality shifts, thanks to more people meditating and following spiritual paths than ever before (…).” (source)

Once I’ve read those words, I felt excited again – it brought back the feeling of satisfaction and contentment with the awareness that each time I meditate, I do something good for My Being, for Myself, both spiritually and physically. It was always exciting when I often felt that even a couple minutes of meditating do matter.

So, feeling that excitement again, I’ve decided to meditate as soon as possible 🙂 . It resulted in 28-minute session with an interesting message of wisdom received:

“A meaningful, successful life is one You lead being Yourself. It’s Your torch – let it glow and unveil what’s the best of You, all around.”

Expanding My Reading Habit.

My reading habit 2019 ()Loop Habit Tracker.

Some time ago I wanted to motivate Myself by tracking how often I read books. Whenever I’ve managed to read long enough (at least one hour per day), I jotted it down into My habit tracking app. But there is also other activity I’d like to be engaged into as a habit: reading posts and articles from My favorite sources. I do it mostly via Handy News Reader – an RSS reader app I prefer (Android). It is, however, challenging to fulfill all those habits which I find worth attention. Therefore My newest idea on the matter is: to expand reading habit to include not only books, but also those smaller pieces of knowledge 🙂 . Maybe this compromise will turn out to be helpful in meeting My reading ambitions.

So, before the beginning of tracking a reading habit in its expanded form, I took a closer look on My current stats (reading books). They look as follows:

My reading habit 2019.

My reading habit 2019.

Although not impressive, it’s worth noticing that I’ve been able to manage a streak of consecutive 6 days of reading at least one hour daily.

Wanted: Paste as Pure Text.

LibreOffice Writer tip.

If You often work with text, there are chances that You might appreciate its so-called plain form. Basically speaking, in a world of computers, smartphones and tablets text can take two forms, depending on what app is used to manage it. The forms are: formatted or plain. Formatted text is the one which allows You to do much more with its appearance (bold, italicize, underline, color, etc.) – whereas plain text is just sole content, which does not carry “within itself” any visual changes performed.

Since there are multiple “sub-kinds” of formatted text, things may sometimes go complicated, especially during copy&paste process, when You need to grab some text from one place and put it into another one (e.g. between two different apps). In such cases sometimes no harm will be done – while sometimes, unfortunately, something may go not necessarily the way You’d prefer.

As an example imagine that: say, You’re working on a book, using some professional word processor, like Microsoft Word, LibreOffice Writer or Apple Pages. Then, suppose You need to quote something from a particular website. The easiest way seems to be simply to copy the text from the web-browser and paste it directly into Your book – but then You may realize that the text You’ve just pasted looks pretty differently than the rest of Your paragraph. If You’ve experienced such a thing, it is due to the way the copy feature works, that is to say, in reality it copies not only the text itself, but also its appearance. Although this could be sometimes useful, it can be also annoying, especially when You need pure information being simply put into Your carefully tailored, holistically looking draft, ** without disturbing it**.

How You can avoid this issue?

There are various ways to do that. The easiest way, although not the most convenient one, is to use “a middle-man” in a form of a Windows Notepad. Before You paste anything into Your book, paste it into an empty Notepad window, then select it all and copy once more, to finally paste into Your document. It should help due to that Notepad is not able to handle formatted text, so any time You hand such a text to it – it simply strips the text out of its all visual characteristics, “downgrading it” to its essence.

The most convenient way, however, may be to use PureText – a small tool providing You with an extra keyboard shortcut (of Your choice) to paste any text always in a pure (plain) form.


So, in other words, it does a trick similar to the one just described above, but this time it does not involve any additional steps to take. Just one shortcut to paste a text, as usual. Moreover, it will work anywhere, apps-wide.

The last method refers to the specific office suite called LibreOffice, which may become Your Microsoft Office or Apple iWork good alternative, free of charge. Libre Office’s text editor (called Writer) includes its own keyboard shortcut (Ctrl + Alt + Shift + V) to do the same thing as described above.

LibreOffice Writer can do the trick :) !

So if You don’t need this functionality to work anywhere but within LibreOffice Writer, You can do without PureText and stick to LO’s native feature.

Formatted text… without formatted text › Your potential sweet spot.

Back to formatted and plain text, You may find interesting to know that there is also the third choice out there: “a Markdown-powered one”. Markdown, in a nutshell, allows plain text to be formatted. You can write in any app You want, and have the certainty that You’ll end up with the text properly and uniformly formatted, while You still have all the advantages of a plain form maintained (e.g. plain text-editors are often lightning quick in comparison to their more advanced counterparts). So this solution reconciles simplicity with power 🙂 . More on my Markdown experience You can read here.

Fix The Bat! Wrong Cookie Character Encoding.

Recently – inspired by Benjamin Dreyer (Dreyer’s English: An Utterly Correct Guide to Clarity and Style.) – I began to apply typographical improvements Myself, whenever I can. One of many places affected by this knowledge is a quote set (“golden thoughts”) which I use within The Bat! (an e-mail app for Windows) via “cookie” feature (which You can use for random quotes within Your message template, for example). The improvement was about switching from “dummy” to “smart” quotation marks and apostrophes.

Soon after this change, however, I’ve noticed that The Bat! doesn’t handle Unicode characters incorporated well: instead of showing the proper final result (e.g. rightly encoded quotation marks), it has displayed “garbage” characters. Since I haven’t found anything helpful within the app’s settings, the only remaining idea was to experiment with character encoding on the Notepad++ side. To My content I’ve soon discovered what solves the problem: Encoding › Convert to ANSI. Works like a charm 🙂 .

Does Your Blogger Contact Form Really Deliver Messages?

Quick survey on what’s coming:

  1. The alternative to Blogger Contact Form.
  2. Drawbacks.
  3. Two different approaches to apply.
  4. How to create a Google Form and put it on Your website.
  5. How to create custom landing page.
  6. How to duplicate a Google Form.

To My surprise, the other day I’ve realized that the contact form of My website does not work properly. Interestingly, it still gives a positive confirmation message once You click “Submit” button – which, however, turns out to be false, because there is no message delivered. The same with all the rest of My websites where I use the contact form gadget.

After a little bit of research I’ve learned that those issues exist at least for couple weeks now, and Google probably is aware of that, working on the fix.

In these circumstances I was pretty sure that I Myself can’t do anything about it, i.e. it’s beyond My competence. But then another surprise has come, this time a positive one: I’ve discovered much better solution. A funny thing is that without this failure there are pretty low chances for Me to stumble upon this interesting alternative – so… I’m grateful 🙂 .

The alternative to Blogger Contact Form.

It has several edges over classic contact form gadget – the following ones I find most important:

  1. It allows You to add more fields to a form, thanks to which You can encourage Your Audience to share a more in-depth feedback. You can use fields of various types, making the interaction more friendly (checkboxes, linear scales, date and time pickers, etc. – there is even a file upload feature).
  2. You can turn Your form into a small interview conducted in a step-by-step manner, i.e. one question displayed at a time, and a progress bar alongside it.
  3. It’s much easier to customize the look&feel of the whole thing – as a result You may end up with a (contact) form in the same visual style as the website on which it is placed. Moreover, it’s much easier to apply Your Own “jQuery magic” (e.g. custom animations, Your Own progress bar, etc.) to make it even more unique/to add more fun 🙂 .
  4. Here You can see a list of all Your (contact) forms at once – no need to switch between blogs.
  5. The dashboard collects all of the responses and gives You different interesting ways of studying them (for example, You can see all the answers to one particular question).
  6. The dashboard gives You its own stats about all the responses – so You can have a look at the big picture.
  7. It allows You to put all the gathered answers alongside the form itself – which enables You to create a guest book (for example – see a simplified demo).
  8. Interestingly, all the forms You’ve created are stored (and automatically saved) on Your Google Drive (You can freely move them to another location within the Drive) – therefore You can easily create their backup, if You’d like to.

All of that is possible thanks to Google Forms, which are part of G Suit (Google’s complete office suite). With the help of Google Forms You can not only create a better contact form, but also forms serving for various different purposes (there are several examples already in place for You to inspect). Moreover, You can create those forms totally from scratch, if You like, caring about every little detail (there are many possibilities here – for example You can choose which fields should be required, or You can apply a validation mechanism checking if an e-mail or a website address have been entered correctly).


So far I haven’t found much of them:

  1. To put such a form on Your website You need to do at least a little bit more than in the classic Blogger contact form case.
  2. Form replies won’t be sent to You via e-mail any more – You can receive notifications only (You need to enable them first – for each form separately).

Two different approaches to apply.

There are two different ways of applying Google Forms on Your website. One is simpler, while the other gives You more flexibility.

In the first scenario You create a form completely within Google Forms dashboard. Once You’ve finished, You can grab a short code snippet to easy embed (copy&paste) on Your website (within the HTML/JavaScript gadget or directly within the template).

In the second scenario You create a basic form within the dashboard (just the fields You want to include – no additional features (like validation) or customization needed). Meanwhile You create a similar form within Your HTML/JavaScript gadget or the HTML template itself. Both forms should have the same fields. Then, using “Inspect” function within Your Chrome(-based) browser, You easily grab some code snippets from the form created within Google Forms – and paste them into the proper place within its HTML-based counterpart.

Both scenarios give You some room for customization, but in case of Google Forms dashboard the possibilities are pretty limited. Besides, it’s worth to remember that an embedded form (the first option) will be presented with accompanying “Google fine print” (like “Never submit passwords through Google Forms” or “This content is neither created nor endorsed by Google. Report Abuse – Terms of Service – Privacy Policy”).

and also Google “landing page” displayed once the form has been submitted.

The second scenario, although requiring more work, allows You to make the outsourced nature of a form completely transparent, i.e. it can not only look exactly like You prefer (landing page included!), but has no signs of Google brand behind it (which You may find beneficial, regarding Your brand’s coherence).

How to create a Google Form and put it on Your website.

Since there are already great how-to’s on the matter (I mean this and that one), I’m not gonna to repeat them because it’s pretty simple:

  1. Create a form within Google Forms.
  2. Open its preview (an eye icon on the top right).
  3. Inspect its title (on the top) – this way it will be easier to quickly find the <form> header with action value to copy and paste into Your HTML form.
  4. Inspect each and every field to gain their names (name attribute’s value) – to also include within Your HTML form.
  5. Remember to enable e-mail notifications, If You’d like to receive them every time someone has filled the form.

Once again, for more detailed step-by-step instruction I recommend You to use this and that one.

How to create custom landing page.

Code-wise, the head of Your HTML form may look like this:

<form action="PasteTheProperActionValue" method="POST">

If You’d like to have Your Own landing page to display once someone has filled and sent the form, it will be enough just to replace the head line mentioned above with this:

<script type="text/javascript">var submitted=false;</script>
<iframe name="hidden_iframe" id="hidden_iframe" style="display:none;" onload="if(submitted) {window.location='YourLandingPageAddressHere.html';}"></iframe>
<form action="PasteTheProperActionValue" method="POST" target="hidden_iframe" onsubmit="submitted=true;">

(the source)

How to duplicate a Google Form.

If You would like to create similar independent forms to put on other websites, the easiest way may be as follows:

  1. Open Your Google Drive and make a copy of Your form file, with the appropriate name.
  2. Open Google Forms dashboard, then open the newly created form. and then open its preview (an eye icon on the top right).
  3. This time You need to grab only its action value – as long as You only need the same fields as before, You don’t need to gain their name values again, because they remain the same.

Wanna use Git? Here are further improvements.

‘git log’ after some touch-ups

So now You know how You may benefit from Git, as far as Your creative work is concerned. Whenever You are a writer, a blogger, a webdesigner, or even a computer graphic artist (You name it) – You could take advantage out of this interesting invention.

In one of the previous posts I described in general, how You can set Git up and use it under Windows. BTW, I find it fantastic that it can be used on other – i.e. non-GNU/Linux – platforms (it wasn’t so obvious, as there are many fantastic tools which are restricted to GNU/Linux and You can’t benefit from them anywhere else).

Now, let’s get things further, making it even easier, faster, and more friendly in everyday use 🙂 . In the meantime You’ll learn some more stuff which also comes in handy and may significantly widen what You could do with all of that. So let’s get started:

Quick survey on what’s coming:

  1. Open terminal window always in the right place.
  2. Learn how to copy&paste in Cygwin.
  3. Harness a text editor of Your preference.
  4. Use more intuitive commands.
  5. Your project status always at hand.
  6. Track Your work progress.
  7. Embrace snapshots.
  8. Embrace multi-version approach.

Earlier on I showed You how You can enrich Windows in-built terminal with proper functionality needed when it comes to Git. There is yet another approach, though, which You might find much easier to handle: You could call it Just stick to the Cygwin 🙂 .

As You may remember, Cygwin is the tool to install when You need GNU/Linux commands (or GNU/Linux-like apps) under, let’s say, Windows. Our first approach did not incorporate Cygwin much, at least not in front of Your eyes – reserving “the creamy stuff” for Windows own console, with which You might be already familiar (in case You find the nomenclature confusing, I recommend You to take a look at this note on terminal, console, and other similar terms – explained in a nicely, straightforward way).

As such, Cygwin seems to be a pretty interesting bit of software. At first glance it looks like just another terminal, nothing really special – but then You may realize that it has additional power under the hood, providing You with a whole bunch of stuff well-known for many GNU/Linux users. In this respect Cygwin may take You a long way deep down its own adventure, as a result of which You may find Git just one of many stops during the journey.

Sticking with Our main subject today, which is Git, it is fine to say that Cygwin may be Your (much) better command prompt under Windows – for a number of reasons. First of all, You can skip the whole part of “teaching” Windows terminal anything in order to use Git – because we won’t use this terminal at all. Have Cygwin installed? Great, You are good to go 🙂 . Second, it is way more flexible: You can customize many things which are virtually a no-go when it comes to Windows classic terminal – like, for example, a nice elegant smoky-glass transparency effect which You may apply to its window – or interesting copy&paste approach You may have never encountered before, which automatically copies the selected text (You don’t even need to use a keyboard shortcut!) and paste it via simple right click (!). Blows the mind 😉 !

Open a terminal window always in the right place.

Remember custom terminal shortcuts? It’s a nice little trick to make things easier by skipping several steps, otherwise needed to be taken each and every time You want to use Git. Today I’ll present You with yet another, even more extravagant method 😉 , which saves much time, doesn’t require creating any custom shortcuts and will allow You to launch terminal window always opened in the desired place, whenever it would be. This is possible thanks to AutoHotkey – a fantastic powerful tool, which I’ve mentioned several times before, through various occasions.

In case You don’t know AutoHotkey, this survey may be an interesting road to take.

Today I’ll tell You how You can harness AutoHotkey to elevate Your terminal experience to the next level 🙂 . Here You are how this is supposed to work:

  1. Whenever You want to use Git, open a window displaying Your project folder first, and then press a keyboard shortcut of Your choice.
  2. This will results in opening a Cygwin window with Your working directory already set in place.
  3. Whatever folder You’ll open on Windows, the same keyboard shortcut acts accordingly, opening new Cygwin terminal window with the proper directory in place – so You don’t need to navigate toward it any more.

As a curiosity: there are many things You could achieve much easier and faster just using a sole terminal, instead of anything else. One example (described in details later) is searching for files containing a particular word or a phrase and then automatically opening them in a text editor – You can perform this action with one single command. There seem to be no way to do it faster than this. And this is just one example – as I’ve mentioned, there are many more. In case You’d like to use it on a daily basis, the trick with terminal on-demand, launched always in the right place (i.e. accordingly to what You have opened on Your desktop) may be of much wider help than a sole Git-related purpose.

The easiest way of achieving this concept is to download this script and make it running automatically with every Windows launch.

Learn how to copy&paste in Cygwin.

It may be somewhat of surprise that in case of various terminals the classic way of copy&paste is not available (here is an in-depth answer why it is that way). The good news is that in Cygwin there are several other ways to do that, some of which You might find even more appealing than the traditional one. Let’s see…

  1. Copy and paste by Ctrl/Shift+Insert.
    Open Cygwin options (click on the small icon in the left top corner of its window and You’ll find it there) › Keyboard features › check Copy and Paste (Ctrl/Shift+Ins).
  2. Copy on selecting a text.
    Options…Selection and clipboard › check Copy on select.
  3. Paste by right mouse button.
    Options…Mouse functionsClick actions › choose Paste.

Note that the ability to copy on select is especially handy, because You don’t have to perform an additional step of pressing a keyboard shortcut to copy what You’ve selected.

Harness a text editor of Your preference.

Later in this article You’ll learn of a fantastic feature of commenting Your project’s progress key steps. Thanks to this it will be much easier to find the particular point of its development – or to remind Yourself what was all about – especially in the long run, i.e. after months (or years) passed by.

The thing is that sole terminals may not be of the best choice when it comes to write anything longer than ordinary, usually concise commands. It’s not only that the font is pretty small and lacks readability – the more important thing is that You’ll be in the need to learn from scratch how to use Your terminal-based text editor. As long as You are not a GNU/Linux user with the emphasized preference of using such a tool, You definitely need more convenient way for writing Git comments, the one which is already familiar to You: Your current favorite text editor. In My case it is a Notepad++ – a fantastic tool with many helpful tricks up its sleeve. I use it for everything I can: from blogging to coding. A nice thing is that You can also use it to write Git comments 🙂 .

If You, however, consider using terminal also for non-Git purposes – harnessing Your Own text-editor of preference may also be a good move. Consider just one example mentioned a moment ago: You need to find text files containing a particular phrase, then You need to open each of them to inspect which one is indeed the one You are looking for. All of this You can achieve with one single command, which will both find the files and automatically open them within Your text-editor. We’ll take a closer look on that concept after a while in this article.

First, let’s talk about

Custom text editor for Git.

You can simply set up Your Own text editor in Git with the following command:

git config --global core.editor "'C:/Program Files/Notepad++/notepad++.exe' -multiInst -notabbar -nosession"

If You don’t use Notepad++, just replace C:/Program Files/Notepad++/notepad++.exe with the path to Your text editor, remove -multiInst -notabbar -nosession and You’re good to go 🙂 .

Custom text editor for Cygwin.

In case You’d appreciate using Your Own text editor paired with a terminal also for non-Git purposes, here what You can do:

  1. In Your text editor open the .baschrc file (by default it should be placed on C:\cygwin\home\YourUserName).
  2. Add the following code snippet to the very end of the file:

    npp () { /cygdrive/c/Program\ Files/Notepad++/notepad++.exe -multiInst -nosession $(cygpath -w -- "$@") }

You can replace “npp” with Your Own abbreviation to initiate the text editor from the command line (as in, for example, npp text.txt).

Again, if You don’t use Notepad++, correct the path to the editor of Your preference (remember to keep /cygdrive/ part, as well as the backslash within Program\Files if Your editor is placed somewhere there) and remove -multiInst -nosession part.

Kind credits for Greta “Jade” Krafsig and Her post Cygwin Tutorial: Use External Editor Notepad++.

Now, You can recall the idea of searching text files and opening the ones founded – all with a single command:

IFS=$'\t\n' && npp $(grep -l -r 'cat')

The command above will search for files (within the current directory) containing a “cat” and open the ones which do contain it in Notepad++.

The IFS=$'\t\n' part ensures You that files containing spaces within their names will be properly handled.

Use more intuitive commands.

In this section we will dive a little bit deeper into Git everyday usage. All in all, it could be great if it could perform anything You need – in a fast and convenient fashion. Wonderful news is that, indeed, it can be that way 🙂 ! Moreover, it can reach such a convenience point which You might find surprising 🙂 . So, let’s get to the nitty-gritty without any further ado:) .

As You already know, using Git comes down to harnessing several “geeky” commands, like – for example – git commit for saving the current state of Your project. One interesting thing is that Git allows You to replace those commands with Your Own wording (so-called “aliases”), which You may find much more intuitive in everyday use. For instance, You could replace git commit with a simple git save 🙂 .

Moreover, there are cases in which You need to use more complex, much longer commands – which are especially inconvenient when You need to perform them repeatedly from time to time. In such a case You could either type the whole thing each and every time… or You could ascribe Your Own (i.e. much simpler) wording to do the same thing. As an example take a look on this long command which results in displaying Your project’s history:

git log --format="%n %h %Cgreen %cr %Creset (%Cred%an%Creset) %n %s %n" --reverse

You could replace it all with a simple – say – git story. Once You do that, it will be enough to simply type git story every time You need to see it in Your Own carefully tailored way (see the longer variant mentioned earlier).

Here You are examples of how to ascribe Your Own wording to already existing Git commands:

git save (for git commit)

git config --global alias.save "commit -a"

Note that in the example above I use commit -a which always add all the changed files to a snapshot. Besides, as it does not include an -m appendix, the command will result in opening Your default text-editor for You either to inspect changes and/or provide a comment to the snapshot You are about to create (more on comments a little bit later).

git story (for git log.........)

git config alias.story 'log --format="%n %h %Cgreen %cr %Creset (%Cred%an%Creset) %n %s %n" --reverse'

Taking a closer look You will notice that this command wraps the actual Git command with apostrophes – while the previous one used quotation marks. The reason is that if the command to wrap has already quotation marks within it, then it should be wrapped with apostrophes to make it work right.

If You’d like to fix or change anything within the aliases You’ve already created, just use the same command with --replace-all attached to it after a space.

Your project status always at hand.

In this section we will explore a handful of good habits which may significantly improve Your workflow. Furthermore, You’ll learn about several useful procedures which come in handy when working with Git on a daily basis.

Since Git pays much attention to details, caring about Your work and its progress’ tracking – it is a good idea to follow suite, at least to some degree 🙂 . This way You will ensure that everything will work as You expect. The essential good habit here comes with a git status command (which I replaced with git s for convenience and speed). It will give You a clear picture of what has happened to Your project – i.a. which files have been changed, which are completely new (and therefore require to be included within “Git’s tracking mind” 😉 ). Using this command You can, for example:

  1. Ensure Yourself that Your project does (not) require taking another snapshot to save its progress.
  2. Remind Yourself which particular files You’ve been working on recently (sometimes it’s easy to loose track).

Here is how the result of using git status may look like:

git status

In this case it tells that one file (“style.css”) has been changed. Note that it is red-colored – You will notice here and there that Git incorporates colors to make information more clear and readable.

Track Your work progress.

With Git You can very easily check not only on what – but also when You’ve been working on something. This is why it’s a great tool to inspect “how are things” in terms of a particular project, e.g. when was the last time You’ve dropped it, or how intensively You’ve been engaged.

Although the proper commands already exist, their default result is not so convenient – i.e. there is much room for readability improvement. By default it may look like this:

‘git log’ default behavior

Fortunately, Git provides You with a whole bunch of smaller commands acting like “building blocks” to tailor a bigger one, which would suit You much more. A command made like this, however, may be often pretty long – so it is a great opportunity to apply Your Own wording here (i.e. aliases).

I did that with git story, which in My case results in something like this:

‘git log’ after some touch-ups

But first I needed to create a much longer command, with the help of which I wanted to achieve:

  • more readability thanks to applying different colors and blank lines,
  • reverse history order, thanks to which I instantaneously see the most recent stage of My project development;

Keeping the above in mind I’ve ended up with this:

git log --format="%n %h %Cgreen %cr %Creset (%Cred%an%Creset) %n %s %n" --reverse

which did its job well and therefore had been ready to be replaced with git story mentioned earlier on.

Embrace snapshots.

Let’s begin with a thing which You might call “snapshots”. In general, this is about saving Your project’s state every time You consider a key point on its development (not necessarily a milestone). Usually those “key points” refer to some task or a stage which You’ve just completed. Then it’s always a good idea to make “a snapshot” of Your work in that point in time, i.e. when one particular step has been achieved. In the long run it’s easy to imagine a nicely-grown history of Your work, clearly organized into logical steps, labeled with timestamps and, more importantly, with Your comments. Those are great things: every time You save a snapshot of Your work, You can describe it as precisely and clearly as You can. While creating such a comment, think of Yourself reading it after a longer while (a couple of months or even longer), therefore describe the snapshot in such a way which should be comprehensive to You (or someone else) even regardless of the passage of time.

The actual command for saving a snapshot looks as follows:

git commit -a -m "Your comment here."

I, however, prefer to use much more intuitive git save for that task, which turns the thing into this:

git save -m "Your comment here."

Now, before You go any further, let’s focus on comments as such for a moment. In Git each snapshot should be described – which may come in handy especially in the future, when You don’t necessarily remember what the particular work was all about. Then comments may turn out to be the key information needed to quickly figure things out – provided they’ve been written in the right manner, i.e. concise, precise, and comprehensive.

Note, however, that although You indeed could summarize some snapshots with a single sentence – there may be other cases in which it could be a good idea to provide more detailed information about what work has been done. In such cases You can take a little bit different approach: still stick to summarizing the whole thing in one sentence, but then elaborate on it (still in a form of a summary) via further sentences.

From the command-line perspective it looks like this:

A single-sentenced comment:

Just use one of those commands:
git commit -m "Type the comment here."
git save -m "Type the comment here."

A more-detailed (multi-sentenced) comment:

1, Use git commit or git save – but without anything added at the end of the command. Confirm.
2. Git should initiate Your default text editor and open a file.
3. At the very bottom of this file write the main summary in a form of a single sentence.
4. Create a blank line and then provide more detailed summary in a form of further sentences (perhaps a numbered list?).
5. Save and close the file.

An interesting approach to Git comments You’ll find here.

It’s worth noticing that git story we were talking about earlier on presents only those very first sentences alongside each snapshot. If You’d like to see full comment, use this command:

git show ID

  • where “ID” stands for a snapshot “hash” (You’ll learn about it soon).

So let’s practice a little bit. Suppose You’ve just finished the next step of Your project development – which is a good time to make its snapshot. Before You’ll do that, a good habit is to ensure that everything will be included in the snapshot:

  • if You didn’t create any new files, just use git status (or git s if You’ve created the abbreviation of this command) and You’ll see all the files which have been modified,
  • if You did create some new files, use git add . first, and then git s (as a curiosity if You revert the order and use git s first – You’ll see that Git differentiates newly created files from already existing modified ones – every time You create a new file, You need to tell Git that it should include it within further snapshots – and You do that via git add . command);

Once You’ve ensured that all the files You want to include – in fact will be included, You can create the actual snapshot. Keeping all of the information above in mind, the complete procedure would look like this:

To create a snapshot of Your project:

  1. Inspect what files should be included within the snapshot:
    git status (or git s).
  2. If there are any new files, include them by
    git add . (note the period at the end of the command is important)
  3. Create a snapshot:
    git commit -a -m "Your comment here..."
    git save -m "Your comment here..."
  4. Optionally You can ensure that everything went well by git s again – and throw an eye on the project’s history with Your newly created snapshot via git story.

Now, speaking of the git story – You may remember how I’ve described it a little bit earlier. It refers to this exact “history” thing we’re exploring now. It could look like this:

‘git log’ after some touch-ups

Note those random strings of characters just before green timestamps: they are called “hashes” and You could consider them to be snapshots’ “IDs”. They are very important and You will often rely on them – so at this point it’s worth to remember of their existence and how to recognize them.

You might wonder when git story may come in handy. There are multiple answers to this question. For example, with git story You could easily tell:

  1. When was the last time You’ve worked on some particular project.
  2. How intense Your engagement had been (based on snapshots frequency and maybe also their character).

But an even greater thing may be that You can go back and forth in time, picking one particular snapshot and switching to it. As a result, Your project files will be reverted to the point at which they were at the time You’ve created the snapshot. In other words, this is a great way of undoing things: in case something went wrong, You can always go back to the newest stable state (a snapshot consisting of such one) and all Your project files will be fine again.

What is fantastic here is that this mechanism is not confined by traditional ctrl+z history or even to a current session at Your computer till it’s turned off. With Git You can undo changes at any given time, even years and many further snapshots later.

So let’s take a closer look on how to travel in time and also how to revert Your project to one of its previous snapshots:

Go back and forth in time:

  1. First, You need to find out to which particular snapshot You’d like to switch. Use
    git story
    to view Your project snapshots history.
  2. Once You know to which snapshot You want to switch, copy its ID/hash (see Learn how to copy&paste in Cygwin). Important: note on the side also the newest snapshot’s ID, which will come in handy whenever You want to go back to it again.
  3. To switch to the previous chosen snapshot, use this:
    git checkout ID
    where “ID” stands for the snapshot’s hash.
  4. Once You want to go back to the newest snapshot again, grab its ID from the previous git story (or from notes on the side) and repeat the step 3, then confirm by
    git checkout master

Undo changes (revert the project to the chosen snapshot for good):

  1. First, You need to find out to which particular snapshot You’d like to revert Your project. Use
    git story
    to view snapshots history and find out.
  2. Once You know to which snapshot You want to revert, copy its ID/hash (see Learn how to copy&paste in Cygwin).
  3. To revert to this snapshot, use this:
    git reset --hard ID
    where “ID” stands for the snapshot’s hash.

Sometimes, however, what You’d like to do is to cancel a sole snapshot, not changes introduced by it. In such a case perform the instruction above, but instead of “hard” enter “soft”. Then create a new snapshot as usual (one of the previous instructions in this article).

Embrace multi-version approach.

One of incredible things which Git enables You to do, is a multi-version approach to Your work. Suppose You are a graphic artist, designing in Photoshop. Working on a new project You might want to explore every avenue of its development, or, to put it differently, You might have more than one idea for the directions it could go – and You’d like to see the results of all of them. To do so, You could multiply layers and folders within Your source .psd file in order to organize multiple versions inside it – or You may simply prefer to copy&paste the file storing Your preferred “starting point”, and then work on each version separately. Either way it’s a bit of a hassle: You need to properly name all those files in order for You to easily find the particular version You need at the time, and Your file library is growing and growing… And there is one more thing: how easily You will be able to figure out what is what – after a few months or so of not working on it?

On the contrary, let’s see what Git has to say in a similar case. Once again imagine that You have Your project .psd file containing the starting point from which You would like to develop it down multiple different roads, i.e. creating a couple of different versions, different ideas of how this project could look like. Multiple approaches, multiple styles. Before You begin to work on the first version, You save in Git the starting point… as “the starting point” (ascribing that comment to the snapshot). Now You’re ready to work on the first version.

When You want to develop the other approach to Your project (second version), the other idea out of the same starting point – You can easily switch to the beginning (the starting point) and once again start from scratch (!). Just one important thing to remember is that You need to save the first version in order not to get it lost. You could comment it as Your “First Version” – or in some much better way which could give You an idea of what it really is – especially in the long run, i.e. after months (or years?) passed by. Then You switch to Your starting point and begin the work on the second approach. Once You finish that, You repeat the same thing: save the work as Your “Second Version” (apply Your Own wording) and that’s all.

Notice that all the time You’re working with one single .psd file. Git does not create its copies for You – it just tracks what have been changed, and is able to recreate any changes made down the road. In the meantime it’s well-organized, especially given that You’ve applied comprehensive comments to each of Your versions. Now, You can switch to any of them at any given time – and Your .psd file will act accordingly, i.e. if You’ve switched to the starting point and then open Your .psd file, it will show You the starting state. If You, however, switch to the first or second version of it in Git – the .psd file will show You those particular work instead of the starting point. It’s like magic, but it does work that way 🙂 . One single .psd file – no additional layers and folders, no file copies. Just one .psd and… travelling back and forth in time 🙂 .

To achieve that kind of a multi-version approach in Git, I’d recommend You to use so-called “branches”. Imagine Your project’s starting point as “the root” of a tree – and Your various ideas of developing it as its independent “branches”. It’s pretty simple: first You develop a project to the point which You consider “the root”, i.e. from which You’d like it to grow toward different directions. By default, Git comes with one single branch already in place. The branch is called “master” – it’s up to You if You prefer Your First Version to sit on this branch or not. Suppose You want to reserve the master branch for the starting point – while create separate branches for the First and Second Version. You can achieve this in the following way:

Set up multi-version approach:

  1. Create Your “starting point” snapshot first (one of the previous instructions in this article).
  2. Create Your “First Ver.” branch:
    git branch FirstVer

Unfortunately Git allows to use only a single word as a branch name. therefore “FirstVer”…

  1. Use git branch to see which branch is currently active (now it should still be “master”).
  2. Switch to the newly created branch:
    git checkout FirstVer
  3. You can use git branch once more to ensure that You are already on this branch.
  4. From this moment forward You can develop Your project in the desired direction, saving multiple snapshots related to it. Just remember that all of this development history will be put on the “FirstVer” branch.
  5. Whenever You’d like to switch back to Your project’s starting point, use this command:
    git checkout master. Once You are back on “master” branch, You can repeat the procedure, starting from the step 2, to create another branches (“SecondVer”, etc.).

Just as a reminder: note that Your project files will act accordingly to what You do within Git, i.e. to what particular snapshot and/or branch You’ve switched.

Another thing which may come in handy is the situation in which You might want to add some changes to the already existing (the newest) snapshot. In such a case the command may look like this:

git commit --amend test.txt -m "test.txt updated."

This example adds “test.txt” file to the newest existing snapshot – and overwrite its comment with “test.txt updated”.

Now, it was a pretty big chunk of knowledge – congrats if You’re still here, and wish You much fun, satisfaction and positive difference thanks to incorporating Git into Your Own workflow.

Life can be much easier thanks to this Windows tool.

updated …at some nice evening of October 26 🙂 (9:44 ᴘ.ᴍ.):
new script: Quote anything the smart way
updated: Insert Your Own flexible timestamp everywhere.

AutoHotkey resembles a construction set, with the help of which You can design from scratch various mechanisms to make Your life easier. You could summarize Its bottom line the following way:

  1. Recall some action which You often perform under Windows (it may be some ordinary thing, like searching some phrase via Google).
  2. Describe the action in the AutoHotkey way (it has its own scripting language, don’t worry about the code – there are many ready-to-use examples out there),
  3. Ascribe a keyboard shortcut to it and that’s it: from this moment forward, instead of taking several steps You’re accustomed to, You need just to press a simple – usually thee-key combination.

Most likely You’ll appreciate this especially in the long run, when You can really feel how much time and hassle it saves.

Here are a few examples of how You could benefit from AutoHotkey:

Quick survey on what’s coming:

  1. Lightning quick Google search.
  2. Drag’n’drop windows much easier.
  3. Insert Your Own flexible timestamp everywhere.
  4. Launch a terminal within the active window directory.
  5. Standard text-formatting keyboard shortcuts… going Markdown 🙂 !
  6. Quote anything the smart way.
  7. Other examples.
  8. Launch an app.
  9. Close an app.
  10. Force-close (kill) an app.
  11. How to make an AutoHotkey script work?
  12. Ascribe a Your Own sys-tray icon.

You can initiate a Google search on a selected text (select the text in any app, press the keyboard shortcut of Your preference and this will open Your web-browser with a Google search results page on what You’ve selected).

Here is the code (find out how to make all the code snippets actually working, at the end of this article):

;- Control+1 = <!-- {Google it!} -->
send ^c
Run, https://www.google.com/search?q=%clipboard%

Take a closer look on

;- Control+1 = <!-- {Google it!} -->

It is here where You have a keyboard shortcut ascribed (in this particular case the shortcut is Ctrl+1).

If You’d prefer to use Your Own keyboard shortcut, here You can learn which code stands for various keyboard and mouse buttons – thanks to which You’ll be able to ascribe Your Own keyboard shortcuts.

As a result, provided You’ve already launched the script file. whenever You press Ctrl+1, the script will be initiated. Similar way it looks in case of other scripts described below.

Drag’n’drop windows much easier.

You can reposition windows on Your screen in a much more convenient way. So far You need to click and hold on a window’s thin title bar in order to drag it to some other place. Now You can click anywhere within the window itself, provided You’ve pressed and hold a key of Your choice (in the example below it is LWin & LButton:: – which stands for holding Win logo + left mouse button clicked within a window). This will do the trick and the window will move, as effectively as before 🙂 .

; This script modified from the original: http://www.autohotkey.com/docs/scripts/EasyWindowDrag.htm
; by The How-To Geek
; http://www.howtogeek.com 

LWin & LButton::
CoordMode, Mouse  ; Switch to screen/absolute coordinates.
MouseGetPos, EWD_MouseStartX, EWD_MouseStartY, EWD_MouseWin
WinGetPos, EWD_OriginalPosX, EWD_OriginalPosY,,, ahk_id %EWD_MouseWin%
WinGet, EWD_WinState, MinMax, ahk_id %EWD_MouseWin% 
if EWD_WinState = 0  ; Only if the window isn't maximized 
	SetTimer, EWD_WatchMouse, 10 ; Track the mouse as the user drags it.

GetKeyState, EWD_LButtonState, LButton, P
if EWD_LButtonState = U  ; Button has been released, so drag is complete.
	SetTimer, EWD_WatchMouse, off
GetKeyState, EWD_EscapeState, Escape, P
if EWD_EscapeState = D  ; Escape has been pressed, so drag is cancelled.
	SetTimer, EWD_WatchMouse, off
	WinMove, ahk_id %EWD_MouseWin%,, %EWD_OriginalPosX%, %EWD_OriginalPosY%
; Otherwise, reposition the window to match the change in mouse coordinates
; caused by the user having dragged the mouse:
CoordMode, Mouse
MouseGetPos, EWD_MouseX, EWD_MouseY
WinGetPos, EWD_WinX, EWD_WinY,,, ahk_id %EWD_MouseWin%
SetWinDelay, -1   ; Makes the below move faster/smoother.
WinMove, ahk_id %EWD_MouseWin%,, EWD_WinX + EWD_MouseX - EWD_MouseStartX, EWD_WinY + EWD_MouseY - EWD_MouseStartY
EWD_MouseStartX := EWD_MouseX  ; Update for the next timer-call to this subroutine.
EWD_MouseStartY := EWD_MouseY

Insert Your Own flexible timestamp everywhere.

It would be a nice idea to be able to insert Your Own timestamp with one single keyboard shortcut – in any app You’re using at the moment. Furthermore, what if the timestamp would be flexible, e.g. depending on the time of the day?

It may look like this (You can design it from scratch to Your Own liking):

…at some nice evening of October 23 🙂 (19:42).


…at some nice day of October 23 🙂 (1:43 ᴘ.ᴍ.)


…at some nice night of October 23 🙂 (10:52 ᴘ.ᴍ.)


To make such a timestamp You need the following code:

24-hour format:

;- Control+Shift+D = <!-- {text} -->

formattime, hourvar, , HH
formattime, minutevar, , mm
formattime, dayvar, , dd
formattime, monthvar, , MM
formattime, yearvar, , yyyy

ctime:=hourvar . minutevar

if (monthvar=01)
if (monthvar=02)
if (monthvar=03)
if (monthvar=04)
if (monthvar=05)
if (monthvar=06)
if (monthvar=07)
if (monthvar=08)
if (monthvar=09)
if (monthvar=10)
if (monthvar=11)
if (monthvar=12)


if (ctime>=500) and (ctime<=759)
	send ...at some nice morning of %cmonth% %d% :) (%h%:%m%)

if (ctime>=800) and (ctime<=1859)
	send ...at some nice day of %cmonth% %d% :) (%h%:%m%)

if (ctime>=1900) and (ctime<=2159)
	send ...at some nice evening of %cmonth% %d% :) (%h%:%m%)

if (ctime>=2200) and (ctime<=2359)
	send ...at some nice night of %cmonth% %d% :) (%h%:%m%)

if (ctime>=0000) and (ctime<=0459)
	send ...at some nice night of %cmonth% %d% :) (%h%:%m%)


12-hour format (ᴀ.ᴍ./ᴘ.ᴍ.):

;- Control+Shift+D = <!-- {text} -->

formattime, hourvar, , HH
formattime, hourvar2, , h
formattime, minutevar, , mm
formattime, dayvar, , dd
formattime, monthvar, , MM
formattime, yearvar, , yyyy

ctime:=hourvar . minutevar

if (monthvar=01)
if (monthvar=02)
if (monthvar=03)
if (monthvar=04)
if (monthvar=05)
if (monthvar=06)
if (monthvar=07)
if (monthvar=08)
if (monthvar=09)
if (monthvar=10)
if (monthvar=11)
if (monthvar=12)


if (ctime>=500) and (ctime<=759)
	send ...at some nice morning of %cmonth% %d% :) (%h%:%m% ᴀ.ᴍ.)

if (ctime>=800) and (ctime<=1159)
	send ...at some nice day of %cmonth% %d% :) (%h%:%m% ᴀ.ᴍ.)

if (ctime>=1200) and (ctime<=1859)
	send ...at some nice day of %cmonth% %d% :) (%h%:%m% ᴘ.ᴍ.)

if (ctime>=1900) and (ctime<=2159)
	send ...at some nice evening of %cmonth% %d% :) (%h%:%m% ᴘ.ᴍ.)

if (ctime>=2200) and (ctime<=2359)
	send ...at some nice night of %cmonth% %d% :) (%h%:%m% ᴘ.ᴍ.)

if (ctime>=0000) and (ctime<=0459)
	send ...at some nice night of %cmonth% %d% :) (%h%:%m% ᴀ.ᴍ.)


As far as ᴀ.ᴍ./ᴘ.ᴍ. are concerned, I’m currently reading Benjamin Dreyer’s Dreyer’s English – An Utterly Correct Guide to Clarity and Style, in which the author recommends to use so-called small caps instead of capital letters:

"When writing of time, I favor (…) those pony-size capital letters (affectionately known as small caps) rather than the horsier A.M./P.M. or the desultory-looking a.m./p.m. (AM/PM and am/pm are out of the question)."

Since I’ve noticed that You may encounter issues with copy&paste the code with the small caps included – in this particular case it’s better for You to download the script file from here – this way You’ll be sure that everything will be working fine.

If, however, You’d like to create such a script from scratch, small caps included – then 1) make sure that Your text file is UTF-8 encoded and 2) use this website to copy&paste small caps version of ᴀ.ᴍ./ᴘ.ᴍ..

The dependence on the time of the day is based on the following time spans:

  • 5:00 am – 7.59 am
  • 8:00 am -6:59 pm
  • 7:00 pm – 9:59 pm
  • 10:00 pm – 11:59 pm
  • 12:00 pm – 4:59 am

There are more time spans in
case of 12-hour format, due to
determining whether am or pm text should be displayed.

The script is international, i.e.:
1. You can replace month names with Your Own (by default AutoHotkey always uses month names according to what Windows language You use).
2. In case of 12-hour version used in 24-hour format countries: You should still have them properly displayed (despite of that by default AutoHotkey supports 12-hour am/pm format, but it may not work properly when You live in 24-hour format country and use this country Windows language).

Interestingly, once You press the timestamp keyboard shortcut (both examples above use Ctrl+Shift+D), it will be inserted into Your text editor in a characteristic way, resembling live-typewriting. If You, however, would prefer to show it instantly, replace all the instances of send with sendInput.

Launch a terminal within the active window directory.

If You often use a terminal, You can launch it alongside a currently window-opened directory (the one which You have displayed in a Windows Explorer active window) – so You don’t need to use additional commands to navigate to the desired place.

;; Open terminal in current Explorer window folder
#If WinActive("ahk_class CabinetWClass") ; explorer

	WinGetTitle, ActiveTitle, A
	If InStr(ActiveTitle, "\")  ; If the full path is displayed in the title bar (Folder Options)
		Fullpath := ActiveTitle
	If InStr(ActiveTitle, ":") ; If the title displayed is something like "DriveName (C:)"
		Fullpath := SubStr(ActiveTitle, -2)
		Fullpath := SubStr(Fullpath, 1, -1)
	else    ; If the full path is NOT displayed in the title bar 
	; https://autohotkey.com/boards/viewtopic.php?p=28751#p28751
	for window in ComObjCreate("Shell.Application").Windows
		try Fullpath := window.Document.Folder.Self.Path
		SplitPath, Fullpath, title
		If (title = ActiveTitle)
	Run, mintty.exe, %Fullpath%


One note: the code above runs Cygwin – a very interesting terminal which You can use under Windows to introduce a bunch of GNU/Linux commands and apps into Your non-Linux operating system. Besides, it has some advantages over the classic Windows command prompt. If You, however, would prefer to use the Windows terminal instead of Cygwin – just replace mintty.exe with cmd.exe.

Standard text-formatting keyboard shortcuts… going Markdown 🙂 !

If You write in Markdown, You can make well-known classic text-formatting shortcuts acting Markdown way, e.g. Ctrl+B will bold the text, Ctrl+I will italicize it, and so on. A set of common shortcuts You’ll find here.

Quote anything the smart way.

We are accustomed to the basic punctuation marks such as quotes. Whether it comes to double or single quotation marks, there is one intriguing thing which You might not know about. If You open Windows Notepad, for example, and insert quotation marks – they look differently than the ones You know pretty well from books, articles on the Web, etc. The latter are a little bit curly, while the former seems to be more straight.

"straight quotes" vs “curly quotes”

Although quotation mark button on the keyboard results in the straight form (with the exceptions of some apps like Microsoft Word – which change the button’s behavior in favor of the curly quotes) – it seems that the curly one is much more popularized (let alone it looks nicer). The thing is: how to insert curly quotes, if they don’t have their own button on a keyboard?

Although there are some key sequences to bring those characters forth – they definitely are not convenient in use (think about the Alt+0147 and Alt+0148 numeric keypad sequences for the left and right double quotation marks, respectively). What about one simple keyboard shortcut instead? I mean, any shortcut of Your preference, even one single button, if You like.

The script looks like that:

saved := clipboardall
Send, ^x
SendInput, {U+201C}%clipboard%{U+201D}
clipboard := saved
saved := ""

In the example above I use Ctrl+2 (^2::) as the shortcut.

Now, if You want to wrap something with curly double quotation marks, just select the text and press the keyboard shortcut You’ve chosen for the script.

Note that it could be good to include all the rest appropriate variants: single curly quotation marks and a curly apostrophe, too. In case of single curly quotation marks the code goes as follows:

saved := clipboardall
Send, ^x
SendInput, {U+2018}%clipboard%{U+2019}
clipboard := saved
saved := ""

The last piece is a single curly apostrophe, which – surprisingly or not – is exactly the same character as the right curly single quotation mark:

“The official Unicode name for the curly type of apostrophe is ‘right single quotation mark (…) this is [also] the preferred character to use for apostrophe.

In other words, a curly apostrophe and a right single curly quotation mark are the same thing”. ( source )

So the code goes as follows:

Send, {U+2019}

Other examples.

AutoHotkey is a sky’s-the-limit kind of an app, with which You can do a great deal of things (e.g. close or open particular apps, launch files, etc.). The final frontier seems to be Your Own imagination. Here are some other code snippets for You to grab’n’go 🙂 :

Launch an app.

Run "C:\Program Files\Siber Systems\GoodSync\GoodSync.exe" /tray


The example above runs the GoodSync app (a tool to make backup of Your data). In addition, it runs it in Windows tray – which is not an AutoHotkey command, though, but a GoodSync’s supported launch parameter. I use this simple script in tandem with Watch 4 Idle, which detects that I’m back at My desk, so it runs the backup app (it also deactivates it when it detects that I’m out for a long enough time 🙂 – You can read more about this concept here).

If You’d like to launch any other app, just replace the C:\Program Files\...... directory with the one leading to the executable file of Your app of preference.

Close an app.

When You need just to close a particular window – this little script may come in handy. Remember that it only closes a window – while the app responsible for it may still be working in the background (if what You want is to make an app stop working – look at the next script). If You’d like to use this, first find out what is the window’s title (the one which You want to close by the script) – then replace YourAppWindowTitle with the title.

PostMessage, 0x112, 0xF060,,, YourAppWindowTitle ; 0x112 = WM_SYSCOMMAND, 0xF060 = SC_CLOSE


Force-close (kill) an app.

This one is useful when You need to completely shutdown an app – close both its windows and processes working in the background. If You want to use this, first You need to find out what is the name of Your app’s process. To do so, try to find it through Windows Task Manager: just press Ctrl + Shift + Esc and (on the Processes tab) try to find Your app’s item (it often has a recognizable name followed by .exe extension). As before, replace GoodSync.exe with Your app’s process name:

process, close, GoodSync.exe

How to make an AutoHotkey script work?

  1. Install AutoHotkey.
  2. Create a new text file (e.g. in Windows Notepad), copy&paste a desired code into it and save it as YourName.ahk.
  3. Whenever You want to initiate the script, simply double-click the file You’ve just created – and/or use the keyboard shortcut You’ve ascribed to it (in theory You don’t have to ascribe a keyboard shortcut, but it often comes in handy – especially when You perform some action many times a day).
  4. Whenever You want the script to be automatically launched on every Windows startup:
    1. Open the Autostart folder (under Windows 7 its location may look like this: C:\Users\YourUserName\AppData\Roaming\Microsoft\Windows\Start Menu\Programs\Startup).
    2. Hold the Alt key and drag’n’drop Your script file into the Autostart folder to create a shortcut to it there.

Ascribe Your Own sys-tray icon.

Once You run an AutoHotkey script, it will be represented among other icons on Your system tray. It’s good to know that You can change its icon to make it more intuitive – which especially comes in handy when You use many scripts. If You ascribe an individual icon to each script, it will be easy to determine which icon in fact represents which script.

To do so, simply paste the following code at the beginning of Your script, and replace C:\YourPathtoTheIcon\IconFileName.ico with a real path leading to the icon You want to use:

;- Optional = <!-- {If You want to ascribe a custom icon tray for this script.} -->
Menu, Tray, Icon , C:\YourPathtoTheIcon\IconFileName.ico

Don’t bother with Table of Contents anymore.

If You write blog posts or articles and publish them on a website, You may consider incorporating Table of Contents. It allows Your Readers to quickly orientate on the content they are about to read (this luxury may be highly appreciated). Furthermore, it provides a way of easy navigating through particular parts of Your work, thanks to which one may quickly jump to the part of their interest right off the bat. Last but not least, it nicely supports and encourages the habit of clarity within the content.

Quick survey on what’s coming:

  1. How does it work in general?
  2. How does it work under the hood?
  3. A closer look on the code.

Being a writer, however, the HTML code needed to create such a Table of Contents is not necessarily something You’d be happy to play with. You would rather prefer to stay focused on the actual work (the text), which already puts enough on Your plate.

On the other hand Table of Contents with all its advantages mentioned above seems to be tempting and, what’s more important, could make a significant difference from Your Audience perspective.

Fortunately, it doesn’t have to be an extra amount of bothering work to handle. Thanks to jQuery You can have Your cake and eat it – simultaneously 🙂 . The only thing You need is to incorporate a simple script under the hood – and You’re good to go: keep writing, and Table of Contents will take care on itself pretty well 🙂 .

Here is

how does it work in general.

The idea is simple: the only thing You need is to equip Your article with 1) Table of Contents and 2) headers to which its items refer.

Table of Contents.

A simple numbered list will do 🙂 . You can put it anywhere within Your article, although the most appropriate place seems to be somewhere on the beginning for it to be easily accessible to Your Readers, i.e. without a need to scroll down throughout the page to find it out.

One important thing is a Table of Contents’ own header, i.e. a text indicating its role (something like ordinary “Table of Contents” or “Quick summary”, etc.). Choose it wisely and then stick to it, because the whole jQuery mechanism will use this to determine is a particular numbered list a Table of Contents, or not necessarily.

Headers throughout article’s text.

All Table of Contents items should render Your article’s “flow of logic”: its main consecutive parts, which should give Your Readers an idea of what they may expect out of it (“the big picture” = what is all about, what its main parts are about).

Once You gave a point to all the main aspects of Your article in a form of a complete Table of Contents – copy each and every ToC item and paste it in the proper places throughout Your article. If You just begin to work on it, just place all the items, one under another, and make some space between then for further fulfillment. Such a “grid” will help You to stay on track while working on the article.

One important thing here is to turn those items into headers. The most appropriate (as far as publishing on the Web is concerned) is to use first-level header as Your article title – while ToC-related headers should stay right next in hierarchy, i.e. taking the form of second-level headers. Whatever You choose, take care that all the ToC-related headers should be of the same type – so if You choose them to be second-level headers, pay attention that all of those will in fact be of this type, not any other.

If You’d like to incorporate more headers than within Your Table of Contents, i.e. more specific ones, say, third-level – feel free to do so, just remember to use appropriate header type, i.e. anything other than the one meant for Table of Contents.

If You write in Markdown, You probably know how awesome and simple are those things there: ## ........ marks a second-level header, ### ..... marks a third-level header, and so on.

How does it work under the hood?

The whole mechanism is based on the HTML approach to the Table of Contents, in which You can easily create such a thing, simply using hyperlinks leading to so-called anchors. Since the trick is meant to do all of this behind-the-scene stuff for You, You don’t need to bother Yourself with the code while writing an article.

Here is how does the script work in details:

  1. Check if a numbered list within a currently displayed article is in fact a Table of Contents.
  2. If so, make each of its items a hyperlink.
  3. Put an anchor next to each ToC-related header (throughout the article).
  4. Ascribe proper consecutive numbers to all the ToC items.
  5. Ascribe proper consecutive numbers to all the ToC-related headers.

Technically-speaking, the whole mechanism wraps the first numbered list’s (the one titled in a particular way) items with hyperlinks leading to the proper anchors (which are also automatically created just next to h2 article headers).


a closer look on the code.

Let’s investigate this in a step-by-step manner, and then look at the complete final result.

First of all, ensure that You’re dealing with a genuine Table of Contents instead of any other numbered list You could use. To do so, the script checks if there is a particular phrase present within the text – the phrase You’ve chosen as the Table of Contents’ title. In My case the phrase is Quick survey on what’s coming:

if ($(".post-body:contains('Quick survey on what's coming')").length > 0) {

If a numbered list is really Your Table of Contents, let’s do the trick 🙂 . First, wrap each of its items with empty (leading nowhere – You’ll handle it soon) hyperlinks with ToC class ascribed.

$(".post-body ol:first li").wrapInner("<a href='' class='ToC'></a>")

Curiosity #1: first next to ol means that the mechanism should be applied only to the first numbered list present within an article. This way it won’t confuse it with any other numbered list which You might need to place within the same text.

Curiosity #2: wrapInner wraps everything which is placed between li tags – instead of a sole wrap, which includes those tags in wrapping, therefore lowering the semantics of the code (the only thing wrapped with a hyperlink should be the hyperlink’s text to display, not a numbered list’s item’s HTML tag).

Then put an empty anchor just before each and every second-level header within Your article (remember to carefully choose which headers should be related to Your Table of Contents). Furthermore, as in the previous case, ascribe a (h2) class to those anchors:

$(".post-body h2").before("<a name='' class='h2'></a>")

The reason we use empty hyperlinks and anchors is that in a moment we will fill all of them with proper consecutive numbers, so each Table of Contents’ item will be related to the proper in-article header. As a result, when Your Reader click a ToC item, it will lead them to the right place within the article, i.e. where the related header is placed (thanks to the anchor put just next to it).

So let’s do the counting 🙂 . First, ascribe proper consecutive numbers to Table of Contents’ items:

var cloneCount = 1;
$('a.ToC').each(function() {
$(this).attr('href', '#' + cloneCount)
cloneCount ++;

Now You can see why ToC class comes in handy 🙂 . The same is in case of h2 class present here:

var cloneCount = 1;
$('a.h2').each(function() {
$(this).attr('name', cloneCount)
cloneCount ++;

But what exactly those two code snippets above do? The first snippet takes a closer look on ToC-classed hyperlinks (i.e. those which make out Your Table of Contents) and fill their address with a # character + the proper consecutive number. So however much ToC items You have, each and every item will be leading just to an anchor named by a simple number (#1, #2, #3, and so on – those are numbered by the second code snippet). As You might know, this is a special way of hyperlinking, which You use whenever You want to lead to some place within the current document. In such a case, instead of providing a full target address (like https://www.somesite.com), a sole #1 will be sufficient. The last needed part of equation here is, however, the accordingly-named anchors placed throughout Your article, signifying its fragments to which their are referring.

Now, here You are the complete final code:

/* *Table of Contents* - start */

if ($(".post-body:contains('Quick survey on what's coming')").length > 0) {

	$(".post-body ol:first li").wrapInner("<a href='' class='ToC'></a>")

	$(".post-body h2").before("<a name='' class='h2'></a>")

	var cloneCount = 1;
	$('a.ToC').each(function() {
	$(this).attr('href', '#' + cloneCount)
	cloneCount ++;

	var cloneCount = 1;
	$('a.h2').each(function() {
	$(this).attr('name', cloneCount)
	cloneCount ++;


/* *Table of Contents* - end */

How You could benefit from file surnames?

Files and folders are essential concepts with which You’re most likely to deal using a computer. It’s obvious that they have names – whereas it’s not so obvious that they have also a kind of a last name. It’s not obvious because files’ "last names" are hidden by default – so You don’t see them, and, in fact, You couldn’t even have a clue that such a thing may exist.

Quick survey on what’s coming:

  1. Why bother?
  2. How come this to be true?
  3. How to quickly uncover Your files’ secrets?
  4. AutoHotkey approach.
  5. Alternative approach.
  6. Classic (Windows in-built) approach.

Why bother?

You could ask this question due to the fact that there is probably a reason to make file "surnames" hidden by default. One may suppose that such a reason is not to confuse an average user by additional information which seems not to be crucial. Unfortunately, the same average user may become a victim of a fraud, due to this approach. There are malicious files flying all over the Internet, being "in disguise" of completely ordinary stuff. For example, You may download a nice mp3 file from somewhere, and double-click it without knowing that it’s not a mp3 file at all – it’s just looks like that. It’s very easy for a file to look any way, while being a completely different thing in the same time.

How come this to be true?

To understand this we need to go back to files’ mysterious "surname" thing. A file "surname" is usually a three-letter string separated from the ordinary file name by a period. So if You’ve created and saved a file via Windows Notepad, You may end up with a file named, say, notes – while in fact its real and full name stands for notes.txt. The .txt part, hidden by default, tells You what kind of a file it really is (and, therefore, Your computer will know what app should be used to handle it).

The thing is it’s easy to mislead people when they don’t see this nature-revealing part. For example, one may create a virus and ascribe a well-known text file icon to it, so You will perceive it as just another ordinary text file, nothing special – while its real nature stays hidden in a form of a completely different "surname" than txt, docx or other text-related so-called extensions (which is a technical nomenclature for the "surnames" used in this article). So You may want to open this file, because why not? And boom, an unpleasant surprise comes in.

You wouldn’t be willing to open this file, however, if You could just be able to see its real nature in plain view: instead of a sole notesnotes.txt, notes.docx, etc. What You need is just to find out which are the safe and predictable file extensions You have every rights to expect to see. Once You know this, You can’t be mislead anymore, at least not so easily. Stumbling upon a file which looks like an ordinary text file as many similar ones on Your computer, You will be able to notice that it has an .exe or any other unexpected extension attached to it, and that it’s enough to abandon the idea of opening it.

How to quickly uncover Your files’ secrets?

Although You might think that a good solution should be to simply make "the surnames" visible – it’s not always so obvious. There are people who still would prefer to have a clean and readable look when it comes to file lists (especially longer ones). Fortunately there is a way to reconcile the both: a clean file lists’ look preserved – while files’ real nature available close at hand (a simple keyboard shortcut to temporarily show file extensions – pressed another time it will hide them again).

There are various ways to prepare such a trick. One is to create an AutoHotkey script (it still fascinates Me how many things You can do with this tool). Another is to create a Virtual Basic script which will do without a need to install any additional app (in case You haven’t installed AutoHotkey yet). There is also one more, let’s call it "classic", method which does not involve creating any scripts at all – it utilizes native OS (Operating System) settings, scattered over several windows. But since it requires several clicks each and every time You need to switch file extensions on or off, it may not be the best choice to go. However, in case You don’t wanna switch file extensions, but prefer to turn them on permanently – it does the best for You, because You don’t need either to install any app or create any file with some code inside.

Let’s go through each of those methods.

AutoHotkey approach.

Provided You have AutoHotkey installed, create a new text file, copy&paste the following code into it:

RegRead, HiddenFiles_Status, HKEY_CURRENT_USER, Software\Microsoft\Windows\CurrentVersion\Explorer\Advanced, HideFileExt
If HiddenFiles_Status = 1 
RegWrite, REG_DWORD, HKEY_CURRENT_USER, Software\Microsoft\Windows\CurrentVersion\Explorer\Advanced, HideFileExt, 0
RegWrite, REG_DWORD, HKEY_CURRENT_USER, Software\Microsoft\Windows\CurrentVersion\Explorer\Advanced, HideFileExt, 1
WinGetClass, eh_Class,A
If (eh_Class = "#32770" OR A_OSVersion = "WIN_VISTA")
send, {F5}
Else PostMessage, 0x111, 28931,,, A

and then save it as, say, switchFileExtensions.ahk.

Notice the ahk part included and separated from the rest of the file name with a dot: it informs Your computer that the file should be handled by AutoHotkey, instead of being treaded as ordinary text and opened with, say, Windows Notepad.

The original form of this script ascribes Win logo + Y (#y::) keyboard shortcut to switch file extensions’ visibility (You need to refresh desktop or window’s content to notice the changes). If You know how (You can learn it here), You can of course ascribe Your Own keys of preference instead of this one. Once You launch the script .ahk file, You’ll be able to use the keyboard shortcut – till You turn-off Your computer. To make it always working, open the Autostart folder (under Windows 7 its location may look like this: C:\Users\YourUserName\AppData\Roaming\Microsoft\Windows\Start Menu\Programs\Startup), hold the Alt key and drag’n’drop Your script file into the Autostart folder to create a shortcut to it there, which will launch the script automatically on every Windows startup.

Alternative approach.

If You don’t prefer AutoHotkey, You can make things a little bit easier by using an in-built Windows script engine – Virtual Basic. There is one drawback, however: it doesn’t provide You with the ability to switch file extensions via keyboard shortcut (instead of which You need to double-click the script file anytime You want to switch file extensions visibility). If You don’t mind this anyway, create a text tile, copy&paste the following code into it:

FileExt = "HKCU\Software\Microsoft\Windows\CurrentVersion\Explorer\Advanced\HideFileExt"
Set Sh = WScript.CreateObject("WScript.Shell")
St = Sh.RegRead(FileExt)
If St = 1 Then
Sh.RegWrite FileExt, 0, "REG_DWORD"
Sh.RegWrite FileExt, 1, "REG_DWORD"
End If

and save it as, say, switchFileExtensions.vbs. Now, whenever You will need to show or hide file extensions, just double-click this file (and refresh the desktop or a folder’s content to notice the changes).

Classic (Windows in-built) approach.

This method works best when all You want is to have file extensions always displayed. It will do both without any additional apps or script files.

Windows <10:

  1. Use Win logo + R, type control folders and confirm.
  2. In the new window switch to the View tab.
  3. Uncheck "Hide extensions of known file types",
  4. Confirm by Apply and OK.

Windows 10:

  1. Open File Explorer (Win key + E).
  2. Go to View tab on the ribbon menu.
  3. Check "File name extensions" under Show/hide section.