• Metadata
  • DEVONthink Source
  • 2024-12-20_00-05_transcript-obsidian-cursor-magical-ai-knowledge-management
• Summary
  • 0s Obsidian Overview: A tool for managing engineering logs, notes, highlights, bookmarks, and example code.
  • 27s Central Store: Obsidian acts as a central repository for various types of information.
  • 40s Traditional Tools: Separate apps for bookmarks, code, and highlights.
  • 1m Obsidian’s Advantage: Consolidates all information in one place with extensions.
  • 1m 24s What is Cursor?: An AI code editor that replaces traditional code editors.
  • 1m 37s Features: Auto-completion, code actions, and a user-friendly interface.
  • 3m 30s Loading Obsidian into Cursor: Syncing and managing files.
    • Initial Sync: Describes the initial process of syncing Obsidian files into Cursor, which may cause a slight delay.
    • File Embeddings: Explains how Cursor generates embeddings to better understand the files.
    • Ignored Files Configuration: Details on configuring which files should be ignored during the sync process.
    • Troubleshooting: Suggestions for resolving sync issues, such as deleting the sync and reconfiguring ignored files.
  • 4m 13s Ignoring Files: Configuring files to be ignored during sync.
  • 5m Asking Questions: Using AI to search and analyze Obsidian data.
  • 6m Example Use Cases: Finding AI tools and recent posts.
    • AI Tool Discovery: Using AI to identify and evaluate new tools for various tasks.
    • Recent Post Analysis: Leveraging AI to locate and summarize recent posts or updates.
    • Prompt Evaluation: Asking AI to assess the effectiveness of different prompts.
    • Content Retrieval: Efficiently finding specific content within a large dataset.
  • 6m 35s Linking Files: Difficulty in traversing links between files.
    • Link Traversal Issues: Challenges faced when trying to navigate between linked files.
    • Potential Solutions: Suggestions for improving link navigation and management.
  • 7m 21s Adding Context: Improving AI responses by providing full document context.
    • Contextual Enhancement: Methods to provide additional context to AI for better responses.
    • Document Integration: Techniques for integrating full document context into AI queries.
  • 8m 45s Brainstorming: Combining past videos and bookmarks for new insights.
    • Idea Synthesis: Using AI to combine information from various sources for new ideas.
    • Resource Compilation: Gathering and organizing past resources for effective brainstorming.
  • 10m 3s Improving Documents: Using AI to enhance existing content.
    • Content Enhancement: Strategies for using AI to improve document quality and clarity.
    • AI Editing Tools: Overview of tools and features available for document enhancement.
  • 12m 7s Obsidian vs. Cursor: Each tool has unique strengths; both are valuable.
    • Tool Comparison: Analysis of the strengths and weaknesses of Obsidian and Cursor.
      • Obsidian Strengths: User-friendly interface, effective for managing workflows, and consolidating information in one place.
      • Obsidian Weaknesses: May lack advanced AI capabilities compared to dedicated AI tools.
      • Cursor Strengths: Powerful AI capabilities, flexibility in handling files, and ability to perform complex searches and analyses.
      • Cursor Weaknesses: May not offer the same level of user interface customization and visual appeal as Obsidian.
    • Use Case Scenarios: Examples of when to use each tool for optimal results.
      • Obsidian Use Cases:
        • Note-taking and Organization: Ideal for managing notes, logs, and consolidating information in one place.
        • Visual Mapping: Useful for creating visual maps of content and linking related information.
      • Cursor Use Cases:
        • AI-Driven Code Editing: Best for tasks requiring AI-assisted code completion and analysis.
        • Complex Searches: Effective for performing in-depth searches and analyses across large datasets.
  • 14m 39s Final Thoughts: The combination of Obsidian and Cursor offers powerful knowledge management capabilities.
  • 15m 9s Call to Action: Encouragement to subscribe and visit the blog for more insights.

  #Processing

• Metadata
  • DEVONthink Source
  • 2024-12-18_08-41_transcript-notcon04-danny-obrien-life-hacks
  • 2024-12-18_09-45_danny-obrien Danny O’Brien
• Summary
  • 16s Opening Story: Begins with a humorous anecdote about Silicon Valley and index cards.
  • 46s Inspiration for Lifehax: Visit to Xerox PARC and encounter with Ken Beck, founder of Xtreme programming.
  • 3m 34s Survey of Technologists: Contacted 70 technologists, received 14 detailed responses.
  • 16m 6s Common Themes: Use of simple tools like Todo.txt for organization.
  • 17m 5s Text Files for Organization: Importance of quick data entry and retrieval.
    • Quick Data Entry: Emphasizes the need to quickly dump information to avoid forgetting it (17m 13s).
    • Efficiency: Organizing systems must be fast, typically taking no more than 1-3 minutes (17m 23s).
      • Time Management: The goal is to ensure that the process of organizing does not become a time-consuming task. By limiting organizational activities to 1-3 minutes, individuals can maintain productivity and focus on their primary tasks without being bogged down by the system itself.
    • Text Processing: Text files allow for quick cutting, pasting, and searching (17m 45s).
    • Minimal Metadata: Preference for minimal metadata to keep systems simple (18m).
  • 18m 36s Incremental Search: Described as a powerful tool for efficiency.
    • Incremental Search Explained: Incremental search is a feature that allows users to search text as they type, providing immediate feedback and results. This is similar to how search engines like Google offer suggestions and results as you type each letter. In text editors and other applications, this feature helps users quickly locate information without needing to complete the entire search query. It is particularly useful in environments like Emacs or Mozilla, where users can start typing and see results instantly, enhancing productivity by reducing the time spent searching for information.
      • I have good incremental search in the following apps:
        • LaunchBar
        • DEVONthink
        • The Archive
        • Vim
        • Cursor
        • Obsidian
    • Applications and Benefits: Incremental search is prevalent in many text processing tools and is becoming more common in other software environments. It allows for faster navigation and retrieval of information, making it a valuable tool for anyone dealing with large amounts of text or data. The ability to quickly narrow down search results as you type can significantly improve workflow efficiency.
  • 27m 1s Private Tools: Many prolific technologists use personal scripts and software.
  • 29m 23s Examples of Secret Software: Random stick generators, Netscape killers, SSH tricks.
  • 31m 2s Syncing Challenges: Custom solutions for file synchronization due to lack of trust in existing apps.
  • 39m 13s Publicizing Tools: Many secret tools are used to create public-facing applications.
  • 51m 11s Final Thoughts: Emphasis on adaptability and simplicity in software design.
• Notes
  • We need simple formats, like text which can be easily edited.
    • Even in multiple applications.
    • 2.8.4
  • We need simple systems, or shallow hierarchy so we can quickly organize information.
  • We need to have incremental search, for finding information quickly.
    • Apps on my Mac with good incremental search
      • LaunchBar
      • DEVONthink
      • The Archive
      • Vim
      • Cursor
      • Obsidian
  • In essence…
    • We need to have a text based system when working with documents, so it can be easily manipulated regardless of the app we’re using. It should be one flat folder, and organize it using tags and good naming.
    • Always keep a note open when thinking since it can be edited, adjusted, kept as a history of our thinking.
      • It can be…
        • a Bike outline file
          • this can’t be edited in Cursor
        • TaskPaper for plain text
        • or even a simple Markdown outline like this

#Processing

Technology journalist and writer known for his work on life hacks and productivity.

Links

• Interview: father of “life hacks” Danny O’Brien | Lifehacker
• Tech: Nem csak a számítógépeket, az életünket is meghackelhetjük | hvg.hu

#Person #Productivity #LifeHacks

• Metadata
  • DEVONthink Source
  • 2024-12-17_22-34_transcription-best-cursor-workflow-that-no-one-talks-about Transcription Source
• Notes
  • Introduction
    • 0s Introduction to the video and sponsorship by HeadCon.
    • 6s Overview of the video’s purpose: improving cursor workflow.
  • Understanding Cursor
    • 13s Explanation of what Cursor is and its popularity.
    • 18s Cursor’s capability to enable application building using natural language.
  • Challenges and Solutions
    • 24s Common issues faced when using Cursor.
    • 39s Strategies to improve success rates with Cursor.
  • Effective Documentation
    • 45s Importance of writing detailed documentation for Cursor.
    • 49s Aligning core functionalities and file structure with Cursor.
  • Instruction Files
    • 8m 32s Creating instruction files, such as instructions.md, is crucial. These files should contain:
      • 8m 36s A project overview and core functionalities.
      • 8m 38s Detailed documentation of the packages used.
      • 8m 54s The current file structure and any relevant code examples.
      • 9m 4s This documentation helps in planning and ensures that the development process is organized and efficient.
      • I should look into how to use this in my own projects.
  • Workflow Integration
    • 1m Integrating Cloud V0 and Cursor into a cohesive workflow.
      • Note: The integration involves using V0 to enhance UI aesthetics and Cursor for backend functionalities. This combination allows for a seamless development process where V0 handles the visual aspects while Cursor manages the logic and data processing.
      • Copy-Paste Process: Code is often copied from V0 and pasted into Cursor to integrate UI components with backend logic.
    • 1m 10s Personal success story with improved workflow.
  • Example Application: Gummy Search
    • 1m 23s Introduction to the example application, Gummy Search.
    • 1m 28s Gummy Search’s functionality in analyzing Reddit posts.
  • Building the Application
    • 2m 30s Planning and scoping core functionalities.
    • 3m Setting up a GitHub repository and initial project structure.
  • Core Functionalities
    • 4m 3s Overview of core functionalities needed for the application.
    • 5m Using OpenAI to analyze post data and categorize themes.
  • Documentation and Libraries
    • 6m Using SnowRab for fetching Reddit data.
    • 7m Example of setting up Reddit API credentials.
  • OpenAI Integration
    • 9m Using OpenAI for structured output and categorization.
    • 11m Debugging and refining the OpenAI integration.
  • Project Setup
    • 12m Setting up the project with Next.js and necessary libraries.
    • 13m Installing required packages and setting up environment variables.
  • Superbase Integration
    • 27m Introduction to Superbase for backend integration.
    • 29m Setting up database schema and data storage.
  • UI Enhancements
    • 37m Using V0 to improve UI aesthetics.
      • Note: V0 is used to enhance the user interface, making it more visually appealing and consistent. This is achieved by leveraging V0’s capabilities to generate and refine UI components.
    • 39m Step-by-step UI updates for consistency and style.
  • Deployment
    • 41m Deploying the application using Verso.
    • 42m 43s Encouragement to join the AI Builder Club for further learning.
  • Conclusion
    • 42m 43s Closing remarks and invitation to join the community.

• CEO of Cognisys, a company specializing in AI technologies and language model development
  • Otto is an linked on his Twitter profile
• Leading practitioner in the field of large language models (LLMs)
• Known for innovative approaches including meta prompts and model orchestration
• Active in sharing AI insights and trends on social media platforms

Links

• Twitter Profile

Others

• I had to create a custom RSS.app based JSON feed from his Twitter feed
  • He shares interesting stuff there, and I want to follow him from Reeder

#Person #AI #LLM

• Metadata
  • DEVONthink Source
  • 2024-12-17_18-53-sully-omar Sully Omar
  • 2024-12-17_15-42_transcript-2-years-of-llm-advice-in-35-minutes-sully-omar-interview
• Notes
  • Introduction and Overview
    • 0:00
    • Sully Omar’s background and the scope of the interview.
  • The Three-Tier Model of Language Models
    • 2:14
    • Breakdown of tier 1 through tier 3 models based on intelligence, price, and use cases.
  • Tier-Specific Use Cases
    • 5:11
    • Use case examples for tier 2 and tier 1 models, focusing on task differentiation and workflow.
  • Combining Models for Optimal Performance
    • Notes
      • 09:32 Gemini is useful for video
      • 11:18 GPT-4o Mini is better with structured data
        • Summary: GPT-4o Mini excels in handling structured data due to its efficiency and cost-effectiveness. It is particularly useful for tasks that require organized outputs, such as extracting detailed information from large documents or generating structured insights. This model’s ability to process data without high costs makes it ideal for applications needing a balance between performance and affordability.
    • 9:06
      • Multi-Model Workflows: Leveraging different models for their strengths, like using Gemini for multimedia and GPT-4 Mini for text reasoning.
    • 9:19
      • Nuanced Strengths: Understanding each model’s capabilities, such as Gemini’s data search and GPT-4 Mini’s reasoning.
    • 9:40
      • Model Orchestration: Combining Claude and GPT-4 Mini for structured outputs.
    • 10:00
      • Trade-offs and Challenges: Managing outputs and compatibility issues.
    • 10:40
      • Future of Model Routing: Potential for automated routing to enhance performance.
  • Model Routing and Trade-offs
    • 12:01
    • Discussion on model routing and its challenges in production environments.
  • Understanding Model Distillation
    • 15:01
    • Benefits and pitfalls of distilling larger models into smaller ones for efficiency.
  • Workflow Demo: Meta Prompting and Prompt Optimization
    • Notes
      • 18:46 Metaprompting meaning
        • 2024-12-17_19-26
      • 20:06 Anthropic prompt optimizer
      • 20:23 Demo
      • 21:52 He demos the exact thing I’m trying to adapt for video extraction
      • 22:16 Voice is interesting
        • 25:38 LLMs perform the best when you just talk to it
          • 2024-12-17_19-25
      • Here we can see how Sally is using multiple LLMs to create a prompt
        • 24:54 Paste the prompt draft into ChatGPT o1
        • 27:50 Gemini Pro is better at extracting information
        • 29:18 Google AI Studio
      • 30:43 Prompt management
        • 31:16 LangSmith
          • Summary: LangSmith is a developer platform designed to support the lifecycle of applications powered by large language models (LLMs). It provides tools for debugging, testing, evaluating, monitoring, and tracking usage metrics, helping developers transition LLM applications from prototype to production. LangSmith aims to simplify the development process by offering an intuitive UI and integration capabilities, making it accessible
            • Checkout LangSmith
    • 18:01
      • Initial Problem Setup
        • 18:01
        • Overview of the problem-solving approach with a focus on extracting insights from a text or task.
      • Prompt Generation
        • 19:10
        • Using multiple models (GPT, Claude) to generate initial drafts for optimized prompts.
      • Iterating on Prompts
        • 21:31
        • Refining the generated prompts by testing and comparing across models to improve clarity and output quality.
      • Voice Input for Optimization
        • 22:10
        • Leveraging voice mode as a faster, more natural way to interact with the models and iterate on prompts.
      • Testing Prompts with Different Models
        • 27:02
        • Applying the finalized prompts in Gemini Pro and other systems for structured outputs and insights.
  • Test-Driven Development with LLMs
    • Notes
      • 32:58 Write the LLM tests first, so we can do TDD with LLMs
      • 37:53 LLM TTD This can give feedback to agents
      • 38:52 Think out loud first
        • 2024-12-17_19-22
    • Writing Tests First
      • 32:55
      • Creating tests before implementing the code to ensure clear objectives and measurable outcomes.
    • Debugging with LLMs
      • 34:00
      • Using LLMs to analyze test failures, interpret error messages, and suggest fixes.
    • Iterative Code Generation
      • 35:10
      • Generating code incrementally and refining it based on test results and feedback loops.
    • Handling Complex Workflows
      • 36:30
      • Addressing multi-file and conditional logic scenarios using test-driven workflows.
    • Benefits of Test-Driven Development
      • 37:50
      • Reducing errors, improving code clarity, and ensuring robust, maintainable solutions.
    • 32:55
    • Using LLMs to write tests first and then generate code iteratively.
  • The AI Community’s Discussions and Trends
    • 39:30
    • Popular topics like model compute, distillation, and EVALS.
  • Building a Product and Growing on Twitter
    • 43:22
    • Insights on crafting viral tweets and the impact of good timing and storytelling.

VS Code automatically detects the Python interpreter for a project and activates the corresponding virtual environment in the shell, unless the project lacks one. Although I saw that even when the virtual environment was deleted and I deactivated the env, when I reopened the Project, the Virtual Environment was already activated.

To resolve this, I used Command + Shift + P, selected Python: Clear Workspace Interpreter Settings, and then chose Python: Clear Cache and Reload Window.

#Development #Troubleshooting #VSCode #Python

Watched Simon Willison: The Future of Open Source and AI | Around the Prompt #10

• Metadata
  • DEVONthink Source
  • 2024-12-17_10-42_transcript_simon-willison-the-future-of-open-source-and-ai
  • 2023-12-08_20-16-simon-willison
• Notes
  • 32:57 Checkout PyTorch
    • I don’t really have a use for it ATM
  • 42:39 Senior engineers are accelerated by AI models, not replaced
    • I know this, I don’t need a note for this
  • 49:42 myllm command line tool
  • 50:25 MLC Chat
  • 53:21 Gemma 2.0
    • I should check it out on Llama
    • Well, it needs more than 8 GB of RAM. I should try it on my MBP

#AITools #Development #LLMs #OpenSource #Interviews

To start the server for the first time:

docker run -d -v ollama:/root/.ollama -p 11434:11434 --name ollama ollama/ollama

To stop and start

docker stop ollama
docker start ollama

To interact with it:

docker exec -it ollama ollama pull gemma2
docker exec -it ollama ollama run gemma2

FYI: gemma2 needs more than 8GB of RAM to run.

→ docker exec -it ollama ollama run gemma2
Error: model requires more system memory (9.1 GiB) than is available (8.4 GiB)

Questions

• How we can move the models to an external SSD?

Moving Models to External SSD on macOS

To move Ollama models to an external SSD when using Docker:

1. Stop the Ollama container:

   docker stop ollama
   

2. Create a directory on your external SSD:

   mkdir /Volumes/YourSSD/ollama-models
   

3. Update the Docker run command to mount the external SSD location:

   docker run -d \
     -v /Volumes/YourSSD/ollama-models:/root/.ollama \
     -p 11434:11434 \
     --name ollama \
     ollama/ollama
   

If you already have models and want to move them:

1. Copy existing models from the Docker volume to your SSD:

   docker cp ollama:/root/.ollama/. /Volumes/YourSSD/ollama-models
   

2. Remove the old Docker volume:

   docker volume rm ollama
   

3. Start Ollama with the new mount point as shown above.

#Development #Docker #AI #LLMs

• Collaboration between AI and humans
  • These are tools that enable humans to do things that was harder previously.
  • Using machine learning that feels like a collaborative effort.
• ChatGPT Search is the ultimate collaboration between humans and AI
• This is the ultimate collaboration between AI and humans, since humans still feed AI with their knowledge, and AI can help us to reuse that knowledge
• It can tap into human knowledge through web search
• People still hide their knowledge behind password protected pages
  • Companies are protecting their knowledge
  • Protected knowledge is what makes money for people and companies
  • These are in a way company secrets
  • ChatGPT missing out on these things

#Drafting

iA Writer has an Authorship feature which can mark the text source. I’m trying to find a plugin for Obsidian that uses these annotations.

• People are asking about this plugin in the forums
• There is an alternative plugin called Commentator
• Here is a topic about using iA Writer with Obisidian. He uses Obsidian to do the linking.

Creating POCs can give us more insights since we’re touching the real thing, even if it’s just a spec file where we’re trying out a new library or a concept.

Try to keep the POC in one spec file so everything is in one place. This works fine for backend features. But how would one handle UI changes?

Sometimes creating a new playground (in the form of a separate project) can also be a tool to try out something. Then we can use the experience acquired from it to implement the idea in the main project.

#Linking

Experience can only be developed via getting our hands dirty, so it’s more important to try out new things than reading about them.

We should aim for trying out something, not reading about it.

One form of gaining experience can be creating POCs 2024-12-16_09-38

This note is talking about the same idea as I had earlier in 2024-12-11_22-58.

Annotations from A high-velocity style of software development

Page 1

I want to have a chat with the computer in its own language right from the start.

I like the idea of coding is a way of having chat with the computer. POCs are touching the real thing, even if it’s a spec file where we’re trying out a new library or a concept. This article also talks about creating playgrounds (as separate projects) to try out new features before implementing them in the main project.

Page 2

Ideally, I would have a project consisting of just a single file that I don’t have to leave for hours on end.

So this means we should keep a project in one file? This can be an Rspec file too. How would one handle UI features?

Page 3

Nobody sees these ugly scraps but me. I can decouple and isolate parts of the project as a result, and work on them independently without the need to keep calling all the different modules all the time or fire-up all parts of the project on each code change.

To me having a spec file which contains experimental code seem better than having it inside the implementation files.

Page 7

Flowing data through pipes allows the execution of functions to also take place without specifying the arguments. They are implicit, like one would flow data through a Linux pipe. There are no intermediate variables and assignments.

This seems interesting. I should ask about this from ChatGPT.

Page 10

That gut feeling is only developed through experience, through trying things out, failing and trying again.

Experience can only be developed via getting our hands dirty, so it’s more important to try out new things than reading about them.

We should aim for trying out something, not read about it.

Extracted notes

• 2024-12-16_09-12

This is an example article written by Cursor after collecting notes from my Zettelkasten, creating a tree structure, and asking it to generate an article from those notes.

Introduction

The Zettelkasten method provides a systematic framework for organizing and developing ideas. By utilizing the human mind’s strengths in recognizing patterns and making intuitive decisions, this method facilitates effective knowledge management. This article examines the goals, processes, and applications of the Zettelkasten system, drawing insights from various linked notes.

The Foundation of Zettelkasten

The Zettelkasten method focuses on externalizing thought processes to improve problem-solving and idea generation. This approach is similar to the GTD (Getting Things Done) methodology, which also emphasizes transferring mental tasks to external systems, allowing the mind to focus on more creative and intuitive work.

The Zettelkasten workflow aims to break down research, learning, and idea development into clear, manageable steps. This structured approach supports analytical and comparative reading and integrates these processes into daily routines, making complex tasks more accessible.

The Zettelkasten Process

A key component of the Zettelkasten method is the collection and processing of notes. For example, during reading sessions, notes should be exported to an inbox immediately afterward to maintain the context and freshness of ideas. This practice ensures that notes remain useful for future idea development.

The Zettelkasten can be used to advance R&D projects by serving as a framework for managing information and connections. This method provides a historical view of learning progress and helps identify the next steps in the research process.

The Zettelkasten method aligns with the GTD’s Natural Planning Model by allowing ideas to develop organically. This approach avoids forced idea generation, instead fostering an environment where the mind can naturally connect and expand upon existing knowledge.

Applications of Zettelkasten

The Zettelkasten system is particularly effective in project management, especially within the GTD framework. It supports the development of Someday/Maybe lists and facilitates the organization of project-specific notes, which can be stored separately from the main note collection.

The Zettelkasten’s structured approach can be adapted for product development, where the steps of writing are translated into stages of product design and implementation. This includes transforming ideas into functional specifications and tracking their progress through development.

A fundamental principle of the Zettelkasten method is atomicity, which involves breaking down ideas into discrete, self-contained notes. This principle ensures that each note is independently understandable and can be recombined with others to form new insights and connections.

Conclusion

The Zettelkasten method offers a structured framework for managing knowledge and fostering creativity. By externalizing thought processes and leveraging the mind’s natural strengths, it provides a flexible approach to idea development and project management. Whether used for personal knowledge management or professional development, the Zettelkasten system is a valuable tool for enhancing cognitive processes and productivity.

Source tree

• 2 - Externalizálásra alapuló módszertanok
  • 2.6 - A Zettelkasten rendszer célja
    • 2.6.5 - A Zettelkasten jegyzetek feldolgozási folyamata
      • 2.6.5.1 - Using the Zettelkasten to advance R&D projects
        • 2.6.5.1.3 - Jegyzetek gyűjtése könyvolvasás közben
        • 2.6.5.1.5 - Using the Zettelkasten to advance R&D projects
      • 2.6.5.5 - A Natural Planning Model és a Zettelkasten ugyanaz a folyamat csak más kontextusban használva
        • 2.6.5.5.1 - A Natural Planning Model és a Zettelkasten ugyanaz a folyamat csak más kontextusban használva
      • 2.6.5.7 - A Zettelkastennel párhuzamosan több dolgot is írhatunk
    • 2.6.6 - Zettelkasten project jegyzetek tárolása a GTD project support mappákban
      • 2.6.6.1 - Projekt alapú Zettelkasten használata SomedayMaybe ötletek fejlesztésére
        • 2.6.6.1.1 - A Zettelkasten használata a SomedayMaybe lista fejlesztésére
      • 2.6.6.2 - Egy GTD projektben is használható a Zettelkasten workflow?
      • 2.6.6.3 - Előre meghatározott témák kutatása Zettelkastennel
      • 2.6.6.4 - A Zettelkasten folyamata használható termékfejlesztésre
    • 2.6.9 - A Zettelkasten jegyzetek egy outline-t építenek fel
      • 2.6.9.5 - Principle of atomicity
        • 2.6.9.5.1 - Atomikus blokkokból összeileszthetők önálló jegyzetek?
        • 2.6.9.5.2 - Az új Zettelkasten jegyzetek Crafttal helyben is kibonthatók
      • 2.6.9.6 - A Zettelkasten jegyzetek egy outline-t építenek fel
        • 2.6.9.6.2 - Az outline alapú Zettelkastennel el kell gondolkozunk a jegyzet konkrét helyén
          • 2.6.9.6.2.1 - Leave permanent note linking to the Mac

We can’t learn to swim from the internet.

When we read about something, we don’t gain firsthand experience with it. Instead, we merely observe the author’s insights. The most effective way to learn about a subject is through active engagement with it. This allows us to witness its functioning (or failure) firsthand.

If we just read about something, we’re seeing the subject through the eye of the author.

Instead of simply reading about a subject, the best way to gain practical experience is to work on a project that allows you to apply your knowledge in some way. For instance, you could try using a programming framework for a personal project. LLMs can be also helpful in generating a working prototype, but it’s crucial to actually interact with the subject matter.

One form of gaining experience can be creating POCs 2024-12-16_09-38.

#Linking #Workflow

defaults write com.apple.dock ResetLaunchPad -bool true                                                                             
killall Dock

#Terminal #macOS

Claude AI now can control a computer, but it is in a really early phase. It can be useful for UI scripting or automated testing.

Questions

• Why is it better than just using Capybara for web UI?
• Why is it better than just using AppleScript for UI automation?
  • Even Automator can record clicks and replay them since Leopard.

References

• Introducing computer use, a new Claude 3.5 Sonnet, and Claude 3.5 Haiku \ Anthropic
• Computer use for automating operations - YouTube

#AITools

My problem is that my #Zettelkasten is a #Jekyll project and it doesn’t contain my notes in a nicely formatted folder name. If I want to index it, I have to rename it somehow.

From Is there a way to change indexed folder’s display name, without change its actual name? - DEVONthink - DEVONtechnologies Community:

It also seems to be possible to rename a group by

1. only temporarily locking in Finder,
2. renaming in DEVONthink,
3. unlocking in Finder.

This solution works perfectly. We can just lock the folder in Finder, rename it in #DEVONthink, then unlock it. Now the folder name and the path will be different.

#DEVONthink #Application #macOS

Notes about the programmer’s notebook concept:

• Personal Software Process
  • This one is actually pretty long, and mentions multiple examples.
  • Sometimes I feel like people are taking notes, but don’t have a clear system about what to do with them. They just happy about collecting them 1.3, then there is no next step.
    • Then the system is dropped because “it doesn’t work for some reason”.

#Drafting

Independent Writer, Speaker, and Broadcaster - Merlin Mann:

Merlin Mann is an independent writer, speaker, and broadcaster based in San Francisco.

Content Marketing Developer @ Tower

Bruno enjoys learning new things just as much as he enjoys teaching them. Thanks to his carefully crafted content, you won’t need to wrestle with hard topics. When he’s recharging, you will find him listening to electronic music while playing video games.

#Person

• Article
  • Beyond “Commit” and “Push”: 5 Advanced Git Features You Should Know
• Author
  • 2024-10-06_09-58-bruno-brito

Page 2

{Git Bisect is a powerful debugging tool that helps you pinpoint the exact commit that introduced a bug in your project. This feature is a great example of how Git can be much more than just a version control system, offering valuable debugging capabilities as well!}

Git bisect is a tool to find a commit that causes a bug.

Page 2

{First, you need to inform Git of a commit where the code is working correctly \(the "good" commit\) and another commit where the bug is present \(the "bad" commit\).}

First, we have to set a good commit and a bad commit. These will be the start and end points of a binary search.

Page 2

{Git then selects a commit that lies halfway between the two points you provided and prompts you to confirm whether the bug is present in that commit.}

Git then finds a commit halfway through, and we have to test if the commit works.

Page 2

{This iterative process continues as Git narrows down the range of commits until it pinpoints the exact commit that introduced the bug.}

Then, repeat the process, which means, after a while, it will find the buggy commit halfway somewhere.

So, it uses binary search to find the commit causing the bug.

Page 3

{\$ git bisect start \$ git bisect bad \# Current version is "bad" \$ git bisect good \<good-commit-hash\> \# Commit that is known to be "good" \# Git then checks out a commit for you to test and you mark it as "good" or "bad" \$ git bisect good \# or git bisect bad, depending on your conclusion \# Repeat until Git identifies the problematic commit \$ git bisect reset \# to end the bisect session}

Here’s how we can start a git bisect session.

Page 3

{allows Git to remember how you've resolved a merge conflict so that it can automatically resolve it the same way if it encounters the same conflict again.}

Git Rerere is a way to tell Git to remember the merge conflict I already solved and reuse it again.

Page 3

{This is particularly useful when working with long-lived topic branches, as you may encounter the same conflicts repeatedly.}

There are long-living branches that always need to resolve the same conflict, so this can help in those cases.

Page 4

{git config --global rerere.enabled true}

How to enable Rerere.

Page 4

{Once enabled, Git will automatically record how you resolve conflicts and reuse these resolutions in future conflicts.}

I wonder if this will cause problems because I feel it makes me trust blindly in Git for conflict resolution.

#Drafting #Literature #Development

We should have a published section in the project plan. Or we can link to published assets using Hookmark. This is how we can prove that the project is actually producing output.

The published abstraction can be a physical thing that we made:

• We can create a picture and a journal entry about the end-result
• We have to have some form of external thing that we can point to at the end of a project

This note is the possible continuation of 2.8.4 Szabályok a digitális végtermékek előállítására.

#Drafting

• Writing by Bob Doto

Starting out in 2001 as both a writing tutor and high school substitute teacher, for the past twenty years Bob has been teaching and mentoring everywhere from public schools to punk warehouses to living rooms to online Zoom rooms and colleges. These days, he teaches courses on zettelkasten, PKM, social media, and spirituality. He is a former Building a Second Brain mentor, was the managing editor of _Parabola_ magazine between 2005–2010, has been blogging since 2003, and publishing zines on and off since the early 90s. He is the author of five books:

• A System for Writing: How and Unconventional Approach to Note-Making Can Help You Capture Ideas, Think Wildly, and Write Constantly
• Sitting with Spirits: Exploring the Unseen World In the Margins of Christianity
• The House of I Am Mirrors: And Other Poems
• Acupressure For Beginners
• The Power of Stretching

You can stay up to date on his comings and goings by finding him online or by signing up for his weekly email “The High Pony: ‘Really Good’ Insights from a Modest Perch.” For everything else » bobdoto.computer

#Person

• Article
  • How I Use CLOGs to Organize My Writing Files
• Author
  • 2024-10-05_20-53-bob-doto

Page 3

{Folders are like servers. They're the places where all your information is stored. Files, working docs, notes, PDFs, resources, images, every digital thing you've collected is stored somewhere, be it in a vault or on a hard drive. In folders, this information is typically stacked alphabetically or in numerical order. The only real way to organize the contents of a folder according to what best suits you is to rename, number, or https://writing.bobdoto.computer/how-i-use-clogs-to-organize-my-writing-files/ Page 3 of 7}

Folders are there to organize information. I like this idea that the file system is a backend of my projects.

2.8.2.4.5 The file system is a backend for our projects

Page 4

{If folders are servers, then CLOGs are user interfaces. A CLOG is the means by which I engage with my writing files so I don't have to engage with what's stored in my folders. Kind of like email.}

The CLOG is like an OmniFocus project. Linking resources to a project from folders.

I wonder if I need separate ideation folders. Would be just one TaskPaper document enough (Interstitial Journal).

What does he mean by kind of like email?

Page 4

{Whenever you open Gmail, you're engaging with Google's UI. This UI allows you to curate what you'd like to see. When you're in Gmail, you're engaging with a representation of the information stored on the server. You're engaging with whatever you've allowed to pass through your pre-defined filters. When you delete an email, it disappears from your UI, but not necessarily from the server. CLOGs function in the same way.}

He explains email here.

So a folder is a backend, the project is the frontend of our system.

2.8.2.4.4 The project view is the frontend of our file system

Page 6

{Underneath "PUBLISHED" I list all the places I published my piece and how it did on each platform.}

Having a published section for plans is actually helpful to see outputs of a project. So technically this should managed in TaskPaper. I don’t think I need the ideation database like I think. It should be one folder called Project Support, and that’s it. Maybe organize it by area, but otherwise the folder of a project is just a backend. How I use that information in my Interstitial Journal is what’s interesting.

I want to have a way to click from OmniFocus and filter everything related to a project in TaskPaper.

• Plans
• Journal entries

I have to use the OmniFocus ID.

2024-10-05_21-08 The published section for plans is helpful to see the outputs of a project

#Literature

I found this workflow about how we can use an integration branch as a base for stacked branches.

Stacked branches with vanilla Git

Instead start the work by creating a feature-integration branch, which will contain all the changes you are working on together. Later, when you better understand the specific changes you are making, you can re-order the commits with git rebase -i to group commits together that you want to slice off as their own reviewable and mergeable branches.

We don’t know the hierarchy first of our work, so we can create an integration branch to mess around with ideas. The good thing is that this doesn’t need to be pushed. I can start working on the branch without too much structure and then organize my work later.

Naming these would be something like this: TICKET-ID/integration

This would be the source branch for the stacked branches so that Tower will show it as the first item in the branch tree in the sidebar.

Just like in typical programming, the commits are in no particular order. As so frequently happens, you only wrap your head around the overall change you want to make after you’ve touched a bunch of different pieces.

What does he mean by “commits are in no particular order”? Maybe I should ask ChatGPT… Here’s what it generated about this:

In a typical programming session, you might start working on one thing, then realize another part of the system needs to be changed, and by the time you’re done, the commits reflect this non-linear process. Only afterward do you gain a clearer understanding of the full scope of the changes you’ve made.

This mirrors the messy, real-world workflow where things evolve organically as you work, rather than being neatly planned out in advance.

This essentially means that we organize our commits after we create a mess. It could be avoided, though, with frequent committing and then squashing related ones later. This would force a commit review workflow on me, which can be helpful in Finding a session wrap-up process so I can wrap up my work more efficiently.

Then we have to somehow create the branches to point at the associated commits. Remember the rule though: never switch off your integration branch. So how are we going to create these branches?

We branch off from commits. Then, these branches are pushed and sent for code review. It is still important that a PR has the proper base, so we have to maintain some form of connection between them.

Or, it can be solved by pushing the integration branch too, and setting that as a base, but then we lose the nice local, private sandbox.

• So the question is, what should we use a base for a PR here?

The beauty of this method is that you are still on the feature-integrationbranch, ready to keep adding new work, while feature-a can go up for review.

In theory, this sounds good, but what about keeping stuff current?

• Can I re-order branches in Tower so one commit gets into a branch automatically?
  • Or do I have to cherry-pick?
• What about editing an existing commit where I do the coding?
  • I don’t see that as a convenient way to integrate commits
• Will the Tower re-stacking workflow work in this case?

I have to review these use cases first in Tower. I don’t care about the command line git for now.

Follow-up on 2024-08-14_23-33

I’m not sure if this is a good idea, but maybe I should hide the front page of my Zettelkasten? It would give me a way to discover random ideas.

On the other hand, I’m trying to make it more journal-like, so this idea would not help with that.

I’m introducing a new “Thought” tag, which will be used as entry points for the current threads I’m thinking about and developing.

The idea is to have an initial post tagged with “Thought” and follow-up notes are linked to that as a new reply. Over time, I’ll end up with a conclusion that can be developed into one or more permanent notes (2.6.9.5.1 and 2.6.11).

This is a remixed version of the #Folgezettel and 2.6.4 A strukturált jegyzetek a Zettelkasten belépőpontjai.

Follow-up on 2024-09-06_23-25

I want to find more ideas about using blogs as an external mind. Digital gardening is one way of doing this. 2.6.10

But I’m more interested in the commonplace book, where ideas are just thrown into a journal and, over time, developed into more refined ideas. I don’t care about nurturing the same post over the years.

My problem with that idea 2.6.10 is that I don’t know what the end result will look like. Instead of working on something for a long time, we should focus on outputting more posts and refining each new one better than the previous one.

#DigitalGarden

This method was first mentioned in 2024-08-18_08-52 Writing Inbox in iA Writer.

These are my highlights from reading The Memex Method—Pluralistic: Daily links from Cory Doctorow.

The blog as an annotated browser-history

Is blogging like adding annotations to browser history? If you mainly blog about things you found online, sure…

Every day, I load my giant folder of tabs; zip through my giant collection of RSS feeds; and answer my social telephones – primarily emails and Twitter mentions – and I open each promising fragment in its own tab to read and think about.

If the fragment seems significant, I’ll blog it: I’ll set out the context for why I think this seems important and then describe what it adds to the picture.

So, his primary source is his web browsing. That’s fine.

My primary blogging sources also include my ideas. Maybe that’s why having a Zettelkasten is important at the end. Perhaps I should also keep a tab open for my ideas? I love the idea of fragments being opened in tabs. This is a nice metaphor since macOS tabs exist in the UI everywhere, so they provide a simple UI for fragments of information in apps that are made for browsing and managing information.

In the (my) blogging method, the writer blogs about everything that seems interesting, until a subject gels out of all of those disparate, short pieces.

So, blogging on its own can be a Zettelkasten-like way of emerging ideas as we develop them. Why do I need my Zettelkasten, then? Maybe my blog is my Zettelkasten. I think a Zettelkasten can help thread ideas together in an outline format, forcing ideas to emerge.

Blogging isn’t just a way to organize your research – it’s a way to do research for a book or essay or story or speech you don’t even know you want to write yet. It’s a way to discover what your future books and essays and stories and speeches will be about.

Blogging is a way of discovery, so blogging about something should be like date-ordered public thinking. Tags are subjects of interest. Maybe I should have more specific tags, like “Mac app renaissance.”

• Maybe I should even add descriptions to tag pages.

To conclude, my Zettelkasten is one of the backbones of my blog, along with journaling and browsing the web.

#Zettelkasten #Blogging

Follow-up on 2024-09-01_12-48

Looks like having the comma after the wikilink in follow-up notes will break the backlinks feature (relevant code).

For now, I’m going to use the following format:

Follow-up on wikilink

Follow-up on 2024-08-14_23-33

I forgot that I have a “Follow-up” button on my Zettelkasten website. This can be used for quickly writing a follow-up note about something I already started. Basically yet another way to create threads.

Then, I could save these threads by opening them on the website one-by-one and saving the stacked note URL.

Here’s an example for a stacked notes URL.

• Website

#Person #PKM

• This note is a daily note, which I can use for capturing thoughts and ideas
  • This workflow idea comes from Andy Matuschak 2024-08-19_16-24-andy-matuschak who writes his transient notes into daily Markdown documents
    • Daily working log
  • The work log note is yet another inbox that we can use for capturing stuff and then processing it later
  • Questions
    • Should I keep one note per capture or everything in a day-related note?
    • How can I reconcile these notes with my Decoding notes in #Bike
      • Blogging with Bike – Decoding
      • 2024-02-21_00-19-conclusion-on-my-journaltype-apps
• Actually, I think I should keep one note per idea, since my Zettelkasten is already grouped by day

Inbox workflow from Ploum:

I simply have an “inbox” folder where there are drafts in gemtext format. They could linger there for months or years. Sometimes, they are published one hour after starting them. There’s no rule.

I’ve been greatly influenced by Cory Doctorow and his memex method. In my inbox, I keep a “today.gmi” file in which I write small reflections and links to interesting articles. When the file is bigger than 1000 words, I try to give it a direction, I reorder the nuggets and publish it without thinking too much about it.

As a consequence, my blog is a mix of focused posts that took a long time to write, focused posts that were written in a whim and posts containing random thoughts and links. I let you try to guess in which category is a given post.

I like the ideas of this post. Having an inbox where my posts are drafted, then publish them directly. I should have a better system for using iA Writer in my everyday blogging, not just longer posts and the Zettelkasten-type notes.

I basically have a Bike outline named “Decoding”, which is used as daily notes and I can publish things directly from there. iA Writer is more for post drafts, or general ideas. I should maybe use it to draft stuff there. If something emerges, then maybe create a project for it in my Writings folder.

So this is the order of my idea flow:

1. Bike outline for short posts and ramblings
2. Drafts for ideas when I’m away from the computer
   • Or I want to add a new idea to my threads in iA Writer
3. Use iA Writer to write or nurture these draft posts
4. Create a new Writings project if it needs longer form writing
5. Publish the posts from iA Writer depending on the location

I should just have one place, which is the #Drafting tag to use it as a writing inbox.

I really like how Andy Matuschak 2024-08-19_16-24-andy-matuschak uses the writing inbox concept. It is a list of ideas which should be worked on, then formed into something final.

I should have some form of flow with any material which is enters my life somehow, I work on it, shape it, then I have a final artifact 2.8.4 which can be used as a product that I’m sharing with someone (or me).

So when I’m working on something, I should ask that how this will be finalized?

Follow-up on 2024-08-14_23-41 Using Drafts to write notes

Sadly linking in #Drafts doesn’t work like that. If I want to use my follow-up script in #Drafts, then I have to assign a timestamp as the title then it can be used as a link.

• iA Writer links to file names.
• On the other hand, #Drafts links to note titles (which is the first line of the note).
• When I export the note, the file name becomes the timestamp of the note, then the title is assigned if the first line is an h1 element.
  • Looks like my #Zettelkasten can’t parse wikilinks to titles which is weird, because I remember that I had that feature to be compatible with both ways of linking.

Actually I should start my #Zettelkasten notes in #Drafts. When I have multiple ideas, it is easier to capture them in that app.

I can also pre-link these notes together in Drafts in the same as I can in iA Writer, so when I export them, the links should still work.

I’m thinking about giving up the general idea of the #Zettelkasten. I don’t have time to create permanent notes (or whatever we call them) and then link them together if I don’t use any of these notes in a writing project. And I don’t have any writing projects.

Instead, I want to focus more on using my #Zettelkasten as a journal-like medium where I can think freely in public and don’t have restrictions on how I format notes or link them.

This change means I would have more random thoughts like this, and if something is a returning thought, then maybe I’ll convert it into a more refined idea that can be stored in my outline.

On the other hand, if I read about an interesting topic, I would still use this page to store classic Zettelkasten notes (2.6.11).

Managing folgezettels means that I should have a general idea about why I’m collecting notes about a topic. Since a #Folgezettel is a thread, it should have some form of outcome. I can grab them as-is and finalize them into a blogpost or a project, or some form of plan.

When I see a #Folgezettel emerging, I could pick a bunch of notes and paste their content into #Gibberish. This way, I can create the first draft using a chat-like UI and get a feel for the final post.

• 2024-08-14_23-18
• Gibberish

Source: Making my file archive portable in a different way – Decoding

Tasks

• My Sandisk drive is perfect for this, since it has a rubber enclosure
• Test run
  • Setup ChronoSync to sync my file archive to an external drive
  • Connect my 1 TB external G-DRIVE and sync
  • Get the offsite backup drive home
    • My other Sandisk Drive
  • Connect a new external drive to my Mac mini
    • I’m switching from Sandisk drives to OWC enclosures for mobile backups, so I’ll have two drives available for use
• Make a note on my packing list to bring the archive mirror drive when I’m away from home
• Uninstall Tailscale and delete my account
  • This is tracked in a different OmniFocus project

• Streams are information collections, where new information is getting pre-pended or appended.
  • 2.16 Appending information is way to keep a history of changes
• Highlighting information in streams is the #GTD capture and #Journaling process.
  • #GTD capture is for highlighting an interesting thought in the stream of our thoughts
  • #Journaling is for highlighting a moment that we want to process or remember in the stream of our life.
• Streams should not store any state about whether we have seen something or not. A stream is just a raw collection of data, usually sorted by time.

#Linking

I concluded that each of these tools has its place.

• Decoding files #DigitalGarden
  • Raw Bike outlines to quickly edit and publish a post to my blog.
  • All the content in these files should be ready to be published. Private things can be tracked in the interstitial journal.
• Interstitial Journal #Journaling #TaskPaper
  • A way to track information throughout the day.
  • Work on routines using checklists.
• Day One
  • My private blog, where I can explain ideas and thoughts to myself without the fear of any public visibility.
• Apple Journal #Journaling
  • The life bookmarking tool for my thoughts and photo stream.
  • My photos are a stream of captured moments and I can highlight important ones by adding them with a short description to Apple Journal.
    • 2024-02-21_08-08
• Strflow
  • Strflow is great for short idea dumps when I’m thinking about something. Then these ideas can be moved to my system in OmniFocus/Bike.
  • I don’t have any use for Strflow currently, so I’ll remove it from my toolchain.
    • I keep the app installed because I have content inside it.

#Journaling

I have a bunch of apps where I can manage information, and I should cut them back and figure out which one I’m using for what.

Here’s an initial list of my current use case of them.

1. Bike journal for logging information to my blog (or privately).
2. TaskPaper journal, which is more of a running list of tasks for today, but can be used as a private journal.
3. Day One which is an actual journal app, but kept private.
   • I recently re-installed Day One, because it is still the best and most native-looking private journal app I know on the Mac. I don’t trust their custom sync engine though.
4. Strflow, for capturing ideas.
5. #Zettelkasten, which can be also used as a journal.

Follow-up: 2024-02-21_00-19-conclusion-on-my-journaltype-apps

#Journaling