From Passion to Profession - Notes

Temporal Collection

Mon, 25 May 2020 22:24:15 GMT

overview

A temporal collection is a simple way to implement a Temporal Property or a Temporal Object.

A temporal instance (either a Temporal Property or Temporal Object), when going through a series of amendments, the property itself or the properties the object references change over time. Each version of the temporal instance captures the state of the instance that will last for some period of time until the instance changes again with another amendment.

implementation

Temporal Collection

The basic representation and interface for a temporal collection provides get and put operations that use a date as an index:

Single Temporal Collection

The temporal collection implementation can use a Map to keep track of the changes.

A Single Temporal Collection is an implementation of Temporal Collection. A Single Temporal Collection keeps track of changes of an instance over time - over a single kind of time. That is, the updated time which is also the effective time.

[1] Temporal Collection is backed by a private HashMap. This HashMap contains the values indexed by the effective date (the date of when they become effective).
[2] milestones() returns a List of keys (effective dates) in a reverse order from the MashMap.
[3] get() works through these milestones to find the right key (effective date). This algorithm works best when you are more likely to ask for the most recent value.
[4] Sorts the specified list into reverse order. All elements in the list must implement the Comparable interface.

Bi-Temporal Collection

A Bi-Temporal Collection is also an implementation of Temporal Collection. A Bi-Temporal Collection keeps track of changes of an instance over time. Two kinds of time are involved. That is, the updated time and the effective time of the change, both times can be different.

examples / usages

Temporal Property vs. Temporal Object

If you want the underlying implementation tracks the changes of an instance at the property level but not at the object level, implement Temporal Property.

[1] addresses is a Single Temporal Property
[2] names is another Single Temporal Property

On the other hand, if the changes at the object level are to be stored in some sort of version history, implement Temporal Object.

[1] Temporal Collection is for storing version history of CustomerVersion

When a class has a few properties that has temporal behavior and you want access to those temporal values, use Temporal Property. Whereas, if most of the properties of the class are temporal, use Temporal Object.

references

Data Transfer Object Design Pattern

Tue, 19 May 2020 07:56:05 GMT

overview

Data Transfer Object (DTO) is an object used to pass data with multiple items in one shot between client and server, to avoid client from issuing multiple calls to a remote server to get each item in separate calls.

Optionally, we can make use of a DTO Assembler class as some sort of a mapper in between DomainObject and DataTransferObject to map from one side to another in either direction. That is, to create a serializable DTO object given a Domain Object, or to update a Domain Object given a DTO object.

code example

scenarios

Use DTO pattern to:

transfer data between processes/layers/objects. (e.g. between javax.persistence.Entity and org.springframework.http.ResponseEntity)
encapsulate parameters for method calls.

Inversion of Control / Dependency Injection Pattern

Fri, 20 Mar 2020 07:48:03 GMT

People who just started to learn Spring framework is often confused by the term "Inversion of Control" (IoC) which can be achieved through "Dependency Injection" (DI).

DI is a way of providing the dependencies (e.g. creating objects and its dependencies), wiring components into application. In Spring, those objects defined and instantiated by Spring containers then inject into application are called Spring Beans.

IoC is a concept, it means to create instances of dependencies first, the concept is usually achieved by using metadata-driven approach to assemble instances at runtime. IoC is the end result of DI. However, DI is not the only way to achieve IoC. For example, Workday's XpressO is a great example of metadata-driven development to achieve IoC.

Here are some more good explanations:

Inversion of Control (IoC) means to create instances of dependencies first and latter instance of a class (optionally injecting them through constructor), instead of creating an instance of the class first and then the class instance creating instances of dependencies. Thus, inversion of control inverts the flow of control of the program. Instead of the callee controlling the flow of control (while creating dependencies), the caller controls the flow of control of the program.

~https://stackoverflow.com/questions/3058/what-is-inversion-of-control

IoC is a programming technique, expressed here in terms of object-oriented programming, in which object coupling is bound at run time by an assembler object and is typically not known at compile time using static analysis.

~http://en.wikipedia.org/wiki/Inversion_of_control

IoC is a common pattern in the Java community that helps wire lightweight containers or assemble components from different projects into a cohesive application.
~http://www.martinfowler.com/articles/injection.html (reworded)

Spring helps in the creation of loosely coupled applications because of Dependency Injection.

In Spring, objects define their associations (dependencies) and do not worry about how they will get those dependencies. It is the responsibility of Spring to provide the required dependencies for creating objects.

-https://stackoverflow.com/questions/9403155/what-is-dependency-injection-and-inversion-of-control-in-spring-framework

references

Coin Change Problem

Wed, 04 Apr 2018 05:08:13 GMT

Given coins of different denominations and a total amount of money, find the number of combinations that makes up that amount. For example, given unlimited coins in 1, 2, 4 denominations, how many combinations are there to make up the amount of 12?

Thought Process

Given coins in different denominations, we'd solve this problem by breaking it into sub-problems which means given coins in less different denominations. The answer to the problem of given coins in n different denominations is based on solving the problem of given coins in (n-1) different denominations, and the answer to the problem of coins in (n-1) different denominations is based on solving the problem of coins in (n-2) different denominations.

We can use an array named combination to store the number of combinations that make up the amount. For example, the number of combinations to make up the amount of 1 is stored combination[1], and the combinations to make up the amount of 12 is stored in combination [12].

The number of combinations to make up a given amount is equal to the number of combinations before a coin denomination is added to the picture, plus the number of combinations after such a coin denomination is added to the picture for the amount of "amount - coin".

When adding the first coin to the picture, we'd calculate this array - combination. When adding the 2nd coin to the picture, the same combination[amount] is being calculated based on the following pseudocode:

This video explains using the array very well:

Code Sample

Note the trick of initializing the combination[0] to 1 to begin with. [1]

references

The Coin Change Problem

Where Binary Heap is Used

Sat, 03 Mar 2018 02:03:05 GMT

definitions

A full binary tree (sometimes referred to as a proper binary tree or plane binary tree) is a tree in which every node other than the leaves has two children. In other words, each node has either 0 child or 2 children.

A complete binary tree is a binary tree in which every level, except possibly the last, is completely filled, and all nodes are as far left as possible.

A perfect binary tree is a binary tree with all leaf nodes at the same depth. All internal nodes have degree 2.

Perfect Tree

A Binary Heap is a binary tree with following 2 properties:

A complete tree.
A Min Heap or Max Heap. In a Min Binary Heap, the key at root must be minimum among all keys present in Binary Heap. The same property must be recursively true for all nodes in Binary Tree. Max Binary Heap is similar to Min Heap.

implementation

A very efficient way to implement a max heap is by using an array. To find an object’s children within the array we can use the formula:

leftChild = 2 * nodeIndex + 1
rightChild = 2 * nodeIndex + 2

To build a Heap it takes O(n):

def build_heap(A[1...n]):
size <- n
for i from n/2 downto 1:
siftDown(i)

There are 4 major methods for implementing a max heap:

add()

When objects are first added to the heap they are initially added to the end of the heap (end of array).

remove()

Remove and return its largest object. The remove() method removes the root object (or first object in the array), immediately replaced with the last object in the heap, followed by siftDown()

siftUp()

The siftUp() method is used to move a newly inserted object from the last position in the array to its final location.

siftDown()

The siftDown() method is used to move the newly added root object (or first object in the array) to its correct position.

applications

Heap Sort: Heap Sort uses Binary Heap to sort an array in O(nLogn) time.
Priority Queue: Priority queues can be efficiently implemented using Binary Heap because it supports insert(), delete() and extractmax(), decreaseKey() operations in O(logn) time.
Dijkstra’s Shortest Path: Min Heap to store the vertices not yet included in Shortest Path Tree (the unsettled set, or the vertices for which shortest distance is not finalized yet). Min Heap is used as a priority queue to get the minimum distance vertex from set of not yet included vertices. Time complexity of operations like extract-min and decrease-key value is O(logn) for Min Heap.
Prim’s Minimum Spanning Tree
K’th Largest Element in an array (partial sorting)
Sort an almost sorted array
Merge K Sorted Arrays

comparison

Binary Heap vs. Binary Search Tree

By comparison, if a binary tree is sorted, items to the left of a particular node are smaller, items to the right are larger, then we call it Binary Search Tree. Binary Heap does not guarantees the order while Binary Search Tree does. A Balanced Binary Search Tree guarantees height of O(log n) for n items.

Binary Heap vs. Red-Black Tree

Red-Black tree is a self-balancing binary search tree done by coloring each node in the tree with either red or black and preserving a set of properties that guarantee that the deepest path in the tree is not longer than twice the shortest one, while Binary Heap is a complete tree that guarantees the tree is balanced.

references

Java 1.8 Lambda & Method Reference

Mon, 26 Feb 2018 06:19:16 GMT

One way to create thread is to pass a object that implements Runnable Interface to a Thread constructor as mentioned in Java Multithreading Approaches (Java Concurrency - Part 1):

public class MyRunnable implements Runnable{
// this method is called when a runnable thread starts
  public void run(){
printMessage();
}
}

public class ThreadDemo{
public static void main(String args[]){
  Thread t1 = new Thread(new MyRunnable);
  Thread t2 = new Thread(new MyRunnable);
Thread t3 = new Thread(new MyRunnable);
t1.start();
t2.start();
t3.start();
}

public static void printMessage(){
System.out.println("Hello");
}
}

Java 1.8 introduce Functional Interface. Any interface with a SAM (Single Abstract Method) is a functional interface, and its implementation may be written as a lambda expression. A Functional Interface can have many default methods or static methods declared, but can only have one single abstract method.

You may use Lambda Expression in place of a Functional Interface. For example, Runnable interface is a Functional Interface. Let me use the Lambda Expression instead. In this approach, I no longer need to define MyRunnable.

public class ThreadDemo{
public static void main(String args[]){
  Thread t1 = new Thread(() -> printMessage());
  Thread t2 = new Thread(() -> printMessage());
Thread t3 = new Thread(() -> printMessage());
t1.start();
t2.start();
t3.start();
}

public static void printMessage(){
System.out.println("Hello");
}
}

A method reference is the shorthand/alternative syntax for a lambda expression that executes just ONE method. Replace,

() -> printMessage();

with,

ThreadDemo::printMessage

and get:

public class ThreadDemo{
public static void main(String args[]){
  Thread t1 = new Thread(ThreadDemo::printMessage);
  Thread t2 = new Thread(ThreadDemo::printMessage);
Thread t3 = new Thread(ThreadDemo::printMessage);
t1.start();
t2.start();
t3.start();
}

public static void printMessage(){
System.out.println("Hello");
}
}

To take the Method Reference syntax one step further, as another example, you can replace Lambda Expression:

(p) -> System.out.println(p)

with,

System.out::println

as in:

public class MethodReferenceExample{
public static void main(String[] args){
List people = Arrays.asList(
new Person("Charles", "Dickens", 60),
new Person(Lewis", "Carroll", 42)
);
performConditionally(people, p -> true, System.out::println);
}

private static void performConditionally(List people, Predicate predicate, Consumer consumer)
for (Person p: people){
if (predicate.test(p)){
consumer.accept(p);
}
}
}

Technical Product Manager Skills

Thu, 28 Dec 2017 21:14:51 GMT

A product manager does many things. A product manager is like a CEO with all responsibilities except any of the authority.

Here's a list of skills that tech companies look for in product managers:

Technical Skills - Coding level knowledge. Some companies prefer software development as a prerequisite for product managers, Some don't. A good technical understanding will never hurt.

People Skills - Build communication and trust from your development team.

Research Skills

Management Skills

User-centricity

Data-driven Analytics - Use SQL, Excel, etc. to make data-driven decisions. Put product investments in the areas that will produce the best return on investment.

Strategic Thinking - Product go-to-market strategy. Game theory.

Good Design-sense - Markup/wireframe.

Experimentation Mindset - A/B testing.

References

Sales Copy Framework

Mon, 13 Mar 2017 22:42:58 GMT

Copywriting is using words to get people to give up their money in exchange for services or products. In other words, it is “salesmanship in print.” as defined by John E. Kennedy back in 1904.

The copywriting should be all about the consumers so the copywriter have to talk about them, talk about the problem, the promise, the proof, and the proposal to solve the problem. The copy must be useful and valuable. No copy is too long, too short, only too boring. Write about the preponderance of proof so the consumer have to make a decision.

Here's a six-part framework (PASTOR) for writing better sales copy that Ray Edwards mentioned:

P = person, problem, pain.
A = amplify the consequence of not solving the problem.
S = story, solution , system.
T = transformation, testimony
O = offer
R = response

Position Yourself for Products in Competitions

Tue, 08 Nov 2016 19:25:15 GMT

You want to stand out when the competition is already there when entering a market. Think about three things:

Form your own personality for your identity: Clone a service offer by a guru won't make you a guru. You want to have the content come out your personality, yourself. Clients respond to what you like. It's too risky to be a me-too.
Find out from the customers to identify the REAL problems.
Create a single superpower to tackle one of most identified problem.

Once the company is positioned, then, move on to design irresistible products.

references

How To Stand Out When The Competition Is Already Outstanding

Flyweight Design Pattern Principle

Wed, 15 Jun 2016 23:44:16 GMT

Flyweight pattern is a structural pattern in GoF as it supports large numbers of fine-grained objects efficiently. Since each fine-grained object (e.g. a character in an editor application) may incur overhead that adds up. This pattern shares objects in a pool (Flyweight Factory) to minimize memory use.

source: GoF

overview

Flyweight: A flyweight is a shared independent object with its own intrinsic state (e.g. character code) that is stateless or immutable. If the intrinsic state is not going to be modified, then the object can be shared. Flyweight objects are shared among different contexts that hold extrinsic states (e.g. coordinate position in the document and its typographic style). These extrinsic state (out side of object) of the context will be passed by client object to the flyweight to operate. A flyweight makes as much of its state information extrinsic as possible and that is where the memory saving comes from.

FlyweightFactory: Once you have flyweight, then you can have a FlyweightFactory as a Flyweight Pool which is a collection of Flyweights that are cached to be shared. FlyweightFactory is usually a Singleton to keep track of whether a particular flyweight has been generated and returns either a new instance or reference to one that it has already generated.

Real world Flyweight use cases:

Apply Flylweight to cells on a big board. For example, each cell on a 1000 by 1000 game of life game board can be a flyweight object to reduce memory footprint for each cell since extrinsic state are kelp outside of the Flyweight object.
The Java language specification requires that integers between -128 and 127 be 'cached' is actually a form of flyweight to conserve system resource.

flyweight code example

source: Java™ Design Patterns: A Tutorial

when to use

Need use large numbers of objects when a simple repeated shared representation would save a large amount of memory.
Not often used at the application level in Java, more of a system resource management technique that is used at a lower level than Java.

comparison

Flyweight vs. Composite

Flyweight tends to go with composite that contains Flyweight objects.

Flyweight vs. Strategy

Flyweights are small strategy classes handled by the flyweight factory.
Both Strategy and Flyweight externalize extrinsic state.

references

The Game of Life

From Passion to Profession - Notes

Temporal Collection

overview

implementation

examples / usages

references

Data Transfer Object Design Pattern

overview

code example

scenarios

Inversion of Control / Dependency Injection Pattern

​references

Coin Change Problem

Thought Process

Code Sample

references

Where Binary Heap is Used

definitions

implementation

applications

comparison

references

Java 1.8 Lambda & Method Reference

Technical Product Manager Skills

References

Sales Copy Framework

Position Yourself for Products in Competitions

references

Flyweight Design Pattern Principle

overview

flyweight code example

when to use

comparison

references

references