Notes – Page 2 – Chuck Conway

What I Learned Doing 250 Interviews At Google – Moishe Lettvin

Interview question

Favorite interview question: "Find all the words on a Boggle board"

"You could interview the same candidate twice with the same set of interviews and come to different conclusions each time."

Steve Yegge has an idea that each candidate at a perfect slate of interviews and a perfect slate of anti-slate of interviewers.

Google’s philosophy is "Missing someone who is good, is ok, compared to hiring someone who is bad." A false positive is much worse than a false negative.

Interviewing is a team effort, you might have one person that goes deep in one area, the other person doesn’t need to ask the same questions.

The hiring committee was cross teams. No one person had the power to say yay or nay.

Be prepared. Have a set of questions that you plan to ask, have an idea of your follow-up questions.

An interview is a conversation, you’re both humans, treat it as such.

Good interviewers are generous, they teach and even if the candidate isn’t the right fit.

Good questions are like onions

i.e. Conway’s law

Strive for higher bandwidth

prefer video to phone
prefer in-person to video

Strive for more signal to less noise, you job is to get them to show their best work.

Career Change – A Conversation with Dave Winters

Benefits and problem

Sales pitch., psychological.

Code world

know Business and know technology and communicate it.

Phase zero

Find my core competencies. This is the hard part. And then Sell this.

Strategic advisor

Be a strategic advisor, not a code monkey.

Code Monkey

Don’t be a code monkey

Microsoft is pivoting their business from, desktop software, to a cloud service provider. The questions I have is where does this leave the developer who has made a career using their technologies?

Learn about the Mckinsey model, specifically look at the H3 initiatives

Keys to be valuable. (Time to value) Get value out of data as fast as possible.

Do you want to be the architect, who puts the vision together or the plumber, the electrician or the carpenter?

Characterizing data, self servicing data. Vanguard data architect. Understand the business problem. Actionable business value. Help a business executive get business insights from the data.

Do I move forward as an entrepreneur or do I move in the direction of an architect/manager?

The Fifth Discipline – Peter Senge

To simplify the world, we break up ideas and tasks into smaller pieces, but then we fall into the trap that the smaller pieces are a reality, but they are small windows into the world and interact outside the boundaries of our perception.

A learning organization is a group of people who are continually enhancing their capacity to create what they want to create.

It’s important that organizations pick up the ability to learn to together on a reliable, regular and predictable schedule.

Traditional, authoritarian, hierarchical business organizations fail to tap the abilities of people. For years and years, we’ve acted as the workers have checked their brains at the door and we just wanted them to do “their work, not to think.”

The notion that people are interchangeable units is going to change. Knowledge and learning are always embodied in a person. This makes the person the organization’s most important asset.

Ultimately, it’s a change in ourselves; that will drive the change in our organization.

Systemic structures are the underlining patterns of inner dependencies.

Efficiency with Algorithms, Performance with Data Structures – Chandler Carruth

"Software is getting slower more rapidly than hardware becomes faster. -Niklaus Wirth: A Plea for Lean Software"

Niklaus Wirth – Algorithms + Data Structures = Programs

There are two sides to the performance coin:

Efficiency through Algorithms – How much work is required by a task.

Improving efficiency involves doing less work.
An efficient program is one that does the minimum (that we’re aware of) amount of work to accomplish a given task.

Performance through Data Structures – How quickly a program does it work.

Improving performance involves doing work faster
But there is no such thing as a "performant", not even work in the English language.
There is essentially no point at which a program cannot do work any faster… until you hit Bremermann’s limit…
What does it mean to improve the performance of software?
- The software is going to run on a specific, real machine
- There is some theoretical limit on how quickly it can do work
Try to light up all the transistors, get the most work done as fast as possible.

All Comes back to Watts

Every circuit not used on a processor is wasting power
Don’t reduce this to the absurd — it clearly doesn’t make sense to use more parts of the CPU without improving performance!

Algorithms

Complexity theory and analysis
Common across higher-level languages, etc.
Very well understood by most (I hope)
Improving algorithmic efficiency requires finding a different way of solving the problem.
Algorithmic complexity is a common mathematical concept that spans languages and processors. Don’t get lazy, you have to pay attention to your algorithms.
Example: – "it’s about doing less work", analyze the current approach and find ways to do it more efficiency
- Initially, you might have a basic O(n^2) algorithm
- Next, we have a Knuth-Morris-Pratt (a table to skip)
- Finally, we have a Boyer-Moore (use the end of the needle)

Do Less Work by Not Wasting Effort, Example 1

std::vector<X> f(int n) {
 std::vector<X> result;
	for(int i = 0; i < n; ++i)
		result.push_back(X(...));
    return result;	
}

Initialize the collection size

std::vector<X> f(int n) {
 std::vector<X> result;
 result.reserve(n);
	for(int i = 0; i < n; ++i)
		result.push_back(X(...));
    return result;	
}

Do Less Work by Not Wasting Effort, Example 2

X *getX(std::string key,
        std::unordered_map<std::string, std::unique_ptr<X>> &cache) {   
    
    if(cache[key])
       return cache[key].get();
    
    cache[key] = std::make_unique<X>(...);
    return cache[key].get();    
}

Retain the reference to the cache entry

X *getX(std::string key,
        std::unordered_map<std::string, std::unique_ptr<X>> &cache) {   

	std::unique_ptr<X> &entry = cache[key];

    if(entry)
       return entry.get();

    entry = std::make_unique<X>(...);
    return entry.get();
}

Always do less work!

Design API’s to Help

Performance and Data Structures = "Discontiguous Data Structures are the root of all (performance) evil"

Just say "no" to linked lists

CPUs Have Hierarchical Cache System

Data Structures and Algorithms

They’re tightly coupled, see Wirth’s books
- You have to keep both factors in mind to balance between them
Algorithms can also influence the data access pattern regardless of the data structure used.
Worse is better: bubble sort and cuckoo hashing