Savvas Alexandrou

My Old-School Superpower: Why Emacs Skills Still Rock in the Age of AI and Modern IDEs

Sat, 27 Sep 2025 00:00:00 +0300

It’s funny how specific skills stick with you. Recently, I found myself SSH’d into a virtual server, needing to tweak some configuration files. Without thinking, my fingers danced across the keyboard, opening multiple Emacs buffers (what some might call “tabs”), copying and pasting text, and performing complex multi-edits. It was like riding a bike – a skill I honed during my university days, but one I hadn’t actively used in years, preferring the comforts of modern IDEs like VS Code or the latest JetBrains offerings. This experience got me thinking: In a world dominated by feature-rich IDEs and the incredible rise of AI-powered code generation, are these “old-school” terminal editor skills still relevant? Do I really need my Emacs superpower anymore? My conclusion? Absolutely, yes. And here’s why I believe these foundational text-editing skills are more critical than ever.

The Unavoidable Command Line: Your Server’s Best Friend

Modern development often involves working with remote servers, cloud instances, and containerized environments. Whether it’s AWS, Azure, Google Cloud, or your own local Docker setup, there will be times when a full-blown graphical IDE isn’t an option.

Here, SSH and a text editor like Emacs (or Vim, if that’s your flavor) become your primary interface. Need to quickly adjust a Nginx config, check a log file, or fix a critical bug in a script running on a production server? You won’t have to drag and drop files with your mouse. Your proficiency with terminal commands and an efficient text editor will be your most valuable asset. It’s the digital equivalent of being able to fix your own car instead of always relying on a mechanic – essential for quick diagnostics and repairs.

Beyond Basic Editing: Multi-editing as a Superpower

The ability to perform multi-edits, copy/paste efficiently across different files, and manipulate large blocks of text with precision is a core skill that transcends any specific tool. While modern IDEs have excellent multi-cursor support, the underlying principles of text manipulation (using regular expressions, macros, or strategic block selections) are what truly matter.

Whether I’m refactoring a large codebase, transforming data, or cleaning up automatically generated content, these multi-editing techniques save immense amounts of time. My Emacs background instilled a deep appreciation for this kind of efficiency, and those techniques are directly transferable to any advanced text editor.

AI is a Co-Pilot, Not an Auto-Pilot

The rise of AI tools like GitHub Co-Pilot and ChatGPT is revolutionary. They can suggest code, complete functions, and even generate entire boilerplate sections, drastically speeding up the initial coding process. But here’s the crucial point: AI is a co-pilot, not an autopilot.

AI-generated code needs review, debugging, and often significant refinement to integrate seamlessly into an existing project. It may introduce subtle bugs, security vulnerabilities, or fail to adhere to your team’s coding standards. It is where your foundational text-editing skills come back into play. You need to be able to efficiently navigate, understand, and surgically modify the AI’s output. The more adept you are at manipulating text, the more effectively you can leverage AI as a productivity enhancer rather than a crutch.

Versatility in a Diverse Tech Landscape

The tech world is incredibly diverse. You might find yourself working on a brand new JavaScript framework one day, and then maintaining an ancient Perl script on a legacy system the next. A developer who can adapt to various environments and tools is an invaluable asset. Being comfortable in a text-only terminal environment demonstrates a fundamental understanding of computing that goes beyond any specific IDE’s graphical abstractions. It means you’re not locked into a single ecosystem, giving you incredible flexibility and resilience in your career.

My Takeaway: The Hybrid Developer

Ultimately, the most effective developers in the coming decade won’t be those who exclusively use modern IDEs or solely rely on AI. They will be “hybrid developers” – those who can leverage the power of AI and sophisticated IDEs for speed and convenience, but who also possess the deep, foundational skills to work in any environment, debug complex issues, and meticulously refine code. My old-school Emacs superpower isn’t just a nostalgic trick; it’s a vital part of my toolkit that continues to pay dividends. So, if you’re starting or contemplating brushing up on those terminal editor skills, I say go for it. They’re not going anywhere, and they’ll make you a more versatile, capable, and efficient developer in the long run. What are your thoughts? Do you still use terminal editors, or have you fully transitioned to modern IDEs?

Why Low-Code is a Must-Have in Every Product Team's Toolkit

Tue, 24 Jun 2025 00:00:00 +0300

In many product teams, a quiet tug-of-war exists: developers focus on building robust systems, while product managers and stakeholders push for speed and validated outcomes. Somewhere in the middle, we often forget that impact doesn’t always come from complexity.

This article is a personal story about how a simple low-code solution shifted my thinking after a decade in software development—and why I now believe low-code should be part of every team’s toolkit, from discovery to delivery.

When a Simple Automation Made a Real Difference

In July 2015, I interned at CCMC, a multi-communal community center in Cyprus. My colleague Orestis mentioned that the WordPress blog for MYCY Radio rarely had new content. All the radio producers were posting show updates on Facebook, but none of them made it to the blog.

As a developer, I knew this was bad to SEO and long-term visibility, but I also understood why it was easier for the team on Facebook. So, I set up a basic IFTTT integration that cross-posted Facebook content to WordPress. It took me just a few minutes.

To me, it didn’t feel like much. But to Orestis, it solved a frustrating, ongoing issue—and he made sure the whole team knew.

That moment stuck with me. At the time, value came from writing code, diving into infrastructure, and solving technically complex problems. But Orestis reminded me that the people you’re helping define the value, not the tools you use.

Fast Forward: A Decade in Software Engineering

Ten years later, my hands have gotten dirty: Angular, Laravel, Symfony, Go, Kubernetes, Docker, testing frameworks, CI/CD pipelines—you name it. I’ve built things that felt complex, ambitious, and “senior.”

And yet, many of these projects—despite their technical merit—never launched or were shut down after months of work due to shifting priorities or unclear business value. Effort doesn’t always equal impact.

During this time, low-code tools like Zapier, Pipedream, and Google Application Integration were quietly evolving. I saw people around me using them—sometimes to automate small tasks and sometimes just out of curiosity. But I never seriously considered them for professional use.

When Low-Code Became Real Again

That changed recently when my girlfriend attended an online course on n8n, an open-source workflow automation tool. She came back excited, and I decided to give it a try.

In just two days, I built a functional prototype for a side project with:

Notion for dashboard
Google Sheets as the database
Tally Forms for input
An AI agent connected via Vertex AI for analyzing data

Two days. There are no servers to deploy. There is no backend to maintain. If I’d built it with traditional code, even with my experience, it would’ve taken at least a month of full-time work.

And it worked. I had something to test, to show, to learn from. It’s not just a pitch deck—a real, usable tool.

The Trade-offs Are Real—But So Is the Value

Of course, low-code tools come with limitations:

No version control
No formal testing frameworks
Harder to scale in complex team environments

But every tool has trade-offs. What low-code offers in return is speed, agility, and a lower barrier to experimentation. It’s ideal for:

Prototyping new features
Validating assumptions before committing to full sprints
Getting internal stakeholder buy-in through working demos
Testing real user behavior in production with minimal effort

Once validated, a low-code prototype can act as the living spec for developers. You can then scale it with serverless functions, microservices, or traditional systems, confident that you’re building something that people want.

Conclusion: A Shared Language for Speed and Value

To developers: low-code won’t replace your skills. It complements them. Your experience helps guide when and how to scale things the right way.

To product managers and stakeholders: you don’t always need to wait weeks for a dev sprint to test an idea. With the right tools, you can build and validate in just a few days.

To everyone involved in shipping products: low-code is no longer just a shortcut—it’s a strategy. It’s a bridge between ideas and outcomes, between what we think users want and what they do.

In a world where speed matters and uncertainty is high, the faster we can learn, the better. Low-code helps us do just that.

A simple explanation to TF-IDF algorithm

Thu, 02 Jan 2020 00:00:00 +0200

Consider yourself about being part of the following scenario.

You are a successful journalist, your new article has been already ready and you are so impatient to publish it immediately. However, you have to get through the process of summarizing your article into 4-5 keywords, in order to have a catchy description, which will make your article more visible by the different Search Engines. Why though? Is there any algorithm to help you figuring out those keywords automatically, by pressing just a button? The answer is yes and it’s called tf-idf.

More specifically, this algorithm assigns a percentage (tf-idf) to every word indicating the possibility to be used as a keyword. Another key to remember is that this algorithm takes as input a sample of articles. With this in mind, please take into consideration the fact that the purpose of this article is to explain this procedure as simple as possible, since the mathematical definition of this algorithm, can be easily found to the wikipedia article.

Let’s take as an example an article from “The Guardian” regarding New Zealand glaciers that are turning brown from Australian bushfire smoke. Possible keywords of this article could be the words team, smoke, photos, health, bushfire, glaciologist. To give an illustration, some people would prefer to use the word bushfire instead of the word team, while others would prefer the term glaciologist of the term photos. All things considered, the algorithm can calculate all those possibilities by a straightforward way. To put it another way, firstly, it calculates the frequency of each term in the article (tf), in order to figure out how many times a specific term appears in the article, by contrast to the rest of the words included in the article. For instance, to the 500 words of the article:

The words team, photos, health and glaciologist, appear only one time, so the percentage comes to 0.02
The word bushfire appears four times, so 0.08%
The word smoke appears eight times, so 0.16%

To continue with, the percentage increases or decreases accordingly to the number of the articles the term appears to (idf).

If a specific term appears in the 1/3 of all the articles included into the corpus, as a result, the percentage remains the same as previously. In other words, the tf-idf of the word health is again 0.02% for the current article.
If a term appears in less than the 1/3 of the articles of the corpus then the percentage is increasing accordingly. So, if the word glaciologist is not very commonly used in the corpus the percentage 0.02% will get increased.
If a term appears in more than the 1-3 of the articles of the corpus then the percentage is being decreased. For example, the percentage of the word smoke might be decreased to less than 0.16% if it presents a high frequency in the corpus.
If a term appears almost to every article of the corpus, then the percentage is almost 0.

Last but not least, the tf-idf algorithm is provided by elasticsearch similarity and you can learn more about it by listening to Elasticsearch podcast episode through the Software Engineering Daily podcast.

If you have any comments do not hesitate to contact me by Email 📧.

Special thanks to Christina for the proofreading 😊!

Notes regarding Code Reviews

Sun, 22 Dec 2019 00:00:00 +0200

Code Review is the most Valuable interaction between the Engineers in the Team.

Apart from the Team Events, Team Lunches that they suppose to bring the Team together, Code Reviews is an honest interaction between the Engineers.

Here are some resources:

How to play a Song on Guitar using PHP (part 3)

Sat, 18 May 2019 00:00:00 +0300

Let’s improve the previous script that we have wrote in the previous post.

At the previous script we modify our Classes to support the double equality == operator. If we want to check whether two Songs are the same, we have to remember or check or keep in the documentation whether we have impement the support of double equality operator. So what if instead of

$song == $anotherSong

we compare with the a method called isSameWith?

$song->isSameWith($anotherSong)

The code is saying what is doing
We hide the details of the implementation
We can easily change the specifications of the definition of isSameWith inside the object, without affecting other objects that is using it.

class Note
{
	/** hidden code */
	
    public function isSameWith(Note $anotherNote): bool
    {
        return $this == $anotherNote;
    }
}

class Song
{
	/** hidden code */

	public function isSameWith(Song $anotherSong): bool
	{
        return $this == $anotherSong;
    }
}

function printWhetherSongsAreEqual(Song $song, Song $anotherSong)
{
    if ($song->isSameWith($anotherSong)) {
        echo 'The two songs are the same.' . PHP_EOL;
    } else {
        echo 'The two songs are NOT the same.' . PHP_EOL;
    }
}

When we run the script we will see the following.

[savvas@localhost play_guitar_with_php]$ php play_guitar_second.php
Is $song equal with $anotherSong?
The two songs are the same.
Is $song equal with $beethovenFifthSympony?
The two songs are NOT the same.

That’s all for today.

Copy the Script 🔓 and Play with it ⛹.

Be Creative 🎨 and Send me an Email 📧.

How to play a Song on Guitar using PHP (part 2)

Wed, 01 May 2019 00:00:00 +0300

Let’s compose and play another song with our script that we have wrote in the previous post.

$anotherSong = new Song(['Sol', 'Sol', 'Sol', 'Mi', 'Fa', 'Fa', 'Fa', 'Re']);
$guitar->play($song);

It sounds the same song as the first one. We can compare them by the operator ==.

if ($song == $anotherSong) {
	echo 'The two songs are the same' . PHP_EOL;
} else {
	echo 'The two songs are not the same' . PHP_EOL;
}

When we run the script we will realize that the two Songs are the same. Now let’s compose a third Song.

$beethovenFifthSymphony = new Song(['G', 'G', 'G', 'E', 'F', 'F', 'F', 'D']);

Now we want to compare the third Song also. Since we don’t want to repeat ourselves, we can write a printWhetherSongsAreEqual function.

function printWhetherSongsAreEqual(Song $song, Song $anotherSong)
{
	if ($song == $anotherSong) {
		echo 'The two songs are the same' . PHP_EOL;
	} else {
		echo 'The two songs are not the same' . PHP_EOL;
	}
}

And then use that function.

$notes = ['Sol', 'Sol', 'Sol', 'Mi', 'Fa', 'Fa', 'Fa', 'Re'];
$song = new Song($notes);

$anotherSong = new Song(['Sol', 'Sol', 'Sol', 'Mi', 'Fa', 'Fa', 'Fa', 'Re']);
echo 'Is $song equal with $anotherSong?' . PHP_EOL;
printWhetherSongsAreEqual($song, $anotherSong);

$beethovenFifthSymphony = new Song(['G', 'G', 'G', 'E', 'F', 'F', 'F', 'D']);
echo 'Is $song equal with $beethovenFifthSympony?' . PHP_EOL;
printWhetherSongsAreEqual($song, $beethovenFifthSymphony);

When we run the script we will see the following.

[savvas@localhost play_guitar_with_php]$ php play_guitar_second.php
Is $song equal with $anotherSong?
The two songs are the same.
Is $song equal with $beethovenFifthSympony?
The two songs are NOT the same.

But it sounds the same song again. Actually is the same with different notation. The first two are with the Romance notation and the latter one with the English notation. But PHP does not know that. PHP compare oparator is comparing the array whether it has the same strings. We need to define the Notes model, and encapsulate this knowledge inside the class. Let’s start by creating a Note class.

class Note
{
	public $note;

	public function __construct(string $note)
	{
		$this->note = $note;
	}
}

Is that a good class for the Note?

What if we compare two notes var_dump(new Note('Sol') == new Note('G') by using var_dump? We will see that this comparison returns false. Obviously because PHP is comparing again strings. One possible solution is to keep in the internal object one of the two notations and on the construction of the Note, map to the internal notation. But we need two constructors, one that will construct the Note fromRomanceNotation and one that will construct a Note object fromEnglishNotation. English notation looks simpler, since it’s one character so let’s keep this one and at the Romance Notation constructor we will map the notes to the English notation.

class Note
{
    const FROM_ROMANCE_TO_ENGLISH = [
        'Do' => 'C',
        'Re' => 'D',
        'Mi' => 'E',
        'Fa' => 'F',
        'Sol' => 'G',
        'La' => 'A',
        'Si' => 'B'
    ];

    public $note;

    public function __construct(string $note)
    {
        $this->note = $note;
    }

    public static function fromRomanceNotation(string $romanceNotationNote)
    {
        return new static(self::FROM_ROMANCE_TO_ENGLISH[$romanceNotationNote]);
    }

    public static function fromEnglishNotation(string $englishNotationNote)
    {
        return new static($englishNotationNote);
    }
}

Note that we have used the static keyword. Functions that are declared as statics can be called without the need to instantiate an object first.

The class Note now has the flexibility to be constructed from both notations. But some weaknesses still in the class. We can use the Note class in a way that will cause inconsistencies.

$do = new Note('Do');
// The internal notation is the English, but we parsed to it Romance notation
$do->note = 'Re';
// We are assigning directly to the internal property the note.
$re = Note::fromRomanceNotation('D');
// We are using the English notation to create from Romance notation.
$mi = Note::fromEnglishNotation('mi');
// And the opposite.

To prevent those issues we will do the followings

Switch the visibility of the constructor to private so only the internal methods of the class will be able to use it.
Switch the visibility of the property $note to private, so it can be change only from the class.
Allow only the romance notation strings for the Romance Notation constructor and the English notation for the English Notation constructor.

class Note
{
    const ENGLISH_NOTATION_NOTES = [
        'C', 'D', 'E', 'F', 'G', 'A', 'B'
    ];

    const ROMANCE_NOTATION_NOTES = [
        'Do', 'Re', 'Mi', 'Fa', 'Sol', 'La', 'Si'
    ];

    const FROM_ROMANCE_TO_ENGLISH = [
        'Do' => 'C',
        'Re' => 'D',
        'Mi' => 'E',
        'Fa' => 'F',
        'Sol' => 'G',
        'La' => 'A',
        'Si' => 'B'
    ];

    private $note;

    private function __construct(string $note)
    {
        $this->note = $note;
    }

    public static function fromRomanceNotation(string $romanceNotationNote)
    {
        if (!in_array($romanceNotationNote, self::ROMANCE_NOTATION_NOTES)) {
            throw new \Exception('Invalid arguments for the Romance Notation constructor.');
        }
        return new static(self::FROM_ROMANCE_TO_ENGLISH[$romanceNotationNote]);
    }

    public static function fromEnglishNotation(string $englishNotationNote)
    {
        if (!in_array($englishNotationNote, self::ENGLISH_NOTATION_NOTES)) {
            throw new \Exception('Invalid arguments for the English Notation constructor.');
        }

        return new static($englishNotationNote);
    }
}

Note here that we have used constants, exceptions and the in_array function.

Now we can improve also the Song class, so we will be able to construct songs from array of both notations.

class Song
{
    private $notes = [];

    private function __construct(array $notes)
    {
		$this->notes = $notes;
    }

    public static function fromEnglishNotation(array $arrayEnglishNotationNotes)
    {
        $arrayNotes = [];
        foreach($arrayEnglishNotationNotes as $stringEnglishNotationNote) {
            $arrayNotes[] = Note::fromEnglishNotationString($stringEnglishNotationNote);
        }
        return new static($arrayNotes);
    }

    public static function fromRomanceNotation(array $arrayRomanceNotationNotes)
    {
        $arrayNotes = [];
        foreach($arrayRomanceNotationNotes as $stringRomanceNotationNote) {
            $arrayNotes[] = Note::fromRomanceNotationString($stringRomanceNotationNote);
        }
        return new static($arrayNotes);
    }
}

And then rewrite our test script.

$notes = ['Sol', 'Sol', 'Sol', 'Mi', 'Fa', 'Fa', 'Fa', 'Re'];
$song = Song::fromRomanceNotation($notes);

$anotherSong = Song::fromRomanceNotation(['Sol', 'Sol', 'Sol', 'Mi', 'Fa', 'Fa', 'Fa', 'Re']);
echo 'Is $song equal with $anotherSong?' . PHP_EOL;
printWhetherSongsAreEqual($song, $anotherSong);

$beethovenFifthSymphony = Song::fromEnglishNotation(['G', 'G', 'G', 'E', 'F', 'F', 'F', 'D']);
echo 'Is $song equal with $beethovenFifthSympony?' . PHP_EOL;
printWhetherSongsAreEqual($song, $beethovenFifthSymphony);

When we run again the script, on both cases the songs will be equal.

[savvas@localhost play_guitar_with_php]$ php play_guitar_second.php
Is $song equal with $anotherSong?
The two songs are the same.
Is $song equal with $beethovenFifthSympony?
The two songs are the same.

That’s all for today.

Copy the Script 🔓 and Play with it ⛹.

Be Creative 🎨 and Send me an Email 📧.

How to play a Song on Guitar using PHP

Sat, 30 Mar 2019 00:00:00 +0200

An introduction to Object Oriented Programming with PHP

With PHP we can play a Song using a Guitar! For example with the following script.

<?php

$guitar->play($song);

In order to do that, we need to create two new Objects,

A Guitar and
A Song

<?php

$guitar = new Guitar();
$song = new Song();
$guitar->play($song);

The PHP does not know how to create those Objects, since they are not familiar to her. In order to instantiate them, we have to define their Classes.

<?php

class Guitar
{
}

class Song
{
}

Also the Guitar needs a method called play with a Song as parameter.

<?php

class Guitar
{
  
  function play(Song $song)
  {
	/* I am not able to play the $song yet :( */
  }
}

Our Guitar is not able to play the Song yet 😞

We have to implement the method play and the song needs some notes!

Let’s construct a song first. We’ll use the solfège naming convention Do, Re, Mi, Fa, Sol, La, Si for notes. A simple melody is the Beethoven 5th Symphony, that is sounds like that:

Sol, Sol, Sol, Mi, Fa, Fa, Fa, Re

We will use the structure of Array to represent the 5th Symphony and by the instantiation of a Song we parse as parameter the Array of notes.

$notes = ['Sol', 'Sol', 'Sol', 'Mi', 'Fa', 'Fa', 'Fa', 'Re'];
$guitar = new Guitar();
$song = new Song($notes);
$guitar->play($song);

We modify the Song class in order to accept the song notes as parameter on its construction. We can do this by implementing the method __construct

<?php

class Song 
{
  public $notes = [];
  
  function __construct(array $notes)
  {
	$this->notes = $notes;
  }

}

Note that $notes is a property of the Class Song. The variable $this is refering to the object.

After we have instantiated the song we will be able to implement the play method.

<?php

class Guitar
{  

  function play(Song $song)
  {
	foreach($song->notes as $note) {
		echo '🎵' . $note . PHP_EOL;
		sleep(1);
	}
  }  

}

Here is the script.

Copy the Script 🔓 and Play with it ⛹.

Be Creative 🎨 and Send me an Email 📧.

Top 100 most common street names in Cyprus (latin characters)

Fri, 18 Jan 2019 00:00:00 +0200

Position	Road Name	Occurence
1	Grigoriou Afxentiou	220
2	Archiepiskopou Makariou C’	212
3	Kyriakou Matsi	163
4	Agiou Georgiou	161
5	Eleftherias	161
6	Georgiou Griva Digeni	157
7	Evagora Pallikaridi	154
8	Markou Drakou	138
9	Keryneias	119
10	25 Martiou	115
11	Anexartisias	115
12	Dimokratias	115
13	Michail Karaoli	114
14	Apriliou	113
15	Ammochostou	105
16	28 Oktovriou	98
17	Agias Marinas	98
18	Foti Pitta	98
19	Apostolou Andreou	97
20	Salaminos	93
21	Morfou	90
22	Makedonias	89
23	Theodorou Kolokotroni	88
24	Spyrou Kyprianou	86
25	Stylianou Lena	83
26	Afroditis	82
27	Kosti Palama	82
28	Megalou Alexandrou	82
29	Archiepiskopou Kyprianou	81
30	Pentadaktylou	81
31	Thermopylon	80
32	Athanasiou Diakou	78
33	Dimitri Liperti	78
34	Dionysiou Solomou	76
35	Agiou Nikolaou	75
36	Kritis	74
37	Riga Feraiou	73
38	Ellados	72
39	Akropoleos	70
40	Kantaras	70
41	Boumpoulinas	70
42	Charalampou Mouskou	70
43	Eirinis	67
44	Georgiou Karaiskaki	66
45	Vasili Michailidi	65
46	Omirou	63
47	Agias Paraskevis	62
48	Archangelou Michail	62
49	Ithakis	62
50	Andrea Zakou	60
51	Mesolongiou	60
52	Konstantinoupoleos	59
53	Pavlou Liasidi	58
54	Athinon	57
55	Karpasias	56
56	Lapithou	55
57	Spartis	55
58	Stadiou	55
59	Agiou Ilarionos	54
60	Konstantinou Kanari	54
61	Athinas	53
62	Georgiou Seferi	53
63	Giannou Kranidioti	53
64	Kimonos	53
65	Agiou Dimitriou	52
66	Apostolou Varnava	52
67	Karava	52
68	Thessalonikis	51
69	Agias Sofias	50
70	Apollonos	50
71	Modestou Panteli	50
72	Nikis	50
73	Andrea Dimitriou	49
74	Eleftheriou Venizelou	49
75	Ioanni Makrygianni	49
76	Marathonos	49
77	Platonos	49
78	Rodou	49
79	Misiaouli kai Kavazoglou	48
80	Michail Paridi	48
81	Petraki Giallourou	48
82	Kerkyras	46
83	Parthenonos	46
84	Grigoriou Papaflessa	45
85	Iakovou Patatsou	45
86	Odyssea Elyti	45
87	Psaron	45
88	Agias Varvaras	44
89	Nikou Kazantzaki	44
90	Savva Rotsidi	44
91	Agias Elenis	43
92	Mesaorias	43
93	Omonoias	43
94	Sokratous	43
95	Andrea Miaouli	42
96	Michail Koutsofta	42
97	Aigialousis	41
98	Aischylou	41
99	Thiseos	41
100	Poseidonos	41

Statistics have been generated with the help of ruby and the data is noble sponshorship of Cyprus Open Data Portal.

Backup config files with git

Fri, 11 Jan 2019 00:00:00 +0200

In the home directory there are a bunch of config files that decided to backup them in case of whatever happen.

There are a lot config files especiall under .config directory. For the beginning decided to backup the emacs configs .emacs and .emacs.d/ directory and the .bashrc that includes mostly aliases.

When I am sshing at a vps I will be able to just clone the emacs config repository and voila.

So here is the receipt.

Firstly initialize git repo for the emacs and copy them to different directories, because it is one directory with multiple repositories.
```
cd ~
git init
cp -rf .git .git-emacs-config
rm -rf .git
```

And then the same for the bash configs

git init
cp -rf .git .git-bash-config
rm -rf .git

Now we have to ignore everything except those files that we need. And we don’t have the luxury of .gitignore currently. So edit the .git-emacs-config/info/exclude by appending the following

*~
.*
*
!.emacs.d
!.emacs.d/*
!.emacs

And then do the same with .git-bash-config/info/exclude

.*
*
!.bash_history
!.bash_logout
!.bash_profile
!.bashrc
!.zlogin
!.zshrce

The only difference now for the git command you have to run ```bash git –git-dir .git-emacs-config add . git –git-dir .git-emacs-config commit -m ‘first commit’ git –git-dir .git-emacs-config push to-your-server ``

That’s it.

Imagine that you can switching branches with different config flavors in an existing home directory, instead of create a new unix user if you want to try different configuration environments 🎉 🎊.

Top 100 most common street names in Cyprus (greek names)

Sat, 15 Dec 2018 00:00:00 +0200

Position	Road Name	Occurence
1	Γρηγορίου Αυξεντίου	220
2	Αρχιεπισκόπου Μακαρίου Γ’	212
3	Κυριάκου Μάτση	163
4	Αγίου Γεωργίου	161
5	Ελευθερίας	161
6	Γεωργίου Γρίβα Διγενή	157
7	Ευαγόρα Παλληκαρίδη	154
8	Μάρκου Δράκου	138
9	Κερύνειας	119
10	25ης Μαρτίου	115
11	Ανεξαρτησίας	115
12	Δημοκρατίας	115
13	Μιχαήλ Καραολή	114
14	1ης Απριλίου	113
15	Αμμοχώστου	105
16	28ης Οκτωβρίου	102
17	Αγίας Μαρίνας	98
18	Φώτη Πίττα	98
19	Αποστόλου Ανδρέου	97
20	Σαλαμίνος	93
21	Μόρφου	90
22	Μακεδονίας	89
23	Θεοδώρου Κολοκοτρώνη	88
24	Σπύρου Κυπριανού	86
25	Στυλιανού Λένα	83
26	Αφροδίτης	82
27	Κωστή Παλαμά	82
28	Μεγάλου Αλεξάνδρου	82
29	Αρχιεπισκόπου Κυπριανού	81
30	Πενταδακτύλου	81
31	Θερμοπυλών	80
32	Αθανασίου Διάκου	78
33	Δημήτρη Λιπέρτη	78
34	Διονυσίου Σολωμού	76
35	Αγίου Νικολάου	75
36	Κρήτης	74
37	Ρήγα Φεραίου	73
38	Ελλάδος	72
39	Ακροπόλεως	70
40	Καντάρας	70
41	Μπουμπουλίνας	70
42	Χαράλαμπου Μούσκου	70
43	Ειρήνης	67
44	Γεωργίου Καραϊσκάκη	66
45	Βασίλη Μιχαηλίδη	65
46	Ομήρου	63
47	Αγίας Παρασκευής	62
48	Αρχαγγέλου Μιχαήλ	62
49	Ιθάκης	62
50	Ανδρέα Ζάκου	60
51	Μεσολογγίου	60
52	Κωνσταντινουπόλεως	59
53	Παύλου Λιασίδη	58
54	Αθηνών	57
55	Καρπασίας	56
56	Λαπήθου	55
57	Σπάρτης	55
58	Σταδίου	55
59	Αγίου Ιλαρίωνος	54
60	Κωνσταντίνου Κανάρη	54
61	Αθηνάς	53
62	Γεωργίου Σεφέρη	53
63	Γιάννου Κρανιδιώτη	53
64	Κίμωνος	53
65	Αγίου Δημητρίου	52
66	Αποστόλου Βαρνάβα	52
67	Καραβά	52
68	Θεσσαλονίκης	51
69	Αγίας Σοφίας	50
70	Απόλλωνος	50
71	Μοδέστου Παντελή	50
72	Νίκης	50
73	Ανδρέα Δημητρίου	49
74	Ελευθερίου Βενιζέλου	49
75	Ιωάννη Μακρυγιάννη	49
76	Μαραθώνος	49
77	Πλάτωνος	49
78	Ρόδου	49
79	Μισιαούλη και Καβάζογλου	48
80	Μιχαήλ Παρίδη	48
81	Πετράκη Γιάλλουρου	48
82	Κερκύρας	46
83	Παρθενώνος	46
84	Γρηγορίου Παπαφλέσσα	45
85	Ιακώβου Πατάτσου	45
86	Οδυσσέα Ελύτη	45
87	Ψαρών	45
88	Αγίας Βαρβάρας	44
89	Νίκου Καζαντζάκη	44
90	Σάββα Ροτσίδη	44
91	Αγίας Ελένης	43
92	Μεσαορίας	43
93	Ομονοίας	43
94	Σωκράτους	43
95	Ανδρέα Μιαούλη	42
96	Μιχαήλ Κουτσόφτα	42
97	Αιγιαλούσης	41
98	Αισχύλου	41
99	Θησέως	41
100	Ποσειδώνος	41

Statistics have been generated with the help of ruby and the data is noble sponshorship of Cyprus Open Data Portal.