Joplin vs Logseq

Pros

• Open-source and cross-platform note-taking application
• Supports Markdown formatting and rich text editing
• Offers end-to-end encryption for secure note storage
• Provides synchronization across multiple devices and platforms

Cons

• Learning curve for users unfamiliar with Markdown syntax
• Limited collaboration features compared to some proprietary alternatives
• Sync conflicts can occasionally occur when using multiple devices
• Mobile apps may have fewer features compared to desktop versions

Pros

• Open-source and privacy-focused knowledge management tool
• Supports both Markdown and Org-mode syntax
• Offers local-first storage and offline functionality
• Provides a graph view for visualizing connections between notes

Cons

• Steeper learning curve compared to some other note-taking apps
• Limited mobile support (currently in beta)
• Fewer integrations with third-party services compared to some competitors
• May require additional setup for cloud sync and collaboration features

Note Creation and Manipulation

This snippet demonstrates how to create a new note and set its properties using the Joplin API:

const joplin = require('api');

async function createNote() {
  let newNote = await joplin.data.post(['notes'], null, {
    title: 'My New Note',
    body: 'This is the content of my new note.',
    parent_id: 'your_notebook_id_here'
  });
  console.log('New note created with ID:', newNote.id);
}

Plugin Development

Here's an example of how to create a simple Joplin plugin that adds a custom command:

import joplin from 'api';

joplin.plugins.register({
  onStart: async function() {
    await joplin.commands.register({
      name: 'myCustomCommand',
      label: 'My Custom Command',
      execute: async () => {
        await joplin.commands.execute('showModalMessage', 'Hello from my plugin!');
      }
    });
  }
});

Graph Query

This snippet demonstrates how to perform a graph query in Logseq, which is a core feature for retrieving and filtering data:

(defn query-blocks
  [query-string]
  (let [query (parse-query query-string)
        blocks (db/get-all-blocks)]
    (->> blocks
         (filter #(match-block? % query))
         (map #(assoc % :block/page (:db/id (:block/page %))))
         (sort-by :block/created-at))))

Markdown Parsing

Logseq uses Markdown for content creation. Here's a snippet showcasing the parsing of Markdown content:

(defn parse-markdown
  [content]
  (-> content
      (string/replace #"(?m)^#\s+(.*?)\s*$" "<h1>$1</h1>")
      (string/replace #"(?m)^##\s+(.*?)\s*$" "<h2>$1</h2>")
      (string/replace #"(?m)^###\s+(.*?)\s*$" "<h3>$1</h3>")
      (string/replace #"\*\*(.*?)\*\*" "<strong>$1</strong>")
      (string/replace #"\*(.*?)\*" "<em>$1</em>")))

Plugin System

Logseq supports a plugin system for extending functionality. Here's a snippet demonstrating how to register a new plugin:

(defn register-plugin
  [plugin-name plugin-fn]
  (swap! plugins assoc plugin-name plugin-fn)
  (println "Plugin registered:" plugin-name))

(defn run-plugin
  [plugin-name & args]
  (if-let [plugin-fn (get @plugins plugin-name)]
    (apply plugin-fn args)
    (println "Plugin not found:" plugin-name)))

Installation

1. Install Node.js (version 12 or later) on your system.

2. Open a terminal and run the following command to install Joplin:

   npm install -g joplin
   

3. After installation, start Joplin by running:

   joplin
   

Basic Usage

Creating a Note

1. In the Joplin terminal interface, press n to create a new note.

2. Enter a title for your note and press Enter.

3. Write your note content using Markdown syntax.

4. Press Ctrl+S to save the note.

Example Note

Here's a simple example of a note in Joplin:

This is a **bold** statement.

- Item 1
- Item 2
- Item 3

[Visit Joplin's website](https://joplinapp.org)

Synchronization

To sync your notes across devices:

1. Press :config to open the configuration menu.

2. Set up a sync target (e.g., Dropbox, OneDrive, or WebDAV).

3. Press Ctrl+S to save the configuration.

4. Use the :sync command to synchronize your notes.

For more detailed information and advanced features, refer to the official Joplin documentation.

Installation

1. Visit the Logseq releases page on GitHub.
2. Download the appropriate version for your operating system (Windows, macOS, or Linux).
3. Install the application:
   • For Windows: Run the .exe installer
   • For macOS: Drag the .dmg file to your Applications folder
   • For Linux: Use the .AppImage file or install via your package manager

Basic Usage

Creating Your First Graph

1. Open Logseq after installation.
2. Click on "Create a new graph" and choose a location on your computer to store your notes.
3. Start writing in the main editor. Logseq uses Markdown syntax for formatting.

Adding Pages and Links

1. To create a new page, simply type [[Page Name]] anywhere in your notes.
2. To link to an existing page, use the same [[]] syntax and start typing the page name. Logseq will show autocomplete suggestions.

Using Daily Notes

Logseq automatically creates a daily note for you. To access it:

1. Click on the calendar icon in the left sidebar.
2. Select today's date or navigate to a specific date.
3. Start writing your daily entries.

Example Usage

Here's a simple example of how you might use Logseq for note-taking:

- [[Project X]] kickoff meeting
- Attendees: [[John]], [[Sarah]], [[Mike]]
- Action items:
  - [ ] John to prepare project timeline
  - [ ] Sarah to contact potential clients
  - [ ] Mike to set up development environment

## Next Steps

- Schedule follow-up meeting for next week
- Review [[Project Goals]]

#meeting #projectx

This example demonstrates creating links to other pages, using task checkboxes, and adding tags to your notes.