Pages

20220912

DINOSAUR TRAINING SECRETS: VOLUME II: HOW STRONG ARE YOU? by Brooks D. Kubik

  • The ability to put 200 pounds over your head was the mark of strength back in the day.
  • In the modern world of drug-free training, we have Stuart McRobert's 300/400/500 standards. The goal for an advanced trainee weighing about 190 pounds at a height of 5'9" would be a 300 pound bench press, 400 pound squat and 500 pound deadlift. These lifts are drug-free and without any lifting gear other than a belt. In other words, they're "raw" lifts.
  • Most lifters of the era used a power clean when they did a press.
  • The crucifix is a tremendous test of shoulder, arm and upper body strength.
  • strength training is one of the most important keys to lifelong strength and health – and as you grow older, it becomes more and more important.
  • Many regard the standard deadlift as the best measure of over-all body strength. It's a very effective movement, and one of the best exercises to include in your training program.
  • The back hand or reverse curl was one of the exercises in the York Barbell training courses, and it was widely practiced back in the day. It's not used nearly as often today, and that's a shame. It's a very good exercise, and a terrific test of arm, forearm, and wrist strength.
  • Pressing exercises build real-world "stand on your feet" strength. They are a very important part of a strongman's training, and should be a regular part of your workouts. And they're a great way to match your strength against the legendary strongmen of the past.
  • The alternate dumbbell press is a terrific exercise for the pressing muscles, as well as the abdominals and obliques, and even the lower back muscles. You perform the exercise by cleaning the dumbbells to the shoulders. From there, you press the left arm to the extended position. Now press the right arm up – and as you do so, lower the left arm. Continue until you perform a total of 10 reps – five reps with each hand. Finish with both arms overhead, and hold for a count of two.
  • The military press is a tremendous exercise, and one that every trainee should do. It builds the kind of rugged, total body strength that is very rare nowadays.
  • The repetition press begins by cleaning the bar to the shoulders. After a two-second pause, the lifter presses the weight for five consecutive reps.
  • Of course, if you prefer to do so, you can make the exercise harder and more demanding by performing one clean and one press on every rep.
  • The repetition clean and press is a real man-maker.
  • However you do it, the snatch is a wonderful exercise.

DINOSAUR TRAINING SECRETS: VOLUME I: EXERCISES, WORKOUTS AND TRAINING PROGRAMS by Brooks D. Kubik

  •  devote all or substantially all of your training time to the very best and most effective exercises. The best and most effective exercises are the basic, compound exercises such as squats, presses, bench presses, deadlifts, etc.
  • There are no "secret exercises," so don't waste time looking for them. Stick to the basics.
  • Of course, the sad reality is that most trainees spend almost all of their training time on isolation exercises, and some "gyms" even prohibit their members from performing some of the most important and most effective compound movements, such as squats, deadlifts, military presses and push presses.
  • The basic, compound exercises are best because they allow you to work several muscle groups at the same time, and thus, to work up to substantial amounts of weight in your different exercises.
  • Over time, hard work on the basic, compound exercises leads to enormous increases in strength and muscle mass.
  • Your best compound exercises are squats, front squats, deadlifts, Trap Bar deadlifts, standing presses with barbells or dumbbells (or a single dumbbell), barbell and dumbbell bent-over rowing, pull-ups, chin-ups, pull-downs, weighted push-ups, bench presses (performed with barbells, dumbbells, or a single dumbbell), incline presses (performed with barbells, dumbbells, or a single dumbbell), shoulder shrugs (performed with a barbell, two dumbbells, one dumbbell or a Trap Bar), deadlifts from the knees (performed with the bar or Trap Bar elevated by resting the plates on sturdy wooden blocks), hand and thigh lifts, and Hise shrugs.
  • Grip work, gut work, and neck work are all important.
  • Altogether, there are about 20 basic, compound exercises.
  • So do this: pick one squatting exercise, one deadlifting movement, one or two upper body pushing movements and one or two upper body pulling movements. That gives you four to six "big" exercises to focus on. Train these exercises hard for six to twelve weeks, and then, if you want some variety, switch to other movements.
  • Contrary to what many mistakenly believe, there's no need to change exercises as long as they're working for you and as long as you are motivated to train hard and heavy on them.
  • Many very strong and powerful men have performed the same exercises for pretty much their entire training careers.
  • Your job is to train hard and heavy on the basics, and that's where the lion's share of your time and effort needs to go.
  • The simplest way to train with heavy, awkward objects is to carry them as far as you can, put them down, rest, and then carry them back to where you started.
  • The farmer's walk is the simplest and best of the lot, and doubles as a very effective grip builder.
  • By building your back muscles and avoiding over-development of the chest muscles, you develop a tall, erect posture.
  • Heavy dumbbell training is a lost secret of strength, power and muscular development.
  • The two-dumbbell clean and press is an excellent dumbbell exercise.
  • Over time, thick bar training will make your entire upper body much more massive and more heavily developed than would ever happen otherwise.
  • The only caveat is to be careful when lifting thick-handled dumbbells. Don't hold them over your head or feet, and make sure you get out of the way fast if you drop them.
  • Understand that with the right kind of training, you can make incredible gains with nothing other than a barbell.
  • Unless you are an advanced trainee who plans to enter a bodybuilding contest, training for "cuts" is a waste of time.
  • Instead of training for "cuts," train for strength. Strength is a positive quality. It's something you build.
  • A healthy diet is one that promotes recovery from your workouts, builds muscle and keeps you from adding unwanted body-fat.
  • Don't get hung up about training for "cuts" or extreme definition. Train for strength instead.
  • As your strength increases, so will your muscle mass.
  • There are many excellent exercises for the midsection. I've always preferred leg raises to anything else.
  • Hanging knees to chest, leg scissors, leg raises, and windshield wipers are all excellent exercises.
  • Planks are excellent for mid-section training.
  • The gains from workout to workout are extremely small, but over time, they add up to enormous increases in strength and muscular development.
  • If you train too much, too hard or too often, you outrun your body's recovery system. It's that simple.
  • The biggest challenge for most older trainees is finding the right balance between training hard enough, heavy enough and often enough to build strength and muscle without training too hard, to heavy or too often.
  • Abbreviated programs work far better than longer, more complicated, more demanding workouts.
  • There's no magic about 5 x 5.
  • Always use what works best for you in terms of sets and reps.
  • The key to building great strength and muscle mass is to add weight to the bar whenever you can.
  • Do gut work to finish the first workout, grip work to finish the next workout, and neck work to finish the first workout of week two.
  • I've suggested that you use the 5 x 5 system. Try four progressively heavier warm-up sets and one set with your working weight for the day.
  • The squat and deadlift are especially good for building all-around strength and muscle mass.
  • Diet and nutrition helps you recover from hard workouts, but there quickly comes a point where diet and nutrition can’t do anything more.
  • If you've been paying careful attention, you will have noticed that the primary message of this book is to train hard and heavy on sensible, low-volume training programs that focus on the basic, compound exercises.
  • Devote yourself to hard, heavy training on a small number of the very best exercises.

20210721

Measure What Matters by John Doerr

  • As much as I hate process, good ideas with great execution are how you make magic. And that’s where OKRs come in.
  • Ideas are easy. Execution is everything.
  • The practice that molded me at Intel and saved me at Sun--that still inspires me today--is called OKRs. Short for Objectives and Key Results. It is a collaborative goal-setting protocol for companies, teams, and individuals. Now, OKRs are not a silver bullet. They cannot substitute for sound judgement, strong leadership, or a creative workplace culture. But if those fundamentals are in place, OKRs can guide you to the mountaintop.
  • An Objective is simply what is to be achieved, no more and no less. By definition, objectives are significant, concrete, action oriented, and (ideally) inspirational. When properly designed and deployed, they’re a vaccine against fuzzy thinking--and fuzzy execution.
  • Key Results benchmark and monitor how we get to the objective. Effective KRs are specific and time-bound, aggressive, yet realistic. Most of all, they are measurable and verifiable. You either meet a key result’s requirements or you don’t; there is no gray area, no room for doubt.
  • Where an objective can be long-lived, rolled over for a year or longer, key results evolve as the work progresses. Once they are all completed, the objective is necessarily achieved.
  • OKRs surface your primary goals. They cannel efforts and coordination. They link diverse operations, lending purpose and unity to the entire organization.
  • For anyone striving for high performance in the workplace, goals are very necessary things.
  • In the technology sector, two out of three employees think they could find a better job inside of two months.
  • An effective goal management system--an OKR system--links goals to a team’s broader mission. It respects targets and deadlines while adapting to circumstances. It promotes feedback and celebrates wins, large, and small. Most importantly, it expands our limits. It moves us to strive for what might seem beyond our reach.
  • The higher the ratio of reports, the flatter the org chart--which means less top-down oversight, greater frontline autonomy, and more fertile soil for the next breakthrough. OKRs help make all of these good things possible.
  • High-performance organizations home in on work that’s important, and are equally clear on what doesn’t matter. OKRs impel leaders to make hard choices. They’re a precision communication tool for departments, teams, and individual contributors. By dispelling confusion, OKRs give us the focus needed to win.
  • Andy Grove’s quantum leap was to apply manufacturing production principles to the “soft professions,” the administrative, professional, and managerial ranks. He sought to “create an environment that values and emphasizes output” and to avoid what Drucker termed the “activity trap”.
  • On an assembly line, it’s easy enough to distinguish output from activity. It gets trickier when employees are paid to think.
  • “Bad companies,” Andy wrote, “are destroyed by crisis. Good companies survive them. Great companies are improved by them.”
  • An effective goal-setting system starts with disciplined thinking at the top, with leaders who invest the time and energy to choose what counts.
  • Leaders must get across the why as well as the what.
  • Don’t allow the perfect to be the enemy of the good.
  • Remember that an OKR can be modified or even scrapped at any point in its cycle.
  • Sometimes the “right” key results surface weeks or months after a goal is put into play. OKRs are inherently works in progress, not commandments chiseled in stone.
  • A few goal-setting ground rules: key results should be succinct, specific, and measurable.
  • As Steve Jobs understood, “Innovation means saying no to one thousand things.”
  • In most cases, the ideal number of quarterly OKRs will range between three and five.
  • Too many objectives can blur our focus on what counts, or distracts us into chasing the next shiny thing.
  • We learned the three watchwords for entrepreneurs:
    • Solve a problem
    • Build a simple product
    • Talk to your users
  • Research shows that public goals are more likely to be attained than goals held in private.
  • One underrated virtua of OKRs is that they can be tracked--and then revised or adapted as circumstances dictate.
  • Annual performance reviews are costly, exhausting, and mostly futile.
  • In short, we need a new HR model for the new world of work. That transformational system, the contemporary alternative to annual reviews, is continuous performance management.
  • It is implemented with an instrument called CFRs, for:
    • Conversations: an authentic, richly textured exchange between manager and contributor, aimed at driving performance.
    • Feedback: bidirectional or networked communication among peers to evaluate progress and guide future improvement.
    • Recognition: expressions of appreciation to deserving individuals for contributors of all sizes.
  • For companies moving to continuous performance management, the first step is blunt and straightforward: divorce compensation (both raises and bonuses) from OKRs. These should be two distinct conversations, with their own cadences and calendars.
  • Feedback can be highly constructive--but only if it is specific.
  • Continuous recognition is a powerful driver of engagement.
  • Recognize people for actions and results.
  • Corrective feedback is naturally difficult for people. But when done well, it’s also the greatest gift you can give to someone--because it can change people's mindset and modify their behavior in the most positive, valuable way.
  • People watch what you do more than what you say.
  • Ideas are easy; execution is everything.
  • Poorly done/managed OKRs are a waste of time, an empty management gesture. Well done OKRs are a motivational management tool that helps make it clear to teams what’s important, what to optimize, and what tradeoffs to make during their day-to-day work.
  • Objectives are the “Whats”. They:
    • Express goals and intents.
    • Are aggressive yet realistic.
    • Must be tangible, objective, and unambiguous; should be obvious to a rational observer whether an objective has been achieved.
    • The successful achievement of an objective must provide clear value for Google.
  • Key results are the “Hows”. They:
    • Express measurable milestones which, if achieved, will advance objectives in a useful manner to their constituents.
    • Must describe outcomes, not activities.
    • Must include evidence of completion.
  • OKRs have two variants, and it is important to differentiate between them: commitment OKRs and aspirational OKRs.
  • OKRs are often written principally based on what the team believes it can achieve without changing anything they’re currently doing, as opposed to what the team or its customers really want.
  • If your objective doesn’t fit on one line, it probably isn’t crisp enough.
  • Four superpowers of OKRs:
    • Focus and commit to priorities.
    • Align and connect for teamwork.
    • Track for accountability.
    • Stretch for amazing.
  • Too many OKRs dilute and scatter people’s efforts.
  • Expand your effective capacity by deciding what not to do, and discard, defer, or deemphasize accordingly.
  • In choosing OKRs, look for objectives with the most leverage for outstanding performance.
  • When leaders openly admit their missteps, contributors feel freer to take healthy risks.
  • Establish an environment where individuals are free to fail without judgement.
  • To get leaps in productivity or innovation, follow Google’s “Gospel of 10x” and replace incremental OKRs with exponential ones. That’s how industries get disrupted and categories reinvented.


20210711

Smart & Gets Things Done by Joel Spolsky

  • The process of hiring great technical talent is an elimination course.
  • But there’s a silver lining, if you will: a bright side to all this meandering mathematical moroseness. And that is this: if you can eliminate one obstacle--just one!--you can double the number of people you hire. Eliminate two obstacles, and you quadruple the number that make it past the remaining obstacles. And so on, and so forth.
  • But there is no silver bullet. There is no magical single thing you can do to solve all your hiring problems and get great developers working for you tomorrow.
  • What you have to do is look at the whole process as an obstacle course and start to think about how to eliminate as many obstacles as possible.
  • Duplication of software is free. That means the cost of programmers is spread out over all the copies of the software you sell. With software, you can improve quality without adding to the incremental cost of each unit sold.
  • Essentially, design adds value faster than it adds cost.
  • The quality of the work and the amount of time spent are simply uncorrelated.
  • A single good programmer working on a single task has no coordination or communication overhead. Five programmers working on the same task must coordinate and communicate. That takes a lot of time.
  • The real trouble with using a lot of mediocre programmers instead of a couple of good ones is that no matter how long they work, they never produce something as good as what the great programmers can produce.
  • The mediocre talent just never hits the high notes that the top talent hits all the time.
  • People like to feel in control. It makes people happy to feel in control.
  • It’s not just a matter of “10 times more productive”. It’s that the “average productive” developer never hits the high notes that make great software.
  • The software marketplace, these days, is something of a winner-take-all system.
  • The great software developers, indeed, the best people in every field, are quite simply never on the market.
  • The average great software developer will apply for, in total, maybe four jobs in their entire career.
  • The great college graduates get pulled into an internship by a professor with a connection to industry, then they get early offers from that company and never bother applying for any other jobs.
  • The corollary of that rule--the rule that the great people are never on the market--is that the bad people--the seriously unqualified--are on the market quite a lot. They get fired all the time, because they can’t do their job.
  • Numerically, great people are pretty rare, and they’re never on the job market, while incompetent people, even though they are just as rare, apply to thousands of jobs throughout their career.
  • Think about where the people you want to hire are hanging out.
  • The corollary of this rule is to avoid advertising on general-purpose, large job boards.
  • One good way to snag great people who are never on the job market is to get them before they even realize there is a job market: when they’re in college.
  • Even though only about one in three applications who make it to the in-person interview stage passes all our interviews, it’s really important that the ones who do pass have a positive experience.
  • An internship program creates a pipeline for great employees, but it’s a pretty long pipeline, and a lot of people get lost along the way.
  • We basically calculate that we’re going to have to hire two interns for every full-time employee that we get out of it, and if you hire interns with one year left in school, there’s still a two-year pipeline between when you start hiring and when they show up for their first day of full time work.
  • That means we hire just about as many interns as we can physically fit in our offices each summer.
  • No programmer in their right mind should ever sign a non-compete agreement, but most of them do because they can never imagine that it would be enforced, or because they are not in the habit of reading contracts, or because they already accepted the employment offer and moved their families across the country and the first day of work is the first time they’ve seen this agreement and it’s a little bit too late to try to negotiate it. So they sign, but this is one of the slimiest practices of employers, and they are often enforceable and enforced.
  • [...] if the great programmers don't want to work for you, they ain’t gonna come work for you.
  • Peopleware is a great book.
  • There’s a strong culture in Silicon Valley that requires you to jam a lot of programmers into a big open space, despite a preponderance of evidence that giving them private offices is far more productive.
  • No matter what you think about productivity, and no matter what you think about egalitarian workspaces, two things are incontrovertible:
    • Private offices have higher status.
    • Cubicles and other shared space can be socially awkward.
  • A lot of tech people are remarkably unaware of the general condition of their office.
  • There is simply no reason not to get your developers top-of-the-line computers, at least two large (21”) LCD screens (or one 30” screen), and give them free rein on Amazon to order any technical book they want.
  • These are obvious productivity gains, but more importantly to our discussion here, they’re crucial recruiting tools, especially in a world where most companies treat programmers as interchangeable cogs, typists. Really, why do you need such a big monitor and what’s wrong with 15” CRTs?
  • Software developers are not really all that different from regular people.
  • All else being equal, developers are going to prefer an organization that treats them like stars.
  • Keep reminding yourself that when your candidate goes home and has to make a decision about where to work, if everyone they met was glum, they are not going to have such a positive memory of your company.
  • By the way, the original hiring rule for Fog Creek, stolen from Microsoft, was “smart, and gets things done.” Even before we started the company, we realized that we should add a third rule: “Not a jerk.”
  • Who wants to work at a company where jerks are tolerated?
  • Basically, if you’re going to hire smart people, you’re going to have to let them apply their skills to their work.
  • Developers want to be hired for their skills, and treated as experts, and allowed to make decisions within their own realm of experience.
  • Actually, politics happens everywhere that three or more people congregate, and it can be completely harmless.
  • Programmers have very well-honed senses of justice. Code either works, or it doesn’t.
  • And this is the kind of environment you have to create to attract programmers.
  • When a programmer complains about “politics”, they mean--very precisely--any situation in which personal considerations outweigh technical considerations.
  • Nothing is more infuriating than when a developer is told to use a certain programming language, not the best one for the task at hand, because the boss likes it.
  • Nothing is more maddening than when people are promoted because of their ability to network rather than being promoted strictly on merit.
  • Nothing is more aggravating to a developer than being forced to do something that is technically inferior because someone higher than them in the organization, or someone better-connected, insists on it.
  • All in all, focusing on the social dynamics of your organizations is crucial to making a healthy, pleasant place to work that will retain programmers and attract programmers.
  • To some extent, one of the best ways you can attract developers is to let them work on something interesting.
  • If you can find ways for developers to get experience with newer languages, frameworks, and technologies, they’ll be happier.
  • As a recruiter, your job is to identify the idealistic aspects of your company, and make sure candidates are aware of them.
  • The real point of this section is to think of what your company stands for, how it’s perceived, and how it could be perceived. Managing your corporate brand is just as important for recruiting as it is for marketing.
  • They don’t care about money, actually, unless you’re screwing up on the other things. If you start to hear complaints about salaries where you never heard them before, that’s usually a sign that people aren’t really loving their job.
  • You do have to pay competitively, but all said, of all the things that programmers look at in deciding where to work, as long as the salaries are basically fair, they will be surprisingly low on their list of considerations, and offering high salaries is a surprisingly ineffective tool in overcoming problems like the fact that programmers get 15” monitors and salespeople yell at them all the time and the job involves making nuclear weapons out of baby seals.
  • Sometimes a resume gives pretty strong negative clues that allow you to screen out applicants without going much further.
  • We try to be selective about how we advertise our jobs, so as to limit the amount of noise in the resume pile.
  • We look for evidence that the applicant is passionate about computers and really loves programming.
  • That said, years of experience working with programmers have taught me that programmers who can communicate their ideas clearly are going to be far, far more effective than programmers who can only really communicate well with the compiler.
  • Brilliant programmers who have trouble explaining their ideas just can’t make as much of a contribution.
  • Another thing we look for on resumes is evidence that someone has gone through some highly selective process in the past.
  • Our company criterion for selectivity is usually getting into a school or program that accepts less than 30% of its applications, or working for a company that is known to have a difficult application process, like a whole day of interviews. Getting into highly selective courses in the military or getting into highly selective units like the Marines, indicates someone who has made it through some kind of difficult application/selection procedure, and all in all this is a positive sign.
  • People who have worked on operating systems or compilers are more hardcore than  people who have worked on simple database front-ends.
  • Remember angina that I said that resume are a very weak way of judging programmers, and you only get the faintest signals from them; that said, some technologies are just harder than other technologies, and if you happened to have worked with them successfully, there’s a smidgen more evidence that you might be the right person to hire, so for the purposes of sorting resumes, difficult technologies tend to float you to the top, while claiming competence in say, Microsoft Word tends to float you toward the bottom.
  • To top programmers, the most maddening thing about recruiters is their almost morbid fascination with keywords and buzzwords. The entire industry of professional headhunters and recruiters is bizarrely fixated on the simple algorithm of matching candidates to positions by looking for candidates who have the complete list of technology acronyms that the employer happens to be looking for.
  • It becomes especially infuriating to realize that most of these recruiters have no idea what any of these technologies are.
  • The reason recruiters do this is because it’s easy, it can be computerized, and it’s the only way they know how to judge developers. For almost all software development positions, though, it is the worst possible way to hire.
  • Don’t start a new project without at least one architect with several years of solid experience in the language, classes, APIs, and platforms you’re building on.
  • A phone screen has distinct advantages over a normal in-person interview. First, it’s cheap. [...] More importantly, it’s more fair.
  • The bottom line in my interviewing technique is that smart people can generally tell if they’re talking to other smart people by having a conversation with them on a difficult or highly technical subject so that the interviewer’s judgement can form an opinion on whether this is a smart person or not.
  • The very first thing you have to do right if you want to have good programmers is to hire the right programmers, and that means you have to be able to figure out who the right programmers are, and this is usually done in the interview process.
  • You should always try to have at least six people interview each candidate, including at least five who would be peers of that candidate (that is, other programmers, not managers).
  • It’s too easy to fake out one interview, especially when a non-programmer interviews a programmer.
  • If even two of the six interviewers think that a person is not worth hiring, don’t hire them.
  • Don’t try to interview a bunch of people at the same time. It’s just not fair. Each interview should consist of one interviewer and one interviewee, in a room with a door that closes and a whiteboard.
  • In software, things change so often and so rapidly that you need people who can succeed at just about any programming task that you throw at them.
  • Just say no! If you are on the fence, that means no hire.
  • Don’t lower your standards no matter how hard it seems to find those great candidates.
  • In principle, it’s simple. You’re looking for people who are:
    • Smart, and
    • Get things done
  • People who are smart but don't get things done often have PhDs and work in big companies where nobody listens to them because they are completely impractical. They would rather mull over something academic about a problem than ship on time.
  • People who get things done but are not smart will do stupid things, seemingly without thinking about them, and somebody else will have to come clean up their mess later. This makes them net liabilities to the company because not only do they fail to contribute, but they soak up good people’s time.
  • How do you detect smartness in an interview? The first good thing is that you don’t have to explain things over and over again. The conversation just flows.
  • Remember, smart does not mean “knows the answer to trivia questions.” Anyway, software teams want to hire people with aptitude, not a particular skill set.
  • Any skill set that people can bring to the job will be technologically obsolete in a couple of years, anyway, so it’s better to hire people who are going to be able to learn any new technology rather than people who happen to now how to make JDBC talk to a MySQL database right this minute.
  • Here’s a typical plan for interviewing a programmer:
    • Introduction
    • Question about recent project candidate worked on
    • Easy programming question
    • Pointer/recursion question
    • Are you satisfied?
    • Do you have any questions?
  • Look for passion. Smart people are passionate about the projects they work on. They get very excited talking about the subject. They talk quickly and get animated. Being passionately negative can be just as good a sign.
  • Bad candidates just don’t care and will not get enthusiastic at all during the interview.
  • Good candidates are careful to explain things well, at whatever level. I often reject candidates because when they talked about their previous project, they couldn’t explain it in terms that a normal person could understand.
  • If the project was a team project, look for signs they took a leadership role.
  • The only way you’re going to be able to tell if somebody gets things done is to see if historically they have tended to get things done in the past.
  • Most of the time in the interview, though, should be spent letting the candidate prove that they can write code.
  • If the basic concepts aren’t so easy that you don't have to think about them, you’re not going to get the big concepts.
  • 15 years of experience interviewing programmers has convinced me that the best programmers all have aptitude for dealing with multiple levels of abstraction simultaneously.
  • I’ve come to realize that understanding pointers in C is not a skill, it’s an aptitude.
  • The optimal time to make a decision about the candidate is about three minutes after the end of the interview. Far too many companies allow interviewers to wait days or weeks before turning in their feedback. Unfortunately, the more time that passes, the less you’ll remember.
  • If you’re having trouble deciding; there’s a very simple solution. No hire. Just don’t hire people that you aren’t sure about.
  • Remember: most normal recruiting in our society is structured as if the company has something precious (a job) that the individual wants. But when you’re recruiting top developers, the situation is completely reversed. Pay very, very close attention to the details of the entire recruiting, interviewing, and hiring process to make sure there are no accidental parts of the procedure that send any message other than “We’re not worthy!” to your star candidates.
  • Great people are much, much more valuable than average people. In programming, they are three to ten times as productive, while only costing 20% to 30% more. And they hit high notes that nobody else can hit.
  • An extremely people and seemingly scientific way to improve a team is with performance measurements and incentives. [...] This is a common management technique, and it’s devastatingly ineffective.
  • In software development teams, everybody is working on something else, so attempts to micromanage turn into hit-and-run micromanagement. That’s where you micromanage one developer in a spurt of activity and then suddenly disappear from that developer’s life for a couple of weeks while you run around micromanaging another developer.
  • The Econ 101 manager assumes that everyone is motivated by money, and that the best way to get people to do what you want them to do is to give them financial rewards and punishments to create incentives.
  • Intrinsic motivation is your own, natural desire to do things well. People usually start out with a lot of intrinsic motivation. They want to do a good job.
  • Extrinsic motivation is a motivation that comes from outside, like when you’re paid to achieve something specific.
  • Intrinsic motivation is much stronger than extrinsic motivation. People work much harder at things they actually want to do. That’s not very controversial.
  • When you use Econ 101 management, you’re encouraging developers to game the system.
  • Developers are clever this way. Whatever you try to measure, they’ll find a way to maximize, and you’ll never quite get what you want.
  • The biggest problem with Econ 101 management is that it’s not management at all: it’s an abdication of management. A deliberate refusal to figure out how things can be made better.
  • Management, in general, needs to set up the system so that people can get things done, it needs to avoid displacing intrinsic motivation with extrinsic motivation, and it won’t get very far using fear and barking out specific orders.
  • The real trick to management is to try to make people identify with the goals you’re trying to achieve.
  • To be an Identify Method manager, you have to summon all the social skills you have to make your employees identify with the goals of the organization, so that they are highly motivated, then you need to give them the information they need to steer in the right direction.
  • In general, Identify Management requires you to create a cohesive, gelled team that feels like a family, so that people have a sense of loyalty and commitment to their coworkers. The secondary part, though, is to give people the information they need to steer the organization in the right direction.
  • The Joel Test
    • Do you use source control?
    • Can you make a build in one step?
    • Do you make daily builds?
    • Do you have a bug database?
    • Do you fix bugs before writing new code?
    • Do you have an up to date schedule?
    • Do you have a spec?
    • Do programmers have quiet working conditions?
    • Do you use the best tools money can buy?
    • Do you have testers?
    • Do new candidates write code during their interview?
    • Do you do hallway usability testing?
  • If the [build] process takes any more than one step, it is prone to errors.
  • Breaking the build is so bad (and so common) that it helps to make daily builds, to ensure that no breakage goes unnoticed.
  • You absolutely have to keep track of bugs formally.
  • “Zero defects” means that at any given time, the highest priority is to eliminate bugs before writing any new code.
  • In general, the longer you wait before fixing a bug, the costlier (in time and money) it is to fix.
  • There are extensively documented productivity gains provided by giving knowledge worker space, quiet, and privacy.
  • Productivity depends on being able to juggle a lot of little details in short-term memory all at once. Any kind of interruption can cause these details to come crashing down.
  • Top-notch development teams don't torture their programmers.
  • Even minor frustrations caused by using underpowered tools add up, making programmers grumpy and unhappy. And a grumpy programmer is an unproductive programmer.
  • To add to all this...programmers are easily bribed by giving them the coolest, latest stuff. This is a far cheaper way to get them to work for you than actually paying them competitive salaries!
  • Do whatever you want during interviews, but make the candidate write some code.
  • A hallway usability test is where you grab the next person that passes by in the hallway and force them to try to use the code you unjustly wrote. If you do this to five people, you will learn 95% of what there is to learn about usability problems in your code.
  • Good user interface design is not as hard as you would think, and it’s crucial if you want customers to love and buy your product.

20210710

Complexity: A Guided Tour by Melanie Mitchell

  • Reductionism is the most natural thing in the world to grasp. It’s simply the belief that “a whole can be understood completely if you understand its parts, and the nature of their ‘sum’.”
  • Reductionism has been the dominant approach to science since the 1600s.
  • Since the time of Descartes, Newton, and other founders of the modern scientific method until the beginning of the twentieth century, a chief goal of science has been a reductionist explanation of all phenomena in terms of fundamental physics.
  • In complex systems, many simple parts are irreducibly entwined, and the field of complexity is itself an entwining of many different fields.
  • Common properties of complex systems
    • Complex collective behavior
    • Signaling and information processing
    • Adaptation
  • Now I can propose a definition of the term complex system: a system in which large networks of components with no central control and simple rules of operation give rise to complex collective behavior, sophisticated information processing, and adaptation via learning or evolution.
  • Systems in which organized behavior arises without an internal or external controller or leaders are sometimes called self-organization.
  • Since simple rules produce complex behavior in hard-to-predict ways, the macroscopic behavior of such systems is sometimes called emergent.
  • Here is an alternative definition of a complex system: a system that exhibits nontrivial emergent and self-organizing behavior.
  • The central question of the sciences of complexity is how this emergent self-organized behavior comes about.
  • It was the understanding of chaos that eventually laid to rest the hope of perfect prediction of all complex systems, quantum or otherwise. The defining idea of chaos is that there are some systems--chaotic systems---in which even minuscule uncertainties in measurements of initial position and momentum can result in huge errors in long-term predictions of these quantities. This is known as “sensitive dependence on initial conditions”.
  • A linear system is one you can understand by understanding its parts individually and then putting them together.
  • A nonlinear system is one in which the whole is different from the sum of the parts.
  • Seemingly random behavior can emerge from deterministic systems, with no external source of randomness.
  • The behavior of some simple, deterministic systems can be impossible, even in principle, to predict in the long term, due to sensitive dependence on initial conditions.
  • In summary, changing, hard-to-predict macroscopic behavior is a hallmark of complex systems.
  • Dynamical systems there provide a mathematical vocabulary for characterizing such behavior in terms of bifurcations, attractors, and universal properties of the ways systems can change.
  • In short, classical mechanics attempts to say something about every single microscopic entity by using Newton’s laws. Thermodynamics gives laws of macroscopic entities--heat, energy, and entropy--without acknowledging that any microscopic molecules are the source of these macroscopic entities. Statistical mechanics is a bridge between these two extremes, in that it explains how the behavior of the macroscopic entities arise from statistics of large ensembles of microscopic entities.
  • Shannon’s definition of information involves a source that sends a message to a receiver.
  • The second law of thermodynamics states that the total entropy of an isolated system will always increase until it reaches its maximum value.
  • To summarize the major ideas of Darwin’s theory:
    • Evolution has occurred; that is, all species descended from a common ancestor. The history of life is a branching tree of species.
    • Natural selection occurs when the number of births is greater than existing resources can support so that individuals undergo competition for resources.
    • Traits of organisms are inherited with variation. The variation is in some sense random--that is, there is no force or bias leading to variations that increase fitness. Variations that turn out to be adaptive in the current environment are likely to be selected, meaning that organisms with those variations are more likely to survive and thus pass on the new traits to their offspring, causing the number of organisms with those traits to increase over subsequent generations.
    • Evolutionary change is constant and gradual via the accumulation of small, favorable variations.
  • The collection of all of an organism’s physical traits--its phenotype--comes largely due to the character of interactions between proteins in cells. Proteins are long chains of molecules called amino acids.
  • Subsequences of DNA from genes. Roughly, each gene codes for a particular protein. It does that by coding for each of the amino acids that make up the protein. The way amino acids are coded is called the genetic code. The code is the same for almost every organism on Earth.
  • Each amino acid corresponds to a triplet of nucleotide bases.
  • One simple measure of complexity is size. By this measure, humans are about 250 times as complex as yeast if we compare the number of base pairs, but only about four times as complex if we count genes.
  • Another proposed measure of the complexity of an object is simply its Shannon entropy, defined [...] to be the average information content or “amount of surprise” a message source has for a receiver.
  • An important missing piece for current day computers is the ability to make analogies.
  • Perceiving abstract similarities is something computers are notoriously bad at. That’s why I can’t simply show the computer a picture, say, of a dog swimming in a pool, and ask it to find “other pictures like this” in my online photo collection.
  • A model, in the context of science, is a simplified representation of some “real” phenomenon. Scientists supposedly study nature, but in reality much of what they do is construct and study models of nature.
  • Models are ways for our minds to make sense of observed phenomena in terms of concepts that are familiar to us, concepts that we can get our heads around.
  • Models are also a means for predicting the future [...].
  • Network thinking means focusing on relationships between entities rather than entities themselves.

20210515

THE KILL CHAIN by Christian Brose

  • it is impossible to solve a problem that no one knows exists.
  • Over the past decade, in US war games against China, the United States has a nearly perfect record: we have lost almost every single time.
  • The goal is to buy deterrence, the prevention of war. And the only way to deter wars is to be so clearly capable of winning them that no rival power ever seeks to get its way through violence.
  • Rather, the ability to prevail in war, and thereby prevent it, comes down to one thing: the kill chain.
  • The kill chain is a process that occurs on the battlefield or wherever militaries compete. It involves three steps: The first is gaining understanding about what is happening. The second is making a decision about what to do. And the third is taking action that creates an effect to achieve an objective.
  • We remained focused on building and buying platforms rather than kill chains.
  • From 1990 to 2017, the Chinese military budget increased by 900 percent.
  • The Chinese Communist Party aims to become the dominant power in Asia and in the world, and it believes that for China to win, America must lose.
  • A core pillar of the Chinese Communist Party’s plan is harnessing emerging technologies to “leapfrog” the United States and become the world’s preeminent power.
  • New technologies are important, but not as important as new thinking.
  • the real problem is a lack of imagination.
  • The result is that we have run our military into the ground through repeated deployments of limited strategic value, and US adversaries have factored this into their plans to counter us.
  • The bigger issue is that most of these allegedly information age military systems struggle to share information and communicate directly with one another to a degree that would shock most Americans.
  • Such information-sharing problems are more the rule than the exception, not just with Air Force programs but also in the Army, Navy, and Marine Corps, and certainly between them.
  • The Pentagon kept planning to fight in the same ways: technologically inferior enemies, uncontested battlefields, iron mountains, slow kill chains, and little attrition in combat.
  • The connections between our military systems tend to be highly rigid, excessively manual, rather brittle, and thus slow.
  • The reason that Washington got Russia so wrong for so long can be traced back to high hopes—perhaps even wishful thinking—after the Cold War.
  • What each president was slow to learn was that Russia was more interested in restoring the great-power status it lost in 1991 than in becoming the partner the United States hoped it would be.
  • Under what it called its 995 Plan (named for the Belgrade embassy attack in May 1999), China accelerated work to build a different kind of military. It continued to spend money on traditional military systems, such as ships and tanks, but its priority was to develop what it called “Assassin’s Mace” weapons. The name refers to special weapons that were used in Chinese history to defeat more powerful adversaries.
  • The simple idea was that the US giant could not move or fight if it were deaf, dumb, and blind.
  • US companies that entered joint ventures in China did so knowing that they were essentially putting their intellectual property in the hands of the Chinese state, which would use it to develop its domestic industries and its military.
  • Americans are inclined to scoff at China’s centralized and authoritarian approach to technological innovation. However, it must be acknowledged that China has consistently beaten US projections of both the quality and the quantity of advanced military technology that it could develop and how quickly it could do so.
  • Ultimately, the strategic challenge that China poses dwarfs that of Russia. Despite all of its hostile rhetoric and saber rattling, Russia possesses orders of magnitude less conventional economic and military power than China, and that disparity grows wider every day.
  • In reality, however, China has been systematically transforming its military since 1993.
  • As early as 1993, China declared that its military’s goal would be “fighting local wars under high technology conditions.”
  • Although some traditional defense companies were developing some of these technologies, such as advanced missiles and directed energy weapons, many of the most consequential technologies were being developed by commercial enterprises that were not interested in providing them to the US military.
  • It is difficult to overstate the all-encompassing sense of urgency that Washington felt in the early years of the Cold War.
  • The paramount concern was picking winners: the priorities that were more important than anything else, the people who could succeed where others could not, and the industrialists who could quickly build amazing technology that worked. Other concerns, such as fairness and efficiency, were of secondary importance.
  • Everyone knew what the priorities were. Everyone knew that a ton of money was being spent on them.
  • This is how Silicon Valley originated: as a start-up incubated by the Department of Defense.
  • A sprawling bureaucracy materialized in the 1960s to administer and discipline the military-industrial complex.
  • Under his tenure, in the spirit of improving efficiency, new layers of oversight, analysis, and management were added, and these grew and began choking off the ability to develop breakthrough technologies quickly.
  • For its part, Congress tied the military’s hands through the budget process, making it harder to spend money in new ways or on new ideas that were not exactly what the Pentagon had “programmed” and Congress had decreed.
  • The result was that the process of developing military technology became harder, slower, and less creative.
  • Military procurement had become “politicized by a blizzard of legislation” and stifled by a “maze of top-down micro-management.”
  • When the Soviet threat disappeared, any sense of urgency in military acquisition went with it.
  • A large and sustained reduction in federal funding for defense research and development began in the 1990s.
  • Members of Congress earmarked much of what money remained for research activities in their states and districts, and these often had more political than military value.
  • An arguably bigger problem was that the United States radically slowed its iterative development of new military systems.
  • More and more of America’s defense spending shifted from developing new things to operating and maintaining old things.
  • The slowing of innovation increased the temptation in government and industry to begin programs that depended on future technological miracles.
  • Defense companies spent less money on research and development and more on armies of lawyers, lobbyists, accountants, and consultants to help them comply with the Pentagon’s growing acquisition bureaucracy and win more of the shrinking number of large contracts.
  • Put simply, the US government created incentives for defense companies to do the wrong things, and that is often what happened.
  • It is estimated that seventeen thousand companies dropped out of the defense business between 2011 and 2015.
  • As defense companies grew larger, their creative engineers and technologists struggled to move fast and solve problems in the face of ever-expanding corporate bureaucracies.
  • The defense establishment primarily thought (and still thinks) in terms of
  • The Pentagon and Congress did not know how to buy synergy between platforms, and building connectivity is not the expertise of traditional defense companies.
  • Nvidia’s core technology is called a graphics processing unit, which its founders created not with militaries in mind but video games.
  • most US military systems are many years behind the state-of-the-art technology that commercial companies such as Nvidia are developing.
  • The information that most US military machines collect is not actually processed onboard the machine itself. It is either stored on the system and then processed hours or even days later when the machine returns from its mission. Or it is streamed back to an operations center in real time, terabyte by terabyte, which places a huge burden on military communications networks.
  • Either way, it is the job of humans, not machines, to comb through most of that data and find the relevant bits of information.
  • At its core, the information revolution still comprises the same basic building blocks as when that term became a buzzword in the 1990s. It is the mutually reinforcing development of sensors (which collect information), computers (which process and store information), and networks (which move information). Because improvements in one of these technologies enable, and indeed require, progress in the other two, the resulting pace of change has been exponential.
  • military networks are like a medieval world of unpaved roads, handmade bridges, and checkpoints that inhibit more than facilitate the flow of information. The result is that most platforms and systems in the Department of Defense do not—indeed, cannot—connect to other platforms and systems, and certainly not easily, quickly, or reliably.
  • The world is now awash in low-cost, high-quality, and increasingly miniaturized sensors—electro-optical, infrared, radar, lidar, and radio-frequency sensors that enable machines to see, as well as acoustic sensors that enable machines like Alexa or Siri to hear everything.
  • As sensors are proliferating on Earth, they are also blanketing it in outer space.
  • Computer processing has been decentralized and pushed out to the edge of the network, creating an ever-expanding network of smart systems such as vehicles, appliances, and even entire homes that collect, process, and communicate information by virtue of being connected to everything else—the so-called Internet of Things.
  • For most military systems, the schedule for hardware updates determines the schedule for software updates. After all, most of the companies building these systems are hardware companies, not software companies.
  • This has created multiyear software development cycles that are doomed to failure.
  • Most of the Department of Defense is ill equipped to take advantage of machine learning in part because of how it deals with its own data.
  • Low-cost space launch has spawned a whole new industry in microsatellites.
  • In short, in just one decade commercial technology companies in California and elsewhere overturned many core assumptions about access to space, and they are now expanding the frontiers of the information revolution beyond Earth’s atmosphere.
  • A development with extraordinary military significance is additive manufacturing, which enables complex parts and even finished products to be printed in three dimensions using different kinds of materials, from low-cost plastics to carbon fiber to molten metals.
  • Quantum science runs contrary to the basic laws of physics, which is why Albert Einstein once called it “spooky.” But it has been demonstrably proven, and there is now a big commercial push to build new kinds of quantum-based information technologies.
  • When people in Washington and elsewhere wonder why more engineering talent and private capital are not flowing into defense technology, the reason is not more complicated than this: three decades of data suggest that if you want to start a successful and profitable new business, defense is not the place to do it (unless you are already a billionaire).
  • The companies that are most able to help are not always willing to do so, whereas the companies that are willing to help are not always able to do so.
  • Washington sacrificed speed and effectiveness in the military-industrial complex for the hope of cost savings and efficiency, and it ended up with neither.
  • Many of the “transformational” procurement programs of the 1990s and 2000s are arriving so late (if at all) that the old systems they were supposed to replace are simply aging out of the force with nothing to take their place.
  • The means to build a different and better US military have been consistently available and never more abundant than now, but too much money has been spent on old or unproven technologies in the pursuit of outdated or misguided conceptions of military power.
  • To a large extent, the reason the United States has been so badly ambushed by the future is because the main problem we are struggling to address is incredibly difficult. Can militaries innovate and change in the absence of war? Indeed, this is the core question as the United States looks to the future of warfare.
  • Militaries are unlike civilian institutions in many ways, but a primary difference is that they lack routine sources of real-world feedback on their performance.
  • Military innovation and adaptation are made more difficult because the nature of any bureaucracy is to resist change, not promote it.
  • For starters, real change requires the definition of clear threats. Militaries need to know with as much specificity as possible what operational problems they must solve through the development of new capabilities and new ways of fighting.
  • It is only when civilian leaders and military mavericks are aligned in favor of disrupting the status quo that real innovation becomes possible in the absence of war.
  • In reality, true military innovation is less about technology than about operational and organizational transformation.
  • China is becoming America’s peer, and it could become more than that.
  • What makes the Chinese Communist Party’s technological ambitions even more threatening to the United States is a major way that Beijing enacts them—through a systematic global campaign to capture the world’s best technology by whatever means necessary, which includes a massive foreign intelligence operation to steal trade secrets and intellectual property through cyber espionage and human spying.
  • when US technology companies refuse to work with the Department of Defense but then do business in China, the practical effect is denying technology to their own military while providing it, knowingly or otherwise, to China’s military.
  • The centerpiece of the Chinese Communist Party’s military buildup is the Chinese Navy.
  • China’s government exports advanced weapons and the tools of high-tech authoritarianism to aspiring police states that want to surveil their citizens, regulate their thoughts, and crush dissent.
  • The problem for the United States is that we have been building our military to project power and fight offensively for decades, while China has invested considerably in precision kill chains to counter the ability of the United States to project military power.
  • The main goal will be accelerating the ability to close the kill chain and break rivals’ ability to do so.
  • Hypersonic weapons are different because they can travel both fast and unpredictably.
  • Commercial technology companies likely will not be the source of hypersonic technologies for the US military.
  • New fiber lasers are much improved over older chemical lasers. Their beams are more concentrated and powerful.
  • Low-kilowatt lasers can now burn holes through drones or vehicle engines. And higher-kilowatt lasers are being developed for defense against aircraft and missiles.
  • The big hurdle that remains is power capacity. It takes a lot of power to fire directed energy weapons of any strength.
  • A shadow cyber war has raged for years, especially between America and its great-power rivals.
  • The broader significance is that the cyber domain and the electromagnetic spectrum will be central battlegrounds of future war.
  • A major threat to the F-35 is not just enemy missiles but also the possibility that it could be cyberattacked before it ever gets off the ground.
  • The application of artificial intelligence will open a whole new front in the cyber arms race that focuses on the corruption or poisoning of data. Artificial intelligence is only as good as the data that trains its algorithms.
  • As classical computers reach the physical limits of their power, quantum computers could become vital to processing all of the data that intelligentized militaries create and collect.
  • the moment of quantum supremacy is drawing near.
  • An enabling capability that may have more immediate military impacts is biotechnology, which is already unlocking better understanding of human genetics and enabling the creation of customized treatments and technologies to augment human capabilities.
  • Developments in biotechnology will mostly be extensions of current practices, albeit significant extensions.
  • In the competition over biotechnology, it is hard to believe that the United States would cross certain ethical lines, but it is less clear whether the same can be said of the Chinese Communist Party.
  • New space-based capabilities will be central to how militaries command and control their forces.
  • Spacecraft have always been limited by the impracticality of refueling them.
  • In the coming years, it will be possible to service, assemble, and manufacture complex orbital infrastructure in space that would be impractical to launch from Earth.
  • In time, space will be transformed into a unique domain of human activity, and this will inevitably have military implications.
  • Of all the new enabling technologies, perhaps the most consequential from a military standpoint is artificial intelligence and machine learning.
  • The US military is drowning in data.
  • Humans will eventually be able to delegate much of the cognitive burden of closing the kill chain to well-trained intelligent machines, thereby enabling people to focus on making better and faster decisions in warfare.
  • Though 5G networks will be critical for broader economic and geopolitical purposes, communications networks are really just pipes for information.
  • The greater danger for the United States is failing to recognize the true gravity of the kind of military technology race with the Chinese Communist Party that we are facing and falling behind because of our lack of urgency to run it.
  • The real issue now and for the foreseeable future is the military use of narrow artificial intelligence.
  • If we choose not to weaponize technologies such as artificial intelligence, that does not mean that our competitors will follow suit and be bound by the same choices.
  • In time, intelligent machines should not just enhance manned platforms; they should replace them.
  • A battle network is the means by which militaries close the kill chain. It is what enables them to understand, decide, and act.
  • The problem is not that the US military is on the verge of taking humans “out of the loop” of the kill chain but that the US military today has way too many loops and way too many humans in the middle of all of them.
  • The US military today is simply much slower and less effective than it could or should be at doing the one thing that will determine its success or failure—closing the kill chain.
  • The most important objective is for the battle network to facilitate human understanding, decisions, and actions.
  • The critical source of future military advantage will be the ability to impose so many complex dilemmas on our opponents at once that we shatter their kill chains, disrupt their ability to command and control their own forces, and leave them incapable of understanding what is happening, making sound decisions, and taking relevant actions.
  • Putting people in machines makes them significantly more complex and expensive.
  • Hiding from overhead surveillance will become infinitely harder as the heavens are filled with thousands of small satellites in the coming years.
  • Militaries in the future will have little hope of hiding large traditional ships, aircraft, or ground force movements.
  • hiding is becoming significantly harder, and militaries will need to search for new ways to conceal themselves beyond their traditional capabilities such as stealth.
  • The speed of future military movement will accelerate further as more and more military things travel at hypersonic speeds, which is more than five times the speed of sound. Movement at these speeds will transform the timing and tempo of warfare.
  • Logistics has been the greatest limiting factor in the history of warfare. Hence the old saying: “Amateurs talk tactics; professionals talk logistics.”
  • Moving to and from space will become cheaper, easier, and more common, which means that militaries could eventually come to view space travel as little different from flying or sailing around the planet.
  • Shooting has consistently and considerably improved over time. But success is always a function of three factors that do not change: the range of fire (how far militaries can shoot), the accuracy of fire (how well they can hit what they are shooting at), and the effect of fire (how much damage they can do).
  • The improved range, accuracy, and effects of fire have already created considerable advantages for defenders over attackers, and emerging technologies will likely further this trend.
  • The laws of physics, geography, and economics apply little or not at all to cyber and other non-kinetic weapons.
  • Safe areas and sanctuaries will disappear. Everywhere will be contested and within range of enemy fires—even the US homeland.
  • The goal of a Military Internet of Things is ubiquity—the ability of any sensor to enable any weapon to strike any kind of target at any time.
  • As 3-D printing improves, however, military forces will be able to print more of their own ammunition near the battlefield.
  • Communications are the links in any military’s kill chain.
  • The new model of military communications will not be built around small numbers of centralized hubs but rather will push critical communications functions out to the edges of vast networks that are physically distributed, more secure, less vulnerable, and more resilient.
  • Ubiquitous space-based communications networks will provide persistent access to information even in the most remote parts of the world.
  • Machine behavior depends on the integrity of the data that trains the machines’ algorithms.
  • The United States should assume that China, in particular, is racing to gain advantage in the same competitions, with the same—and, at times, better—technologies, and that the result could be a future Chinese military that shares most if not all of the same core capabilities and characteristics as our military could have.
  • In short, a lot of people are saying a lot of the right things. But the main problem in recent decades has not been a failure to say the right things. It has been a failure to do enough of those right things.
  • America’s strategic margin for error has disappeared.
  • It is difficult to overstate what a complete anomaly the past three decades have been in the broad sweep of world history. This era of unrivaled American dominance stands in marked contrast to the rest of history, which has always been characterized instead by great-power competitions.
  • What we have not considered, however, is that a foreign competitor would be willing or able to target the continental United States with large numbers of conventional weapons.
  • We optimized the US military to project power overseas.
  • The United States cannot and should not contest every difference that it has with China militarily. To the contrary, US leaders will have to determine what our nation’s core interests really are.
  • US thinking about warfare must shift from an offensive to a defensive mind-set. In short, America needs to put the “defense” back in our defense strategy.
  • If the United States develops a new, defensive way of war that is focused less on projecting military power than on countering the ability of others to do so, we could create the same dilemmas for our competitors that we are facing.
  • The United States needs to build a different kind of military.
  • Our focus must be on building and buying integrated networks of kill chains, not individual platforms and systems.
  • Similarly, rather than expensive systems that are effectively irreplaceable, the future force should be built around lower-cost systems that are effectively expendable. If US systems are cheap to build, operate, and replenish, we would be more willing and able to lose them.
  • People are expensive. Putting people in machines is even more expensive. And no one ever wants to pay the ultimate price of losing a human life.
  • Manned systems will not fare well on future battlefields, which will be extremely violent with heavy losses on all sides.
  • Finally, the future force must be defined more by its software than its hardware. It must be, in every way, a digital force. This is a total inversion of how military power has forever been conceived.
  • What traditionally wins wars is hardware. It is iron and steel.
  • The goal is to acquire whatever combination of smart systems adds up to a superior capability that enables humans to understand, decide, and act.
  • What Trump gets wrong is that the United States does not have allies because we are suckers. We have allies because it benefits America. We want allies because it is better than being alone. We need allies because maintaining a favorable balance of power is not possible without them.
  • The main question is not whether the US military should change but whether we can change—and change fast enough.
  • Think of the budget process as the opposite of the kill chain. Whereas the kill chain is supposed to be fast, meticulous, and uncompromising in its precision, the budget process is slow, tedious, unruly, and defined by messy, imperfect compromises. And yet both are essential.
  • If you want to know what leaders in Washington really value, what they say matters a lot less than what they spend money on. Spending is what reveals their true priorities—what matters most.
  • What precedes the budget process is “the requirements process,” and what follows it is “the acquisition process.”
  • The requirements process is how the Department of Defense determines what constitutes a “validated” military capability to develop or buy.
  • Those who have the authority to do things differently rarely use it, and those who do make decisions often lack the authority and incentives to make riskier decisions to get better outcomes.
  • The requirements process and the acquisition process often impede good outcomes. But the bigger problem is that we spend too much money on the wrong things and not enough on the right things. And that has more to do with the budget process.
  • Most of the incentives that govern the Pentagon’s bureaucracy favor the past over the future.
  • Defense lobbyists are a convenient scapegoat. But the real problem is not that a handful of big defense contractors have a loud voice in the budget process. The real problem is that so few defense companies are left in America after decades of defense industry consolidation, that so few of the remaining companies are leaders in emerging technologies, and that those which are doing this futuristic work for the US military have little to no voice in the budget process.
  • In Congress, less than 1 percent of members have studied computer science, and few have meaningful experience working in the technology industry.
  • The shift to emerging technologies in place of existing systems could happen much faster than most people in the defense establishment realize, and the backlash could be severe.
  • A good idea rarely wins on its merits alone. Its success too often comes down, instead, to the trading of favors and the political dark arts.
  • There are no technological miracles or deus ex machina to save us.
  • Translating vague, buzzwordy goals into clear operational problems is necessary for US leaders to create the incentives that can generate better, more relevant capabilities for the US military much faster.
  • The Department of Defense rarely uses mission-focused competitions to identify the best solutions in the way that has proven so effective in the commercial world.
  • companies that want to build a different kind of military cannot expect to win strictly by the quality of their new solutions alone.
  • There is a reason why parts of the F-35 are built in every state in America, and it is not business efficiency. It is political expediency.
  • If we want different and better outcomes, we have to create different and better incentives to get them.
  • We have so many decent, hardworking, dedicated people. We have such amazing technology in our country. We have all the money we need. The bigger problem, however, remains: we just cannot get out of our own way.
  • Our failure to adapt will not stop others from doing so. If America does not change itself, change will still happen.

                                                                                                                                                                                                                                                                                                                                        20210411

                                                                                                                                                                                                                                                                                                                                        Designing Data-Intensive Applications by Martin Kleppmann

                                                                                                                                                                                                                                                                                                                                        • Many applications today are data intensive, as opposed to compute-intensive. Raw CPU power is rarely a limiting factor for these applications--bigger problems are usually the amount of data, the complexity of data, and the speed at which it is changing.
                                                                                                                                                                                                                                                                                                                                        • A data-intensive application is typically built from standard building blocks that provide commonly needed functionality.
                                                                                                                                                                                                                                                                                                                                        • A fault is usually defined as one component of the system deviating from its spec, whereas a failure is when the system as a whole stops providing the required service to the user.
                                                                                                                                                                                                                                                                                                                                        • It is impossible to reduce the probability of a fault to zero; therefore it is usually best to design fault-tolerance mechanisms that prevent faults from causing failures.
                                                                                                                                                                                                                                                                                                                                        • Many critical bugs are actually due to poor error handling; by deliberately inducing faults, you ensure that the fault tolerance machinery is continually exercised and tested, which can increase your confidence that faults will be handled correctly when they occur naturally.
                                                                                                                                                                                                                                                                                                                                        • Design systems in a way that minimize opportunities for error.
                                                                                                                                                                                                                                                                                                                                        • Some systems are elastic, meaning that they can automatically add computing resources when they detect a load increase, whereas other systems are scaled manually.
                                                                                                                                                                                                                                                                                                                                        • An elastic system can be useful if load is highly unpredictable, but manually scaled systems are similar and may have fear operation surprises.
                                                                                                                                                                                                                                                                                                                                        • One of the best tools we have for removing accidental complexity is abstraction. A good abstraction can hide a great deal of implementation detail behind a clean, simple-to-understand facade.
                                                                                                                                                                                                                                                                                                                                        • Data models are perhaps the most important part of developing software, because they have such a profound effect: not only on how the software is written, but also on how we think about the problem that we are solving.
                                                                                                                                                                                                                                                                                                                                        • Most applications are built by layering one data model on top of another. For each layer, the key question is: how is it represented in terms of the next-lower layer?
                                                                                                                                                                                                                                                                                                                                        • MapReduce is a programming model for processing large amounts of data in bulk across many machines.
                                                                                                                                                                                                                                                                                                                                        • The Datalog approach requires a different kind of thinking to the other query languages discussed in this chapter, but it’s a very powerful approach, because rules can be combined and reused in different queries. It’s less convenient for simple one-off queries, but it can cope better if your data is complex.
                                                                                                                                                                                                                                                                                                                                        • Document databases target use cases where data comes in self-contained documents and relationships between one document and another are rare.
                                                                                                                                                                                                                                                                                                                                        • Graph databases go in the opposite direction, targeting use cases where anything is potentially related to everything.
                                                                                                                                                                                                                                                                                                                                        • On the most fundamental level, a database needs to do two things: when you give it some data, it should store the data, and when you ask it again later, it should give the data back to you.
                                                                                                                                                                                                                                                                                                                                        • In order to efficiently find the value for a particular key in the database, we need a different data structure: an index.
                                                                                                                                                                                                                                                                                                                                        • An index is an additional structure that is derived from the primary data. Many databases allow you to add and remove indexes, and this doesn’t affect the contents of the database; it only affects the performance of queries.
                                                                                                                                                                                                                                                                                                                                        • Key-value stores are quite similar to the dictionary type that you can find in most programming languages, and which is usually implemented as a hash map.
                                                                                                                                                                                                                                                                                                                                        • The simplest possible indexing strategy is this: keep an in-memory hash map where every key is mapped to a byte offset in the data file--the location at which the value can be found. Whenever you append a new key-value pair to the file, you also update the hash map to reflect the offset of the data you just wrote. When you want to look up a value, use the hash map to find the offset in the data file, seek to that location, and read the value.
                                                                                                                                                                                                                                                                                                                                        • An append-only log seems wasteful at first glance: why don’t you update the file in place, overwriting the old value with the new value? But an append-only design turns out to be good for several reasons.
                                                                                                                                                                                                                                                                                                                                        • Appending and segment merging are sequential write operations, which are generally much faster than random writes, especially on magnetic spinning-disk hard drives.
                                                                                                                                                                                                                                                                                                                                        • Concurrency and crash recovery are much simpler if segment files are append-only or immutable.
                                                                                                                                                                                                                                                                                                                                        • Merging old segments avoids the problem of data files getting fragmented over time.
                                                                                                                                                                                                                                                                                                                                        • A full-text index is much more complex than a key-value index but is based on a similar idea: given a word in a search query, find all the documents that mention the word. This is implemented with a key-value structure where the key is a word and the value is the list of IDs of all the documents that contain the word.
                                                                                                                                                                                                                                                                                                                                        • A Bloom filter is a memory-efficient data structure for approximating the contents of a set. It can tell you if a key does not appear in the database, and thus saves many unnecessary disk reads for nonexistent keys.
                                                                                                                                                                                                                                                                                                                                        • The basic idea of LSM-trees--keeping a cascade of SSTables that are merged in the background--is simple and effective.
                                                                                                                                                                                                                                                                                                                                        • B-trees have stood the test of time very well. They remain the standard index implementation in almost all relational databases, and many non relational databases use them too.
                                                                                                                                                                                                                                                                                                                                        • Like SSTables, B-trees keep key-value pairs sorted by key, which allows efficient key-value lookups and range queries.
                                                                                                                                                                                                                                                                                                                                        • In write-heavy applications, the performance bottleneck might be the rate at which the database can write to disk.
                                                                                                                                                                                                                                                                                                                                        • A primary key uniquely identifies one row in a relational table, or one document in a document database, or one vertex in a graph database.
                                                                                                                                                                                                                                                                                                                                        • It is also very common to have secondary indexes. In relational databases, you can create several secondary indexes on the same table [...] and they are often crucial for performing joins efficiently.
                                                                                                                                                                                                                                                                                                                                        • The key in an index is the thing that queries search for, but value can be one of two things: it could be the actual row (document, vertex) in question, or it could be a reference to the row stored elsewhere.
                                                                                                                                                                                                                                                                                                                                        • The heap file approach is common because it avoids duplicating data when multiple secondary indexes are present: each index just references a location in the heap file, and the actual data is kept in one place.
                                                                                                                                                                                                                                                                                                                                        • As RAM becomes cheaper, the cost-per-gigabyte argument is eroded. Many datasets are simply not that big, so it’s quite feasible to keep them entirely in memory, potentially distributed across several machines. This has led to the development of in-memory databases.
                                                                                                                                                                                                                                                                                                                                        • When an in-memory database is restarted, it needs to reload its state, either from disk or over the network from a replica.
                                                                                                                                                                                                                                                                                                                                        • A data warehouse is a separate database that analysts can query to their hearts’ content, without affecting OLTP operations. The data warehouse contains a read-only copy of the data in all the various OLTP systems in the company.
                                                                                                                                                                                                                                                                                                                                        • The big advantage of using a separate data warehouse, rather than querying OLTP systems directly for analytics, is that the data where can be optimized for analytic access patterns.
                                                                                                                                                                                                                                                                                                                                        • The name “star schema” comes from the fact that when the table relationships are visualized, the fact table is in the middle, surrounded by its dimension tables; the connections to these tables are like the rays of a star.
                                                                                                                                                                                                                                                                                                                                        • The idea behind column-oriented storage is simple: don’t store all the values from one row together, but store all the values from each column together instead. If each column is stored in a separate file, a query only needs to read and parse those columns that are used in that query, which can save a lot of work.
                                                                                                                                                                                                                                                                                                                                        • Log-structured storage engines are a comparatively recent development. Their key idea is that they systematically turn random-access writes into sequential writes on disk, which enables higher write throughput due to the performance characteristics of hard drives and SSDs.
                                                                                                                                                                                                                                                                                                                                        • In most cases, a change to an application’s features also requires a change to data that it stores: perhaps a new field or record type needs to be captured, or perhaps existing data needs to be presented in a new way.
                                                                                                                                                                                                                                                                                                                                        • Many programming languages come with built-in support for encoding in-memory objects into byte sequences.
                                                                                                                                                                                                                                                                                                                                        • CSV does not have any schema, so it is up to the application to define the meaning of each row and column. If an application change adds a new row or column, you have to handle that change manually.
                                                                                                                                                                                                                                                                                                                                        • The difficulty of getting different organizations to agree on anything outweighs most other concerns.
                                                                                                                                                                                                                                                                                                                                        • Apache Thirst and Protocol Buffers are binary encoding libraries that are based on the same principle. Protocol Buffers was originally developed at Google, Thrift was originally developed at Facebook, and both were made open source in 07-08. Both Thrift and Protocol Buffers require a scheme for any data that is encoded.
                                                                                                                                                                                                                                                                                                                                        • A key design goal of a service-oriented/microservices architecture is to make the application easier to change and maintain by making services independently deployable and evolvable.
                                                                                                                                                                                                                                                                                                                                        • REST is not a protocol, but rather a design philosophy that builds upon the principles of HTTP. It emphasizes simple data formats, using URLs for identifying resources and using HTTP features for cache control ,authentication, and content type negotiation.
                                                                                                                                                                                                                                                                                                                                        • The detailed delivery semantics vary by implementation and configuration, but in general, message brokers are used as follows: one process sends a message to a named queue or topic, and the broker ensures that the message is delivered to one or more consumers of or subscribers to that queue or topic. There can be many producers and many consumers on the same topic.
                                                                                                                                                                                                                                                                                                                                        • If all you need is to scale to higher load, the simplest approach is to buy a more powerful machine (sometimes called vertical scaling or scaling up). Many CPUs, many RAM chips, and many disks can be joined together under one operating system, and a fast interconnect allows any CPU to access any part of the memory or disk. In this kind of shared-memory architecture, all the components can be treated as a single machine.
                                                                                                                                                                                                                                                                                                                                        • Being able to reboot individual nodes without downtime is a big advantage for operations and maintenance. Thus, our goal is to keep the system as a whole running despite individual node failures, and to keep the impact of a node outage as small as possible.
                                                                                                                                                                                                                                                                                                                                        • Despite being a simple goal--keeping a copy of the same data on several machines--replication turns out to be a remarkably tricky problem. It requires carefully thinking about concurrency and about all the things that can go wrong, and dealing with the consequences of those faults.
                                                                                                                                                                                                                                                                                                                                        • The main reason for wanting to partition data is scalability. Different partitions can be placed on different nodes in s shared-nothing cluster. Thus, a large dataset can be distributed across many disks, and the query load can be distributed across many processors.
                                                                                                                                                                                                                                                                                                                                        • The simplest approach for avoiding hot spots would be to assign records to nodes randomly. That would distribute the data quite evenly across the nodes, but it has a big disadvantage: when you’re trying to read a particular item, you have no way of knowing which node it is on, so you have to query all nodes in parallel.
                                                                                                                                                                                                                                                                                                                                        • A good hash function takes skewed data and makes it uniformly distributed.
                                                                                                                                                                                                                                                                                                                                        • For partitioning purposes, the hash function need not be cryptographically strong.
                                                                                                                                                                                                                                                                                                                                        • Partitioning is necessary when you have so much data that storing and processing it on a single machine is no longer feasible.
                                                                                                                                                                                                                                                                                                                                        • In general, atomic reference to something that cannot be broken down into smaller parts.
                                                                                                                                                                                                                                                                                                                                        • A transaction is usually understood as a mechanism for grouping multiple operations on multiple objects into one unit of execution.
                                                                                                                                                                                                                                                                                                                                        • A key feature of a transaction is that it can be aborted and safely retried if an error occurred. ACID databases are based on this philosophy: if the database is in danger of violating its guarantee of atomicity, isolation, or durability, it would rather abandon the transaction entirely than allow it to remain half-finished.
                                                                                                                                                                                                                                                                                                                                        • If two transactions don’t touch the same data, they can safely be run in parallel, because neither depends on the other.
                                                                                                                                                                                                                                                                                                                                        • The simplest way of avoiding concurrency problems is to remove the concurrency entirely: to execute only one transaction at a time, in serial order, on a single threat. By doing so, we completely sidestep the problem of detecting and preventing conflicts between transactions: the resulting isolation is by definition serializable.
                                                                                                                                                                                                                                                                                                                                        • Transactions are an abstraction layer that allows an application to pretend that certain concurrency problems and certain kinds of hardware and software faults don’t exist.
                                                                                                                                                                                                                                                                                                                                        • A large class of errors is reduced down to a simple transaction abort, and the application just needs to try again.
                                                                                                                                                                                                                                                                                                                                        • This nondeterminism and possibility of partial failures is what makes distributed systems hard to work with.
                                                                                                                                                                                                                                                                                                                                        • With these philosophies come very different approaches to handling faults.
                                                                                                                                                                                                                                                                                                                                        • The bigger a system nuggets, the more likely it is that one of its components is broken. Over time, broken things get fixed and new things break, but in a system with thousands of nodes, it is reasonable to assume that something is always broken.
                                                                                                                                                                                                                                                                                                                                        • When the error handling strategy consists of simply giving up, a large system can end up spending a lot of its time recovering from faults rather than doing useful work.
                                                                                                                                                                                                                                                                                                                                        • If we want to make distributed systems work, we must accept the possibility of partial failure and build fault-tolerance mechanisms into the software. In other words, we need to build a reliable system from unreliable components.
                                                                                                                                                                                                                                                                                                                                        • When one part of the network is cut off from the rest due to a network fault, that is sometimes called a network partition or net-split.
                                                                                                                                                                                                                                                                                                                                        • Rapid feedback about a remote node being down is useful, but you can’t count on it. [...] If you want to be sure that a request was successful, you need a positive response from the application itself.
                                                                                                                                                                                                                                                                                                                                        • UDP is a good choice in situations where delayed data is worthless.
                                                                                                                                                                                                                                                                                                                                        • In a distributed system, time is a tricky business, because communication is not instantaneous: it takes time for a message to travel across the network from one machine to another.
                                                                                                                                                                                                                                                                                                                                        • A time-of-day clock does what you intuitively expect of a clock: it returns the current date and time according to some calendar.
                                                                                                                                                                                                                                                                                                                                        • A monotonic clock is suitable for measuring a duration (time interval), such as timeout or a service’s response time.
                                                                                                                                                                                                                                                                                                                                        • Monotonic clocks don’t need synchronization, but time-of-day clocks need to be set according to an NTP server or other external time source in order to be useful.
                                                                                                                                                                                                                                                                                                                                        • Thus, if you use software that requires synchronized clocks, it is essential that you also carefully monitor the clock offsets between all the machines. Any node whose clock drifts too far from the others should be declared dead and removed from the cluster. Such monitoring ensures that you notice the broken clock before they can cause too much damage.
                                                                                                                                                                                                                                                                                                                                        • A node in a distributed system must assume that its execution can be paused for a significant length of time at any point, even in the middle of a function. During the pause, the rest of the world keeps moving and may even declare the paused node dead because it’s not responding. Eventually, the paused node may continue running, without even noticing that it was asleep until it checks its clock sometime later.
                                                                                                                                                                                                                                                                                                                                        • In embedded systems, real-time means that a system is carefully designed and tested to meet specified timing guarantees in all circumstances.
                                                                                                                                                                                                                                                                                                                                        • Providing real-time guarantees in a system requires support from all levels of the software stack.
                                                                                                                                                                                                                                                                                                                                        • For most server-side data processing systems, real-time guarantees are simply not economical or appropriate. Consequently, these systems must suffer the pauses and clock instability that come from operating in a non-real-time environment.
                                                                                                                                                                                                                                                                                                                                        • The moral of these stories is that a node cannot necessarily trust its own judgement of a situation. A distributed system cannot exclusively rely on a single node, because a node may fail at any time ,potentially leaving the system stuck and unable to recover.
                                                                                                                                                                                                                                                                                                                                        • If a quorum of nodes declares another node dead, then it must be considered dead, even if that node still very much feels alive. The individual node must abide by the quorum decision and step down.
                                                                                                                                                                                                                                                                                                                                        • To tolerate faults, the first step is to detect them, but even that is hard. Most systems don’t have an accurate mechanism of detecting whether a node has failed, so most distributed algorithms rely on timeouts to determine whether a remote node is still available.
                                                                                                                                                                                                                                                                                                                                        • If you can avoid opening Pandora’s box and simply keep things on a single machine, it is generally worth doing so.
                                                                                                                                                                                                                                                                                                                                        • The best way of building fault-tolerant systems is to find some general-purpose abstractions with useful guarantees, implement them once, and then let applications rely on those guarantees.
                                                                                                                                                                                                                                                                                                                                        • One of the most important abstractions for distributed systems is consensus: that is, getting all of the nodes to agree on something.
                                                                                                                                                                                                                                                                                                                                        • Most replicated databases provide at least eventual consistency, which means that if you stop writing to the database and wait for some unspecified length of time, then eventually all read requests will return the same value.
                                                                                                                                                                                                                                                                                                                                        • A better name for eventual consistency may be convergence, as we expect all replicas to eventually converge to the same value.
                                                                                                                                                                                                                                                                                                                                        • The basic idea behind linearizability is simple: to make a system appear as if there is only a single copy of the data.
                                                                                                                                                                                                                                                                                                                                        • Consensus is one of the most important and fundamental problems in distributed computing.
                                                                                                                                                                                                                                                                                                                                        • Surprisingly many data analyses can be done in a few minutes using some combination of awk, sed, grep, sort, uniq, and xargs, and they perform surprisingly well.
                                                                                                                                                                                                                                                                                                                                        • The main difference from pipelines of Unix commands is that MapReduce can parallelize a computation across many machines, without you having to write code to explicitly handle the parallelism.
                                                                                                                                                                                                                                                                                                                                        • In the Unix world, the uniform interface that allows one program to be composed with another is files and pipes; in MapReduce, that interface is a distributed file system.
                                                                                                                                                                                                                                                                                                                                        • In general, a “stream” refers to data that is incrementally made available over time.
                                                                                                                                                                                                                                                                                                                                        • There is no single system that can satisfy all data storage, querying, and processing needs. In practice, most nontrivial applications need to combine several different technologies in order to satisfy their requirements.
                                                                                                                                                                                                                                                                                                                                        • Conventional search engines first index the documents and then run queries over the index. By contrast, searching a stream turns the processing on its head: the queries are stored, and the documents run past the queries, like in CEP.
                                                                                                                                                                                                                                                                                                                                        • Actor frameworks are primarily a mechanism for managing concurrency and distributed execution of communication modules, whereas stream processing is primarily a data management technique.
                                                                                                                                                                                                                                                                                                                                        • One solution is to break the stream into small blocks, and treat each block like a miniature batch process. This approach is called micro batching, and it is used in Spark Streaming.
                                                                                                                                                                                                                                                                                                                                        • An idempotent operation is one that you can perform multiple times, and it has the same effect as if you performed it only once.
                                                                                                                                                                                                                                                                                                                                        • Even if an operation is not naturally idempotent, it can often be made idempotent with a bit of extra metadata.
                                                                                                                                                                                                                                                                                                                                        • A recurring theme in this book has been that for any given problem, there are several solutions, all of which have different pros, cons, and trade-offs.
                                                                                                                                                                                                                                                                                                                                        • Thus, the most appropriate choice of software tool also depends on the circumstances. Every piece of software, even a so-called “general-purpose” database, is designed for a particular usage pattern.