Rollback a specific commit and replace with the correct one - in git

For a specific task I should delete some files, move some others and update some more.
I committed something that was not completely correct (commit A). I needed to delete that commit and create a new one, to replace the old commit.
My options were:

1. to amend the commit (commit A) by making some corrections
(commit Y) <=================================== master
   |
   \
    -(commit X)-(commit A) <================ my-branch-name

2. to create a reverse commit and create a new correct commit (results in multiple commits)
(commit Y) <=================================== master
   |
   \
    -(commit X)-(commit A)-(reverse commit A)-(commit B) <== my-branch-name

3. to reset to the commit X, create a correct commit (commit B) on it, and then reset the HEAD of my-branch-name to that commit.
(commit Y) <=================================== master
   |
   |                     (commit A)
   \
    -(commit X)-(commit B) <================ my-branch-name

Option 1: amend previous commit

Option 1 would be as follows:
On top of the erroneous "commit A" I should provide all the corrective actions, stage them, and then amend the previous commit:
    git commit --amend

Option 2: create reverse commit

Option 2 has the below defects:
        * There were multiple deleted and moved files. It wouldn't be optimal to create a reverse commit and reapply my changes, since the commits should be squashed later.
        * The final changes should be included in a single commit, not multiple.

Option 3: reset to a specific commit

Option 3 is the most elegant and appropriate solution, especially when the changes are created by a script.

E.g. on the first run, the input of the script caused some changes and the commit A has been created. After that, new entries for the input of the script are coming. Then instead of finding which changes are not yet committed with commit A, it's better to reset to the previous commit, and execute again the script with the full new input. This will create a new complete set of changes that can be included in a single commit.
Execution of the script created changes A, B, D, F and G. All these changes are included in a new commit: "commit A". "Commit A" is the HEAD of my-branch-name.
New extra input to the script creates changes A, B, C, D, E, F and G. Imagine that this list could include thousands of entries. It's not easy to find the differences between the lists of changes and amend the "commit A".

To remove from the history my last erroneous commit (commit A), I need to reset the current branch to one commit backwards:
        git reset --hard HEAD~1

Perform the correct set of changes, and commit (commit B)
        git commit -m "comment for commit B"

To reset the current branch HEAD to the correct "commit B", that is not shown in git log, I can find the sha1 id of that particular commit executing:
        git reflog
       
And to reset the HEAD of my-branch-name to that commit I execute:
        git reset --hard <commit-B-sha1>

Connecting your codenvy development environment with a bitbucket git repository

Intro

Find below step-by-step information on how to connect your codenvy development environment with a bitbucket repository using SSH with a SSH key generated by codenvy.

1. Codenvy (generate SSH key)

Having a project open -> window -> Preferences -> SSH keystore -> Generate key -> the aplication asks for a url: give bitbucket.org
It generates a new line in the list of SSH keystore with the host label bitbucket.org (as you gave it)
Press the view button of that line, and the SSH key will be presented to you.
Copy all the content of the message box - including the initial 'ssh-rsa' string and the final 'email@address.com'.

2. Bitbucket.org (add the key to your account)

Account -> SSH keys -> Add key
On the popup window type 'bitbucket' in the label text field, and in the key field paste the generated key from codenvy.

3. Codenvy (add a remote git repository to your project)

Git -> Remotes -> Remotes -> The remote repositories message box includes the already declared remote repositories.
Press add, and in the pop-up window, give the name 'bitbucket' in the name field and type: ssh://git@altssh.bitbucket.org:443/<accountname>/<reponame>/ as described in this page: https://confluence.atlassian.com/display/BITBUCKET/Use+the+SSH+protocol+with+Bitbucket
Where accountname is your account name in bitbucket, and reponame is your repository name in bitbucket.

Intel Edison on my hands

I managed to order the new intel embeddable SD card sized computer from sparkfun.
https://www.sparkfun.com/products/13024

I hope I 'm between the first ones who got it in Greece. It cost 40 euros as a product, 18 euros for postage from US, and finally 46 euros for complete import customs.

Morse code LED - light emitting diode - with Raspberry pi

More than interested in embedded platforms and microcontrollers, I acquired my 2 Raspberry pis full of enthusiasm, waiting at the end of long priority queues.
I downloaded some linux SD card images, I played with Rasbian and XBMC.
My enthusiasm faded out as I had not enough time to tinker more.
In the first months of this year (2014) I found out that Oracle was offering a training exactly on my needs. Using my preferred programming language, Java, a Raspberry pi, and some additional electronic components, a cutting edge project will educate as about embedded computing. This is the perfect chance for me to learn some things I always wanted to.
Unfortunately, I couldn't manage to follow the training, due to other running things.
But, I enjoyed their decision in Oracle to offer the material open to the public with unlimited access. Thank you guys!

Working with the training videos, I found out:

• how a breadboard works
• what are these breakout circuits
• several configuration issues on linux
• programming I/O pins of Raspberry pi using Java ME API

The most helpful tutorial on configuring the development environment with Raspberry pi and Rasbian is found here: http://www.oracle.com/webfolder/technetwork/tutorials/obe/java/RaspberryPi_Setup/RaspberryPi_Setup.html. I found this link on the supporting material of the training course.

It's great! And it's even easier than I thought it could be.
The first hands on project was to blink a LED driven by the Raspberry pi. I found that it may be too easy, and I thought that it would be far more interesting to implement a morse code generator.
Given a message, the machine should blink the LED with Dits and Dahs, and the result would be a correctly transmitted message translated into morse code.

I found the morse code rules at: http://www.colorpilot.com/morse.html

The code for the MIDLet is as follows:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

import javax.microedition.midlet.MIDlet; /** * * @author stavros */ public class TestLed extends MIDlet { MorseDevice dev; @Override public void startApp() { String message = "SOS"; System.out.println("Starting playing message: " + message); dev = new MorseDevice(); dev.setMessage(message); dev.start(); } @Override public void destroyApp(boolean unconditional) { System.out.println("Finished playing message..."); } }

The code for the morse machine is as follows:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82

import java.util.Map; /** * * @author stavros */ public class MorseDevice extends Thread { private final static int UNITMS=200; private GPIOLed led; private String message; public void setMessage(String message) { this.message = message; } private Map<String, MorseCode[]> map = MorseCode.getMap(); @Override public void run() { led = new GPIOLed(18); for (int i=0; i<message.length(); i++) { char character = message.charAt(i); if (character == ' ') { // space has been handled } else { MorseCode[] code = map.get(String.valueOf(character)); play(code); if (i < message.length()-1) { char nextchar = message.charAt(i+1); if (nextchar == ' ') { wordpause(); } else { letterpause(); } } } } } private void play(MorseCode[] code) { for (MorseCode c: code) { this.led.on(); delay(c); this.led.off(); delay(UNITMS/20); } } private void wordpause() { delay(7*UNITMS); } private void letterpause() { delay(3*UNITMS); } private void delay(MorseCode mc) { if (MorseCode.DIT.equals(mc)) { delay(UNITMS); } else if (MorseCode.DAH.equals(mc)) { delay(3*UNITMS); } } private void delay(int milliseconds) { try { sleep(milliseconds); } catch(InterruptedException ie) { System.out.println(ie.getMessage()); } } }

The morse code encoding class is as follows:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55

import java.util.HashMap; import java.util.Map; /** * * @author stavros */ public enum MorseCode { DIT, DAH; public static Map<String,MorseCode[]> getMap() { Map<String, MorseCode[]> map = new HashMap<>(); map.put("A", new MorseCode[]{DIT, DAH}); map.put("B", new MorseCode[]{DAH, DIT, DIT, DIT}); map.put("C", new MorseCode[]{DAH, DIT, DAH, DIT}); map.put("D", new MorseCode[]{DAH, DIT, DIT}); map.put("E", new MorseCode[]{DIT}); map.put("F", new MorseCode[]{DIT, DIT, DAH, DIT}); map.put("G", new MorseCode[]{DAH, DAH, DIT}); map.put("H", new MorseCode[]{DIT, DIT, DIT, DIT}); map.put("I", new MorseCode[]{DIT, DIT}); map.put("J", new MorseCode[]{DIT, DAH, DAH, DAH}); map.put("K", new MorseCode[]{DAH, DIT, DAH}); map.put("L", new MorseCode[]{DIT, DAH, DIT, DIT}); map.put("M", new MorseCode[]{DAH, DAH}); map.put("N", new MorseCode[]{DAH, DIT}); map.put("O", new MorseCode[]{DAH, DAH, DAH}); map.put("P", new MorseCode[]{DIT, DAH, DAH, DIT}); map.put("Q", new MorseCode[]{DAH, DAH, DIT, DAH}); map.put("R", new MorseCode[]{DIT, DAH, DIT}); map.put("S", new MorseCode[]{DIT, DIT, DIT}); map.put("T", new MorseCode[]{DAH}); map.put("U", new MorseCode[]{DIT, DIT, DAH}); map.put("V", new MorseCode[]{DIT, DIT, DIT, DAH}); map.put("W", new MorseCode[]{DIT, DAH, DAH}); map.put("X", new MorseCode[]{DAH, DIT, DIT, DAH}); map.put("Y", new MorseCode[]{DAH, DIT, DAH, DAH}); map.put("Z", new MorseCode[]{DAH, DAH, DIT, DIT}); map.put("0", new MorseCode[]{DAH, DAH, DAH, DAH, DAH}); map.put("1", new MorseCode[]{DIT, DAH, DAH, DAH, DAH}); map.put("2", new MorseCode[]{DIT, DIT, DAH, DAH, DAH}); map.put("3", new MorseCode[]{DIT, DIT, DIT, DAH, DAH}); map.put("4", new MorseCode[]{DIT, DIT, DIT, DIT, DAH}); map.put("5", new MorseCode[]{DIT, DIT, DIT, DIT, DIT}); map.put("6", new MorseCode[]{DAH, DIT, DIT, DIT, DIT}); map.put("7", new MorseCode[]{DAH, DAH, DIT, DIT, DIT}); map.put("8", new MorseCode[]{DAH, DAH, DAH, DIT, DIT}); map.put("9", new MorseCode[]{DAH, DAH, DAH, DAH, DIT}); return map; } }

The code for the LED is as follows:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40

import java.io.IOException; import java.util.logging.Level; import java.util.logging.Logger; import jdk.dio.DeviceManager; import jdk.dio.gpio.GPIOPin; /** * * @author stavros */ public class GPIOLed { private GPIOPin pin; public GPIOLed(final int pin) { try { this.pin = DeviceManager.open(pin); } catch(Exception ioe) { System.out.println(ioe.getMessage()); this.pin = null; } } public void on() { try { this.pin.setValue(true); } catch (IOException ex) { System.out.println(ex.getMessage()); } } public void off() { try { this.pin.setValue(false); } catch (IOException ex) { System.out.println(ex.getMessage()); } } }

Finally, this is a picture of the breadboard connected with the raspberry and the green light:

Book review: Hadoop Real-world solutions cookbook (Packt)

Introduction

Hadoop is a cutting edge tool and everybody in the software industry wants to know about it. Initially we learn that large amounts of data coming from web 2.0 applications and social media, are rich of valuable raw data. And then, a quest for the best processing tools begins.

NoSQL movement is highly connected with the big data technologies, and their evolution appeared to be remarkable. Hundreds of new persistence solutions and frameworks have been released. Some of them offering high quality and some just being very well advertised. All of them are offering, in short, the advantages of: being easily scalable, giving great speed of random access, storing more intuitive structures that need less time for mapping programmatically.

World leading technology companies participated in promoting development of these technologies and one of the most popular algorithms developed is MapReduce, and Hadoop managed to be one of its mainstream implementations.

Ok, we learned the basics, and now we have some production applications to implement and maintain. Of course we will use different data sources, including text files, relational database servers and NoSQL clusters. And of course there is a large variety of useful tools out there, to choose from. To begin with, we need to decide which tools to learn first, which are the most appropriate for our case, and how exactly to solve possible problems.

Hadoop Real-world solutions cookbook by Jonathan R. Owens, Jon Lentz and Brian Femiano, is a book that does what it promises; it offers recipes of real world working solutions using Hadoop alone, or in well collaborating systems with supplementary open source tools. The recipes are organized in 10 chapters, and every chapter is separated into several sections. Each section has the format of a “how to” article with preparation steps, execution steps and explanation text. Code examples are extensive, and they are available for download along with sample datasets used throughout the book (after registration in Packt publications support site).

 

Chapters 1-2

We learn that there are command line tools helping to import our data files in the magical Hadoop file system (HDFS). And if we have some relational data in a relational database server, we can export and import them using an open source tool called sqoop, in collaboration with JDBC. The most advanced recipes include real-time access of HDFS files from Greenplum, as external tables, and importing data to HDFS from special data sources using Flume. Next, we learn how to compress our data in HDFS, and using different serialization techniques (Avro, Thrift and Protocol Buffers).

 

Chapters 3-4

Some great traffic statistics and analytics can be created and processed using MapReduce in Hadoop processing environment. The recipes in these 2 chapters explain how apache web server log files can be processed, mainly using Pig and Hive, in order to extract very useful information as session logging, page view calculations and geographical event data. Moreover, there are recipes that explain how log files can be mapped as external tables, and proposed recipes for using effectively other external data sources, as news archives.

 

Chapter 5

A whole chapter is dedicated to the concept of joining datasets. There are recipes giving example of replicated join, merge join and skewed join, mainly using Pig. Additionally, more advanced techniques are presented, for full outer joins, increasing performance, using Hive and Redis key-value store.

 

Chapter 6-7

In these two chapters, big data analysis is the main concern of the recipes. Initially, simple MapReduce recipes using Pig and Hive are presented, to process large amounts of data and derive complex pieces of information. Timely sorted aggregated data, distinct values of a variable from very large sets, similarity of data records and outliers discovery in a time series. For better facing this kind of problems, the author suggests graph processing technologies and machine learning algorithms, so, chapter 7 presents recipes using Apache Giraph and Mahout in collaboration with Hadoop.

 

Chapter 8

Chapter 8 is dedicated to debugging. Of course a lot of testing should be performed on every aspect of any distributed MapReduce solution. For this reason, Hadoop offers Counters mechanism that exposes the internals of every map and reduce phases of jobs, in a very practical and user friendly format. Furthermore, a unit testing framework called MRUnit is presented, with the basic features of a testing framework, but for map and reduce phases. Going one step further, the author presents a recipe for generating test data with a very powerful Pig tool called illustrate. And finally, a recipe is addressed to running MapReduce in local mode, for development reasons, enabling local debuggers from within the IDE.

 

Chapter 9

Chapter 9 is dedicated to administrative tasks. These recipes explain how distributed mode is configured in Hadoop systems, how to add or remove nodes on a cluster, how to monitor the health of the cluster, and finally some tuning tips are provided.

 

Chapter 10

In the final chapter, the author suggests Apache Accumulo for persistence layer. Inspired from Google’s BigTable, Apache Accumulo has many unique features as iterators, combiners, scan authorizations and constraints. In combination with MapReduce, example recipes present loading and reading data from Accumulo tables.

 

Conclusion

Overall, this is a recipes based cookbook, and as such, it contains task driven sections and chapters. This is not a book that may be read from the beginning to the end, but it would be better to be used as a reference. In other words, not all of these recipes are appropriate for every reader. The reader being experienced enough, can execute the recipes -that sometimes include downloading tools source code from github- and use this cookbook to select certain tools and solutions. Finally, I would like to note that the recipes are addressed to all the range of IT professionals: developers, dev ops and architects, and I think that the better way to use it is as an asset of a development team, or a guide for experienced developers planning “one man show” startups.

USB flash disk history

Back in year 2000 the best way (and the only way) to transfer large amount of data was the recordable cd-roms. The cd burner devices were very popular and fashionable and everything was burnt on a cool compact disc.
I managed to buy a yamaha cd burner and I was very happy because I could keep backups of my work. But the problem was that I couldn't pay for dial up calls or an ISDN line, and I needed a way get some documents home from the office. Burning a cd for this purpose was an overkill because:
1. only one pc, in the company, had a cd burner,
2. I wanted to trasnfer documents of 5-10 megabytes size, and 650MB of a cd was a waste of resources.

So, then, in 2002, I found the solution called usb flash disc. My first usb flash disk was a sexy designed curved device, with 32 megabytes capacity.

I was proud for my portable device, as it costed about 40 euros. Then I was able to transfer my documents with an efficient way and without the need of having access to the internet from home. With this disc I managed to maintain a collection of programming articles and resources, that I was able to read from home. I had great time with my ripped articles, and the collection was always growing.

After that great step of progress, the need of buying a new hard disk drive appeared. My old hard disk of 8.2 Gigabytes was very small for my new expectations. Then I baught a 40 GB hard disk about 118 euros cost, and it was then when I downloaded a new bios for my old pc in order to support hard disks over 32 GB.

The new hard disk seemed to be a black hole for dropped in data. Data seemed to get lost in the vast spaces of that hard disk. So, I needed a transportation unit that could give a bigger bite to the hard disk capacity. Then I baught my second usb flash disk, that I used to call it usb FLASK disc, which had a capacity of 2 GB and I don't remember its price back then in 2004 (or 2006).

At last, I could transfer videos and pictures home. I started a new collection of data, called "Cool pics" and "Cool videos" of course... And the "new" hard disk drive now seemed to be small. Then, I started to backup data in cds and purchased dvd burner for more efficient backups.

Multimedia introduction

As a child, along with computers I was trying to develop some more “artistic” talents like playing music. I always wanted to learn playing the guitar and rock till the end. Along with guitar and bass, keyboards was really exciting too, and seemed to be easier playing. My parents bought me a small keyboard and I immediately started practicing using study guides and books. Later, they got me a teacher who was coming at my home and helped me develop some basic techniques through playing well-known classic songs.
It was amazing! I could make music! I could write my own music themes, and I could perform. Soon I realized that my computer could be a performer of music too. I thought that it would be a “perfect performer” playing music exactly as it is written on the music book. It could play the music I was “translating” in GW BASIC commands. It would follow my program flow and execute my commands, whatever my program was about, even playing music through that old and odd standard internal speaker. I should admit that listening to the music from my programs seemed perfect to my ears, even through that speaker.
It was then, when I learned that the music notes represent a different frequency, and there is an international code naming system using the first seven letters of the Latin alphabet.
The below table shows the correspondence of the common name, the Latin character, the frequency and the wavelength. (Source: http://www.phy.mtu.edu/~suits/notefreqs.html)

common name	Note	Frequency (Hz)	Wavelength (cm)
do	C0	16.35	2100.
re	D0	18.35	1870.
mi	E0	20.60	1670.
fa	F0	21.83	1580.
sol	G0	24.50	1400.
la	A0	27.50	1250.
si	B0	30.87	1110.

I tried to remember (but I couldn’t) the command I was using to represent music in my programs. I just remembered that I was using the Latin characters and in some manner, using some numbers, I could declare the duration of each note. I finally googled it and I recalled the command was simply:
PLAY "edcdeee2dfedc4"
(example found at: http://en.wikipedia.org/wiki/GW-BASIC)
Later, I discovered that I could declare new sounds, out of the frequency ranges of the notes, using another command: SOUND. Following this idea, I discovered that this command was responsible for the sound of an explosion when playing the game with the gorillas, or, the sound of that primitive speech in some games, and any other sound effects. Next, I tried my first steps in the algorithmic art of music. Using loops, I created some cool sound effects similar to the simple sound effects of the games of that time.
It is a great experience to expand the possibilities of a tool. It is great to discover that there is one new distance in the tool you already use for some time now. So, I happily realized that the computer could not only output some characters on the screen, but it could also produce some audiovisual data!
It was then, when I realized that the games I was playing, have been written by programmers, not by magicians. I realized that I wanted to become one of them. Behind the graphics, the music, and the sound effects is hidden some pages of beautiful code (or ugly code :-)). Anyway, some lines of code could give some magic audiovisual moments to some people.
Later, I needed an upgrade of my computer and I bought a new 8-bit sound card, and real external speakers. I thought that my already written programs would be executed automatically now using the new equipment. And I was wrong.
Then I started to search and read my books about interacting with hardware. As I had no idea about the existence of the Internet to search for a solution, I had to find a good book. My parents let me order whatever book I needed from my already favorite bookstore, and then I first learned about the DMA (direct memory access) and IRQs (interrupt requests). When I studied some pages of code listings and found many hexadecimal numbers, I quited. I decided that first I could study some more mathematics, and some more computer hardware, and some more operating systems theory.
I was also advised to learn C programming language for better playing with the computer hardware programming. I was warned that it is a difficult programming language, but it is also the best. I knew that soon I would be studying C programming language step-by-step (Waite and Prata).

First attempts

It was back in 1991 when my first computer arrived at home. At the age of 10, I was really excited and proud for my new hard-earned 80386 microprocessor, at 8/16(turbo) MHz, with 1 MB of RAM, 40 MB hard disk drive and full-color VGA screen!

I still had not a clue about what was the potential of this great tool, but I surely knew well that I could play some fancy games.

I remember my first technical books were about MS-DOS and GW-BASIC.

I remember my first contact with the operating system shell. I managed to find out how to change directory and go straight to the games folder (cd games). The first disappointment came out when I couldn’t figure out how to change directory stepping out of the current directory. Then I always had to restart the whole computer using the reset button, so, it reloads the operating system. Then I could start over from the root directory, changing directories diving one-way deeper in the directory structure… And then restart again. The end of this series of psychological test sessions ended when I discovered “cd ..”, “cd /”, absolute and relative paths.

I remember myself trying to copy my first programming example, from my first programming book. It was a good reference guide to GW-BASIC. One of its first example code listings was an if-statement, a decision flow example, that would read a number from keyboard and then check if this number is negative or not. Finally, it would print-out jubilantly an appropriately happy message: “This number is positive/negative”. I was reading the book and I was excited by the fact that I could put some logic into a machine. Then this machine would execute my logic and it would react in some manner. I couldn’t wait to type it and put it in some serious testing… but when I started typing, this strange machine replied that this was a “Bad command or file name”. I was not sure about the “file name”, but I knew that the “commands” I was typing were absolutely identical with the commands on the book. The mystery was unveiled when I got the enlightenment of the GW-BASIC compiler and editor existence.


I remember my first computer game. It was something open source software, written in QuickBasic. It's the well known Gorilla. An old time classic. Two gorillas (two king-kongs actually) on the roofs of skyscrappers in a big city, throwing explosive bananas to each other. As a turn based, two player game we could also play against the computer. To run this game, I had to execute QuickBasic editor-compiler, load the source code file named gorilla.bas and then compile and run it from there. Sometimes I tried to read parts of code, but it was really disappointing.