Tech — Work — Ramblings

by Mike Kalvas

Results: 43

  • Leverage

    2021-06-22 11:46

    #thread #structure

  • The fundamental irony of many poor decisions

    2022-01-10 19:43

    #thread

    If we can choose to do things (like getting more sleep) that are objectively better than the alternative (being more tired and less healthy for little or no benefit), then why don't we do those things?

    It's completely within our power and control to make better choices and be the people that we want to be.

    Maybe one reason we make these types of bad decisions is 202109251155 Desire vs expected outcome in decision making. Another probable piece is that immediacy/present bias and hyperbolic discounting. #thread

  • Arthur Schopenhauer

    2021-09-07 13:31

    #thread

    A German philosopher of 202109071330 Late Modern Philosophy who developed an atheistic metaphysical and ethical system that rejected contemporaneous German idealism. He embraced asceticism, denial of self, and other Indian philosophical stances and is viewed as an exemplar of philosophical pessimism.

    Works

    • Essays and Aphorisms
    • The World as Will and Representation
    • Hedgehog's Dilemma (evangelion wisecrack #thread)

    Influence

    • 202206090853 Friedrich Nietzsche
    • Ludwig Wittgenstein
    • Erwin Schrödinger
    • Albert Einstein
    • Carl Jung
    • Leo Tolstoy
    • Hermann Hesse
    • Thomas Mann
    • Jorge Luis Borges
    • Marcel Proust

  • Be a jack of all trades

    2023-08-27 10:55

    #new #thread

    Along with 202308141518 Be a pack rat for little facts, we should become capable at many things. We should try to be familiar with many different systems, languages, technologies, paradigms, etc. The value of being broadly capable may be less than apparent at first, given our current jobs might require us to only specialize in one tool. But when taking a wide view #thread of things, we realize that all of the things we learn and can do will influence our specialized actions as well. Breakthroughs rarely come from specialists #thread.1

    Range #thread

    1. Epstein, D. (2019). Range: How generalists triumph in a specialized world (1st ed.). Macmillan. https://www.goodreads.com/book/show/41795733-range ↩

  • Combination of knowledge

    2021-10-23 14:50

    #thread

    Combination of knowledge is the process of taking newly created or externalized knowledge and connecting it to other areas of knowledge or output. This can be a process of synthesis (Hegel dialectic thesis, antithesis, synthesis #thread), where the output is more 202110231459 Explicit knowledge or it can be a process of construction, where the output is building something concrete.1

    The combination of knowledge can also result in 202104291540 Emergence of new knowledge since 202109060835 Knowledge is constructed and 202109060836 Knowledge should accumulate over time.

    1. Diffey, S. (2020, October 26). The ‘Knowledge-creating’ Product Organisation. Medium. https://productcoalition.com/the-knowledge-creating-product-organisation-6ec80870647b ↩

  • Positive History

    2021-09-10 08:38

    #thread

    I want to do some research around a positive perspective on history and where we are. I feel that part of the current Zeitgeist is to be extremely cynical and nihilistic about the current world situation and outlook on the future, but I would like to see if there's good cause for that.

    Hypothesis: The world is currently the most peaceful and prosperous it's ever been for humankind. Furthermore, it's trending in the right direction.

    references

  • Quantify your cost of delay

    2023-09-01 13:33

    #new #wip #thread

    If you're only going to quantify one thing, quantify the cost of delay.1

    We simply have no business trading money for cycle time if we do not know the economic value of cycle time.

    Cost of delay is the measure that returns the most value while building an economic framework for a project. It will lead to our ability to quantify other important variables such as the cost of queues, batch sizes, and variability.1

    How to quantify it? #wip #thread (should be answered later in the book)

    1. Reinertsen, D. G. (2009). The principles of product development flow: Second generation lean product development (pp. 31). Celeritas Publishing. ↩ ↩2

  • Seek first to understand, then to be understood

    2021-06-24 15:26

    #thread

    One of the 202106221713 Seven habits of highly effective people that can move people out of the 202109121536 Maturity of independence and into the 202109121530 Maturity of interdependence.1

    Understanding people, fully, empathically listening to them, and being open to being influenced by them can cause them to reciprocate that behavior towards you. Without this trust and cooperation, we cannot build meaningful relationships and cooperation.

    This habit borrows from Greek Philosophy. Ethos, pathos, and logos: your character, your relationships, and lastly your reasoning. The order is important. #thread

    1. Covey, S. R. (2004). The 7 habits of highly effective people: Restoring the character ethic (Rev. ed.). Free Press. ↩

  • Software Craftsmanship

    2023-12-16 14:42

    #thread #new

    Software craftsmanship is a long journey to mastery. It’s a mindset where Software developers choose to be responsible for their own careers, constantly learning new tools and techniques and constantly bettering themselves. Software craftsmanship is all about putting responsibility, professionalism, pragmatism, and pride back into software development.[^mancuso2015]

    Or more shortly

    Software craftsmanship is about professionalism in software development.[^mancuso2015]

    Software craftsmanship is a movement in 202109061338 Software Engineering. Though it is broadly a movement about professionalism and quality, most people active in this movement are proponents of things like Test Driven Development #thread, Pair Programming #thread, Mob Programming #thread, and “Clean Code” #thread. This reality directly contradicts the statements made by Mancuso in his book 202312091323 The Software Craftsman. Because of this contradiction, I have trouble feeling like the movement is net positive in the way that the Agile movement, eXtreme Programming (XP), and Lean Programming have all also failed as religions without context or flexibility. “You’re not doing it right or hard enough”. However, similar to those movements I do still agree with many of the underlying values even if the commodification of those values inevitably fail.

    Continue reading

  • Think horses, not zebras

    2023-12-10 18:39

    #thread #new

    There’s a saying in the medical field,

    When you hear hoof beats, think horses not zebras.

    Which is another way of expressing Occam’s Razor (make note #thread), where the simplest explanation is often the correct one.

    The explanation of the saying is that zebras are rare in almost all circumstances, whereas horses can be found anywhere in the world. So it’s more likely that a horse is making the noise than a zebra.

    This can be applied to programming in many ways, for instance when debugging the cause of some issue.1

    Be careful though, when you’re in the right circumstances it may actually be that zebras are the explanation or the more likely one. See this excellent talk about this side of the coin: Zebras all the way down #thread add citation better and stuff.

    1. Thomas, D., & Hunt, A. (2019). The pragmatic programmer, 20th anniversary edition: Journey to mastery (Second edition) (pp. 95). Addison-Wesley. ↩

  • Stop starting, start finishing

    2023-10-24 15:10

    #thread #new

    Instead of starting many things and splitting your attention, you should focus on finishing things that you've started. Note that "finishing" doesn't have to be seeing that project to completion. For example you can finish a project by deciding that you don't have time for it and won't continue with it. This relates to 202110181246 Limit WIP to increase throughput.

    How does this idea work with creativity learning or the fact that 202110212227 Moderate procrastination facilitates creativity? Creativity learning is about chasing the many interesting things that we see without worrying about becoming an expert in them. This leads to generalized knowledge (T-shaped etc.) #thread and this 202304031221 Breadth of knowledge fuels analogy.1

    1. Epstein, D. (2019). Range: How generalists triumph in a specialized world (1st ed.). Macmillan. https://www.goodreads.com/book/show/41795733-range ↩

  • Limit WIP to increase throughput

    2021-10-18 12:46

    #thread

    Limiting the amount of work in progress can increase the total throughput of the system. 202110181247 Humans can't multi-task in a literal sense of concentrating on two things at once. We also can't multi-task in the sense that trying to switch between two tasks repeatedly slows down our ability to understand and complete those tasks. We are much better off pursuing deep 202109091123 Flow state work.

    Taking this one step further, we see that it's better to deeply focus on one thing at a time in order to actually increase our total output.

    Another extrapolation is that teams of individuals should reduce their WIP as much as possible, but may be able to sustain multiple threads. The size of the team, the threads of work, and the knowledge/skills of the members likely contribute to the optimal number. Is there a way to estimate this ideal number of threads? #thread

  • Everything we think we know about reality is a model

    2024-02-20 15:26

    #thread #new

    Everything we think we know about reality is a model. Our models do have a strong congruence with the world. Our models [also] fall far short of representing the real world fully.1

    The purpose of 202203210833 Systems thinking is to make useful models of reality. There are major conflicts here: 202203210832 Models are necessarily incomplete, 202203210831 Models are immutable but reality isn't, and 202203210830 When your model and reality conflict, reality is always right. We know tremendous amounts about the world we live in and the systems we study, but at the same time we know preciously little. Our ignorance always far outpaces our knowledge (epistemology #thread and "I know that I know nothing" 202109071225 Socrates #thread) but at the same time, it's important for us to develop methods for rationalizing about reality. Otherwise, we wouldn't be able to actually exist, live, and thrive in the real world.

    1. Meadows, D. H., & Wright, D. (2011). Thinking in systems: A primer (Nachdr.) (pp. 87). Chelsea Green Pub. ↩

  • Feedback is for changing behavior

    2022-05-02 19:56

    #thread

    The sole purpose of feedback is to drive a specific change in behavior.

    This statement needs no further explanation, but let's drive the point home with a specific corollary.

    If you need to deliver feedback, but the individual has something distressing and distraction going on, don't give the feedback at all.

    this is the ask stage of feedback delivery #thread

    First of all, the feedback will be less effective or counterproductive since the person is distracted.

    More importantly though, there's no need for the feedback to be delivered whatsoever given the purpose is to drive behavior change.

    Take the two possible outcomes for not giving the feedback:

    1. You don't give the feedback and the behavior continues. By definition this gives us another opportunity to give the feedback in better circumstances.
    2. You don't give the feedback and the behavior stops. Our goal is achieved, there's no need for the feedback at all.

  • Simple primitives don't guarantee simple constructs

    2021-07-29 21:08

    #thread

    Using simple primitives to build a system doesn't guarantee that the end system will be simple. Simple primitives can purposely introduce complexity by being composed to express complex ideas. 202104291540 Emergence can also contribute to the complexity through unknown interactions #thread, 202110231515 Feedback loops and 202110231516 Feedforward loops, and chaos #thread.

    Consider the axioms of mathematics. All of mathematics and a huge portion of other applied sciences is built on top of a few simple rules. There's seemingly no limit to the expressivity of those rules.

    Corollary

    Using complex primitives to build a system does not guarantee that the resulting system will be complex.

    Consider the real numbers. A nuanced system with infinities and apparent paradoxes provides us with a way to intuitively express the real world around us. It gives us calculus and other methods that have been effective at building the modern world.

    How does this relate to programming system design and the primitives we choose for libraries? There seems to be a bottleneck in efficiency for low level (complex?) primitives that can build complex systems, but a lower ceiling of high level primitives. You're blocked from being fast with low-level, but blocked from even expressing certain things in high-level. #thread

  • Hofstadter's Law

    2024-02-25 12:13

    #thread #new

    Hofstadter's Law: It always takes longer than you expect, even when you take into account Hofstadter's Law.1

    A self-referential adage about how 202402251224 Delays are ubiquitous. It has continued to gain popularity in programming culture in particular connection to The Mythical Man-Month and the concept of estimating how long any sufficiently complex task will take to complete.

    In Gödel, Escher, Bach, Hofstadter talks about the difficulty in creating a chess engine that could beat the top grandmasters. For years, the proponents of engines claimed that they would be able to win at the highest levels within the next few years. Such predictions always came to pass, then doubled or more and the goal was not achieved. Compare this to the AI bulls today. There are claims that artificial general intelligence is upon us and we can expect that breakthrough any day now. More than likely it will take a long time to ever achieve (if it's even truly possible technically or philosophically #thread)

    Why is it so difficult for us to accurately predict things like this? #thread

    1. Hofstadter, D. R. (20). Gödel, Escher, Bach: An eternal golden braid (20th-anniversary ed.) (pp. 152). Basic Books. ↩

  • Learning to follow and learning to lead

    2022-08-21 14:04

    #thread

    What you learn from others you can use to follow; What you learn for yourself you can use to lead.1

    If you put in the hard work (202208211352 There is no shortcut to learning) to learn something for yourself, you'll know it through and through. You'll be able to make connections to other pieces of information. You will have constructed durable knowledge for your life (202109060835 Knowledge is constructed).

    I often think of this in relation to 202109061338 Software Engineering where some of the simplest tools to learn end up causing the most pain down the road, whereas tools that teach you how they work even if it takes more effort end up being more stable, reliable, and maintainable. #thread (move to own zettel)

    1. Hamming, R. W. (2020). The art of doing science and engineering: Learning to learn (pp.292). Stripe Press. https://www.goodreads.com/book/show/53349431-the-art-of-doing-science-and-engineering ↩

  • Run to change ratio of a program

    2021-10-11 19:01

    #thread

    The more often a program is run as a ratio of how often it’s changed, the better it is for it to have static typing. Another way of saying this is that code that rarely changes and runs a lot should be statically typed. Code that is changed often (e.g. personal scripts) is better suited for dynamic typing.

    This is very similar to saying that when debugging the program and running it are nearer to one-in-the-same activity, the more dynamic it needs to be and the better suited dynamic types are for it.

    How much do I agree with this? A counterpoint: static typing makes refactoring (i.e. changing) a program less error-prone and quicker. At the same time, prototyping it to start with is slower. #thread

    This ties in with 202107291950 Optimizing requirements and implementations. Specifically, that note is about the optimization of our change rate that we use for the denominator here. This note builds a meaningful metric about the value in making changes relative to its frequency of use.

  • Knowledge should accumulate

    2021-09-06 08:36

    #thread

    If we don't turn our learning practices into an ongoing accretive effort, what's the point?

    As we learn new things we should be mindful that none of our knowledge exists in a vacuum. We seldom think of all of the unconscious things that we know and how they make learning new things easier (or harder #thread). We also tend to discount the time and effort that has gone into past learning (202208211352 There is no shortcut to learning) instead favoring the idea that it's natural to know certain things. Most people could not specify how and when they created some arbitrary piece of knowledge (202109060835 Knowledge is constructed).

    Therefore, we should be mindful of the compounding effort of learning (202304112152 Intellectual investment is like compound interest, 202304102048 Compounding Interest). 202109091133 Notes should associate organically as we build clusters of information and we should allow surprise connections to expand our thinking (202109091131 Notes should surprise us), but we should also put in the conscious effort to expand our areas of knowledge.

    It takes effort to 202109060816 Do your own thinking especially as we utilize the 202205021249 Stock and flow of knowledge to accumulate information in a modern 202205021701 Digital streams vs gardens ecosystem.

    Continue reading

  • Only artists can appreciate art

    2024-08-12 18:12

    #thread

    A particularly insightful quote from 202408121814 The Story of Mel, a Real Programmer concerns the intricacies and beauty of programming and the perception and recognition thereof.[^nather1983]

    I have often felt that programming is an art form,
whose real value can only be appreciated
by another versed in the same arcane art;
there are lovely gems and brilliant coups
hidden from human view and admiration, sometimes forever,
by the very nature of the process.

— Ed Nather, The Story of Mel, a Real Programmer

    I've always felt this to be true. It's hard to directly describe the exact nature of this phenomenon, but my gut tells me that it has to do with intuition. 202408021018 Intuition and instinct are implicit knowledge, which means that our intuition about what code is beautiful is really a deep subconscious judgement of its strengths and weaknesses. Still — beauty is subjective (is it? Aristotle, Kant etc. #thread) and perhaps some of this perception of the art of programming is simply personal, inscrutable, irrational preference.

    More broadly, this would apply to other fields. In particular, I've heard mathematicians and physicists discuss the beauty and elegance of research findings in a similar way. After all, Hamming wrote a whole book about it: 202205092134 The Art of Doing Science and Engineering.

    Continue reading

  • RGM development

    2022-06-05 16:39

    #thread

    Rube-Goldberg Development is a term I’ve come up with to describe the trial and error development that poorly crafted systems often force upon us or result in.

    In RGM development, we build one step at a time, requiring perfect synchronicity between each moving piece and acquiring that synchronicity only through tedious trial and error. Then, we add another step to the chain or pile.

    This works to a point, but a) is tedious, time consuming, and error prone and b) will completely fall down when faced with change.

    Imagine a Rube Goldberg machine built with a specific marble that will run its length. If we swap that marble for a different one with different weight, drag, or coefficient of friction, the machine won’t work. The only option is to rework the whole machine for the new constraints, going through the whole trial and error process again.

    Similarly if you wanted something more drastic like a second machine or one that works with a bowling ball, it’s almost pointless to talk about similarities with our machine because there will be many more differences than things that work.

    Avoid RGM development because it results in brittle, rigid, and unreliable systems, wasted effort, and inevitable large-scale changes or rewrites in order to reclaim the system (202109251102 Reclaiming software systems). But also be 202206112125 Zen in the face of programming because even the best written 202205131318 Software only supports one order of magnitude.

    Continue reading

  • Architecture as a form of procrastination

    2024-07-18 10:26

    #thread

    Don't let architecting your application, library, or system prevent you from doing the actual work that needs to be done. It's better to have something working and shipped than to have it be perfect the first time.

    Avoid architecture as a form of procrastination. [...] There's a lot of disguised procrastination in dev in general. Lots of working around the work, planning how to work, talking about the work, instead of actually working. And I know there's a balance to that because you want to think about what you're doing beforehand, before you do it, and have a good plan.1

    202106221150 Procrastination is a complex subject with a range of causes and effects. Architectural 202109090909 Decision paralysis could mean that we need to just get something going in order to make progress and get a better feel for the problem space (throw one away #thread).

    Knowing when to architect and plan ahead vs just get moving is something that comes with experience, and can be a good indicator of people who can operate at the 202206112236 Senior engineer or 202206112233 Staff-plus engineer level.

    1. Otwell, T., & Stauffer, M. (2024, June 24). The Laravel Podcast | Listener Q&A: ChatGPT, Laravel Hangups & Best Practices, API Docs, Inertia Next Steps (S6:E13) [Broadcast]. https://laravelpodcast.com/episodes/listener-q-a-chatgpt-laravel-hangups-best-practices-api-docs-inertia-next-steps ↩

  • Protein folding

    2021-10-22 09:37

    #thread #structure

    Protein folding is the process of determining the 3D shape of a protein from its amino-acid sequence. The 3D shape determines the protein's function and linking the amino acid sequence to the structure therefore links the sequence to the function. This has long been regarded as one of if not the hardest problem known to humanity due in part to 202110221009 Levinthal's paradox.

    DeepMind's Breakthrough

    DeepMind's program for determining the 3D shapes of proteins stands to transform biology[^callaway2020]

    The Google owned AI company DeepMind made a massive leap in 2020 in our ability to predict how protein folding works. DeepMind's AlphaFold outperformed all the competitors by a wide range in the biennial Critical Assessment of Structure Prediction (CASP) contest. One scientist even went so far as to say, "in some sense the problem is solved."

    It's a game changer. This will change medicine. It will change research. It will change bioengineering. It will change everything.

    — Andrei Lupas, Max Planck Intitute for Development in Biology[^callaway2020]

    In many cases, the structure predicted by DeepMind was indistinguishable from the state of the art experimental methods of directly measuring protein shapes.

    Continue reading

  • Impact vs effort model of task value

    2022-04-09 10:39

    #thread

    The impact vs effort model of task value is a simple two axis graph that's split into quadrants.

    Along one axis we have the value/impact of a task from low to high. Along the other we have the effort it takes to complete that task from low to high.

    The quadrants then break down as follows:

    1. Pit of despair — low impact, high effort tasks. There's nothing good about a low value task that's incredibly difficult and time consuming. It's our job to stay out of this quadrant at all cost. The good news is that it's typically easy to detect these pits and avoid them.
    2. Snacks — low effort, low impact tasks. Tempting to indulge in because they're quick to build, but they don't offer much value and amount to busy-work. This is an easy and insidious quadrant to get trapped in. Many many organizations reward performative work #thread in this quadrant.
    3. Quick wins — low effort, high impact tasks. These are the best things to work on. The only downside is that a mature organization will soon run low on items here and need to fill their time with tasks in other quadrants.
    4. Deep work — high effort, high impact tasks. These are what we should be filling our time with when the low effort high value tasks are dried up. Instead of drifting to "snacks", we should deepen our efforts, dig in, and apply ourselves to long-term, valuable work. It can be hard to get buy-in for this type of work because many people favor short-term games, but as we know, we should be trying to 202109251140 Play long term-games

    Continue reading

  • Data-last pipe design

    2021-07-27 23:06

    #thread

    Contrasts with 202107272307 Data-first pipe design.

    Background

    To start, the basic idea here is that the “data” or “object” is passed as the last parameter to a function. Consider the standard library List.map function from OCaml.[^chavarri2019]

    let numbers = [1, 2, 3];
(* numbers is the "data" and the last parameter *)
let listTwo = List.map(a => a + 1, numbers);

    Data-last pipe design is common in functional languages because of currying #thread and partial application #thread.

    Let’s take the example from above and break it up taking advantage of currying and partial application.[^chavarri2019]

    let addOneToList = List.map(a => a + 1);
let listA = [1, 2, 3];
let listB = addOneToList(listA);

    It’s obvious in this example why data-last makes sense. Partially applying the function gives us a new function that we can reuse on different data objects. This is a powerful (de)composition #thread mechanism and the style of programming building up composed functions without specifying their parameters is called point-free programming #thread. Point-free programming is only possibly because of currying and partial application.

    Functional languages supported currying by default and therefore naturally gravitated towards data-last conventions.

    Continue reading

  • Reclaiming software systems

    2021-09-25 11:02

    #structure #thread

    Software systems are organic entities. They take on a life of their own over the passage of time under the pressure of external forces. They slowly transition from 202109251124 Golden age software to 202109251125 Post-apocalyptic software.[^larson2019reclaim]

    How do we get from golden age software to post-apocalyptic then? At some point we find an elegant extension to the golden system. It's looked at as proof of the system's power and flexibility. But in reality, it's the beginning of the end. It causes the system to be harder to reason about, and eventually becomes impossible. It's better to build systems for the problems they solve and keep them running with simplicity.

    Each company is allowed to rewrite exactly once, but afterwards you have to learn how to reclaim your software instead.[^larson2019reclaim]

    One option is to rewrite the system. This is expensive, time consuming, and may actually cause problems by losing years worth of sweat and knowledge that's been put into the system.[^spolsky2000] The good news is that rewrites aren't inevitable here, and we can reclaim the system instead.

    Reclaiming the system is the project of evolving beliefs into behaviors and properties (202109251100 Verify behaviors and assert properties). We start off by believing that something works like it does. This might be a specific property of "all the DB calls come from ActiveRecord" or something. We turn that belief into a behavior or property that can be tracked and verified or asserted.

    Continue reading

  • Bloom's taxonomy of actions

    2021-10-26 09:25

    #thread

    One of the three sections of 202110260923 Bloom's taxonomy of educational objectives. The taxonomy of action focuses on the psycho-motor (action-based) domain of development.

    Skills in the psycho-motor domain describe the ability to physically manipulate a tool or instrument like a hand or a hammer. Psycho-motor objectives usually focus on change and/or development in behavior and skills.

    Perception

    The ability to use sensory cues to guide motor activity. This ranges from sensory stimulation, through cue selection, to translation.

    Set

    The readiness to act. This includes mental, physical, and emotional readiness.

    Guided response

    The early stages of learning a complex skill that includes imitation and trial and error. Practice makes perfect here. This section is akin to mastery of skills used in 202109090946 Kind learning environments.

    Mechanism

    The intermediate stage of learning a complex skill where learned responses have become habitual and the movements can be performed with confidence and proficiency.

    Complex overt response

    Skillful performance of motor actions that involve complex movement patterns. Proficiency is indicated at this stage through accuracy, coordination, and efficiency of energy expenditure. This category includes performance without hesitation and automatic performance.

    Continue reading

  • The Entry Point

    2021-04-29 15:22

    #new #thread #source #structure #wip

    This is the main entry point into my knowledge graph. At the risk of being prescriptive about categories and connections, a single top-level entry point is useful to maximize discoverability. If you're looking for other things I do, check out my home page.

    The lofty goal of this project is to contain all of my knowledge. I hope this will be a lifelong project where I can learn, collect, and create a record of my thoughts in a simple, plain-text format that should never become obsolete.

    Workflow

    This will change drastically over time, but in an effort to keep myself organized, here's my process.

    1. Find a source of information
    2. Create a #source note with solid citations (managed in Zotero) for taking notes while consuming the source.
    3. Create, link, and manage the Zettel and my Zettelkasten.

    For more information on the why and how of using a Zettelkasten, see 202107272242 The Art of using a Zettelkasten.

    Tags

    • The #structure tag is used for structure notes. These are hubs of Zettel that are connected under some sort of idea. They help with discoverability and maintenance of the Zettelkasten as a whole.
    • The #source tag is a single Zettel to organize the notes I take while working through some source material. Each Zettel that's a #source is also a #structure Zettel. For example, I take notes while reading a book in a Zettel that's named for the book's title and tag it with the #source tag. These notes aren't technically needed if we do a good job citing sources, but it's helpful during the initial reading and note taking for long-form content that requires multiple sessions.

    Continue reading

  • Play long term-games

    2021-09-25 11:40

    #thread

    Everything in here is a great #thread to pull on

    The days are long but the decades are short.

    In a lot of ways, our entire lives are unforgivably short. In other ways, they are long. We have the opportunity in some areas to play long-term games. We should be playing more long-term games and less short-term ones. Long term games take advantage of 202304102048 Compounding Interest.

    Continue reading

  • Prototype, Expand, Consolidate

    2021-08-26 13:02

    #thread

    An efficient, sustainable engineering loop can be describe through the motto prototype, expand, consolidate.[^foote1994] This loop consists of three eponymous phases. This has also been referred to as the Fractal Model of software development lifecycles.

    Phases

    Prototype

    Our primary objectives during the prototyping phase are learning about the problem space and fitting a solution to that. We pick specific portions of the problem space to stake our understanding to and just start building something.

    We deliberately don't spend time trying to build perfect understanding and systems during this phase. Doing so is a waste of time because we're inevitably blind to the realities at the end location without walking the path first.

    Expand

    Our next objective is to expand. Similar to prototyping, we expand our understanding of the problem space and the robustness of our solution. This is the phase where nuance comes in. People find themselves saying "I didn't know that worked like that" or "I didn't know it needed to be able to do that" which causes us to expand our knowledge and systems to incorporate new ideas and functions.

    There's another optional objective in this phase though.

    Continue reading

  • Knowledge is constructed

    2021-09-06 08:35

    #structure #thread

    Constructivism and also Constructionism are theories of knowledge that requires there to be a learner for knowledge to exist. Until someone learns information, connects it to things they already know, and internalizes the information in a personal context, knowledge cannot exist.

    Supporting arguments

    • Having a text or reference at hand does nothing to increase knowledge, we have to create something, do the work, wrestle with the ideas, and engage effortfully to create our own knowledge.
    • Research works better one thing at a time. Find a source, process it to completion, then use your newfound knowledge to find another source. If we don't, we run the risk of picking sources that are useless by the time we get around to reading them. Processing to completion includes writing about what you've read. This is where these notes come in. We take transient notes as we're reading and then write our thoughts here or in drafts of actual writing. (Iterative accumulative approach to writing #thread and writing is important #thread)
    • Consider that data patterns and descriptions mean nothing on their own. For instance, strongly correlated but spurious patterns may be obviously meaningless.[^vigen2013] Instead, we require a pattern or description (what), an interpretation of that pattern (why), and — critically — to synthesize multiple interpretations, hypotheses, theories, or models into a bigger picture and create something useful or interesting (why why or higher level why). Patterns and interpretations are the main work of our knowledge management system here. Synthesis happens when we write about (or just read and string together all the knowledge we accumulate in the system).

    Continue reading

  • Do your own thinking

    2021-09-06 08:16

    #thread

    It's too easy to let other people's thoughts, opinions, and models dominate our own.

    202109071331 Arthur Schopenhauer has some great quotes on this topic.

    When we read, another person thinks for us: we merely repeat his mental process. In learning to write, the pupil goes over with his pen what the teacher has outlined in pencil: so in reading; the greater part of the work of thought is already done for us. This is why it relieves us to take up a book after being occupied with our own thoughts. And in reading, the mind is, in fact, only the playground of another’s thoughts. So it comes about that if anyone spends almost the whole day in reading, and by way of relaxation devotes the intervals to some thoughtless pastime, he gradually loses the capacity for thinking; just as the man who always rides, at last forgets how to walk. This is the case with many learned persons: they have read themselves stupid.[^schopenhauer1851]

    For the more one reads the fewer are the traces left of what one has read; the mind is like a tablet that has been written over and over. Hence it is impossible to reflect; and it is only by reflection that one can assimilate what one has read if one reads straight ahead without pondering over it later, what has been read does not take root, but is for the most part lost. Indeed, it is the same with mental as with bodily food: scarcely the fifth part of what a man takes is assimilated; the remainder passes off in evaporation, respiration, and the like.[^schopenhauer1851]

    Continue reading

  • Caution and perfectionism hurt progress

    2024-08-06 01:33

    #thread

    Being overly cautious or too much of a perfectionist will undoubtedly limit progress and potentially even destroy the ultimate outcome of a project as a whole. Being overly cautious can manifest in different ways:

    • Having meetings about meetings. This shows that there are issues with how the organization runs that need to be addressed pre- or post-hoc in order for something to actually get done.
    • Meetings to discuss how we should do something in order to get consensus before getting things done. This shows that contributors do not have the authority, responsibility, or capability to do things individually and have to justify, wait, and ask others to do their job.
    • A lack of desire from contributors to be associated with a particular project or task. This shows that risk and reward are not appropriately balanced in your organization. If people don't want to be a part of a risky project, then they know that they don't have the authority or latitude to address the project correctly or perhaps know that they won't be rewarded for working hard and taking a risk on something that could hurt them.
    • Requiring large chains of approval and sign-off. If many people need to see something in order for it to be approved, then the contributors and the teams responsible for making something don't really have the authority or empowerment to do the job they were asked to do (202407081040 If you can't cancel the project you're not the product owner). If people who are not intricately involved in the project day-to-day get more say than as a potential source of feedback, they are in the way of that project's success and the team will revert to caution and perfectionism in order to avoid re-work and disapprovals.

    Continue reading

  • Value reciprocity in the insurance industry

    2022-04-05 10:48

    #thread

    This is a social ecosystem structured around reciprocity of value. The way that people earn social connections and trust as good actors in this ecosystem is by providing value to their connections. This is the whole ball game.[^wikipedia2021reciprocity]

    Reciprocity in market-based societies

    David Graeber argues that balanced gift exchange and market exchange have more in common than normally assumed. Since both are balanced, the social relationship created through the sense of debt and obligation is constantly in danger of being ended by the return gift/exchange. He thinks it better to contrast "open" and "closed" reciprocity. Open reciprocity "keeps no accounts because it implies a relation of permanent mutual commitment." This open reciprocity is closed off precisely when it is balanced. Thought of in this way, we can see the relationship as a matter of degree, more or less open or closed. Closed reciprocity of gifts is most like market exchange. It is competitive, individualistic and may border on barter.[^graeber2001]

    Comes down on the substantivist side of the formalist-substantivist debate arguing for a study of how humans make a living in a social and natural environment.

    Continue reading

  • Curriculum design for software engineering

    2022-06-28 20:18

    #wip #new #source #thread

    I want to teach computer science, what should I do?

    vs

    I want to make software, what should I do?

    Need to ask questions about the desired solution to figure out things like goals, constraints, and methods before you can build that solution. In the education case, the “solution” is the curriculum.

    Ask things like:

    • What age are the students?
    • What exposure have they had before?
    • Is this required? An elective? An extracurricular?
    • How long is the class? How often does it meet?
    • Is it even a class or something else?
    • How many students are in the room?

    etc. but also think about things like

    • Is there internet access?
    • Is the teacher new to programming?
    • Can the students type?
    • Are there students with disabilities?
    • Do the students have regular computer access at home?
    • Do the students have regular computer access at school?

    Think about

    • Equity, Rigor, and Scale

    Methods

    1. Required courses
    • Don’t scale though, need certifications for teacher. The economy for experts means that they’ll go to Jane Street and learn a huge amount more than public HS
    • Rigor has to take a hit because everyone has to pass the course to graduate
    1. Elective courses
    • Not equitable. Hugely biased (currently) to white and asian males, failures and achievement gap #thread lead to further disparity.

    Continue reading

  • Staff-plus engineer

    2022-06-11 22:33

    #thread #structure

    Staff engineering is a complex topic. As nebulous as it can be to get promoted to a 202206112236 Senior engineer role, it’s considerably harder to move into staff-plus roles. Whereas the definition varies a bit from company to company for senior engineering, the definition or even existence of staff-plus roles is completely irregular across the industry. Will Larson wrote an excellent book, Staff Engineer: Leadership Beyond the Management Track[^larson2021staff] on what it means to be a staff-plus engineer. This structure note and its children mostly come from that resource, but also other citations where noted. That book is also (mostly) publicly available at staffeng.com.

    [!important] Being a staff engineer is not just a role. It’s the intersection of the role, your behaviors, your impact, and the organization’s recognition of all those things.

    The value of the title

    • Bypass informal gauges of seniority (especially useful for underrepresented groups)
    • Facilitating access to “the room”
    • Increase current and career earnings
    • Access to interesting work
    • Different rather than better

    Archetypes

    Continue reading

  • Computer Science

    2022-06-19 13:00

    #structure #thread

    The nitty-gritty of computation and technology. Contrasted with 202109061338 Software Engineering which is more about the practice of writing software and careers or organizations in that field.

    Curriculum

    Programming language design

    Asynchronous computing

    • How does asynchronous stuff really work in JS? Promises, async/await, under the hood etc. #thread answer: JS spec requires implementations of JS to implement an event queue which JS processes fifo. Could be fun to implement a JavaScript runtime in Rust or something. (Might already exist from Mozilla, V8 is written in C++)

    Continue reading

  • As We May Think

    2021-09-08 08:47

    #structure #thread #source #new

    A seminal essay on machine augmented thinking written by Vannevar Bush in 1945.[^bush1945]

    He urges that men of science should turn to the massive task of making more accessibly our bewildering store of knowledge. For years inventions have extended man's physical powers rather than the powers of his mind. [These inventions] are new results, but not the end results, of modern science. Instruments are at hand which will give man access to and command over the inherited knowledge of the ages. The perfection of these pacific instruments should be the first objective of our scientists as they emerge from their war work. Like Emerson's famous address of 1837 on The American Scholar this paper calls for a new relationship between thinking man and the sum of our knowledge.

    Consider a future device [...] in which an individual stores all his books, records, and communications, and which is mechanized so that it may be consulted with exceeding speed and flexibility. It is an enlarged intimate supplement to his memory.

    Knowledge evolves and endures throughout the life of a race rather than that of an individual

    Publication of research has been extended far beyond our present (1945) ability to make real use of the record.

    Continue reading

  • Delivery Performance vs Value Delivery

    2022-06-17 12:06

    #blog #thread

    An alternate title for this essay is The "How" Matters.

    I want to talk more about performance — the act of executing, building, delivering, how our team works together and with other teams, and how these stack up against our potential.

    I don't want to stop talking about product value — the product, its value, our direction, how we choose what to build, or if what we built was valuable or not.

    I just want to additionally talk more about performance.

    Here's the way we typically talk about the product, its value, and our performance.

    At an individual level you know if you’re doing a good job based on how effectively you’re contributing.

    At a team level you see if the things the team built were valuable over a longer period of time.

    Directors and executives plan for years out and it can take a long time to get feedback about the value of their decisions.

    Therefore, we can’t know as easily or quickly if leaders (or groups of people as a whole) are doing a good job over these long, ambiguous timelines

    See 202104291527 Live in the ambiguity and 202104291528 Leaders have to accept a slower feedback loop for more support of this position.

    Continue reading

  • Software Engineering

    2021-09-06 13:38

    #thread #structure

    Maybe this should be a structure note of structure notes only since this is a huge topic that I'd like to really dive deep on. There is also the 202206191300 Computer Science structure note that I’ve split out to dig in to the more technical, theoretical stuff in order to keep this one focused more on the practice of writing software and careers or organizations in this field.

    Topics

    Documentation

    Abstraction

    Measurement

    Continue reading

  • The solitude of leadership

    2021-12-20 13:17

    #structure #source #thread

    People think leaders are individuals with others looking to them for direction. People think solitude is something like Thoreau, alone at Walden Pond. What could solitude have to do with leadership?

    Leadership is the qualities of character and mind that will make you fit to command a platoon or a company, a battalion or a corporation, a foundation, a department, a government.

    Solitude is the ability to be alone with your thoughts.

    Solitude is therefore one of the most important necessities of true leadership.

    On the mistaken idea of making it to the top means you're a leader

    Many people can be energetic, accomplished, smart, or ferociously ambitious, but is that enough to make them leaders? No. These types of things are encouraged and developed in our generation of world-class hoop jumpers — they're "excellent sheep". Many institutions that talk about leadership are really talking about this. They're talking about educating people to make big names for themselves with impressive titles that they can brag about. They're talking about training people to climb the greasy pole of whatever hierarchy they decide to attach themselves to. But this idea is wrong and dangerous.

    Continue reading

  • Learning Rust

    A Quick Lesson in Ownership

    2022-05-15 00:00

    #tech #blog

    I'm learning rust

    Ferris the Rustacean crab mascot of Rust

    A note on format

    This is a little stream of consciousness post about my experience working through the official intro to rust book. There's not much point to it other than to help me evaluate how I feel working with the language.

    Getting going

    I started out by installing rustup, but immediately hit a problem. I already had a version of rust installed on my system. It was an old one installed through homebrew. Nevermind that, I just needed to uninstall the brew version and install a newer one via the recommended approach.

    Next, I installed rust-analyzer making sure to grab the VS Code extension which (at the time of writing this) is the recommended language server even though the RLS extension has many more downloads. There's been some sort of maintenance issue or something. I didn't look into it too much, but this is the community direction right now.

    I found that rust-analyzer only works when you have a whole cargo project as the root of your workspace in VS Code though. It's a bummer that we can't have non-root rust projects and still get the benefit of the language server and all it's hover/intellisense/type goodies. I think there's a way to make this work with a rust-project.json file, but I didn't want to get sidetracked before even getting started.

    Continue reading

  • CodeMash 2020 - Live

    An Informal Report on a Conference

    2020-01-08 00:00

    #work #blog #tech

    Live blogging from CodeMash 2020

    CodeMash graphic, welcome to the roaring twenties

    Welcome to CodeMash

    This is my first time attending CodeMash. I had some content about PASS SQL Summit (the only other big tech conference I've been to) when I attended back in 2016 but that all got "lost" when I overhauled my servers/blog/websites. I say "lost" but I still have a backup of all of that data somewhere. It's all compressed down into cold block storage in a backup of backups. It'd be an interesting project to try and do a restore of that version of my stuff. I don't know if I actually could remember how to get it all going again. If that's the case, what's the point in keeping the old backups? I suppose I could still get that data even if it's not on a functioning server. I could grab the text from those old posts and add them here or something. But I digress...

    I'm really looking forward to all the sessions here. This is also going to be a new experience for me. I was the only person I knew at SQL Summit, whereas there are at least 30 Beamers here. It should be fun having people to go to talks and sit at meals with. Although, SQL Summit pushed me to do those things with people I didn't know and make the most of it. There's probably good and bad to both situations. I'm glad I'll be able to experience both of them.

    Continue reading