bakul

c2v may have some assumptions that are not specified by FreeBSD C code. Probably easily fixable.

Rather than assume, you can use V and find out for yourself what works and what doesn’t.

FWIW, my view is that even the best programmers don't always have perfect non-programming skills and it is better to give them specific objective feedback via bug reports/technical comments etc and not focus on how they are not doing the expected thing or behaving in an expected manner. Focus on and encourage their good work if possible.

I tried c2v on some very simple commands in freebsd /usr/src/bin/ such as ls and pwd and it failed. Still, very good to see this progress! May be you can add some FreeBSD commands to your test cases?

It was a mild joke as planetary alignment does play a part in Vedic Astrology.

Astrology indeed had a high place in ancient India and significantly influenced the development of mathematics and astronomy. 5th/6th century mathematician Aryabhatta was also an astronomer as well as an astrologer. He even devised his own numerical encoding, which is far more compact than the Katyapadi system but not as amenable to writing numbers poetically.

Not today as 5 planets are moving into a rare alignment this week :-)

Gold is even used in medicine since ancient times. Look up Swarna Bhasma, used in Ayurveda for several ailments. A more general article on bhasma: https://www.ncbi.nlm.nih.gov/pmc/articles/PMC3960793/

I think we naturally want to share what we find beautiful as it is an expression of our joy as well as it enhances it. What we usually don't want to share is what we think will be profitable.

May be combine this idea with Knuth’s Literate Programming? Then when you get around actually working on the task it already tells you what you’re supposed to do!

There is also the idea of “Morning Pages” by Julia Cameron:

https://juliacameronlive.com/basic-tools/morning-pages/

Just still your inner critic and write 3 pages about anything and everything! Every day. In long hand.

I have tried something similar to this but its self tests still don't pass. Will give this a try. Thanks!

Translating a K expression into something much more readable won't likely help you as the language is extremely compact. So for example, translating "ab",/:\:"cd" to ((each-left (each-right concatenate)) "ab" "cd") will still be inscrutable to you. But you can experiment with k, one expression at a time, play with its builtin operators and incrementally build up knowledge. Long before you get really proficient in it, you will start appreciating its compact syntax.

Without trying you wouldn't know if you are going to love it or hate it. But at the same time, there are far too many interesting things to learn so one has to pick and choose. Ignore what the cool kids of the day are doing or the latest fads. Just do what furthers your personal goals!

Arthur Whitney created a compiler called b that “compiles a language that is isomorphic to c” (his words) and compiles 1000 times faster than gcc etc. The b language code looked very much like k but was essentially exactly equivalent to a subset of C. I read he abandoned it for other reasons but that would not be a bad way of writing a k implementation! “Same madness”:-) May be ngn or someone else would get inspired to write a translator from b to C.

ngn/k is certainly a lot of fun to use. I just wish it also worked on OS X (& plan9).

> So f[;x][y] is f[x;y].

f[y;x]

Both Indians and Pakistanis realize just how much they have in common once they leave their respective countries. Just don't let religions or politics divide people!

Not a fan of this song but there are other Coke Studio songs that I love. For instance: https://www.youtube.com/watch?v=gjaH2iuoYWE

Looks pretty good! Some suggestions: it should support tcpdump's command line arguments and start with them as defaults. It would be neat if packets from different interfaces can be shown in different windows.

I’ve used this for years:

  errno () {
        grep \\\<$*\\\> /usr/include/sys/errno.h
  }

There will be a false positive now & then but this is good enough.

> What I would like to see is a "array scheme."

Me too! I even started on this a few years ago but then got distracted!

For most Indian languages you can use IAST & can use an IAST keyboard, as it transliterates sanskrit based letters precisely. Though I don’t know why people don’t just use the original scripts as they are much more beautiful and you can find (virtual) keyboards for them even for ios & android.

https://en.wikipedia.org/wiki/International_Alphabet_of_Sans...

libthread is available as part of plan9port on Unix systems.

Probably this one: https://9fans.topicbox.com/groups/9fans/Tef717f57ede82d4f-M5...

Scheme adapted lexical scoping and block structure from Algol 60. Lexical scoping was a major departure from LISP in 1970s. Call/CC was not in the original Scheme. Probably added in R4RS. Macros came later too. My point was that calling JS Scheme in Algol clothing even less valid than calling Scheme Algol in LISP clothing!

Actually Scheme is Algol in LISP clothing. I don’t know what that makes JavaScript.

Seems more like the users abandoned it! I used it about 8-10 years ago but only briefly.

Thanks for the correction. Should've read the paper when less tired!

That is a different point than "basically abandoned" :-) I do use X11 programs on Unix and MacOS (so far XQuartz works well enough). And probably Microsoft Windows though I don't use it.

See this: https://newsroom.unsw.edu.au/news/science-tech/maths-whiz-so...

Where one of the authors says "So in this sense, our work is expected to be the end of the road for this problem, although we don't know yet how to prove this rigorously.”

Though I confess I am not up on the latest happenings in this area!

The Schönhage–Strassen algorithm is O(n*log(n)*log(log(n))) time algorithm. Fürer's algorithm is better (& impractical) but still worse than O(n*log(n)). Harvey and van der Hoeven's algorithm is conjectured to be O(n*log(n)) but not yet proven. No idea if it is practical!

https://hal.archives-ouvertes.fr/hal-02070778v2/document

This is just an additional tool. Use it if it works for you. For years I used to dump my interesting product/research ideas in individual files - now I moved them in obsidian. Even before then I used to put them in a computation notebook with light green graph paper pages. Writing, sketching, drawing pictures on paper is certainly more creative and freeing (for me) but searching through old notes is harder. Now with Apple pencil (or equivalent) you can get some features of both worlds in one place, with OCR and such. There is a recent free app called collanote that seems quite promising. Still, I’d prefer a cross platform app.

Back in those days you could write to Xerox PARC to request their Tech Reports and a few days later they’d show up in your (physical) mail box! I got quite a few reports that way, learned a bunch, and even did toy implementations of some things such as the RIP, SPP protocols and so on. I learned about RPC from Bruce Nelson’s thesis and got a chance to use it for a client in 1984!

I may still have this Mesa book somewhere.... On a quick rereading I realize it was basically a variation on Pascal, with a few things cleaned up or made more convenient.

it’s there in the graphviz github repo.