Posts by Chang Park

Pipe & Redirection


Difference between Pipe & Redirection

Pipe is used to pass output to another Program or Utility.

  • thing1 | thing2
    • thing1’s output s will be passed to things2 Program or Utility.

Redirect is used to pass output to either a File or Stream.

  • thing1 > thing2
    • thing1’s outputs will be placed in a file called thing2.



With Pipe, the standard output of one command is fed into the standard input of another.

$ ls | grep "java"

It will find all the file names from ls that contain “java” string.



Standard output directs its contents to the display. To redirect standard output to a file, the “>” character is used.

$ ls > file_list.txt

In this example, all the file names from ls command will be written in an file named file_list.txt. Since the output of ls was redirected to the file, no results on the display. Each time the command above is repeated, file_list.txt is overwritten (from the beginning) with the output of the command ls. If you want the new results to be appended to the file instead, use “>>“.

$ ls >> file_list.txt


Standard Input gets its contents from the keyboard, but like standard output, it can be redirected. To redirect standard input from a file instead of the keyboard, the “<” character is used.

$ sort < file_list.txt

Sort command print the contents of file_list.txt. We could redirect standard output to another file.

$ sort < file_list.txt > sorted_file_list.txt

As you can see, a command can have both its input and output redirected. The redirection operators (the “<” and “>”) must appear after the other options and arguments in the command.



  • sort: Sorts standard input then outputs the sorted result on standard output.
  • uniq: Given a sorted stream of data from standard input, it removes duplicate lines of data (i.e., it makes sure that every line is unique).
  • grep: Examines each line of data it receives from standard input and outputs every line that contains a specified pattern of characters.
  • fmt: Reads text from standard input, then outputs formatted text on standard output.
  • pr: Takes text input from standard input and splits the data into pages with page breaks, headers and footers in preparation for printing.
  • head: Outputs the first few lines of its input. Useful for getting the header of a file.
  • tail: Outputs the last few lines of its input. Useful for things like getting the most recent entries from a log file.
  • tr: Translates characters. Can be used to perform tasks such as upper/lowercase conversions or changing line termination characters from one type to another (for example, converting DOS text files into Unix style text files).
  • sed: Stream editor. Can perform more sophisticated text translations than tr.
  • awk: An entire programming language designed for constructing filters. Extremely powerful.




What is Soot

A framework for analyzing and transforming Java and Android Applications.

  • Soot can process and produce code from the following sources.
    • Java bytecode
    • Android bytecode
    • Jimple
    • Jasmin
  • This is a powerful framework that many research group use.
  • For example, Soot can transform application file(apk) to Jimple code which developers can see actual code.
  • To run Soot, you will also need the projects Jasmin and Heros.

Phantom Reference in Soot



Phantom classes are classes that are neither in the process directory nor on the Soot classpath, but that are referenced by some class / method body that Soot loads.

  • Process Directory: contains Application classes.
  • Soot Classpath: contains Library Classes.

There are several scenarios that reference classes don’t exist. A developer might leave the code to improve it later, or he got rid of some jar files that was in use but not executable. Sometimes people left such code because it will not be reachable on runtime anyway.

However there is another case that is significant. The actual reference classes can be inside of the actual device, and can be not showing until it runs. So in this case, it will be bad idea to touch or to handle this phantom classes.



  • Soot option that can handle phantom classes. (not recommended by Soot)
  • Only use this option if you know what you are doing.
  • Soot will not just abort and fail on such an unresolvable reference, but create an empty stub called a phantom class which in turn contains phanom methods to make up for the missing bits and pieces.


Garbage Collection


How Garbage Collection Really works

All objects are allocated on the heap area managed by the JVM. Every item that the developer uses is treated this way, including class objects, static variables, and even the code itself. As long as an object is being referenced, the JVM considers it alive. Once an object is no longer referenced and therefore is not reachable by the application code, the garbage collector removes it and reclaims the unused memory.


Garbage Collector root

  • Local variables in the main method
  • The main thread
  • Static variables of the main class


Mark and Sweep Algorithm

  • The algorithm traverses all object references, starting with the GC roots, and marks every object found as alive.
  • All of the heap memory that is not occupied by marked objects is reclaimed. It is simply marked as free, essentially swept free of unused objects.
  • When objects are no longer referenced directly or indirectly by a GC root, they will be removed. There are no classic memory leaks.



Java Memory Structure

types of memory area


Static memory (Method area)

  • Method information and Field information.
  • Global constants and other data generated by the compiler(e.g. info to support garbage collection) are allocated static storage.
  • Static variables are bound to memory cells before execution begins and remains bound to the same memory cell throughout execution. E.g., static variables.


  • Names local to a procedure and Parameters are allocated space on a stack. The size of stack can not be determined at compile time.


  • Data that may outlive the call to the procedure that created it is usually allocated on a heap. E.g. new to create objects that may be passed from procedure to procedure.
  • The size of heap can not be determined at compile time. Referenced only through pointers or references, e.g., dynamic objects in C++, all objects in Java
  • Garbage collection cleans up data(not using) on heap.



class Point {
   int x, y;

   void move(int x, int y) {
      this.x = x;
      this.y = y;

   int getX() {
      return x;

   int getY() {
      return y;

   void setX(int x) {
      this.x = x;

   void setY(int y) {
      this.y = y;

   void draw() {
      System.out.println("Point(" + x + ", " + y + ")");

class PointTest {
   public static void main(String args[]) {
      Point p1, p2 = null;

      p1 = new Point();
      p1.move(4, 4);
      // Point 1
      p2 = new Point();
      p2.move(2, 4);

      // Point 2

[ PointTest class loaded ]



[ JVM calls Main method ]



[ At Point 1 in Main method ]



 [ At Point 2 in Main method ]



Java features



  • Java is Easy to write and more readable and eye catching.
  • Java has a concise, cohesive set of features that makes it easy to learn and use.
  • Most of the concepts are drew from C++ this making Java learning simpler.


  • Java program cannot harm other system thus making it secure.
  • Java provides a secure means of creating Internet applications.
  • Java provides secure way to access web applications.


  • Java programs can execute in any environment for which there is a Java run-time-system.(JVM)
  • Java programs can be run on any platform (Linux, Window, Mac)
  • Java programs can be transferred over world wide web (e.g applets)


  • Java programming is pure object-oriented programming language. (while C++ is semi object oriented)
  • Like C++, java provides most of the object oriented features.


  • Java encourages error-free programming by being strictly typed and performing run-time check.


  • Java provides integrated support for multithreaded programming.


  • Java is not tied to a specific machine or operating system architecture.
  • Machine independent i.e Java is independent of hardware.


  • Java supports cross-platform code through the use of Java bytecode.
  • Bytecode can be interpreted on any platform by JVM.

High Performance

  • Bytecodes are highly optimized.
  • JVM can be executed them much faster.


  • Java was designed with the distributed environment.
  • Java can be transmit, run over internet.


  • Java programs carry with them substantial amounts of run-time type information that is used to verify and resolve access to objects at run time.


[String] concat() vs. +

Screen Shot 2016-08-07 at 4.44.23 PM

concat() and + both add up strings. It looks same, but + do one more step. As seen below, + will create string builder and append the strings inside, and then it will give the string. So, concat() is less expensive.

/*      Using + sign      */
String myStr = "str";
myStr += "end";

// Same as above
String myStr = "str";
myStr = new StringBuilder().append(myStr).append("end").toString();


/*      Using concat()     */
String myStr = "str";
myStr = myStr.concat("end");



Definition & steps

DHCP stands for Dynamic Host Configuration Protocol. When DHCP assigns an IP address, it actually leases that connection identifier to the user’s computer for a specific amount of time. The default lease is five days.


  • Because there is certain lease duration, if not using after the duration, they will automatically collect it after the lease. So, it can be used for other computer.
  • Because you don’t need to set the IP one by one, if you move to other office and connect to the that network, it will automatically assign an IP for you.

Screen Shot 2016-08-07 at 12.36.24 PM

How DHCP works

  • Discover: client computer sends a broadcast request looking for a DHCP server to answer.
  • Router directs the DISCOVER packet to the correct DHCP server.
  • The server receives the DISCOVER packet. Based on availability and usage policies set on the server, the server determines an appropriate address (if any) to give to the client.
  • Offer: The server then temporarily reserves that address for the client and sends back to the client an OFFER packet, with that address information.
  • Request: Letting the server know that it intends to use the address.
  • ACK: Confirming that the client has a been given a lease on the address for a server-specified period of time.



Error & Exception

Error & Exception

Screen Shot 2016-08-06 at 10.39.14 PM

Error is thrown by JVM in a scenario which is fatal and there is no way for the application program to recover from that error.

  • Unchecked type: Errors happen at run time. They will not be known to compiler
  • Cannot recover
  • eg. java.lang.StackOverflowError, java.lang.OutOfMemoryError

Exception is an event that disrupts the normal flow of the program. It is an object which is thrown at runtime.

  • Unchecked & Checked type: checked exceptions are known to compiler where as unchecked exceptions are not known to compiler because they occur at run time.
  • Can recover from exceptions by handling then through try-catch blocks.


Types of exceptions

  • Checked Exception: The classes that extend Throwable class except RuntimeException and Error are known as checked exceptions. Checked Exceptions are checked at compile-time.
    • e.g.IOException, SQLException etc.
  • Unchecked Exception: Unchecked exceptions are not checked at compile-time rather they are checked at runtime.
    • e.g. ArithmeticException, NullPointerException, ArrayIndexOutOfBoundsException etc.


Unchecked Exception scenarios

  • ArithmeticException: If we divide any number by zero, there occurs an ArithmeticException.
int a = 50/0;


  • NullPointerException: If we have null value in any variable, performing any operation by the variable occurs an NullPointerException.
String s = null;


  • NumberFormatException: The wrong formatting of any value, may occur NumberFormatException. Suppose I have a string variable that have characters, converting this variable into digit will occur NumberFormatException.
String s = "abc";
int i = Integer.parseInt(s);


  • ArrayIndexOutOfBoundsException: If you are inserting any value in the wrong index, it would result ArrayIndexOutOfBoundsException as shown below.

int a[] = new int[5];

a[10] = 50;


Handling checked exceptions

Due to compilation error, checked exceptions need to be handled by programmer. There are two ways to handle these exceptions.

  • Throw when declaring method
  • Try, catch, and finally inside the method


Throw when declaring method: Toss the exception handling to user when using the method.

public void connect() throws MyException{
   // try ~ catch ~ finally will not be used


Try, catch, and finally inside the method: Handling exception inside the method

public void connect(){

      // Do work here
   } catch (MyException e){
      // Catch lower Exception first
   } catch (Exception e){
      // Highest Exception at the end

      // There are three ways to see the excetption
   } finally {
      // Code on here will be always printed

  • e.printStackTrace(): Name of the Exception, Message of the Exception, Stack trace
    • On example code above:
java.lang.ArithmeticException: /by Zero
   at main()
  • e.toString(): Name of the Exception, Message of the Exception
    • On example code above:
java.lang.ArithmeticException: /by zero
  • e.getMessage(): Message of the Exception
    • On example code above:
/by zero

Creating your own Exception

Extends Exception classe: you can make the most suitable exception for your program.

public class MyException extends Exception{
   public Myexception(String msg){




Wait() vs. Sleep()

Wait and sleep method are completely different to each other

  • wait() & notify(): method for inter thread communication.
  • sleep(): introducing small pause during thread execution.

Screen Shot 2016-07-26 at 2.49.35 PM

wait() & notify()

  • wait() method puts a thread on wait
    • For example, in Producer Consumer problem, producer thread should wait if Queue is full or Consumer thread should wait if Queue is empty.
  • notify()  & notifyAll() method is used to wake up waiting thread by communicating that waiting condition is over now
    • For example, once producer thread puts an item on empty queue it can notify Consumer thread that Queue is not empty any more.
    • notify(): wakes up one thread
    • notifyAll(): wakes up all the threads (use this when you are not sure which one to use)
   Until pizza arrives, eatPiazza will in wait
   If pizzaGuy() executed, it will wake up eatPiazza()
   by using notifyAll();
class MyHouse{
   private boolean pizzaArrived = false;
   public void eatPizza(){

   public void pizzaGuy(){
         this.pizzaArrived = true;


  • sleep() hold a lock, doesn’t release any lock or monitor while sleeping.
  • When a Thread goes to Sleep it can be either wake up normally after sleep duration elapsed or it can be woken up abnormally by interrupting it.
   It will print out count string one at a time
   with a 3 seconds term
public class Example{
   public static void main(String[] args){
      String count[] = ("One","Two","Three","Four","Five");

      for(int i=0; i<count.length;i++){
         Thread.sleep(3000);             // sleep for 3 seconds
          System.out.println(count[i]);  // printout count string