Log 0002 - chains of thought, backlog app, compDSL

Published on

Chains of Thought ​

I've noticed that when I think about certain topics, I generate ideas that then build into a web of reasoning. Some thoughts, when combined, logically lead to conclusions which then serves as an input into other ideas.

It's difficult to keep track of these thoughts over time. This makes it hard to check if the chain of thought is sound, or if it's not valid for some reason. And when some ideas are built up of many composite thoughts, it gets very difficult.

To try and keep tabs on my thoughts, I've been drawing diagrams for these chains of thought.

It's quite hard to draw chains of thought free-hand. Potentially, an app could be quite powerful for organising thoughts. It could have:

  1. Expand/collapse thoughts
  2. Identify weak statements and create branches for different thoughts
  3. Reuse existing thoughts

I'm still very much exploring the idea, but I think it could be really useful for me. When you think about it, linking thoughts is very similar to linking notes together. There might be a way of extending a traditional note-taking app with the ability to view certain tagged notes as thoughts.

Backlog App ​

There aren't enough example apps for statecharts. I've created Backlog App exercise to try and improve the situation.

Requirements ​

Objective: Develop a Backlog application that allows users to view a list of tickets and inspect ticket details.

Backlog List

  • Displays a list of tickets. Each ticket item shows the ticket id and the title:
  • The list shows
    • Loading: While fetching data.
    • Success: Data fetched successfully and displayed.
    • Error: An error occurred during data fetch. The user can click a button to retry

Ticket Detail Sidebar

  • Clicking on a ticket in the backlog opens a sidebar that displays the ticket details.
  • The sidebar shows the ticket ID, title and description
  • The ticket details are loaded from the backend in a separate request from call to get the list.
  • The sidebar shows:
    • Loading: While fetching the ticket details.
    • Success: Ticket details fetched and displayed.
    • Error: An error occurred during fetch. The user can click a button to retry.
  • The user can edit the ticket fields (title and description, not id). Fields update optimistically, on blur. For simplicity, assume the update api is always successful and ignore error and loading states.
  • The user can close the sidebar

CompDSL ​

Imagining an external DSL for components. Mostly just for fun, but the slightly more serious motivation is to think what a component looks like if most of the complications like effects etc are excluded.

xml
<Component name="UserProfile">
    <Template>
        <div>
            <h1>{user.name}</h1>
            <p>Email: {user.email}</p>
        </div>
    </Template>

    <Selector name="user" query="getUserData"/>
</Component>

Looks similar to https://www.npmjs.com/package/stampino-element

https://journal.infinitenegativeutility.com/leaving-haskell-behind

If I had to choose the three big factors that contributed to my gradual loss of interest in Haskell, they were these:

  • the stylistic neophilia that celebrates esoteric code but makes maintenance a chore
  • the awkward tooling that makes working with Haskell in a day-to-day sense clunkier
  • the constant changes that require sporadic but persistent attention and cause regular breakages