VSCode – Markdown Edition | Hacker News Reader

VSCode – Markdown Edition

blog.dendron.so

157 pointskevinslin83 comments

Using VS Code + Markdown All in One (https://marketplace.visualstudio.com/items?itemName=yzhang.m...) has honestly been the most productive blogging tool I've used in a very long time, moreso than dedicated Markdown blogging tools like iA Writer. (granted half of that is due to "Paste link on selected text" which is an embarrassingly common workflow for me)

Adding Prettier (https://marketplace.visualstudio.com/items?itemName=esbenp.p...) for its underdiscussed Markdown formatting keeps READMEs and blog posts clean as well.

Still amazed by the amount of external production dependencies these VSCode extensions all seem to require. I wonder how tight Microsoft's grip is on extension security and how deep any of their automated checks might go.

The extension functionality does look great though. I wrote some similar functions in my nvim which I would have really a hard time living without.

It's no different or worse than the security model of any other text editor or IDE. It runs as your user (unless you're doing something zany like running an admin account), and it can do anything your user can do like launch programs or subprocesses you have access to execute. A vs code extension isn't going to get some unexpected power like root privilege to start messing with your system, opening low ports, etc.

You're right, what I'm curious about is how difficult it'd be to sneak a malicious command into some VSCode extension update trough these production dependencies, and how far, say, an rm -rf <allthethings> could reach from the trusted project root directory from which it is executed.

I'm not a VSCode user myself, but it's pretty much the same story with nvim.

edit: I suppose what I'm really getting at, is that, depending on what their security measures look like, the VSCode extension store might be giving some false sense of security.

A lot of supply chain security relies on trusted actors doing the right thing. It’s similar to how you can trust an ingredients label.

I suppose I could mention that on a Mac, I use Objective-See’s tools to watch what programs do in the background. And also on a Mac, you have to grant access to apps first otherwise they can’t normally access files. Of course, that breaks down in reality as most apps are useless if they can’t access files.

If you really want a scare, consider that if you compromise an ecosystem package (e.g. npm), you can run on developer machines, CI systems and possibly in production, while if you compromise a VS Code extension, you only get dev machines.

If you’re looking for a bit of extra protection, you can run VS Code from a virtual machine or even run it from Docker. Though the usual docker approach, using remote containers extension, still runs on your local computer. There’s GitHub Codespaces or Google Cloud Shell that can run VS Code remotely in a VM, though.

Most projects I'm involved with require measures that go a bit further still. Got to be honest though, it can be frustrating at times.

Just sprinkling bits of awareness around by bringing some of these considerations up whenever I can. It's an uphill battle, although, the general carelessness around extension and dependency use I'm seeing - and that even after all the shit that's been going on in that space - makes it one worth to fight.

Edit: Regarding the chain of trust you mention, that one has sort of come and gone, and there is not a whole lot of trust involved in the processes I'm saddled up with.

That's an aspect from mobile OSes I miss on desktops: apps run as their own user, and have to be granted permissions to do things like read & write files outside their own "home" directory.

Programs should run as their own users. Programs should be granted access to files opened via system (desktop environment) file picker APIs or when passed in via a shell. Desktop environments & shells would need to be modified to allow this, of course.

Mobile OS permissions are way too limited. It's one of the reasons there are no good programming environments on mobile.

> Programs should be granted access to files opened via system (desktop environment) file picker APIs or when passed in via a shell.

For example, this would render the file tree of any IDE or advanced editor (like VS code) completely useless. I can count on one hand the number of times I've used the system file picker when programming.

It should also be possible to manually grant broader permissions. I'm just hoping to avoid how automatic grants tend to be missing from mobile OSes.

It's not like simpler editors have saner defaults https://groups.google.com/g/vim_dev/c/sRT9BtjLWMk/m/BRtSXNU4... (yeah, I got bit by a variation of that one recently) (pro-tip: don't let your autoloader scan for non php file)

That thread turned from a pretty straight-forward permission issue discussion to a display of some esoteric dark arts in only a few posts!

Not sure if I consider vim either simple or sane, but then again, it was first released quite a while ago, in 1991 for the Amiga, and it was based on the even older original vi from 1971 - the era of physical TTYs, no mice, and punchcard programming (ugh! glad I wasn't born yet).

Can hardly blame grandpa for forgetting and acting strange every once in a while at his age :)

> Can hardly blame grandpa for forgetting and acting strange every once in a while at his age :)

When grandpa refuses to wear glasses even though he can't see jack then it's time to take his car's key off of his hands.

His spawn - NeoVim - is truly trying his best but Gramps just won't let go!

+1. Also, Copy Image to File. Very very handy for snipping and just pasting it in the Markdown document you're editing.

This is an incredibly difficult plugin to search for. Can you post a link to it or provide the author's name?

I was also curious. I found an extension called Markdown Paste[0], by searching for an extension to automatically base64 encode images into markdown in VSCode, which is not how this extension works at all.

0: https://marketplace.visualstudio.com/items?itemName=telesoho...

Really sorry! I was not on my laptop so couldn't post an extension link. Here it is: https://marketplace.visualstudio.com/items?itemName=mushan.v...

Not the same extension, but Dendron actually has one:

https://marketplace.visualstudio.com/items?itemName=dendron....

the reason we have our own extension is because dendron is also available on vscodium and the `paste image` extension was not available there

I use VSCode + Foam (wikilinks) + MAIO. It is the best note tool I've found.

I've tried all the tools in the market for personal knowledge management/journalling/todo/whatever.

And I've finally found my comfort in a folder with a certain directory structure containing all markdown files. I use VSCode for this (as it's already my daily driver) and GitJournal in Android to manage sync via git.

These features are a huge value addition to my workflow!

The thing I keep sitting with is what one wants for personal knowledge management vs. collective knowledge management. I've been using athens research ( https://www.athensresearch.org/ ) so far after doing classnotes in roam thinking one there could be extensions in the future to make things 'feel' like navigating directories of markdown files if really needed.

After reading more about dendron which states on https://github.com/dendronhq/dendron "It's a personal knowledge management solution (PKM) built specifically for developers and integrates natively with IDEs like VS Code and VSCodium." , the question is how these tools could serve a wider audience if they were packaged more as standalone app (using something like Eclipse Theia).

In terms of making it available to a wider audience - Dendron comes with a NextJS Template: https://wiki.dendron.so/notes/4ushYTDoX0TYQ1FDtGQSg

This makes it easy to publish your notes as a static site. The plan is to add optional server side capabilities here so that it becomes possible to read *and* write notes, at which point it becomes a web interface for note taking. It also helps with the distribution problem (Dendron is used by teams to publish documentation to non-technical folks so it helps that they can access it as a regular webpage)

I wish Dendron would use a more conventional way for hierarchy. I don't like its choice of dots for that.

that's fair. the dot hierarchy has been a polarizing topic with folks falling on both sides of it.

the reason we went with it is because: - it allows a file to be both a note and a parent of notes - it makes hierarchy an explicit part of note creation - it greatly simplified operations like refactoring (regex over filename, no need to create scaffolding with empty folders or removing folders if they no longer had children) - it makes it easy to work with using cli tools

More discussion on this here: - https://wiki.dendron.so/notes/683740e3-70ce-4a47-a1f4-1f140e... - https://wiki.dendron.so/notes/683740e3-70ce-4a47-a1f4-1f140e...

Have you tried obsidian? It’s basically what you’re doing, but with some nice extra features.

For folks that already use vscode, the selling point is being able to continue to use vscode for everything, code and markdown. VSCode has an editor experience that is hard to beat

(also, disclaimer: I'm the author of the article and founder of Dendron)

> VSCode has an editor experience that is hard to beat

VS Code is a text-editor focused on coding. Obsidian is a markdown-editor focused on knowledge- and self-management. They are each hard to beat in their own specialty. For example, the WYSIWYG-Editor of obsidian is not something that VS Codes raw text-view can beat, especially if you combine it with add-ons for code-blocks.

The WYSIWYG part of obsidian can be somewhat replicated in VSCode by this obscure and community-neglected plugin [1]. Live math preview was the reason why I got this plugin, which works very unreliably, but for other markdown functions it's okay.

[0] https://github.com/tejasvi/markless

Yep. I'm not joking when I say that I've almost tried everything. Joplin, Logseq, Boostnote, Tiddlywiki, Notion, Foam, Workflowy, you name it.

I found out that I end up doing a lot of editing + file organisation tricks native to my VSCode setup. So +1 to kevinslin's sibling comment.

OrgMode?

For anyone interested in Obsidian[0]

[0]: https://obsidian.md/

One missing component (last I heard) to the Obsidian story: there's no web app. With Dendron and others, you can use code-server to use VS Code in a browser. It's a better workflow for ChromeOS, iPad nomads, Wayland users.

Since your knowledge base in obsidian is simply a folder filled with markdown files, it’s quite quick and fairly painless to run say mkdocs or similar which serves up all the markdown as a nicely formatted website.

ref: https://squidfunk.github.io/mkdocs-material/

Some additional third-party plugins make the Obsidian experience much more enjoyable. Be sure to test them.

Can you mention some of them?

Not parent but here's some, downloadable from the built-in plugin store:

- Advanced Tables: for automatic formatting and table operations of markdown tables

- Dynamic Table of Contents: allows you to include a codeblock that automatically renders a table of contents from headers of some level

- Natural language dates: insert dates in your preferred format using language like 'next Friday' or 'first Monday of June'

- Quick latex for Obsidian: autoformat and autocomplete common latex commands (e.g. 'a/b' becomes '\frac{b}{a}'

- Tag Wrangler: rename, merge, toggle and search tags easily

- Sliding Panes: changes notes to panes that can be stacked similar to the ui of Andy Matushchak's notes [0] (check it out, it's rather neat)

[0] https://notes.andymatuschak.org

Some others that I like in my setup...

- Zoom: Work on part of a bullet list structure in isolation, with a breadcrumb line at the top to jump to a different parent level

- Copy button for code blocks

- Auto backup with Git

- Outliner: Vertical indentation lines for bullet lists, and hotkeys to move list items about in the structure

- Recent files: List of files, ordered by most recently opened

- Vimrc support

Not a plugin, but I tried to make a cheatsheet of the supported Prism language types that I'm likely to use. They can be specified in the code fences (```) so that the code and config blocks in my markdown notes look prettier : https://prismjs.com/#supported-languages

Here is the list of those I often use:

- Convert to iframe (transform a pasted URL into a iframe)

- Custom attachment location (so pasting a screenshot automatically stores it in a dedicated subfolder)

- Core search assistant (to preview search results)

- Reveal Active File (to find the current note in the LHS tree)

- Mind map (show the outline of a note as a mind map)

- Excalidraw (draw things in notes)

- Outline (adds a Outline side panel)

And I plan to investigate:

- obsidian-annotator

git is line based, so good for code.

But not for most markdown files, at least how I use it. I only start new line (actually, 2 new lines) when I reach a new paragraph, and I think this is normal for most people who ever write something in markdown.

So now I get a huge 2000 character line with a few small edits, and I can hardly see where the changes are.

`git diff --word-diff` solves this by showing changes inline. Example: https://blog.ipspace.net/2020/04/git-tip-word-diff.html

Oh this feature is great. Solves my problem completely.

I wish github would also implement word-diff option.

Edit: Github actually does some form of word-diff! See example here: https://github.com/chaoxu/chaoxu.github.io/commit/6d9ab6eefc...

I also looked up how word-diff work with Chinese language. Found a useful stackoverflow link with other suggestions.

https://stackoverflow.com/questions/26135133/git-word-diff-o...

> I think this is normal for most people who ever write something in markdown

I recognize that I am not normal and this doesn't contradict your assumption, but I use Emacs' fill command to hard-wrap long lines at ~80 characters when I'm writing Markdown. In fact, it's so habitual for me that it causes me problems when writing Gemtext. I keep meaning to disable filling in gemini-mode.

I think this is pretty normal. Some people like to put linebreaks after every sentence/clause, which makes diffs much more convenient.

> But not for most markdown files, at least how I use it. I only start new line when I reach a new paragraph, and I think this is normal for most people who ever write something in markdown.

Markdown treats lines separated with a single line break as a continuous line/the same paragraph, and you need to add two or more newlines for Markdown to interpret it as a new paragraph.

Git works just fine with Markdown.

This is true.

But how does someone take advantage of it without changing their current behavior: write an entire paragraph and do 2 line breaks.

Always end a sentence with '.\n'? Manually format lines so no line have more than 80 characters?

There are some options here on SO: https://stackoverflow.com/questions/43122175/automatically-h...

Prettier options to extensions like Rewrap, one of those might fit your use case.

> But how does someone take advantage of it without changing their current behavior: write an entire paragraph and do 2 line breaks.

I don't understand your question. Markdown's syntax already requires 2+ newlines to define a paragraph. There should be no change in a workflow if you're already using Markdown.

The only nuance is that if you want git to track changes in each sentence that forms a paragraph, just add a single line break after the punctuation mark. Markdown still interprets that as the same text block, but git is able to handle changes per line.

Hmm, interesting. I've not yet come across a situation where I'd need diffing or going back to a change or looking for one. I just use git for syncing.

Nice heads-up to look out for.

I’d recommend using line wrapping at some reasonable line length (e.g 80-120 chars)

Hard line wrapping is not a panacea in this regard, like when you have a words added/removed from a line and then you get a cascading series of changes for the rest of the paragraph as you rewrap it.

i think it depends on your writing style. i tend to do a lot of outlining with bullet points so it works pretty well. for longer paragraphs it can definitely be a pain

I’ve settled on similar setup. One nice thing about is there many tools that can work on this type of note setup, so you are not locked into one tool.

Working Copy works decently well on iOS. Gollum [1] on desktop operating systems provides a web interface to the notes. For some shameless self-promotion, I’ve been hacking on a clone of Gollum called Smeagol [2]. It is written in Rust so it is quite a bit faster to install and run on some of my low powered systems than installing Gollum.

[1]: https://github.com/gollum/gollum [2]: https://smeagol.dev/

For anyone looking for an org mode equivalent (also syncing via Working Copy on iOS), I built https://plainorg.com

I do almost the same thing! I also edit with Typora or Vim as the mood strikes. I wrote about this at https://www.bbkane.com/blog/how-i-take-notes/#my-system

Give noteplan a try

I personally use https://github.com/foambubble/foam

Works great and straight forward to setup.

Is there any reason to use Obsidian (i.e. another standalone app) instead of this?Looks great

Live View (a WYSIWYM Editor) - you type markdown, but see it rendered, comes to mind. Also some interesting extensions/add-ons centered around knowledge management are arising. Unfortunately, Obsidian itself is not open-source though; but worth checking out.

Sync across devices is an initial benefit to Obsidian that I can think of. Being able to write notes using your phone or tablet?

You can e.g. sync with Syncthing and write notes (on Android) with QuickEdit. Or use Dropbox and some Markdown editor with Dropbox support?

My knowledge base is a git repository full of markdown files and vscode. I can easly goto a specific file or do text search across all files. Minimal effort and no lockin to s specific tools.

I love writing in vs code and markdown (for my blog https://leloew.com/blog/20220227_5_lines_of_js_for_a_markdow...) they also have an unofficial grammarly plugin which works quite well.

nice writeup!

i'm currently working on shipping the publishing side of dendron in a docker (its a custom nextjs app) so that it can be easily tested locally as well as hosted remotely

I've been trying Obsidian, Foam, Dendron, etc., and most of these Zettelkasten-like editing environments have issues with relative links (i.e., they don't let you specify a base folder) and/or completely ignore front matter, which makes them hard to use when you've got 8000-odd posts across a big directory tree.

(taoofmac.com is like that, and is actually a pretty big wiki)

I've been resisting hacking my own, but I suspect I will eventually have to :)

Have you used LogSeq? Its "thing" is that it doesn't have folders, period. Your workspace is just a graph of files that reference each other. In the event that a page's name has slashes in it, the components will be treated as hierarchical pages, but that's more of an emergent folders thing than real folders (as changing the name of a page changes its own hierarchy without renaming any of its parents in the hierarchy, leaving the existing hierarchy intact)

> Have you used LogSeq?

Not OP but, personally, I was very disappointed when I found out that Loqseq doesn't support free-form text / Markdown as it's an outliner (only).

True, Logseq is mainly an outliner. But you can enable free-form text temporarily by pressing t+d (toggle document mode). Alternatively, you can press ctrl+shift+p to open the command palette and type 'document mode'.

Huh. This is news to me. Is there also a way to enable that mode permanently through the config?

Since I rarely use it, I don't know. But ask on Discord. The community is very friendly and helpful there. You'll find the link to it on their website under Community.

Have you tried Zettlr? I used and liked it for a while, before moving on to TiddlyWiki; https://www.zettlr.com

I gave in to the temptation - hence Dendron

What issues did you encounter with Dendron? Would appreciate feedback so we can make it better!

Not the original poster, but my main problem install Dendron as a vacode plugin was sometimes my Dendron directory wasn't "Dendron", and sometimed Dendron seemed to load and do things when in directoris of unrelated markdown.

I never did figure out what was going wrong, but I moved to Obsidian mainly so I had a clear separate note keeping app.

Well, it blew up trying to index my site, and it apparently can’t parse ISO dates in front matter, as well as not picking up tags…

if you have a public repo or an example note, happy to take a look at it. we've done lots of work on our markdown import and it should address a lot more cases now

My test cases are at https://github.com/rcarmo/sushy/tree/master/pages

But mind you, I don't want to import, I want to edit in place.

> drag and drop files into the editor to create a markdown link

This is nice, but I'd really prefer being able to drag and drop and then have it uploaded to, say, OneDrive. Even better, be able to paste a URL and have it download the file and then upload it to OneDrive or Dropbox or whatever.

> find all references to header|links|files|urls inside of markdown

Sometimes this sort of thing is nice to have, but doesn't it add a lot of overhead when working with markdown files?

what do you mean by overhead? do you mean performance or complexity?

Atom has an "official" Markdown-enhanced plug-in that is released by atom-community. It has pretty much everything you could want. I don't understand why VS Code doesn't just have a similar official plugin and instead relies on people to go install random plugins with warnings about how they may be malicious. Shouldn't they just include a powerful markdown editor and previewer by default?

While I get their point of not enforcing hard tree hierarchies, I hate that as a consequence there is no folder structure. The integrated note explorer is quite cumbersome to use IMO, so dealing with files externally would be more convenient

Hello fellow Murt :)

heh, internet is a small place :)

what year are you? is mcmurtry still in-tents?

Reply on news.ycombinator.com