7 Disciplines

7.1 Keeping focus on results

Hacks to make one’s work effect-oriented and satisfying.

7.1.1 Qutebrowser

Configuration file of ~/.config/qutebrowser/config.py:

c.content.host_blocking.lists = [
  'https://raw.githubusercontent.com/StevenBlack/hosts/master/alternates/social/hosts'
]

config.bind(',h', 'config-cycle -t -p content.host_blocking.enabled')

c.url.start_pages = ["about:blank"]

c.url.searchengines = {
  "DEFAULT": "https://google.com/search?q={}"
}

Setting the default search engine: :set url.searchengines '{"DEFAULT": "https://google.com/search?q={}"}'.

Save to Zotero with a press of the z key: bind the key z to the script using the following command called directly in Zotero:

bind z jseval javascript:var d=document,s=d.createElement('script');s.src='https://www.zotero.org/bookmarklet/loader.js';(d.body?d.body:d.documentElement).appendChild(s);void(0);.

7.1.2 Firefox

7.1.2.1 Clean browsing history and cache

Press: [Ctrl]+[Shift]+[Del].

7.1.2.2 Block obtrusive content

To block hot network questions, go to: uBlock Origin -> Open the dashboard -> Add a rule ###hot-network-questions -> click “Apply changes”.

More useful uBlock Origin filters:

! StackExchange Network
###hot-network-questions

! 4/27/2018, 1:08:35 PM https://medium.com/
! Medium Corporation subscription nag footer
##.js-stickyFooter

! 6/21/2018, 10:55:40 AM https://www.youtube.com/
! YouTube video related content
www.youtube.com###related

! 6/26/2018, 11:39:21 AM https://www.youtube.com/
! YouTube welcome page recommended rubbish
www.youtube.com###dismissable

You might find a network-wide ad-blocker useful. In such a case, see Why You Need a Network-Wide Ad-Blocker for the Pi-hole package.

7.1.2.3 Browsing

Browse tabs as a tree: https://github.com/piroor/treestyletab.

To toggle the sidebar, press [F1].

about:config settings for privacy and performance:

about:config

7.1.3 Fetch Web information through your terminal

7.1.3.1 Wikipedia

Search Wikipedia from terminal: wikit <query>; install with npm install -g wikit.

7.1.3.2 Google

Google quickly from command line

sudo add-apt-repository ppa:twodopeshaggy/jarun
sudo apt-get update
sudo apt-get install googler

$ googler <query>

7.1.3.3 Check your external IP

BLAZINGLY FAST, directly from your terminal emulator. We are ultra-grateful to Tomasz “Sztylet” for every minute we saved thanks to this.

$ curl ifconfig.co

7.1.3.4 Check weather via console

curl wttr.in/warsaw

7.1.3.5 Instant URLs

Google Feeling Lucky: http://google.com/search?btnI=1&q=<query>
Encyclopedia Britannica:
- britannica.com/topic/<query>
- https://www.britannica.com/search?query=<query>

7.1.4 Web browsers

7.1.4.1 Start in a private window

Firefox: firefox --private-window
Opera: opera --private

7.1.5 Filter copycat websites from search results

https://github.com/quenhus/uBlock-Origin-dev-filter

7.1.6 Smartphone SSH access

Connect to your phone via terminal with Termux:

ssh any_user_name@phone_ip -p 8022

7.2 Nature

Constraints we observe in nature.

7.2.1 Euler’s identity

“The most beautiful equation in mathematics”:

\[e^{i*pi} + 1 = 0\]

“like a Shakespearean sonnet that captures the very essence of love, or a painting that brings out the beauty of the human form that is far more than just skin deep, Euler’s equation reaches down into the very depths of existence

– Keith Devlin, Stanford, see Wikipedia

7.2.2 The Dirac Delta equation

\[(i * delta - m) * psi = 0\]

7.2.3 Gravity of a photon

\[R_{\mu\nu} - \frac{1}{2}Rg_{\mu\nu} + \Lambda g_{\mu\nu} = \frac{8\pi G}{c^4}T_{\mu\nu} \quad\quad\quad(1)\]

\[T^{\mu\nu} = \frac{1}{\mu_0}\left[F^{\mu\alpha}F^{\nu}{}_{\alpha} - \frac{1}{4} g^{\mu\nu}F_{\alpha\beta}F^{\alpha\beta} \right] \quad\quad\quad(2)\]

\[F^{\mu\nu} = \begin{bmatrix} 0 & -E^x & -E^y & -E^z \\ E^x & 0 & -B^z & B^y \\ E^y & B^z & 0 & -B^x \\ E^z & -B^y & B^x & 0 \\ \end{bmatrix} \quad\quad\quad(3)\]

Thus, equation (2) tells us how the electromagnetic fields we are familiar with, namely EE and BB, contribute to the energy density of a region of spacetime. Then equation (1) builds on that result to relate the electromagnetic fields to the curvature of spacetime, which as Einstein revealed, manifests as the gravitational field. So yes, the conventional electromagnetic fields, and the photons that constitute them, impact the gravitational field despite having no rest mass!

– James W. Kennington, “Gravity of a Photon”, https://jwkennington.com/blog/gravity-of-a-photon/

7.2.4 Weather forecasting

Meteo and awiacja.imgw are two places where pilots usually check the weather.

Info thanks to Dorota. Thank you, Dorota!

7.2.5 Greek alphabet

The twenty-four letters of the Greek alphabet are:

\[\alpha \beta \gamma\]

etc.

The full list is available here.

With their names:

Letter	Spelling
A a

Source: https://en.wikipedia.org/wiki/Greek_alphabet

7.2.6 Calculus

The Toledan Tables, or Tables of Toledo, were astronomical tables which were used to predict the movements of the Sun, Moon and planets relative to the fixed stars. They were completed around year 1080 by a group of Arabic astronomers at Toledo, Spain.

– https://en.wikipedia.org/wiki/Toledan_Tables

7.3 Mind: Develop better as a programmer

7.3.1 Retype instead of copy-pasting

I was able to quickly remember what I retyped before. Speeded up my work.

7.3.2 Assume responsibility

Take decisions fast and assume responsibility for yourself, your team and your client.

Stop worrying about future decisions and dive in. Make practice fun by treating new skills like toys. Find time to code by only making tiny commitments the way you would with sites like Facebook, YouTube, or Wikipedia. Slow down, take smaller steps, and you’ll learn faster.

More specifically:

Don’t Let Future Decisions Stop You from Progressing Now,
Don’t Let Confidence Trick You into Forgetting Things,
Approach Practice with the Right Mindset,
Find Time to Code Using the Facebook Trick,
Think Slower and You’ll Learn Faster,
Write Complex Code in Plain Language First.

– Yaphi Berhanu ²⁰

7.3.3 Ignitory question

Am I inventing things to do to avoid the important?

– Tim Ferriss, “The 4-Hour Work Week”

7.3.4 Specify clear goals

Remember the SMART rule - a goal should basically be:

Specific,
Measurable,
Ambitious,
Relevant, and
Time-bound.

7.3.5 Make growth a daily routine

Start the day with 2-3 hours of deep work (see “Deep Work” by Cal Newport),
Postpone checking your e-mail until near the end of the day.
Conclude the day with a review of the day (see “Deep Work”) and a quick skim through the headlines on the Hacker News (optional; see “4-Hour Work Week” - news are not at all necessary to thrive, let alone to survive).

7.3.6 Understand what school is ‒ and what it isn’t

I always liked numbers, and patterns, and logic. Things are very black-and-white where there’s one right answer and everything else is wrong. I didn’t like subjective, shades-of-gray-type questions.

I would work on math workbooks for fun. If my parents wanted to shut me up, she would just give me a workbook and I’ll just go do sums and so forth.

I always liked mathematics competitions. Doing that was very different from doing research mathematics.

The type of problems that you’re given in a problem book are very canned problems, things you can do in five minutes, or ten minutes. They don’t prepare you completely for a research problem, where you have to spend six months, you have to read the literature, talk to people, try something: doesn’t work. Modify, try it again.

It’s a very different experience doing research, but I like it a lot better, actually, than all the puzzles I used to do as a kid. I don’t do these things very much anymore.

‒ Terry Tao ²¹

Terry Tao links to several articles from the menu on his website ²².

When you browse any article on that website, including the main page, you’ll see that list on the left.

John kept wondering: is this list that important that Terry would like a visitor to any of his subpages to see it?

He read one article and he realized: yes, it seems so.

The title of the article was “What You’ll Wish You’d Known”.

Reading that around the time he was preparing his master thesis, he understood a number of things.

If you haven’t read it yet, he would highly recommend it, just like Terry does.

Afterwards, you will never look at education the same way.

I’ll start by telling you something you don’t have to know in high school: what you want to do with your life. People are always asking you this, so you think you’re supposed to have an answer. But adults ask this mainly as a conversation starter. They want to know what sort of person you are, and this question is just to get you talking. They ask it the way you might poke a hermit crab in a tide pool, to see what it does.

‒ Paul Graham, “What You’ll Wish You’d Known” ²³

7.4 Software Engineering

7.4.1 Pragmatic Programmer’s Highlights

Care About Your Craft Why spend your life developing software unless you care about doing it well?,
Think! About Your Work Turn off the autopilot and take control. Constantly critique and appraise your work.,
Provide Options, Don’t Make Lame Excuses Instead of excuses, provide options. Don’t say it can’t be done; explain what can be done.,
Don’t Live with Broken Windows Fix bad designs, wrong decisions, and poor code when you see them.,
Be a Catalyst for Change You can’t force change on people. Instead, show them how the future might be and help them participate in creating it.,
Remember the Big Picture Don’t get so engrossed in the details that you forget to check what’s happening around you.,
Make Quality a Requirements Issue Involve your users in determining the project’s real quality requirements.,
Invest Regularly in Your Knowledge Portfolio Make learning a habit.,
Critically Analyze What You Read and Hear Don’t be swayed by vendors, media hype, or dogma. Analyze information in terms of you and your project.,
It’s Both What You Say and the Way You Say It There’s no point in having great ideas if you don’t communicate them effectively.,
DRY – Don’t Repeat Yourself Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.,
Make It Easy to Reuse If it’s easy to reuse, people will. Create an environment that supports reuse.
Eliminate Effects Between Unrelated Things Design components that are self-contained. independent, and have a single, well-defined purpose.
There Are No Final Decisions No decision is cast in stone. Instead, consider each as being written in the sand at the beach, and plan for change.
Use Tracer Bullets to Find the Target Tracer bullets let you home in on your target by trying things and seeing how close they land.
Prototype to Learn Prototyping is a learning experience. Its value lies not in the code you produce, but in the lessons you learn.
Program Close to the Problem Domain Design and code in your user’s language.
Estimate to Avoid Surprises Estimate before you start. You’ll spot potential problems up front.
Iterate the Schedule with the Code Use experience you gain as you implement to refine the project time scales.
Keep Knowledge in Plain Text Plain text won’t become obsolete. It helps leverage your work and simplifies debugging and testing.
Use the Power of Command Shells Use the shell when graphical user interfaces don’t cut it.
Use a Single Editor Well The editor should be an extension of your hand; make sure your editor is configurable, extensible, and programmable.
Always Use Source Code Control Source code control is a time machine for your work – you can go back.
Fix the Problem, Not the Blame It doesn’t really matter whether the bug is your fault or someone else’s – it is still your problem, and it still needs to be fixed.
Don’t Panic When Debugging Take a deep breath and THINK! about what could be causing the bug.
“select” Isn’t Broken. It is rare to find a bug in the OS or the compiler, or even a third-party product or library. The bug is most likely in the application.
Don’t Assume It – Prove It Prove your assumptions in the actual environment – with real data and boundary conditions.
Learn a Text Manipulation Language. You spend a large part of each day working with text. Why not have the computer do some of it for you?
Write Code That Writes Code Code generators increase your productivity and help avoid duplication.
You Can’t Write Perfect Software Software can’t be perfect. Protect your code and users from the inevitable errors.
Design with Contracts Use contracts to document and verify that code does no more and no less than it claims to do.
Crash Early A dead program normally does a lot less damage than a crippled one.
Use Assertions to Prevent the Impossible Assertions validate your assumptions. Use them to protect your code from an uncertain world.
Use Exceptions for Exceptional Problems Exceptions can suffer from all the readability and maintainability problems of classic spaghetti code. Reserve exceptions for exceptional things.
Finish What You Start Where possible, the routine or object that allocates a resource should be responsible for deallocating it.
Minimize Coupling Between Modules Avoid coupling by writing “shy” code and applying the Law of Demeter.
Configure, Don’t Integrate Implement technology choices for an application as configuration options, not through integration or engineering.
Put Abstractions in Code, Details in Metadata Program for the general case, and put the specifics outside the compiled code base.
Analyze Workflow to Improve Concurrency Exploit concurrency in your user’s workflow.
Design Using Services Design in terms of services – independent, concurrent objects behind well-defined, consistent interfaces.
Always Design for Concurrency Allow for concurrency, and you’ll design cleaner interfaces with fewer assumptions.
Separate Views from Models Gain flexibility at low cost by designing your application in terms of models and views.
Use Blackboards to Coordinate Workflow Use blackboards to coordinate disparate facts and agents, while maintaining independence and isolation among participants.
Don’t Program by Coincidence Rely only on reliable things. Beware of accidental complexity, and don’t confuse a happy coincidence with a purposeful plan.
Estimate the Order of Your Algorithms Get a feel for how long things are likely to take before you write code.
Test Your Estimates Mathematical analysis of algorithms doesn’t tell you everything. Try timing your code in its target environment.
Refactor Early, Refactor Often Just as you might weed and rearrange a garden, rewrite, rework, and re-architect code when it needs it. Fix the root of the problem.
Design to Test Start thinking about testing before you write a line of code.
Test Your Software, or Your Users Will Test ruthlessly. Don’t make your users find bugs for you.
Don’t Use Wizard Code You Don’t Understand Wizards can generate reams of code. Make sure you understand all of it before you incorporate it into your project.
Don’t Gather Requirements – Dig for Them Requirements rarely lie on the surface. They’re buried deep beneath layers of assumptions, misconceptions, and politics.
Work With a User to Think Like a User It’s the best way to gain insight into how the system will really be used.
Abstractions Live Longer than Details Invest in the abstraction, not the implementation. Abstractions can survive the barrage of changes from different implementations and new technologies.
Use a Project Glossary Create and maintain a single source of all the specific terms and vocabulary for a project.
Don’t Think Outside the Box – Find the Box When faced with an impossible problem, identify the real constraints. Ask yourself: “Does it have to be done this way? Does it have to be done at all?”
Start When You’re Ready. You’ve been building experience all your life. Don’t ignore niggling doubts.
Some Things Are Better Done than Described Don’t fall into the specification spiral – at some point you need to start coding.
Don’t Be a Slave to Formal Methods. Don’t blindly adopt any technique without putting it into the context of your development practices and capabilities.
Costly Tools Don’t Produce Better Designs Beware of vendor hype, industry dogma, and the aura of the price tag. Judge tools on their merits.
Organize Teams Around Functionality Don’t separate designers from coders, testers from data modelers. Build teams the way you build code.
Don’t Use Manual Procedures A shell script or batch file will execute the same instructions, in the same order, time after time.
Test Early. Test Often. Test Automatically Tests that run with every build are much more effective than test plans that sit on a shelf.
Coding Ain’t Done ’Til All the Tests Run ’Nuff said.
Use Saboteurs to Test Your Testing Introduce bugs on purpose in a separate copy of the source to verify that testing will catch them.
Test State Coverage, Not Code Coverage Identify and test significant program states. Just testing lines of code isn’t enough.
Find Bugs Once Once a human tester finds a bug, it should be the last time a human tester finds that bug. Automatic tests should check for it from then on.
English is Just a Programming Language Write documents as you would write code: honor the DRY principle, use metadata, MVC, automatic generation, and so on.
Build Documentation In, Don’t Bolt It On Documentation created separately from code is less likely to be correct and up to date.
Gently Exceed Your Users’ Expectations Come to understand your users’ expectations, then deliver just that little bit more.
Sign Your Work Craftsmen of an earlier age were proud to sign their work. You should be, too.

– The Pragmatic Programmer Quick Reference Guide

From the book “The Pragmatic Programmer”, copy here

7.4.2 Tools - greatest version from all modules


# Highest version from submodules.

file_version() {
    path="$1"

    cat "$path" | grep version | awk '{print($2)}' | sed s/\"//g | sed s/,//g
}

function version_gt() { test "$(printf '%s\n' "$@" | sort -V | head -n 1)" != "$1"; }

top_version() {
    a=`file_version package.json`
    b=`file_version submodule/package.json`
    c=`file_version submodule_2/package.json`

    printf '%s\n' $a $b $c | sort -V | tail -n 1
}

top_version

7.4.3 Languages

Programming languages connected via compilers

– akr.am, discussed on YC News

7.4.3.1 JavaScript

Portable GUIs: Node Web Kit

7.4.3.2 ReasonML

I’ve been using ReasonML for building complex ReasonReact (React.js binding for ReasonML) apps. With the strict type system, I can code for hours without constantly looking at the browser and it just works on first try. I never feel so happy with coding like that before with Javascript. I would recommend ReasonML for all Javascript developers.

– https://news.ycombinator.com/item?id=18414084

7.4.3.3 Lisp

1958 - John McCarthy and Paul Graham invent LISP. Due to high costs caused by a post-war depletion of the strategic parentheses reserve LISP never becomes popular[1]. In spite of its lack of popularity, LISP (now “Lisp” or sometimes “Arc”) remains an influential language in “key algorithmic techniques such as recursion and condescension”[2].

– https://news.ycombinator.com/item?id=3503896

7.4.3.4 C/C++

1972 - Dennis Ritchie invents a powerful gun that shoots both forward and backward simultaneously. Not satisfied with the number of deaths and permanent maimings from that invention he invents C and Unix.

– https://news.ycombinator.com/item?id=3503896

7.4.3.5 Dart

Created by Google, optimized for UI.

More: https://dart.dev/

7.4.4 Design patterns

Design patterns are listed further after Wikipedia at https://en.wikipedia.org/wiki/Design_Patterns#Document_Structure.

7.4.4.1 Swift

Offers an addition to enable first-class differentiable programming to Swift.

More: https://github.com/apple/swift/blob/master/docs/DifferentiableProgramming.md

7.4.4.2 Creational

Creational patterns are ones that create objects for you, rather than having you instantiate objects directly. This gives your program more flexibility in deciding which objects need to be created for a given case.

Abstract factory groups object factories that have a common theme.
Builder constructs complex objects by separating construction and representation.
Factory method creates objects without specifying the exact class to create.
Prototype creates objects by cloning an existing object.
Singleton restricts object creation for a class to only one instance.

7.4.4.3 Structural

These concern class and object composition. They use inheritance to compose interfaces and define ways to compose objects to obtain new functionality.

Adapter allows classes with incompatible interfaces to work together by wrapping its own interface around that of an already existing class.
Bridge decouples an abstraction from its implementation so that the two can vary independently.
Composite composes zero-or-more similar objects so that they can be manipulated as one object.
Decorator dynamically adds/overrides behaviour in an existing method of an object.
Facade provides a simplified interface to a large body of code.
Flyweight reduces the cost of creating and manipulating a large number of similar objects.
Proxy provides a placeholder for another object to control access, reduce cost, and reduce complexity.

7.4.4.4 Behavioral

Most of these design patterns are specifically concerned with communication between objects.

Chain of responsibility delegates commands to a chain of processing objects.
Command creates objects which encapsulate actions and parameters.
Interpreter implements a specialized language.
Iterator accesses the elements of an object sequentially without exposing its underlying representation.
Mediator allows loose coupling between classes by being the only class that has detailed knowledge of their methods.
Memento provides the ability to restore an object to its previous state (undo).
Observer is a publish/subscribe pattern which allows a number of observer objects to see an event.
State allows an object to alter its behavior when its internal state changes.
Strategy allows one of a family of algorithms to be selected on-the-fly at runtime.
Template method defines the skeleton of an algorithm as an abstract class, allowing its subclasses to provide concrete behavior.
Visitor separates an algorithm from an object structure by moving the hierarchy of methods into one object.

7.4.5 Architectural patterns

An architectural style defines: a family of systems in terms of a pattern of structural organization; a vocabulary of components and connectors, with constraints on how they can be combined.

– Wikipedia, https://en.wikipedia.org/wiki/Architectural_pattern

7.4.5.1 Microservices

A microservice is a single self-contained unit which, together with many others, makes up a large application. By splitting your app into small units every part of it is independently deployable and scalable, can be written by different teams and in different programming languages and can be tested individually.

– Max Stoiber

A microservice architecture means that your app is made up of lots of smaller, independent applications capable of running in their own memory space and scaling independently from each other across potentially many separate machines.

– Eric Elliot

Sources:

https://medium.com/@cramirez92/build-a-nodejs-cinema-microservice-and-deploying-it-with-docker-part-1-7e28e25bfa8b

7.5 Development Operations (DevOps)

7.5.1 The Joel Test

A quick test to rate the quality of a software team, by Joel Spolsky:

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?

Source: https://www.joelonsoftware.com/2000/08/09/the-joel-test-12-steps-to-better-code/

7.5.2 Testing configuration

Configuration can be tested with BATS which is general, portable and written entirely in Bash. Sometimes however, it is convenient to be able to execute a test suite without installing anything on the target machine and BATS needs to be installed locally to work.

A handy tool to use then is called Chef InSpec. It can be run via SSH.

Chef InSpec defines security and compliance rules as executable code for testing and auditing applications and infrastructure. Chef InSpec compares the actual state of a system with the desired state that is expressed in easy-to-read and easy-to-write code.

Source: https://blog.chef.io/5-things-you-can-do-with-chef-inspec-input/

7.6 Data analysis

Drake is your friend here with Drakefiles: https://www.datascienceatthecommandline.com/chapter-6-managing-your-data-workflow.html.

7.6.1 Habits of highly effective data scientists

Never start with a hypothesis

– Cassie Kozyrkov, Head of Decision Intelligence, Google, Hackernoon

Steps:

Step 1: Write down the default action.

“What do you commit to doing if you stay ignorant?”
“Getting started is about actions, not beliefs.”

Step 2: Write down the alternative action.

Nothing. You beliefe in Nothing. Say it with me.

Picking a default action requires busines savy and is the duty of the team’s decision-maker.

Statistics is the science of changing your mind.