ArrayList: a resizable array.

• maintain an array with potential unused cells.
• will expand the array if there is no unused cells available, by replacing the maintained array with a new larger array (1.5 times larger by default).

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

class ArrayList<E> {
	private E[] array; // the maintained array, the current maximum capacity is array.length;
	private int size; // the number of actually used cells in the maintained array
	// no direct access to these internal implementation details.
}

// get(int index): array[index]
// set(int index, E e): array[index] = e
// size(): size, when call add(), remove(), size is modified as well.
// .add()
// .remove
List<Integer> list = new ArrayList<Integer>(); // <>
list.add(1); // list.add(Integer.valueOf(1));
list.size();
list.add(0, 2);
list.get(1);
list.remove(1);
list.set(0, 4);

for (int i = 10; i <= 20; i++) {
  list.add(i);
}

for (int i = 0; i < 5; i++) {
  list.remove(list.size() - 1);
}

LinkedList: 1 by 1，并且中间空了以后需要挪动。

ArrayList: 中间空了以后需要挪动

When ArrayList, When LinkedList?

1. a lot of random access: ArrayList
2. always add/remove at the end: ArrayList. (when time complexity is similar for using ArrayList and LinkedList, use ArrayList. ArrayList uses memory more efficiently. For each element, LinkedList needs to create different ListNode in memory, extra cost of storing the “next”, “prev” reference (overhead), and the allocation is not contiguous.)
3. Stack and Vector class not recommended. Vector => use ArrayList. Stack => use Deque (LinkedList, ArrayDeque).

Logical Operator Short Circuit

• Bitwise AND (&)

  The AND operator compares each binary digit of two integers and gives back 1 if both are 1, otherwise it returns 0.

  This is similar to the && operator with boolean values. When the values of two booleans are true the result of a && operation is true.

  Let’s use the same example as above, except now using the & operator instead of the | operator:

  1 2 3 4 5 6 7

  @Test public void givenTwoIntegers_whenAndOperator_thenNewDecimalNumber() { int value1 = 6; int value2 = 5; int result = value1 & value2; assertEquals(4, result); }

  Let’s also see the binary representation of this operation:

  1 2 3 4

  0110 0101 ----- 0100

  0100 is 4 in decimal, therefore, the result is:

  1	result : 4

• && is logical AND operator comparing boolean values of operands only.

Linked List

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

class ListNode {

	public int value;

	public ListNode next;

	// public ListNode prev;

	public ListNode (int value) {

		this.value = value;

		this.next = null;

	}

}

ListNode head = new ListNode(3);

head.next = new ListNode(4);

Array vs. Linked List:

1. Memory Layout

   Array: consecutive allocated memory space, no overhead;

   Linked List: non-consecutive, overhead of multiple objects with the “next” reference

2. (Random access time)

   Array: O(1)

   Linked List: O(n)

3. Search time non-sorted

   Array: O(n)

   Linked List: O(n)

4. Search time sorted

   Array: O(logn)

   Linked List: O(n)

Linked List Operations:

length():

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

int length (ListNode head) {

	int length = 0;

	while (head != null) {

		length++;	

		head = head.next; //.next as index in array to move to different elements

	}

	return length;

}

get(index):

1
2
3
4
5
6
7
8
9
10
11
12
13

ListNode get(ListNode head, int index) {

	while (index > 0 && head != null) {

		head = head.next;

		index--;

	}

	return head;

}

appendHead()

1
2
3
4
5
6
7
8
9

ListNode appendHead(ListNode head, int value) {

	ListNode newHead = new ListNode(value);

	newHead.next = head;

	return newHead;

}

appendTail()

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

ListNode appendTail (ListNode head, int value) {

	// 1. head == null

	if (head == null) {

		return new ListNode (value);

	}

	// 2. head != null, find the last node in the list.

	ListNode prev = head;

	while (prev.next != null) {

		prev = prev.next;

	}

	// exit the while loop when prev.next == null

	prev.next = new ListNode (value);

	return head;

}

// usually need to consider head == null   head.next == null

remove()

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

ListNode remove(ListNode Head, int value) {

	// 1. head == null

	if (head == null) {

		return null;

	} else if (head.value == value) { // 2. remove head

		return head.next;

	}

	// 3.

	ListNode cur = head;

	while (cur.next != null && cur.next.value != value) {

		cur = cur.next;

	}

	// out of the while loop, cur.next == null || cur.next.value == value

	if (cur.next != null){

		cur.next = cur.next.next; // remove done

	}

	return head;

}

LinkedList In Java

backend by a doubly linked list, wrap the size, head and tail information.

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

class ListNode<E> {
  E e;
  private ListNode<E> prev;
  private ListNode<E> next;
}

class LinkedList<E> {
  private ListNode<E> head;
  private ListNode<E> tail;
  private int size;
  
  public E get(int index) {
    //traverse from the head/tail and find the node at index.
  }
  // set(int index, E e)
  // add(int index, E e), add(E, e)
  // remove(int index) // at head: update the head to head.next; at tail: update the tail to tail.prev
  // size() - O(1) - eager computation.
  // isEmpty()
  
  List<Integer> list = new LinkedList<Integer>();
  
  // Below: both work
  // 1. Preserve the general semantic of a List: can only use methods in a List interface 例如 list.poll(); // wrong; Not to make any assumptions on implementation; Make sure interchangeable in future. List as interface.
  //在方法参数中尽量用List，这样在以后调用该方法时，ArrayList 也可以调用，LinkedList也可以调用。假如之前你写的一个List变量是new ArrayList，后来你改成new LinkedList，不需要改被调用方法的参数类型
  // List as interface
  List<Student> l = new LinkedList<>(); 
  // Good practice: Declare into a general type, initialize into a concrete type (Interfaces are also types.)
  // LinkedList, ArrayList as implementation class.
  // 2. Provide concrete implementation by using LinkedList: choose the best implementation for the current use case. LinkedList as class
  LinkedList<Student> l = new LinkedList<>();
  
  // E Cannot be a primitive type: (int: Integer, char: Character, boolean: Boolean, wrapper class)
  
}

//Lists can contain duplicate elements.

List Interface In Java

• Interface extends interface
• Class extends class
• Class implements interface

Semantics (interface or abstract class) vs. implementations (implementation class):

Separate semantic and implementation: language specs define semantics 结果, language impelemntations (such as JVM) defines the actual behavior of a program 动作.

Abstrct Class VS Interfaces

An interface in the Java programming language is an abstract type that is used to specify a behavior that classes must implement. They are similar to protocols. Interfaces are declared using the interface keyword, and may only contain method signature and constant declarations.

An abstract class is a class that is declared abstract —it may or may not include abstract methods. Abstract classes cannot be instantiated, but they can be subclassed. Abstract class: is a restricted class that cannot be used to create objects (to access it, it must be inherited from another class). An abstract class allows you to create functionality that subclasses can implement or override. An interface only allows you to define functionality, not implement it. And whereas a class can extend only one abstract class, it can take advantage of multiple interfaces.

• Both can have methods declared without implementation (abstract methods).

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

interfact 猫 {

	public void 抓老鼠()

}

public class 黑猫 implements 猫 {
	public void 抓老鼠() {
			//黑猫抓老鼠的姿势
	}
}

public class 白猫 implements 猫 {
  public void 抓老鼠() {
    	//白猫抓老鼠的姿势
  }
}

• Abstract class/Interface: you cannot instantiate an object by abstract class or interface.

  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

  interface Dicitonary { public Integer get(int index); } Dictionary myDict = new Dictionary(); // Wrong! class DictionaryImpl implements Dictionary { @Override public Integer get(int index) { return null; } } // interface => class => then, could new. DictionaryImpl myDict = new DictionaryImpl(); // Right! public int search(Dictionary dict, int target) { // interface as input parameter return dict.get(target); // return based on interface } interface A { public void print(); } class B implements A { @Override public void print() { Syustem.out.println("B"); } }

Abstract Class VS Interface

1) Abstract class can have final, non-final, static and non-static variables.

​ Interface has only static and final variables.

2) Abstract class can have static methods, main method, and constructor.

​ Interface can’t have static methods, main method, or constructor.

3) Abstrac class can have static methods, main method, and constructor.

​ Interface can’t have static methods, main method, or constructor.

4) Abstract class can have abstract and non-abstract class.

​ Interface can have only abstract methods.

5) Abstract class doesn’t support multiple inheritance.

​ Interface supports multiple inheritance.

6) The abstract keyword is used to declare abstract class.

​ The interface keywork is used to declare interface.

• 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

  // Abstract class abstract class Animal { // Abstract method (does not have a body) public abstract void animalSound(); // Regular method public void sleep() { System.out.println("Zzz"); } } //Animal myObj = new Animal(); // will generate an error // Subclass (inherit from Animal) class Pig extends Animal { public void animalSound() { // The body of animalSound() is provided here System.out.println("The pig says: wee wee"); } } class Main { public static void main(String[] args) { Pig myPig = new Pig(); // Create a Pig object myPig.animalSound(); myPig.sleep(); } }

• Use LinkedList/ArrayDeque (better)/ Array List to implement: stack(LIFO), queue (FIFO, Java Interface), deque (dequeue, enqueue, Java Interface).

SOLID principles are object-oriented design concepts relevant to software development. SOLID is an acronym for five other class-design principles: Single Responsibility Principle, Open-Closed Principle, Liskov Substitution Principle, Interface Segregation Principle, and Dependency Inversion Principle.

SOLID is a structured design approach that ensures your software is modular and easy to maintain, understand, debug, and refactor. Following SOLID also helps save time and effort in both development and maintenance. SOLID prevents your code from becoming rigid and fragile, which helps you build long-lasting software.

https://google.github.io/styleguide/javaguide.html

https://www.oracle.com/java/technologies/javase/codeconventions-contents.html

Clean, elegant, and consistent, follow professional convention.

1. Indentation

2. Spaces on both sides of binary or ternary operators, but not dot (.).

3. class names: upperCamelCase;

   const variable: all upper cases

   otherwise: lowerCamelCase.

HW3

※ Question 2: not in 因为all only!!!

SELECT DISTINCT F.origin_city AS city

FROM FLIGHTS AS F

WHERE F.actual_time < 180 AND F.canceled = 0

ORDER BY F.origin_city ASC;

※ 1 group by

※ null先处理isnull(X,0)再做运算

※ count(*) based on outside query:

count(*) would be all count even though it’s group by.

※ EG:

SELECT DISTINCT F.dest_city AS city

FROM FLIGHTS AS F

WHERE F.dest_city NOT IN (SELECT DISTINCT F2.dest_city

FROM FLIGHTS AS F1, Flights AS F2

WHERE F1.dest_city = F2.origin_city AND F1.origin_city = ‘Seattle WA’) AND

F.dest_city NOT IN (SELECT DISTINCT F3.dest_city

FROM FLIGHTS AS F3

WHERE F3.origin_city = ‘Seattle WA’ AND F3.dest_city != ‘Seattle WA’)

ORDER BY city ASC;

– NOT IN, outer: need distinct.

※ EG:

1
2
3
4
5
6
7
8
9

SELECT DISTINCT F.dest_city AS city
FROM FLIGHTS AS F
WHERE F.dest_city NOT IN (SELECT DISTINCT F2.dest_city
  FROM FLIGHTS AS F1, Flights AS F2
  WHERE F1.dest_city = F2.origin_city AND F1.origin_city = 'Seattle WA') AND
  F.dest_city NOT IN (SELECT DISTINCT F3.dest_city
  FROM FLIGHTS AS F3
  WHERE F3.origin_city = 'Seattle WA' AND F3.dest_city != 'Seattle WA')
ORDER BY city ASC;

First subquerry + second subquery, no runtime issue, coz first will rule out more querries. just switch the sequence to try.

※ Subquery distinct:

Case 1: outside main query: distinct, when inside subqueries NOT IN distinct.

Case 2: outside no need to distinct, as mainquery and subquery are connected through id.

1
2
3
4
5
6
7
8
9
10
11
12

WITH
  FlightCarrier
  AS
  (SELECT DISTINCT F.carrier_id
   FROM FLIGHTS AS F
   WHERE F.origin_city = 'Seattle WA'
   AND F.dest_city = 'San Francisco CA'
  )
SELECT C.name AS carrier
FROM CARRIERS AS C, FlightCarrier AS FCarrier
WHERE C.cid = FCarrier.carrier_id
ORDER BY C.name ASC;

Case 3: group by in this case => distinct, main query no need distinct too. Due to MIN(P1.time), but it’s better to have Distinct in subquerry. group by ID is not necessary 1id/line.

1
2
3
4
5
6
7
8
9
10
11
12

WITH
 ShortestCompletion
 AS
 (
  SELECT DISTINCT M1.id AS id, MIN(P1.time) AS time
  FROM Meet AS M1, Event AS E1, Performance AS P1
  WHERE M1.id = E1.mid AND P1.eid = E1.id AND P1.won = 1
  GROUP BY M1.id
 )
SELECT M.name, M.year, E.name, P.time
FROM Meet AS M, Event AS E, Performance AS P, ShortestCompletion AS SC
WHERE M.id = E.mid AND P.eid = E.id AND SC.id = M.id AND P.time = SC.time;

※ Subqueries in WHERE (NOT) IN: uncorrelated, no id = id.

Walkaway is an adult science fiction novel by Cory Doctorow, published by Head of Zeus and Tor Books in April 2017.

Set in our near-future, it is a story of walking away from “non-work“, and surveillance and control by a brutal, immensely rich oligarchical elite; love and romance; a post-scarcity gift economy; revolution and eventual war; and a means of finally ending death.

In a world of non-work, ruined by human-created climate change and pollution, and where people are under surveillance and ruled over by a mega-rich elite, Hubert, Etc, his friend Seth, and Natalie, decide that they have nothing to lose by turning their backs and walking away from the everyday world or “default reality”.

With the advent of 3D printing – and especially the ability to use these to fabricate even better fabricators – and with machines that can search for and reprocess waste or discarded materials, they no longer have need of Default for the basic essentials of life, such as food, clothing and shelter.

As more and more people choose to “walkaway”, the ruling elite do not take these social changes sitting down. They use the military, police and mercenaries to attack and disrupt the walkaways’ new settlements.

One thing that the elite are especially interested in is scientific research that the walkaways are carrying out which could finally put an end to death – and all this leads to revolution and eventual war.

In ‘Walkaway,’ A Blueprint For A New, Weird (But Better) World

Here’s the thing I love about Cory Doctorow: No one is weirder than he is.

And I don’t mean run-of-the-mill weird. I don’t mean personally weird (though he might be, I don’t know him), but as a writer? Super-weird in the best possible way. And he’s deep-weird, not gimmicky-weird. Weird in the sense that he has done the math, calculated the forking paths, and is presenting to you a world which isn’t just amusing and borderline plausible, but a dispatch from next Tuesday.

2019 Letter to Shareholders

To our shareowners:

One thing we’ve learned from the COVID-19 crisis is how important Amazon has become to our customers. We want you to know we take this responsibility seriously, and we’re proud of the work our teams are doing to help customers through this difficult time.

Amazonians are working around the clock to get necessary supplies delivered directly to the doorsteps of people who need them. The demand we are seeing for essential products has been and remains high. But unlike a predictable holiday surge, this spike occurred with little warning, creating major challenges for our suppliers and delivery network. We quickly prioritized the stocking and delivery of essential household staples, medical supplies, and other critical products.

Our Whole Foods Market stores have remained open, providing fresh food and other vital goods for customers. We are taking steps to help those most vulnerable to the virus, setting aside the first hour of shopping at Whole Foods each day for seniors. We have temporarily closed Amazon Books, Amazon 4-star, and Amazon Pop Up stores because they don’t sell essential products, and we offered associates from those closed stores the opportunity to continue working in other parts of Amazon.

Crucially, while providing these essential services, we are focused on the safety of our employees and contractors around the world—we are deeply grateful for their heroic work and are committed to their health and well-being. Consulting closely with medical experts and health authorities, we’ve made over 150 significant process changes in our operations network and Whole Foods Market stores to help teams stay healthy, and we conduct daily audits of the measures we’ve put into place. We’ve distributed face masks and implemented temperature checks at sites around the world to help protect employees and support staff. We regularly sanitize door handles, stairway handrails, lockers, elevator buttons, and touch screens, and disinfectant wipes and hand sanitizer are standard across our network.

We’ve also introduced extensive social distancing measures to help protect our associates. We have eliminated stand-up meetings during shifts, moved information sharing to bulletin boards, staggered break times, and spread out chairs in breakrooms. While training new hires is challenging with new distancing requirements, we continue to ensure that every new employee gets six hours of safety training. We’ve shifted training protocols so we don’t have employees gathering in one spot, and we’ve adjusted our hiring processes to allow for social distancing.

A next step in protecting our employees might be regular testing of all Amazonians, including those showing no symptoms. Regular testing on a global scale, across all industries, would both help keep people safe and help get the economy back up and running. For this to work, we as a society would need vastly more testing capacity than is currently available. If every person could be tested regularly, it would make a huge difference in how we fight this virus. Those who test positive could be quarantined and cared for, and everyone who tests negative could re-enter the economy with confidence.

We’ve begun the work of building incremental testing capacity. A team of Amazonians—from research scientists and program managers to procurement specialists and software engineers—moved from their normal day jobs onto a dedicated team to work on this initiative. We have begun assembling the equipment we need to build our first lab and hope to start testing small numbers of our frontline employees soon. We are not sure how far we will get in the relevant timeframe, but we think it’s worth trying, and we stand ready to share anything we learn.

While we explore longer-term solutions, we are also committed to helping support employees now. We increased our minimum wage through the end of April by $2 per hour in the U.S., $2 per hour in Canada, £2 per hour in the UK, and €2 per hour in many European countries. And we are paying associates double our regular rate for any overtime worked—a minimum of $34 an hour—an increase from time and a half. These wage increases will cost more than $500 million, just through the end of April, and likely more than that over time. While we recognize this is expensive, we believe it’s the right thing to do under the circumstances. We also established the Amazon Relief Fund—with an initial $25 million in funding—to support our independent delivery service partners and their drivers, Amazon Flex participants, and temporary employees under financial distress.

1. SQLite vs MySQL

SQLite vs MySQL – What’s the Difference

A core part of any website or development design is the database. There are several databases available on the market. SQLite, as well as MySQL, are equally popular open source databases. In this article, we’ll break down the essential differences between the two and help you understand the two – SQLite vs MySQL.

The database management system also referred to as a DBMS is often called RDBMS. RDBMS stands for Relational Database management system. At the most rudimentary level, all databases are used to manage, maintain, and manipulate data.

Data models can be one of two:

1. NoSQL – an unstructured and is still evolving model
2. Relational DBMS – a structured and more prominently used model

What is a Database Management System

A DBMS is a software that interacts with a database. It facilitates several operations over the databases it manages. A few of these operations are:

• Managing the access of a database
• Running SQL queries
• Writing data into the database
• Updating database
• Deleting data from the database

In most cases, database and DBMS are used interchangeably. However, a database is a collection of stored data while a DBMS is the software used to access the database.

Every DBMS has an underlying model which decides the structure of the database and how the data can be retrieved. A relational DBMS uses the relational data model. Here data is organized in the form of tables. Each table has a set of attributes or columns, and each row also referred to as tuples have a relation. Owing to this, the structuring is referred to as RDBMS.

To work on a RDBMS, you have to use SQL or Structured Query Language. Each RDBMS has a different dialect.

SQLite vs MySQL

SQLite, as well as MySQL, are open source RDBMS. Let’s deep dive into their differences.

Architectural Difference – SQLite vs MySQL

• SQLite is an open source project available in the public domain
• MySQL is an open source project which is owned by Oracle

SQLite is a server-less database and is self-contained. This is also referred to as an embedded database which means the DB engine runs as a part of the app.

On the other hand, MySQL requires a server to run. MySQL will require a client and server architecture to interact over a network.

Data Type Support – SQLite vs MySQL

SQLite supports these datatypes: Blob, Integer, Null, Text, Real.

MySQL supports the below-mentioned datatypes:

Tinyint, Smallint, Mediumint, Int, Bigint, Double, Float, Real, Decimal, Double precision, Numeric, Timestamp, Date, Datetime, Char, Varchar, Year, Tinytext, Tinyblob, Blob, Text, MediumBlob, MediumText, Enum, Set, Longblob, Longtext.

As you can tell, MySQL is a lot more flexible when it comes to data types.

Storage and Portability – SQLite vs MySQL

The SQLite library is about 250 KB in size, while the MySQL server is about 600 MB. The SQLite directly stores info in a single file, making it easy to copy. No configurations are required, and the process ca be done using minimal support.

Before copying or exporting MySQL you need to condense it into a single file. For larger databases, this will be a time-consuming activity.

Multiple Access and Scalability – SQLite vs MySQL

SQLite does not have any specific user management functionality and hence is not suitable for multiple user access. MySQL has a well-constructed user management system which can handle multiple users and grant various levels of permission.

SQLite is suitable for smaller databases. As the database grows the memory requirement also gets larger while using SQLite. Performance optimization is harder when using SQLite. This has a few write constraints.

On the contrary, MySQL is easily scalable and can handle a bigger database with less effort.

Security and Ease of Setup – SQLite vs MySQL

SQLite does not have an inbuilt authentication mechanism. The database files can be accessed by anyone. However, MySQL comes with a lot of inbuilt security features. This includes authentication with a username, password, and SSH.

SQLite does not require too many configurations and is easy to set up. MySQL requires more configurations as compared to SQLite. MySQL also has more setup guides available.

Amazon Explained – The Day 1 Mentality

Amazon CEO Jeff Bezos has always been a strong proponent of the “Day 1” business outlook. In fact, he’s preached the idea so often that it has become one of the company’s internal mantras. The Day 1 mentality means that even though Amazon is nearly 25 years old, the company treats every day like it’s the first day of their new startup.

Day 1 is an incredible idea – it’s a way to stay relevant and on your toes. Every successful startup begins with a solution to some problem or need. A promising startup focuses on what the consumer needs, and how they want it, even if they don’t know it yet.

“The outside world can push you into Day 2 if you won’t or can’t embrace powerful trends quickly. If you fight them, you’re probably fighting the future. Embrace them and you have a tailwind”—Jeff Bezos

Bezos suggests that strong trends are not that hard spot in today’s world. Many big companies get caught up with what has worked for them in the past instead of embracing what the present and future call for. That’s what Day 1 is all about; attacking every day by searching for ways to become and stay relevant to your customers.

Does it work?

The concept of Bezos Day 1 mentality has received its fair share of backlash within the business community. The chief argument against the Day 1 ideology is that most companies and startups don’t know the first thing about anything when they first begin; so why stay in that awkward growing phase? The answer to that is simple: When you treat every day like it’s Day 1, you’re not simply sitting stagnant on the information you had at the start. You’re building on what you’ve learned, and you continue to evolve. Amazon certainly hasn’t been stuck in the past – quite the opposite. Amazon is now worth north of $1 trillion and doesn’t show any signs of slowing down.

When you look at the incredible success of Amazon, it’s hard to ignore the idea of Day 1. If it works for Jeff Bezos and the second largest company in the world, there has to be something to it. Bezos holds that it isn’t enough to have Day 1 be in your mission statement – it has to be a constant reminder. That’s why the main office building that Bezos works out of is named Day 1.

Day 2

Bezos is dead-set on maintaining a business culture that will continue to innovate, create and look outwardly towards successful trends. Day 2 brings comfort and contentment with how things have been. That’s why Amazon maintains a “never Day 2” attitude.

“Day 2 is stasis. Followed by irrelevance. Followed by excruciating, painful decline. Followed by death. And that is why it is always Day 1.” -Jeff Bezos

To hold to the Day 1 mentality, you cannot be afraid of change. You must recognize how you can create a better future for your company. The absolute best way to do this is to hire the right talent around you. It may cost more initially, and it might be hard to find the right people. But when you build a team of innovative professionals, the possibilities are endless.
Be sure to allow your team leaders and other specialists freedom to do their job creatively. The best change happens when you allow the best minds access to their potential.

Day 1 Keys

In a 2016 letter to shareholders, Bezos outlined the following four keys to maintaining the Day 1 mentality.

1. True Customer Obsession

“Even when they don’t yet know it, customers want something better, and your desire to delight customers will drive you to invent on their behalf.”

Here we learn that it’s just not enough to supply a product that the customer needs. To be truly relevant to the consumer, you must provide an experience and a product before they even know they want it! You must research, observe and obsess over the clients.

2. Resist Proxies

“As companies get larger and more complex, there’s a tendency to manage to proxies. This comes in many shapes and sizes, and it’s dangerous, subtle, and very Day 2.”

No amount of calculations can guarantee repeated results in business. If you focus on the process, you are likely to lose sight of the outcome.

3. Embrace External Trends

“Big trends are not that hard to spot (they get talked and written about a lot), but they can be strangely hard for large organizations to embrace.”

This ties right into the idea of avoiding proxies or algorithms. Allow your management teams freedom to embrace trends – even further, require them to embrace trends!

4. High-Velocity Decision Making

“Day 2 companies make high-quality decisions, but they make high-quality decisions slowly. To keep the energy and dynamism of Day 1, you have to somehow make high-quality, high-velocity decisions.”

Can you see the theme here? Don’t let your business get bogged down by procedures at the cost of missing opportunities.

The Day 1 mentality has had a major impact on Amazon’s success and proves itself as an excellent business practice for all who can commit and stick to it.

Jeff Bezos’ philosophy for Amazon is that it’s always ‘Day 1’ — here’s what that means and why it works

Almost 80% of the Dow Jones 30 have disappeared over the last several decades. Others, like Sears, have either gone bankrupt or are in serious decline. Why? Because they failed to adapt to a shifting climate and instead stuck to outdated business models. From the very beginning, Jeff Bezos was determined not to repeat the mistakes of these companies, so he implemented a mindset that kept Amazon on a continuous cycle of experimentation, innovation, iteration, and even failure (remember the Fire Phone and Askville?). Bezos calls this mindset “Day 1” and it has become the company’s mantra for longevity.

“The Amazon Management System: The Ultimate Digital Business Engine That Creates Extraordinary Value for Both Customers and Shareholders.” Courtesy of Idea Press

If you read through all the shareholder letters that Bezos meticulously wrote over the past 22 years (1997-2018), the phrase “Day 1” appeared an amazing 22 times, with striking consistency. For the past 10 years, every shareholder letter has ended with the same line:

“As always, I attach a copy of our original 1997 letter. Our approach remains the same, and it’s still Day 1.” (2009-2015, with a one-word deviation in 2014)

“As always, I attach a copy of our original 1997 letter. It remains Day 1.” (2016-2018)

If you go to Amazon headquarters, you will find a building named “Day 1” where Bezos’s office is located. When he moved buildings, he took the name with him. The plate reads: “There’s so much stuff that has yet to be invented. There’s so much new that’s going to happen.” Why is Day 1 so important to Bezos? Why has he felt such a strong urge to constantly remind everyone that it’s still Day 1?

Why Day 1?

Normally, in the beginning, the organization will still function with speed, nimbleness, and a risk-acceptance mentality, but as the business grows bigger, complexity starts increasing, and layers begin creeping in, the once-nimble startups inevitably fall into the trap of so called “large organizations” characterized by slowness, rigidity, and risk aversion.

Bezos graduated from Princeton University in 1986 with degrees in electrical engineering and computer science and initially intended to study physics. That’s why he borrowed the term “entropy,” an indicator of a system’s disorder. In thermodynamics, entropy is a measure of the unavailable energy in a closed thermodynamic system that is also usually considered to be a measure of the system’s disorder. The second law of thermodynamics states that for a thermodynamically defined process to actually occur, the sum of the entropies of the participating bodies must increase. In short, in the world of physics, the total entropy, or disorder, of the universe is continually increasing. In the world of business, the inevitable path of any organization, if left unattended, will lead to decrease in efficiency and vitality, and increase in complexity and rigidity. This is the law of “entropy increase.” In a way, it is a depressing law because it states that, no matter how great a company is now, without deliberate vigilance and institutional determination to fight entropy, it will fall into mediocrity. Bezos’s goal is to defy the law of entropy increase at Amazon: “We want to fight entropy. The bar has to continuously go up.”

Day 2 is not an option

Bezos’s evocative and sticky model of “Day 1 vs. Day 2” has proved to be an immediate and useful way. This simple phrase captured Bezos’s aspiration for Amazon to grow aggressively in scale and scope while preserving the entrepreneurial vitality of a startup and building on the numerous advantages of a large company at the same time.

To defy the law of entropy increase is, by default, never easy. Bezos was fully aware of the challenge. As he noted, “There are some subtle traps that even high-performing large organizations can fall into as a matter of course, and we’ll have to learn as an institution how to guard against them.” Every day is a new day, every day the world changes, and we must look for the change, create the change, and adapt to change. It’s a lesson to every manager and leader. It’s the meaning behind Forever Day 1.

So what does Day 2 look like in Bezos’s mind? “Day 2 is stasis. Followed by irrelevance. Followed by excruciating, painful decline. Followed by death. And that is why it is always Day 1.” To Bezos, someone who wanted to win so badly during childhood that he would cry publicly over the loss of a football game, Day 2 is never an option.

Reference

https://www.podean.com/amazon-explained-the-day-1-mentality/#:~:text=The%20Day%201%20mentality%20means,to%20some%20problem%20or%20need.

https://www.businessinsider.com/jeff-bezos-says-always-day-1-amazon-philosophy-2019-12

Reference

http://i.gzn.jp/img/2018/03/22/linux-kernel-map/00.png