tangentstorm

Yeah, the same idea works for any language, and the software I wrote for it is language-neutral. I just happen to have a history of making J videos. (I haven't actually used the software in a video yet... I was just saying the videos tend to follow that similar narrative structure.)

Decker is amazing. I've started a set of tutorials (decks + videos) as a byproduct of trying to teach my 8-year old daughter to program with it.

https://itch.io/t/6632495/decker-programming-tutorials-video...

Not even remotely. it's just plain vanilla C, with dense formatting. Whitney makes extensive use of macros to completely change the language.

Yes to pretty much all of the above. It's an extremely terse array programming language in the APL family, but with ASCII primitives and strong distributed programming / IPC support. There are also at least a couple companies that still use K3 (I work at one), and no official support from the author (who went on to make other versions of K that are also awesome but completely different).

IMHO the biggest thing holding K back is lack of a production-ready / batteries included open source implementation. (There are a couple nice open source implementations of K but none of them are as feature complete as this one... Plus this one has at least a start on interoperating with .NET)

Perhaps you would enjoy https://internet-janitor.itch.io/decker

He has done this many times on his YouTube channel!

For an example, this guest was particularly clever and charming:

https://www.youtube.com/watch?v=FJP2zkl_44o

J/k. It's me. I'm the guest. :)

BUT: this was our talk after he saw my livestream where I was stumbling around trying to do things in GT early on, so it might help other people.

For one: https://internet-janitor.itch.io/decker

It even looks a bit like Hypercard, by default (it's lo-fi, but there are colors under the hood).

Location: NY Remote: Strongly preferred Willing to Relocate: Probably not Technologies: python, js, kdb/k/j/apl, pascal, rust, go, etc. Resume: https://www.linkedin.com/in/tangentstorm/ Email: michal.wallace at gmail.com

3 decades of experience in web, data, consulting. Currently working on a course to teach programming from the ground up, using assembly language on a virtual machine I've designed, but open to joining the right team.

https://github.com/tangentstorm/

I've livestreamed some of my recent work on YouTube: https://www.youtube.com/@tangentstream

You have unlocked: Irony!!

Oh. I had hoped this was about https://ryelang.org/.

This seems like an awful lot of worrying about a problem that doesn't actually exist.

Yes but in whatever language you're imagining here, a "list" probably isn't the kind of list that lisp uses (linked lists of cons cells).

> Even though you aren’t writing the 3P code yourself, by including it in your project you are committed to understanding it—and refreshing that understanding if you want to upgrade it.

This is a nice thought, but I suspect hardly anyone who uses a framework or library really understands it, or makes the commitment to try.

Obviously, a subset of really talented users eventually learn to understand the framework, but most are at its mercy.

Even then, you can't study every possible framework before choosing one to master - there are too many, and the cost of understanding the foreign code is simply too high.

So I suspect that in general, people try frameworks by taking a leap of faith, and then, sometimes, make the effort to actually understand it later - if and when it becomes necessary.

Is this something you can actually configure on modern processors, or is it more hypothetical advice for future chip makers?

Oh, interesting! I heard other array programmers talking about jq, and (having not seen your website) went off to study the json transformation language, which is also kind of cool, but nothing to do with kdb or q. :)

Nice to see this getting some attention again. I hope some people venture out to learn about the actual J language:

https://code.jsoftware.com/wiki/Guides/GettingStarted

For what it's worth, I've also studied this code a bit. This repo has an annotated and (somewhat) reformatted version of the code:

https://github.com/tangentstorm/j-incunabulum

Good point. I did now. Both models stuck with their second answer.

(I see now I didn't know how to share ChatGPT links properly. Updating the links now...)

I tested their first example in ChatGPT 4.

Interestingly, it gives the correct answer on the first try:

  https://chat.openai.com/share/d86fe16a-9dfd-4753-8eaf-6d2948096ea3

I then gave GPT4 a "chain-of-thought" flavored prompt, telling it to treat the problem like a geometry proof. It gave the same incorrect answer as GPT3 did in the paper. I then told it to "Review your work and check for mistakes." With this follow-up, it checked each line of the proof and was able to find and explain the error:

  https://chat.openai.com/share/c4ce6e98-43e3-4547-a4c8-380c1d1cc5fe

GPT3.5, given the same prompts, was still confident in its incorrect answer:

  https://chat.openai.com/share/1a0be419-092d-4dbb-a6c3-79e61914fd0d

(edited to update links and ask them each version to check its work twice)

I am such a person! I make J videos at http://youtube.com/@tangentstorm (many of them are recordings of live-coding on a single J application), work professionally in another array language called K, and also use forth (one of his other puzzle languages) for various things (currently working on a forth-like scripting language for an animation tool, for example).

I would definitely categorize J as having a strong puzzle culture. Many of the people who use it are just doing it for recreation and to stretch their brains, and insist on writing everything in "tacit" (J's version of point-free) style.

Personally, I'm more interested in building things. Most of my J and K code look like any other scripting language, but just very highly compressed.

I would agree that Haskell is not quite in the same category, and don't get the sense that Haskellers strongly favor a particular brand of bending over backwards to make things happen. But then again I'm not nearly as tuned in to the Haskell community, and he was writing this 14 years ago...

This reminds me of the association between tetanus and rusty nails.

Why would rust make the presence of bacteria more likely? Is it a food source? No, tetanus on a rusty nail was just an example used in an article many years ago.

Sadly, I cannot find a source for the idea coming from an article at the moment. :/

yes, you are the only one. that's part of what makes you special!

[j/k. i like it too, but i'm sure you're still special. :D]

I was able to get ChatGPT 4 to produce a working websocket server in rust fairly quickly I know rust but had no experience with the networking crates or async runtimes.

Getting it to also serve HTTP, it fell into quite a few issues. Part of it was not telling me I needed to enable a feature, and part of it was that it's knowledge was quite a bit out of date.

I actually filmed that whole interaction here:

https://www.youtube.com/watch?v=TFsbMGSOeCY

I also was able to get it to make a working (though extremely basic/naive) SAT solver in J. J is pretty far out of the mainstream, so I had to go through MANY rounds of correcting it. (That was the only time I used up all my ChatGPT4 prompt quota for the 3-hour period.)

Since then, I've stumbled on the technique of presenting it with a rough plan or idea and then iteratively having it ask ME questions about what I posted, and summarizing everything we've agreed so far, rather than just immediately writing code. I find that it's actually pretty good at pointing out things I hadn't considered (security and scaling questions, for example), and asking for clarification.

Most recencly, I've started using it to help me get past the learning curve in languages where I'm not fluent at all (making an animation in Mathematica, and discovering how to do some simple things in smalltalk).

In general, I try to ask it for the most minimal/general example it can give me that shows what I actually want to know. For example, building on the rust web server thing, I asked it to give me the structure for building a restful API with certain endpoints (which "we" worked out "together" using the iterative design discussion method) but just leave the implementations blank, because they would be un-necessary detail for it, and I already knew how to do that part.

Aside from that, I've used ChatGPT 3 in a non-chatting context through GitHub Copilot, and that is a whole other ballgame: it's basically a plugin for Visual Studio Code that acts like a super-smart autocomplete.

It doesn't always guess what I'm about to type correctly right, and the wrong suggestions are occasionally annoying when I'm pausing to think through how to word a comment... But very often now when I start to write a function, several whole lines that were just a vague idea in my head suddenly appear on my screen exactly as I would have written them. (And I mean exactly, including my sometimes unusual code formatting choices...)

I'm still on the waitlist for copilot chat, which presumably is just ChatGPT but insta-trained on your codebase... I'm very much looking forward to trying it, though.

I've had the pleasure of alpha-testing several builds of lil and decker. It's nice to see that it's out in the wild now.

Some of the little applications I made in an hour or two each (with live help from the creator of Lil):

- a plotting program that tweens between two different plots when you move a slider

- a frame based traditional animation program

- a (color!) paint program with reflections for drawing little mandalas

It's actually quite a nice tool for rapidly prototyping all kinds of applications.

Also, I'm not sure if it's obvious from the given link, but there are implementations of both lil and decker in both C and JavaScript, so it's an incredibly portable little system!

I don't know if this counts as major, but I work on a presentation tool written with J and Godot. It's a "time travelling" REPL recorder built atop a console widget library. The Godot integration is written in rust (so also a start on rust integration). Godot provides the ability to sync audio and arbitrary animations/graphics with the console animations.

https://github.com/tangentstorm/jprez

Does trying to build a Youtube channel around J count as professional?

I've been livestreaming a presentation tool / time-travelling REPL for J for a few months now:

https://github.com/tangentstorm/j-prez

It hasn't paid anything directly yet, but my videos probably helped me land my current job.

At work, I use another APL-inspired language called K.

I'm working on an outliner/repl presentation tool (for programming videos) in J, and I started livestreaming the process for an hour each morning.

If you've ever been interested in learning J (and you're up at this hour), come by and say hello. :)

The code I'm working on is here:

https://github.com/tangentstorm/jprez

And if you can't make it but are interested in the stream, past episodes are on youtube:

https://www.youtube.com/playlist?list=PLMVwLeG3bKmmctpRZt7u7...

I once found myself implementing Ulam's spiral in J, and was so taken by the (one) line of code it required, that I made a video about it: https://www.youtube.com/watch?v=dBC5vnwf6Zw

Wait, do you actually know the author? I only ask because he's a good friend of mine, and another friend was just showing me your APE code. Small world. :)