bookmarks/PRINCIPLES.md

• Shared problems are solved faster
• Transparency forces authenticity and honesty
• Participative communities are more open to change
• Open standards provide business agility
• With more eyes, all typos are shallow
• Jon Prall - (2007) 85 Operations Rules to Live By
• Make decisions using the path of least regret
• The simplest explanation is always the most likely.
• Christopher Diggins - The Principles of Good Programming
• You are the books you read, the films you watch, the music you listen to, the people you spend time with, the conversations you engage in. Choose wisely what you feed your mind.
• Lars Kappert - Categorized Overview of Programming Principles
• Lucas Medeiros Reis - The Single Most Important Driver Of Software Quality
  • don't change code you don't understand
  • never merge a branch with known defects
  • use checklists to make sure the whole problem is solved
  • static analysis tools for everything
  • code review for everything
  • test (automated and manual)
  • make small changes and iterate
• Ozan Onay - You Are Not Google
  • Don’t even start considering solutions until you Understand the problem. Your goal should be to “solve” the problem mostly within the problem domain, not the solution domain.
  • enumerate multiple candidate solutions. Don’t just start prodding at your favorite!
  • Consider a candidate solution, then read the Paper if there is one.
  • Determine the Historical context in which the candidate solution was designed or developed.
  • Weigh Advantages against disadvantages. Determine what was de-prioritized to achieve what was prioritized.
  • Think! Soberly and humbly ponder how well this solution fits your problem. What fact would need to be different for you to change your mind? For instance, how much smaller would the data need to be before you’d elect not to use Hadoop?
• Viktor Farcic - Jenkins World 2017: The Ten Commandments Of Continuous Delivery
• do pull requests
• prioritize
• finish what you're doing, focus on a small number of tasks in parallel.
• delegate some work to others if you already have lot of work to achieve, so you have more time to work on what matters for you
• O'reilly - contributions appearing in book 97 Things Every Programmer Should Know
• Daniel Miessler - Lot of concepts summarized by Daniel Miessler
• Kent Beck - If you break a problem into sub-problems and the sub-problems aren't simpler than the original problem, git reset --hard and try again
• Stuart Sierra - There's always a reason, no matter how strange the bug
• Johannes Seitz - Software Engineering best practice: Actually understand what you’re doing. Unfortunately it’s rarely used in practice.
• Stuart Sierra - "Bugs are dependency-transitive"
• Stuart Halloway - the #1 source of software defects is easy presumption. Presume nothing.
• "The Principle of Least Astonishment: Make a user interface as consistent and as predictable as possible"
• "Worried that TDD will slow down your programmers? Don't. They probably need slowing down." J. B. Rainsberger
• encourage others when they need it. relevant reference
• Tim Lister - If you don't get innate pleasure from writing code, it's time to move on
• Raphaël Yharrassarry - Il faut s'attaquer aux comportements et non aux idées
• Natanael Copa - don't install / start things unless explicitly asked for or needed (to improve security)
• Paul Graham - Don't let other people tell you the problems you're working on don't matter. People are frequently mistaken about this.
• Meir Lehman - An evolving system increases its complexity unless work is done to reduce it.
• Vala Afshar - Tell people where you're going and why. Some may volunteer their time and effort to help you get there sooner.
• Goethe - The way you see people is the way you treat them, and the way you treat them is what they become.
• Amelia Earhart - The most effective way to do it, is to do it. ~ Amelia Earhart RT
• Vala Afshar - The best way to achieve mediocrity is by often choosing the path of least resistance.
• Roy Osing - Anti principles (Don't do this !) / 11 Ways To Lose Yourself In The Crowd
• Martin Fowler - When you feel the need to write a comment, first try to refactor the code so that any comment becomes superfluous
• Craig Zerouni - "If you have too many special cases, you are doing it wrong"
• You learn nothing from life if you think you're right all the time
• Mark Twain : If you tell the truth, you don't have to remember anything.
• One day, you will be at the place you always wanted to be. Don't stop believing.
• There is no elevator to success. You have to take the stairs.
• Andy Hunt & Dave Thomas - the original DRY principle : "Every piece of knowledge must have a single, unambiguous, authoritative representation, within a system"
• A prototype is worth a thousand meetings
• Business software implementation and development is unpredictable. There will always be things to alter timeline and priorities. Tina Marie Parker
• As a developer you should strive to at least understand one level of abstraction deeper than you work on - Scott Davis
• DhilipSiva Bijju - (2013) some Best Practices. Bonus : Related GitHub repo
• Keep your code absolutely simple. Keep looking at your functions and figure out how you simplify further - John Romero
• Fix it immediately, but plan for the long-term resolution. Document the short-term fix. Automate the solution. Adam Bertram
• Finding errors in your past decisions and ideas means you’re progressing. - Greg Kogan
• You can’t go fast when everyone is spending their time fighting with the poor decisions of yesterday - Adam Chester
• Better to Say "Oops" Than "What If…" (= avoid analysis-paralysis, or paralysis by analysis, aka the state of over-analyzing / over-thinking)
• The Art Of Clean Code by Victor Rentea
  • Make it more readable even if it makes writing harder : We read 10x more times than we write
  • Boy scout rule : always check in code cleaner than you found it
  • Functions are verbs
  • Boolean names should always answer yes/no
  • Classes are nouns. Avoid meaningless names (OrderInfo, OrderData vs Order)
  • Delete the interfaces : except for Remoting/API client jars and strategy pattern implementation.
  • Names : Make the name speak for itself. Apply Continuous renaming as your learn the application
  • Names : Names should be at least pronounceable. Don't abbreviate ! Unless it's a basic business concept, like VAT
  • Names : should be consistent and unique (synonyms confuse).
  • Names should have meaningful context. eg: order.customerFirstName. But don't repeat yourself (DRY) : Order.orderCreationDate
  • Functions should be small : 5-10 lines, ... or at least should be understandable in 5 sec no more.
  • Functions do one thing
  • Functions have max 2-3 parameters
• Shirky Principle : Institutions will try to preserve the problem to which they are the solution.
• David McRaney - Confirmation Bias : Your opinions are the result of years of paying attention to information which confirmed what you believed while ignoring information which challenged your preconceived notions.
• David McRaney - Survivorship Bias : When failure becomes invisible, the difference between failure and success may also become invisible.
• David McRaney - Procrastination is fueled by weakness in the face of impulse and a failure to think about thinking.
• David McRaney - Fanboyism and Brand Loyalty : You prefer the things you own because you rationalize your past choices to protect your sense of self. The Internet changed the way people argue.
• Backend Engineer Principles by Kim Hirokuni
  • Security First : Risks have to be measured by the impact when that happens, not how likely it happens
  • Don’t break stuff : Backward compatibility for the win
  • Don’t merge PRs at late night : Merging PRs at Friday night is a terrible thing to do
• Charity Majors - Don't make production decisions just because you want to learn Go. That's what your Saturdays are for.
• Charity Majors - experiment on dev tools, or in your 20% time, or off hour, NOT IN THE CRITICAL PATH
• Wikipedia - Chesterton's fence : the principle that reforms should not be made until the reasoning behind the existing state of affairs is understood.
• Wikipedia - The No Asshole Rule

1. After encountering the person, do people feel oppressed, humiliated or otherwise worse about themselves?
2. Does the person target people who are less powerful than him/her?

• Act. No matter what. Planned Parenthood
• Dave Rupert - (2018) The Eponymous Laws of Tech | A compendium of tech-related laws, fallacies, and other wisdom
• No code is faster than no code. - Merb Motto
• If you can't see yourself working with someone else for life, don't work with them for a day. - Naval Ravikant. Tools of Titans by Tim Ferriss.
• Earn with your mind, not with your time. - Naval Ravikant. Tools of Titans by Tim Ferriss.
• 99% of all effort is wasted. - Naval Ravikant. Tools of Titans by Tim Ferriss.
• Total honesty at all times. It's almost always possible to be honest & positive. - Naval Ravikant. Tools of Titans by Tim Ferriss.
• Praise specifically, criticize generally (Warren Buffett). - Naval Ravikant. Tools of Titans by Tim Ferriss.
• All greatness comes from suffering. - Naval Ravikant. Tools of Titans by Tim Ferriss.
• Enlightenment is the space between your thoughts. - Naval Ravikant. Tools of Titans by Tim Ferriss.
• Love is given, not received. - Naval Ravikant. Tools of Titans by Tim Ferriss.
• Jan Stette - (2020) Things I believe
• dwmkerr/hacker-laws - Laws, Theories, Principles and Patterns that developers will find useful.
• Thomas Nyambati - (2017) How to Avoid Handover Nightmares | I totally adhere to those principles in my daily work... they are well known but still deserve a reminder :-) ...

• Keep things simple.
• Document everything.
• Adopt workflow and best practices.
• Employ separation of concerns.
• Avoid using personal accounts or credentials.
• Automate as much as you can.
• Write good code.

personal thoughts

• MorganGeek - Problem solving / Productivity : Good programmers write code after they found the solution. Un bon programmeur ne commence à coder qu'après avoir trouvé une solution.
• MorganGeek - Productivity : To find a solution, first eliminate the impossible ones. Astuce : Trouver la solution en éliminant d'abord les non solutions.
• MorganGeek - Readability / Reusability : If you wan write a 100 lines function, you can also replace it with a dozen more legible functions

Values I adhere to

• Learn the basics of a language before learning frameworks
• DRY (Don't Repeat Yourself) is not about code, but about knowledge
• Refactoring is a development technique, not a project
• Break rules, take risks.
• True leaders want everybody to be great.
• True leaders don't respect discipline.
• Build and grown trust otherwise it can't work
• Best way to convince is by giving an example / by showing it exists
• Everything we do expresses a need
• We often eat only what we already like / know
• We all criticize, we need to be aware of it
• Violence is an answer to unsatisfied needs
• Take pleasure in simple things
• Ban negative thoughts
• Take the time you need, don't go too fast
• Take risks
• Ask for help when struggling
• Don't do to others what you don't want done to you
• Write down your ideas and your Aha moments
• Share your feelings, don't hide your humanity
• Don't let other people decide your future for you
• Give your word.
• Say no rather than "I don't know" or "whatever you wish"
• Doing / saying nothing is already telling something
• Let go of control / release the need to control
• The faster you do a task the more you learn and the sooner you become satisfied
• The slower you do a task the more painful it will be
• Say thanks
• Smile
• Give, share
• ⭐ Take time for you, for important things and people
• Keep in touch, maintain friendship
• Market yourself. You're putting on the effort, make sure you show it
• Go right to the point
• Ask why
• Keep your ability to be amazed by things and people, they won't last forever
• Act to fight perfectionism
• Take advantage of any opportunities that present themselves
• Physical and visual contact rather than emails, sms, chat
• Accept people as they are
• Select your friends
• More slow, minder stress
• Remain calm and quiet about everything which you will experience
• Reinvent yourself, evolve
• Grow and progress in love, work, leisure
• Be yourself, know yourself
• Be curious, observe and play (mentally, physically) with what surrounds you
• Be positive
• Be realistic, concrete
• Understand your goals and others' goals
• Taking notes, writing things down is a way to free your mind and not forget or lose anything. It's also a way to train your senses of observation and reflection
• Observe without judging, relate facts
• Choose the right tool for the job
• Don't multitask
• Achieve what you're doing before you move to something else
• Life doesn't get easier you just get stronger
• living isn't fucking easy but at least you can make your life more fun
• when you pause what you're doing, you find more interesting ways to do it. So pause often
• Be you ! the world will adjust
• Write simple code that does not need to be refactored immediately : build solutions that can still be used or adapted to tomorrow needs
• Build solutions for today but anticipate future changes and always be at least one step ahead
• Teamwork starts with trust
• Il n'y a pas de forteresses imprenables, il n'y a que des mauvaises stratégies
• Think twice
• when times get tough, if people run away from the process instead of towards it, it's broken. And when people are freaking out, they run away from complexity and towards simplicity. Source
• Perfection is not attainable, but if we chase perfection, we can catch excellence.

Art of Questions

• Just ask
• Explain your misunderstanding
• Explain / state what you know / don't know
• Sound confident
• Have a come back
• Know first which answer type you're expecting : Opinion ? Factually correct answer ? Well reasoned judgment ?
• Avoid "yes" or "no" questions
• Dig deeper (5 Why...)
• Use the power of silence
• Don't interrupt
• Prepare the topic (know a bit what you are talking about)
• Check your assumptions (are you sure about what you think you know ?)
• Find the right person to ask
• Use correct grammar
• Keep the question simple
• Differentiate between open (Why ?) vs closed (when ? who ?) question types
• Explain why you are asking

Art of Communication

• Never use "never", always avoid "always"
• Suggest, don't criticize
• Don't make important decisions alone
• Don't cut communication, don't go away, don't flee
• Share your needs, your wills, your tastes / opinions
• Mutually listen to each other. Know how to listen. Use your right ear for listening (right ear = left brain)
• Feedback is important : Show interest (nod, smile, ...)
• Talk about the connection you have with the other person
• When you communicate a hard decision, don't hide behind emails, talk directly to your audience
• Use the SBI tool (Situation - Behavior - Impact)
• Assertiveness is ability to say yes to the person, no to the task
• ⭐ Prepare, verify carefully what you will communicate
• Check if your message has been heard and understood
• Expect / Give feedback
• Know the 7 C's : Clear Concise Concrete Correct Coherent Complete Courteous
• Set the main idea first
• Focus on your audience
• Avoid passive constructions
• Be open minded, don't think you know everything about your audience
• Use the body language (physical and visual contact, ...)
• Stay calm : Wrap up then stop talking. Pause. Repeat. Ask clarification of a statement. Be clear.
• Look for humor.
• Look for compromise if the other cares about something not important for you
• Agree to disagree : take beak so everyone calms down
• Assert yourself : express (negative) opinions and needs positively. Ask for help. Learn from errors. Accept feedback. Say no
• Observe rather than interpret. Communicate facts not interpretations
• Understand people's needs/feelings
• Use non violent communication

Slow programming principles

See also Calm programming / Slow programming

• No broken window. A repo should always be in a clean and working state, i.e the last commit should always build successfully.
• If you broke it, take ownership for the repair. If you break something, you are responsible of the situation, fix it (it's ok to ask for help).
• Avoid branching/batching your changes | Be careful what you batch. Changes and version bumps should be integrated continuously, not all at once.
• Don't hide your work, branch instead, and get it reviewed before creating a PR / merging it.
• If possible, don't branch, work on trunk/main. Branching/Feature flags can help.
• Use Peer code review, if possible pre-commit reviews. Peer code review is a key element in building a robust and egoless engineering culture of collaborative problem-solving (source)
• If you change the principles/systems/processess, do it incrementally. Developer productivity matters a lot. Minimize friction. e.g don't do a migration of all CI/CD Ecosystem in a way that breaks everything for a while. Do it step by step, phase the changes. Make it possible to rollback easily to previous working state.
• Quality first | Quality is always right. If you’re doing CI and for some reason the integration fails, that means the broken build becomes the highest priority to fix before continuing to add more features. System quality—not just velocity—is important. CI works in three simple stages: push, test, and fix. But despite this simplicity, CI might become challenging if only a few members of the team practice it. Consequently, CI also requires a change in culture and support from management. source
  • There is never enough time to do it right yet we find time to do it again and again. Jack Bergman?
• Refactoring can only truly begin once you've actually learned what a piece of code or some data structure did, the unique properties for which they were written or chosen. Anything else is setting yourself up for failure. source
• It also means that when building systems, you should not assume that operators will do things correctly. Expect failure from people. Try to think about tools you can give them to undo their mistakes, because they will happen sooner or later. Have some dread. Be understanding. Know things won't be perfect. source
• Study your tools, see how you work, understand how you can improve it. Don't rush. Before you run, you have to learn to walk.
  • Whether you’re getting a lot of satisfaction from being busy or just feeling exasperated, don’t forget to occasionally stop and ask yourself: Is this the best use of time?
  • Improve systems : Improving systems helps remove busywork from an employee’s day, but it also makes things easier for the customer.
  • **See also ** Ref : How Being Busy Kills Productivity on how doing less can help you be more productive
  • Focus on results; not time : Time tracking is unavoidable in some instances, but rather than the rule by which companies operate, it should be used as a secondary metric to the results they achieve. Rather than give an employee a 2-hour window to do a job, have her do it right the first time (bonus points for documenting the process), then review and adjust your future plans based on time tracking data.
• Do one thing at a time. Only one item under your name in the WIP. The rest will wait. You cannot fix all things.
• Test the crap out of everything you do before telling anyone you are "finished". See also Ref : Being a slow programmer
• Use right tools for the job (email != todo list, PR and commits != code documentation, Jenkins != long term storage for releases/versions/build info/state of quality of your code)
• Love what you have. Using boring technology. Don't get distracted too often with shiny tools that reinvent the wheel.
• Write less code, read more than you write. Read more tips, manuals, blogs, articles, watch presentations and listen to podcasts about your programming craft. Learn from others prior to writing bugs. As with culture and and knowledge, you are the books you read, the films you watch, the music you listen to, the people you spend time with, the conversations you engage in. Choose wisely what you feed your mind with, and it's true with code as well. See also Ref : Being a slow programmer and Ref : Learn to Read the Source, Luke
• Learn how to write clean code, and repeat. So when you will have to rush, you will not forget to do your work right, and you will naturally provide more quality work. Also you will tend to detect issues earlier before they hit production, i.e during reviews, and writing better code will lead the whole team in getting a better codebase you can all be proud of, which mean work will become more agreeable.
• Do your research, don't always rush in coding or in reinventing the wheel. You will learn a lot through research.
• Don't react yet. Take a little time before taking action / reacting to a task/request/message. It allows you to think more about your answer / action. Also, ask yourself if you really need to take action now for this task, or if it can wait later in the day/week. Check if you're not giving the task more focus/consideration than it deserves.
  • Wait before jumping immediately on every opportunity/request/problem. Don’t touch it / don’t (re)act too soon
  • ⭐ Respond rather than react
  • Before you write any code, think first about what problem this is solving and for whom. See also Ref : Think first about what problem this is solving and for whom
  • The faster you react, the less you think. Not always, but often. Ref : Give it five minutes
  • See also Ref : How Being Busy Kills Productivity on how doing less can help you be more productive
• Reuse existing code. GitHub is your friend.
• Discipline / Consistency beat motivation and quality.
• You don't want heroes, but you might benefit from experts / excellents colleagues / colleagues & managers that provide support and insights and who do not let you take everyting on your plate.
• Simplify. Become a minimalist.
• Don't be overconfident | the fallacy of skipping the planning stage. Some tasks look simple at first glance, but it can hide some challenges. Take the time needed to run your analysis and estimate the effort after you have checked all possible impacts you could check. Overestimating is one thing, but underestimating the effort and challenge can really lead to getting cascade issues and mistakes that would add a lot of pressure on every team and lead then to rushing even more and causing even bigger mistakes. See also Ref : Skipping the planning stage
• Writing classes and functions that do a lot.
• Be helpful not harmful, fix things and care more about your impact. You have a big responsibility on your hands, and you should take it seriously. The world needs as much care and conscience as we can muster. Defend your users against anti-patterns and shady business practices. Raise your hand and object to harmful design ideas. Call out bad stuff when you see it. Thoughtfully reflect on what you’re sending out into the world every day. See also Ref : Move Slowly and Fix Things
• Comment.
  • More so than all other tools (issue tracker, code management system, etc.) comments in code have the greatest chance of still being around and easily searchable if they haven't been deleted. See also Ref : The case for comments in code
  • Code can’t self-document if it isn’t there. If you decide to not write some code and don’t leave a comment explaining why, there will be nothing left to explain what you were thinking! Add comments that explain why the code is doing what it is doing, or is structured the way that it is structured. See also Ref : How to write readable code
• When you're done with your commit and push, just double check what you have just done. Sometimes issues or possible improvements appear obvious only when the work is already pushed. Next time, slow down and double check before pushing ;-)
• Make your app fail fast in case of error. Ignoring errors will have side effects and can cause even more harm than if you just had the app crashing on first error.
• Focus on simplicity. The answer is always there. source
• Slow is steady. Steady is smooth. Smooth is fast. Source

Slow programming Healthy tips / helpers

• Disconnect & Focus. Value your time, use it to focus. Put lot of non-meeting blocks in your agenda.
• Stay positive. Focus on what is doing ok, what you have accomplished. Focus your brain attention more often on something that is stress free.
• Limit your coffee intake.
  • Drinking caffeine triggers the release of adrenaline. Adrenaline is the source of the “fight-or-flight” response, a survival mechanism that forces you to stand up and fight or run for the hills when faced with a threat. The fight-or-flight mechanism sidesteps rational thinking in favor of a faster response. This is great when a bear is chasing you, but not so great when you’re responding to a curt email. source
  • Less caffeine. More hot water and sliced ginger. source
• Get enough sleep.
  • When you sleep, your brain literally recharges, shuffling through the day’s memories and storing or discarding them (which causes dreams), so that you wake up alert and clear-headed. Your self-control, attention, and memory are all reduced when you don’t get enough—or the right kind—of sleep. Sleep deprivation raises stress hormone levels on its own, even without a stressor present. Stressful projects often make you feel as if you have no time to sleep, but taking the time to get a decent night’s sleep is often the one thing keeping you from getting things under control. source
  • The alarm clock is for back-up. Not wake up: get enough sleep. source
• Look for help | Use your support system. It’s tempting, yet entirely ineffective, to attempt tackling everything by yourself. To be calm and productive, you need to recognize your weaknesses and ask for help when you need it. This means tapping into your support system when a situation is challenging enough for you to feel overwhelmed. Everyone has someone at work and/or outside work who is on their team, rooting for them, and ready to help them get the best from a difficult situation. Identify these individuals in your life and make an effort to seek their insight and assistance when you need it. Something as simple as talking about your worries will provide an outlet for your anxiety and stress and supply you with a new perspective on the situation. Most of the time, other people can see a solution that you can’t because they are not as emotionally invested in the situation. Asking for help will mitigate your stress and strengthen your relationships with those you rely upon. source
• Breathe. The practice of being in the moment with your breathing will begin to train your brain to focus solely on the task at hand and get the stress monkey off your back. When you’re feeling stressed, take a couple of minutes to focus on your breathing. Close the door, put away all other distractions, and just sit in a chair and breathe. The goal is to spend the entire time focused only on your breathing, which will prevent your mind from wandering. Think about how it feels to breathe in and out. This sounds simple, but it’s hard to do for more than a minute or two. It’s all right if you get sidetracked by another thought; this is sure to happen at the beginning, and you just need to bring your focus back to your breathing. If staying focused on your breathing proves to be a real struggle, try counting each breath in and out until you get to 20, and then start again from 1. Don’t worry if you lose count; you can always just start over. source
• Drink / eat well.
  • Don’t forget to drink water, get sunlight, and that we are basically a house plant with complicated feelings. source
  • Often when we think we are hungry we are simply thirsty. Drink water first. source
  • Drink decent tea and coffee. Do the simple pleasures properly. source
  • Eat slowly
• Let things blow up from time to time, you're not your work, don't feel you are not responsible for everything within your employer's company, and your employer is more resilient than you think.
• Check your posture. It will reflect how you are treating your body. source
• Unix Sheikh - software engineering principles

• Simplicity: The system should always be as simple and small as possible. When software projects grow, so do errors and bugs. Techniques such as line-by-line inspection of software, relevant unit testing, and physical examination of hardware that implements protection mechanisms are great. For such techniques to be successful a small and simple design is essential. This is sometimes described as the KISS principle and YAGNI.
• Least privilege: Each user and program should operate using the fewest privileges possible.
• Open design: In order for a system to be secure it must never depend on attacker ignorance. Instead the design should be based upon technology that depend upon public scrutiny - whenever possible.
• Complete mediation: Every access attempt must be checked and validated.
• Easy to use: The human interface must be as easy and intuitive to use as possible. Easy and simple is always better than smart and fancy. Simple user testing is a great way to get valuable feedback.
• Usability: Well known usability standards should be met if required.
• Discrimination: User discrimination is never good. User discrimination is when an application only works for a very limited amount of systems, like when a website only works with JavaScript enabled even though it doesn't provide any functionality that really requires JavaScript.
• Documentation: Lacking or inadequate documentation is a bug. Everything needs to be adequately documented from the very beginning, it is an integrate part of software development. I strongly abhor poor or lacking documentation.

Healthy tips in the covid world

• Nicholas Bate - (2021) Seven Productivity Boosters in a Covid-19 World

• Every 45 minutes, take 5 minutes. Stand, stretch, sip water, look out of a window at the horizon and ask what's really important at this moment?
• Control what you can: your mood, where you place your attention (see 1) and the accessibility of distractions.
• Sort out and invest in the home office. It’s permanent.
• Have a flight-deck: one place, one view, one perspective of what you need to focus on. This is not your in-box. Unsure? Read You, Only Better.
• Slow down enough that you can recognise the tantalisingly seductive but perspective destroying, energy depleting and soul withering nature of the blisteringly urgent, but actually not at all important.
• Say 'no'. Say it constructively. Say it nicely. Say it helpfully. But say 'no'.
• Do a few things totally brilliantly every day. And feel very productive.