Craft of Software Development, Gonghan

[gonghanwang-blog]

Summary of Craft of Software Engineering

My learning focus is to write readable codes. From this course, I have learnt the definition, the importance, the practices of code readability. Additionally, by reading good samples and refactoring my own bad code, I improved the code readability of mine a lot. I think this experience will improve my coding skills during my entire career.

Find my weakness

I reviewed my code and found it a little hard to read and understand. So I found some variable names are meanless and there are too many duplicated lines of code.

Find samples and standards to follow

My favorite language is Java and so the sample I choose is the JDK source code. Following the code convention of JDK, the javadoc can be generated automactically.

The regular class in JDK looks like:

Mentor

To discover the code readability, I need to find a skilled programmer to read my code. I found a mentor who is a google engineer, Shelton. Shelton reviewed my code and gave me many suggestions.

Comments for everything.

Remove duplicated(DRY)

Code comparibility

Don’t print unrequired results

Add source of the block of code

Add explanation of long function

Refactor

Follow the suggestions from Shelton, I refactored the code.

Details:  https://github.com/Gonghan/PublicationParser/commits/master

I found nine defects in the original code.

[gonghanwang-blog]

Feedback from my Mentor, Shelton

Shelton is a Google engineer and he agreed to review my code and gave me many precious suggesions.

Your can find the suggesions on github: 

https://github.com/Gonghan/PublicationParser/commits/master

on the day April 09.

code style

indenting style

names of functions or attributes

comments for each class

explanation for long class

sample for complex string

[gonghanwang-blog]

What's new in Java 8

Oracle released Java 8, weeks ago. So what's new in Java 8?

Java programming language

Collections

Compact Profiles

Security

JavaFX

NIO

others

This blog focus on the first part.

Lambda

[gonghanwang-blog]

Mars Rover Kata

Develop an api that moves a rover around on a grid.

You are given the initial starting point (x,y) of a rover and the direction (N,S,E,W) it is facing.

The rover receives a character array of commands.

Implement commands that move the rover forward/backward (f,b).

Implement commands that turn the rover left/right (l,r).

Implement wrapping from one edge of the grid to another. (planets are spheres after all)

Implement obstacle detection before each move to a new square. If a given sequence of commands encounters an obstacle, the rover moves up to the last possible point and reports the obstacle.

Example: The rover is on a 100x100 grid at location (0, 0) and facing NORTH. The rover is given the commands "ffrff" and should end up at (2, 2)

Tips: use multiple classes and TDD

- See more at: http://craftsmanship.sv.cmu.edu/katas/mars-rover-kata#sthash.QAaJMRd1.dpuf

My solution is here.

Action: interface, the basic action of rovers

Grid: use a 2D array to show the map. 1=obstacle

Direction: in this class, use a char to show the direction the rover is facing.

Rover: main class. implements action. Rover can process a string command and implements forward(), backward(), turnLeft() and turnRight(). 

Interesting points:

Action interface:

If needed to create a new type of rover, interface will be reused. No need to rewrite the actions in the new class again. Make the basic actions an interface, so other developers can easily understand the module and no need to read the detailed code. If a new action needs to be added to all rovers, just add one action inside the interface.

Direction:

First, set the default direction of the rover.

Next, based on the facing, override the turnLeft() and turnRight() functions.

Test:

Use junit to test the rover.

By using the notation @before, grid and rover can be instantiated each time before a test function is called.

What to improve:

1. Add a command center. The current solution is that the rover has a grid object.

2. Add an grid interface. As there might be various grids, create the grids based on the specific requirements.

3. ....

[gonghanwang-blog]

Insert a large number of records into mysql

Problem:

Given a XML with over 7 million records, store it into mysql on your local machine.

Preparation:

JDBC

Create database and tables

Parse the XML and create an object to represent the specific data structure.

Solution 1:

Parse the XML and when find a object, create a Java object and insert it into database directly.

Result: 20 insertions a second

Solution 2:

Use a list (size==500) to store the Java objects and use a batch to send all 500 insertions to db on one time.

Result: 20 insertions a second, almost same as the previous one

Solution 3:

Create super long insert statement.

insert into xxx values (a,b,c), (d,e,f),....

Result: Over 5000 insertions a second

[gonghanwang-blog]

Potter kata

Problem Description

Once upon a time there was a series of 5 books about a very English hero called Harry. (At least when this Kata was invented, there were only 5. Since then they have multiplied) Children all over the world thought he was fantastic, and, of course, so did the publisher. So in a gesture of immense generosity to mankind, (and to increase sales) they set up the following pricing model to take advantage of Harry's magical powers.

One copy of any of the five books costs 8 EUR. If, however, you buy two different books from the series, you get a 5% discount on those two books. If you buy 3 different books, you get a 10% discount. With 4 different books, you get a 20% discount. If you go the whole hog, and buy all 5, you get a huge 25% discount.

- See more at: http://craftsmanship.sv.cmu.edu/exercises/potter-kata#sthash.qLcFbFvX.dpuf

My solution:

First, I thought there might be some sets or combinations that could be done ahead. After two hours, I found there was no easy way but a brute force solution.

Then I use a recursive function and dynamic programming.

1. Create a rule map and a dp map:

ruleMap = new HashMap<>();

dp = new HashMap<>(); ruleMap.put(0, 0d); ruleMap.put(1, 1d); ruleMap.put(2, 0.95d); ruleMap.put(3, 0.90d); ruleMap.put(4, 0.80d); ruleMap.put(5, 0.75d);

2. Create an array to only contains the numbers of the distinct books. Then sort it.

int[] nums = new int[ruleMap.keySet().size()]; for (int i : list) {      nums[i]++; } Arrays.sort(nums);

3. Define a recursive function.

private double calculatePrice(int[] nums) 

If all elements in nums are zero: end

If dp has the result, return from dp.

Get all permutations from nums:( no duplicate elements in each permutation). For example, (0,0,0,1,1)=>(0,0,0,0,0),(0,0,0,0,1),(0,0,0,1,0),(0,0,0,1,1)

Traverse all permutations and find the minimum result.

Source code:

private double calculatePrice(int[] nums) {

        if (isAllZero(nums)) {

            return 0d;

        }

        String numsString = arrayToString(nums);

        if (dp.containsKey(numsString)) {

            return dp.get(numsString);

        }

          // generate all possible permutations

        ArrayList<ArrayList<Integer>> permutations = getPermutations(nums);

          double minimum = Double.MAX_VALUE;

        for (ArrayList<Integer> list : permutations) {

            if (list.isEmpty()) {

                continue;

            }

              for (int i : list) {

                nums[i]--;

            }

            int listSize = list.size();

            minimum = Math.min(

                    calculatePrice(nums) + BASE_PRICE * ruleMap.get(listSize)

                            * listSize, minimum);

            // recover

            for (int i : list) {

                nums[i]++;

            }

        }

        dp.put(numsString, minimum);

        return minimum;

    }

      private ArrayList<ArrayList<Integer>> getPermutations(int[] array) {

        ArrayList<ArrayList<Integer>> permutations = new ArrayList<ArrayList<Integer>>();

        permutations.add(new ArrayList<Integer>());

        for (int i = 0; i < array.length; i++) {

            if (array[i] > 0) {

                int psize = permutations.size();

                for (int j = 0; j < psize; j++) {

                    ArrayList<Integer> tmplist = new ArrayList<>(

                            permutations.get(j));

                    tmplist.add(i);

                    permutations.add(tmplist);

                }

            }

        }

        return permutations;

    }

      private String arrayToString(int[] array) {

        String result = "";

        for (int i : array) {

            result += i + ",";

        }

        return result;

    }

[gonghanwang-blog]

Code readability(week 1 to 2)

1. Comments      Follow Javadoc syntax 2. Consistent name schema      Package: all lowercase: com.gonghan.helloworld      Method name: mixed case letters, first letter lowercase: getName      Variable name: mixed case letters, first one lowercase:      destinationPlaceID      Constant name: ALL_UPPER_CASES 3. DRY      Use inherience to reduce redundant methods or logics.      Design patterns: factory 4. Avoid deep nesting      Use switch-case      Create new methods 5. File and folder organization     Follow maven file structure. 6. Consistent temporay names     for(int i...){        for(int j....)     }     Matrix[x][y]     Counter     tmp     list     sub..     prev, next, curr, first, second, last, low, high, mid, index, num, len?, size?,

[gonghanwang-blog]

Java 7 new features

Java 7 new features

Diamond operator

Map<String, List<Trade>> trades = new TreeMap <> ();

Switch String

switch(str){ case: "A": break; //.... }

new try

try (FileOutputStream fos = new FileOutputStream("movies.txt"); DataOutputStream dos = new DataOutputStream(fos)) { dos.writeUTF("Java 7 Block Buster"); } catch (IOException e) { // log the exception }

Numeric literals with underscores

int million = 1_000_000

new exception handling

try { methodThatThrowsThreeExceptions(); } catch (ExceptionOne|ExceptionThree e) { // log and deal with ExceptionOne or Three } catch (ExceptionTwo e) { // log and deal with ExceptionTwo }

[gonghanwang-blog]

Gilded Rose kata

You can find the kata here. And source code here.

The original code is horrible and I  can't wait to refactor it.

I use a design pattern called factory. The reason why I use this pattern is because of the similarities among the different kinds of item.

Use factory like: 

ItemFactory.createItem("name",1,1)

Next, create a concrete item to encapsulate the common rules of all items.

Here AgedItem, BackstageItem, ConjuredItem, NormalItem, SulfurasItem all extends the Concrete Item. Inside these item subclasses, only override the update_quality function and reuse the setter and getter and other functions from the superclass, ConcreteItem.

[gonghanwang-blog]

Prime Factor Kata

[gonghanwang-blog]

  public List<Integer> generate(int n){ List<Integer> primes=new ArrayList<Integer>(); if(n<=1){ return primes; } while(n>1){ for(int i=2;i<=n;i++){ if(n%i==0){ primes.add(i); n=n/i; break; } } } return primes; }

This solution uses one while and one for. The complexity of it is O(n^2).

[gonghanwang-blog]

Maiden Speech

For me software craftsmanship includes the notion of ‘code readability’ as a means to help me improve my testing skills. Often when I frequently modify my codes, my codes become very hard to read even for myself. At the end of a project, I have to spend much time to refactor the codes I wrote weeks ago because of inconsistency. From this course, I will learn how to write high-quality codes.