cdosborn

It is a good resource. Drawabox doesn't actually teach you how to rotate cubes. That was pretty frustrating to me.

I created a little game which doesn't explain it, but allows you to practice and get feedback: https://cdsb.itch.io/draw-cube

> It's mostly about having low-JS, good SEO, easy access to information, which can be managed by very inexperienced users

Nice!

I shared in the parent thread about my tool which spell checks sites, it found a few small issues: https://www.spl.ing/report-card?website=pinkpigeon.co.uk&uui...

Yeah, I'm not referring to drawing which is copying.

> There's very little that can be taught about drawing.

While drawing from the imagination is largely about using the intuition. The intuition can be trained just like the more analytical side of the brain. I can teach you a few properties of rotation/space, etc, and then give you the right exercises, and then you won't need to use construction to draw.

KJG does have some innate ability, and he was clearly obsessed, but it's not actually the bulk of his method. He has a video about drawing scissors. He can articulate nearly everything he is drawing, specifically the function which guides the design. There are others who can draw like him. Look up Tom Fox.

Taking a look. For the past two years I've been thinking about drawing. Why it's difficult, how its possible for people like Kim Jung Gi to draw from their imagination. My theory is that it's a learned thing (as opposed to innate ability), but that it's not taught from primitives well. For example, rotating a cube is something that you cannot really find an explanation for. I think the actual difficulty in drawing (representational-ly) boils down to preserving the identity of objects through rotation. This difficulty is preserved in the presence of perspective or not (orthographic projection).

Cool project. I have a dream to make something like this for drawing spatially.

Came to the parent to share my current project which spell checks websites. It found a few small typos on your site. https://www.spl.ing/report-card?website=www.lightnote.co&uui...

I created a website spellchecker/proofreader (https://spl.ing). We use aws step functions for the actual processing, it's very cool tech! Reply with your websites, and I'll run a few checks!

Perhaps, just judge the content.

That is so fucking great.

validator passes, thanks.

Literate programming requires that there is freedom in ordering content in the literate file. Otherwise, you are restricted to the execution order of the computer. The intent of literate programming is to circumvent that requisite. Otherwise the tool is just a pretty printer of sorts.

Here is an updated example, because a few people were asking for a more complex example. This is the literate version of the root of the program. *Note that the markdown doesn't include links (in the macro names) like the html, it's just the most convenient to share.

https://github.com/cdosborn/lit/blob/master/examples/lit.hs....

If you follow the project, I'm currently writing up the src in literate style :).

This is a feature I'm looking to add. It was designed to be included. When I parse the lit file, I record the line no. which will be represented in comments in the generated source file. Hopefully, this will mitigate some of the extra workflow.

The granularity will be for every macro defn, so there will be some ambiguity.

There should be an HTML class. In the resulting docs I still need a way to separate them from the underlying language (that could be anything). Initially I thought `<<>>` looked archaic, but its rather unique and probably the syntax which clashes with the least number of programming langs.

No they are not

This is my opinion https://news.ycombinator.com/item?id=8185142

In some cases LP won't provide a benefit over commenting. But the idea is that you step outside of the rules of the language (or more appropriately the interpreter/compiler) and write a story where the order is defined by the ease of explanation, not the order mandated by the machine.

Its no different then defining a function and calling it later (and proceeding to change the function name in several places). There are tools that generate a TOC based on markdown headers. I'm not sure I understand. There is also no mandated order, of where macros are defined except in the << * >>= which specifies the root to eventually expand the macros into a code file.

Literate coffescript falls under one one of the pseudo literate tools, i.e. just nice comments. Not to discredit that approach, its just a compromise for most of the benefit. Many of those tools avoid the extra step of having to expand macros and such, before compilation/being interpreted. I ended up borrowing the watch feature, which aids the workflow

My program has only the two constructs `<<>>` and `<<>>=` which you could rather easily alter. src/Processing.he and src/Parse.hs

I really need a more mature example to show, which will be coming soon. However, many tools exist which are just eesentially auto documentation (java docs, literate Haskell, docco). Mine is the simplest iteration of a true literate programming tool which allows for code to be restructured in the way best fit for explanation. If you look at cweb, funnel-web, noweb, mine attempts to be a modern version that still implements macro functionality in a modern context (markdown, HTML, easy to build). Literate programming is more than just comments.

I need to read more of Knuth on literate programming. The plan is to finish the source in literate style.

The narrative doesn't have to jump all over the place. If anything, defining macros allows you greater flexibility. Also, using macros allows for defining different levels of languages that encapsulate a "single-responsibility". Could you be more specific?

The project is still early, and the html generation is rudimentary. Will be working soon to validate.

Not sure what you mean by appearing twice. I debated removing the "<< >>" syntax in the generated html, but I don't think it's bad. It's essentially the syntax for macros, which aid in providing context. It's useful in html, because you can quickly refer to the defn of a macro by following the anchor.

I think the greatest motivation for literate programming is providing context. After five minutes of reading, you can have a very good high level understanding of a complex program. This just isn't achievable in the same amount of time otherwise.