Ubuntu insights, Programming in groovy, java, et als!

Tuesday, June 16, 2015

ConEmu for developer productivity

For the last one and half years, I have been a loyal user of Console 2, an alternative to command prompt on windows. Now, I have moved on to ConEmu for better productivity at workplace. It comes with many settings for customization. What I really love in ConEmu is its split screen support. At times when one is even lazy to shift between tabs/windows. In conjunction with vim, it is a breeze.

Say, you have an executable jar that also produces a log file. To hell with notepad and other UI editors - You could simply split your ConEmu screen to open up two or more console windows and spare one to skim through the output log file (using vim) simultaneously as and when you run the executable through an other.


The only caveat that I see with conEmu is that it eats up a tad bit more of memory than Console2 does (around 40 MB). But I guess I can live with that considering the fact that my laptop is powered with 16 GB of RAM. :)

Wednesday, June 03, 2015

VIM - first things first

Install theme :

https://benaiah41.wordpress.com/2012/01/17/customizing-gvim-in-windows-7/

Append the following lines in ../.vimrc (Startup Settings)

set guifont=Consolas:h11:cDEFAULT
color wombat
set guioptions-=T
set nu
let g:netrw_liststyle=3






















Monday, December 22, 2014

Command Pattern in java/groovy

Command pattern encapsulates a request. A command pattern maybe used whenever there is a Sender, Receiver who communicate via a request (let's call it command). Assume, we simulate the game of cricket via a Simulator class which sends commands  to the Batsman objects to play certain shots. Each shot is a command given by the simulator to a batsman.

interface Shot{
public void execute();
}

class CoverDrive implements Shot{

private Batsman batter;

public void execute(){
batter.playCoverDrive()
}
}

class straightDrive implements Shot{

private Batsman batter;

public void execute(){
batter.playStraightDrive();
}
}

class Batsman{

def playCoverDrive(){
println("Cover drive")
}

def playStraightDrive(){
println("Cover drive")
}
}

class BatSimulator{

Shot shot

def play(){
shot.execute()
}
}

// main - groovy script start

def sachin = new Batsman()
def command = new CoverDrive(batter : sachin)
def simulator = new BatSimulator(shot : command)
simulator.play()

Monday, December 15, 2014

Write a custom event handler in groovy/java

One may write a couple of classes and an interface to achieve event handling without having to implement the Observable/Observer interface. Assume, we have a computer that runs several processes. If it receives a shutdown command, we fire an event to let the running process handle its own clean up method to release resources and halt execution.

interface ShutdownListener{
    public void handle();
}

public class Computer{

    private def listeners = []

    def addShutdownListener(ShutdownListener l){
listeners.add(l)
    }

    def shutdown(){
for(ShutdownListener l : listeners)
l.handle()
    }

    def compute(){ // whatever  }

}

public class Process implements ShutdownListener{

    public void handle(){
// release resources of "this" Process 
// halt execution of self
println("Process ended.");
    }
}

//groovy script start 
def computer = new Computer()
def process = new Process()
computer.addShutdownListener(process)
computer.compute()
computer.shutdown()

Monday, October 20, 2014

Simple way to implement find(select) and collect block closures in java

Languages like ruby, groovy, smalltalk have language constructs for blocks and closures. Java 8 now has feature to evaluate lambda expressions. But here is one simple and straight way to implement the same:

In groovy :

[1, 2, 3, 10, 20, 30].findAll { num -> num > 5 }
=> yields a new list [10, 20, 30]

[ 1, 2, 3, 4 ].collect{ num -> num * num}
=> yields a new list [1, 4, 9, 16]

The above code for those more familiar with the smalltalk syntax will be:

#(1 2 3 10 20 30) select: [ :num | num > 5 ]
==> displays [10, 20, 30]

#( 1 2 3 4 ) collect: [:i | i * i ].
==> displays [1, 4, 9, 16]

In java, the same could be implemented with a set of abstract classes as a collection utility that mandate implementation of method which returns the boolean condition to add or transform the element under iteration :

Find.java
abstract class Find extends ArrayList{ 
    /** let the default constructor worry about iteration **/
    public Find(List list){    
        Iterator it = list.iterator();
        while(it.hasNext()){
            Object element = it.next();        
            if(all(element))           
                this.add(element);         
        }
    }
     
    /** This defines the boolean condition for find/select **/
    public abstract Boolean all(Object obj);
     
}

FindDemo.java
// find all elements in the list that are greater than 5
List list = Arrays.asList(1, 2, 3, 10, 20, 30);
selected = new Find(list) {
    public Boolean all(Object num) {               
        return (int) num > 5;
    }
};
// => yields a new list [10, 20, 30]

Collect.java
abstract class Collect extends ArrayList{  
    /** let the default constructor worry about iteration **/
    public Collect(List list){
        Iterator it = list.iterator();
        while(it.hasNext()){
            Object element = it.next();
            Object transformed = transform(element);
            this.add(transformed);
        }
    }
    /** This defines the transformation logic for collect **/
    public abstract Object transform(Object obj);
}

CollectDemo.java
// collect the squares of all elements in the list
List list = Arrays.asList(1, 2, 3, 4);
collected = new Collect(list) {    
    public Object transform(Object num) {
            return (int) num * (int) num;
    }
};
// => yields a new list [1, 4, 9, 16]

Saturday, October 11, 2014

Gauss Circle Problem

Can do better without two loops :-|


latticePoints = 0
radius = 3.2
mod = int(radius) + 1

def isInCircle(x, y):
    return x*x + y*y <= radius*radius

def calc(x, y):
    global latticePoints
    if x == 0 and y == 0:
        latticePoints = latticePoints + 1
        print((x, y))
    elif x == 0 and y != 0:
        latticePoints = latticePoints + 2
        print((x, y),(x, -y))      
    elif x != 0 and y == 0:
        latticePoints = latticePoints + 2
        print((x, y),(-x, y))      
    else :
        latticePoints = latticePoints + 4
        print((x, y), (-x, -y), (x, -y), (-x, y))          

for i in range(mod) :
    for j in range(mod) :
        if(isInCircle(i,j)):
            calc(i,j)
 
print(latticePoints)





Wednesday, November 06, 2013

Fun with Git

Baby steps : 

1) create an account on github
2) create a git repository. Note down the repo URL.

Install git from terminal : 

sudo apt-get install git

Code Upload :
cd Scripts (or any new folder)
git init (local initialization. creates a local .git folder)
mkdir YourProjectDirectory (and add all source files under it).
git add .
git commit (commits the added source files to the local repository)
git remote add origin yourRepoURL (ex: https://github.com/vamsi-emani/pythonscripts.git)
git pull origin master (to sync with remote copy)
git push origin master (commits all the local changes to remote repository)

To delete a directory: 
git rm -r local-directory-name (recursively remove all local directory files)
git commit (commits to local repo)
git push origin master (commits to remote repo)

Checkout a branch : 
git checkout -b dev_temp origin/test
(creates a local branch dev_temp from remote branch named test)

List local branches only :
git branch

List local and remote branches : 
git branch -a

List all commits on all branches that aren't pushed yet
git log --branches --not --remotes

View commits on a branch (lists out the commits with their hashes)
git log dev_temp

View what's in a specific commit 
git log commit-hash

Remove untracked files
git clean -f --dry-run (to know the damage before doing the action)
git clean -f (to actually delete the untracked files)

Remove untracked files and directories
git clean -f -d