Nice. I had the same idea and now I see it done without lifting a finger.
I could not make it work to watch a session from my vscode in steamos (it could be misconfiguration from my part), so I don't know if you can alter the speed of the reproduction from there, which would be great.
From my inexistent list of improvements, make it so that 2 video sources can be sent simultaneously, one for the speaker, another for a presentation video. That way you can see the person doing the course, while seeing the important bits, and see the code.
One of my list of dream projects that I might never have time to do, and so feel free to "steal" the idea, would be a eink notepad in where you could code in APL or similar.
APL was born as a mathematical notation, pertaining to the blackboard, so it makes sense to write it using a writing implement. Its terseness would make it ideal for the handwriting world, it's REPL implementation would give quick feedback loops, you could move around input and output streams.
You could be in a sofa, writing the solution, expending most of your energy thinking, not writing, once you got used to the new way of thinking and the vocabulary.
If you haven't tested any array language I would recommend you try to solve things using one, and check existing solutions so you can see how to think differently. Some problems are naturally easier with this approach, some are harder.
You are exactly right that the original vision of APL was a handwritten, non-ambiguous, consistent, and executable math notation. This was never accomplished.
In 2021, I made a prototype calculator designed for iPad and Pencil and wrote four essays called "New Kind of Paper" describing this concept. The video demonstration of the prototype [Demo] sums up pretty well how it might be used.
In 2024, Apple released Math Notes, which implements this concept for standard math notation. My "review" of it is at [MathNotes]. In short, it is currently a preview of a damn great tool, but its future depends on notation and expressivity.
APL is a language from 2066, created in 1966. While its semantics make more sense now due to machine learning, syntactically it remains alien to most people. Backus' FP/FL and Iverson's J are more approachable to current programmers, but still not there. In New Kind of Paper, I created a tiny language called Fluent, which is nowhere near the ambition of any language mentioned, but it is intentionally designed to be handwritten. A week ago, I open-sourced it. [Fluent]
There is plenty of work left to do, but it is a good start.
I would probably just go for an Android eink tablet like the ones made by Bigme and Onyx Boox.
It looks like there are a few APL implementations for Android out there, or you could use a remote editor or terminal app to access an APL implementation running elsewhere.
200 years ago slavery was more extended and accepted than today.
50 years ago paedophilia, rape, and other kinds of sex related abuses where more accepted than today.
30 years ago erotic content was more accepted in Europe than today, and violence was less accepted than today.
Morality changes, what is right and wrong changes.
This is accepting reality.
After all they could fix a set of moral standards and just change the set when they wanted. Nothing could stop them. This text is more honest than the alternative.
By definition if you're using the word "considered" you're making some claim that slavery is objectively bad. You can't simultaneously say that morality changes, that what is right and wrong changes, and then say "slavery though is bad objectively it's just people in the 1700s didn't consider it as bad as it is."
Don't you see how that seems at best incredibly inconsistent, and at worst intentionally disingenuous? (For the record I think 99% of people when they use a point like this just haven't spent enough time thinking through the implications of what it means)
I was explicitly trying to avoid making a personal judgment over the matter on the posts. I do have a negative opinion about it, but that was not of importance.
I don't know for sure how people considered slavery 200 years ago, I haven't studied enough history, but the slavery that is more commonly known as slavery was legal. That implies that at least more people accepted that than nowadays.
Nowadays that kind of slavery is frowned upon on at least on the first world.
Modern day slavery has plenty of aspects, and some of them are not considered bad by some part of the population, or not considered a modern iteration of slavery. Working full time for a job that doesn't pay you enough to survive and needing subsidies, not having enough time or energy to look for something better, is IMHO bad and slavery, while for lots of people it is the result of being a lazy person that needs to work more.
Is that situation bad? According to me, yes. According to some economical gurus, no.
Is that situation objectively bad? That is a question I am not answering, as, for me, there's no objective truth for most things.
Perhaps that statement could be read to imply the existence of an objective moral status, but I don't think societal "consideration" does in general. Does this statement? "200 years ago slavery was considered moral; now slavery is considered immoral."
I don't think it implies either is objectively correct, and perhaps this was the intended meaning of the original statement. It might appear to put weight on current attitudes, but perhaps only because we live in the present.
I think your right the statement in and of itself doesn't imply any morality. My issue was with these two sentences in close proximity:
> 200 years ago slavery was more extended and accepted than today...Morality changes, what is right and wrong changes.
In the context of the comment that's replying to (arguing for an objective, and if I can read between the lines a bit, unchanging moral truth) even if it's not explicitly arguing that slavery 200 years ago was fine, it is at least arguing that under some specific mix of time and circumstance you could arrive in a situation where enslaving someone is morally just.
I miss MSAccess, but for the modern age. It has been replaced by basic CRUD using your platform of choice, but it's not as easy.
That would be similar to your solution, so either one would work.
I think that there might be some similar alternatives (maybe Airtable? probably using Lovable or Firebase counts) but nothing that is available for me for now.
APEX is probably just as widely used now as Access was. Access likely had higher market share but of a much smaller market. There are gazillions of APEX apps out there.
Spreadsheets are the killer apps. Since I became pointy haired sheets and documents are the fuel of most what I do. Even things like Jira we use them only for the bare minimum and we refer to sheets to see how things are going. Not that I think it's sane, but it's what works.
I even have done this first day's advent of code, and the first part of day two, in a Google sheet. Formulas only, so no scripting needed.
What I dislike of RFCs is that some are accepted, but still referred as RFC, for no apparent reason.
I specially dislike when some people try to do the same with internal documentation and still call "RFC 2029 Project Lifecycle" when it has been accepted by all the appropriate parties. It makes it harder to look for than needed, and it's not clear, by the name, if it has been passed or not.
They were going to have to choose a name for the entire document series, irrespective of the stage of evolution each document is in. I don't have a good answer to why they choose RFC for it, though a sibling comment does address that part. What you're looking for is an indicator for the stage in its evolution. That is fulfilled by the RFC's 'Status' [1][2]. You can use it as a search criterion on the rfc-editor website [3].
You wrote "I don't have a good answer to why they choose RFC for it" ... with that prompt you will get a summary of the reasons they chose it, with direct quotes from Steve Crocker and citations, all of which can be checked for accuracy.
But sorry for trying to be helpful. No good deed goes unpunished, as they say.
> But sorry for trying to be helpful. No good deed goes unpunished, as they say.
If that was your intention, I apologize. I misunderstood what you were trying to say. But looking at the score on that comment, I don't think I'm the only one who misunderstood it. These comments may need a bit more effort to avoid this confusion. Meanwhile, please don't take it personally - I wasn't trying to insult or be disrespectful. I was just trying to convey that it was annoying. Anyway, thanks for the pointer! I will check it out.
I appreciate the apology ... but the problem isn't a lack of effort on my part. Many people here make little effort to understand what others are trying to convey and take a hostile uncharitable attitude at a drop of the hat, especially at the mere suggestion that anyone might conceivably derive any benefit from an LLM. I myself am a close follower of Gary Marcus and have extreme reservations about the technology, but the fact is that for now they are useful tools.
BTW, you might want to look at a recent comment of mine,
It's because of my familiarity with RFCs and Steve Crocker, who originated the idea, that I had a recollection that he had discussed why they were called that, and prompted the LLM for details.
This is only a tiny part of the trainwreck that is IETF and IETF-adjacent document nomenclature.
IETF documents start as Internet-Drafts, which officially are just draft documents that can be changed at any time. As a practical matter, some I-Ds really have no status and some have been accepted by WGs to work on. You can tell which are which because (mostly) the latter are named draft-ietf-something. As WG documents progress, it's not uncommon to see very wide deployment based on an I-D (this was the situation for QUIC and TLS 1.3), whereas other drafts are just totally half-baked and nobody is deploying. There is no good way to know which is which without paying attention.
Inside the IETF, RFCs can be published be any of Standards Track, BCP, Informational, or Experimental. Nominally, the first group are really standards (see asterisk below), whereas the BCPs are normative but not really standards (e.g., they might describe how the IETF is supposed to run), whereas the latter two are not standards. Except sometimes they are de facto standards, like RFC 6962, specifying Certificate Transparency (note that there is another RFC for CT, RFC 9162, which nominally supercedes RFC 6962, but is not widely implemented). There are two standards levels, Proposed Standard, and Standard (there used to be a middle one, Draft Standard), but as a practical matter lots of specifications stay at PS forever because the WG or authors can't be bothered to get them promoted to full standard. QUIC, TLS, and HTTP are all Proposed Standards.
Moreover, there are other IETF-adjacent organizations that publish RFCs, such as the Internet Architecture Board (IAB) and the Internet Research Task Force (IRTF). These documents aren't standards at all. Finally, there is an Independent Submissions Editor (ISE), appointed by the IAB, who basically can publish whatever he/she wants on the Independent Stream. Note that this is different from an Individual Submission, which is a document processed by the IETF without going through a WG.
The discussion continues for the lifetime of an RFC, even after its acceptance. The idea is to continually keep it in a challenged state so that we remember anything can be possible.
If we desire something new, the RFC invites us to build upon it and not accept it as gospel.
Whether you, your project, or your organization accept it is completely disconnected with the concept of the RFC. You may procedurally accept it as unchallengeable gospel, but the truth remains that you can always have an opinion about it regardless.
The nicer format is "X Change/Improvement Proposal" or something similar, shorted to "XCP/XIP". Not sure where it originally comes from, but is pretty popular in various protocol circles, Bitcoin Improvement Proposal (BIP) is one example.
There are NIPs (for Nostr), PEPs (for Python)... But they all have the problem that parent is complaining about. The possibilities/proposal part of the names remain even after they have been accepted or rejected.
It kind of makes sense! First you make a proposal, and then it's a accepted proposal or rejected one. Just because it changed state doesn't mean it's no longer a "proposal".
Compared to a RFC. If it's accepted/rejected, it's still a RFC, which isn't really true anymore, comments are no longer requested.
FYI naming it Catalan Spanish would be akin to naming Welsh as Welsh English. Catalan and Spanish (also known as Castilian) are two different languages, like French and Italian.
So it's normal that you didn't understand much, as even it having some words that are similar the tonalities and some of the constructs are very different.
And they might have been speaking in Balearic, which is a Catalan dialect, and that's sometimes even harder to understand.
I don’t think it is akin; Welsh is almost completely different to English with only a few modern words in common. Just try reading some Welsh as an English speaker. It’s unintelligible.
Catalan is very much a Latinate language, and anyone who speaks Spanish or Italian or French (or even English) can guess the meaning of a lot of words and understand the grammar quite easily.
One of the projects that I have only in my mind space is an Iversonian language with more data structures and the tools to easily navigate an traverse them. Trees, graphs, ... the sky is the limit. And with the power of notation as a tool of thought, and a pen interface, it would be fun to do whiteboard sessions that produced real code that could be executed as is.
OTOH I read/heard that the beauty of array languages is that they have few data types, but they can be easily worked on. So maybe the answer is not easier tree traversal primitives, but better literature/training on how to transform it in a more manageable data type.
Sometimes the answer is to adapt our vision to our world, sometimes the answer is to adapt the world to our vision.
It's the other way around. Python notebooks fall short compared to this because they don't have the same kind of interactivity with the data as GT has.
A single tool in the toolkit is already equivalent to notebooks, at least from what I glimpsed at the introductory video. Then you have the rest of the tools, how it can easily inspect the objects, and probably manipulate them.
This is probably one of the future ways in which we will work in programming in the future, when someone creates some similar tool, around a mainstream language, that can easily interact with LLMs, APIs, and data visualization tools.
In fact, there is already LLM integration including programmable chats with the possibility of contextualizing the interface of each message in the chat :)
I could not make it work to watch a session from my vscode in steamos (it could be misconfiguration from my part), so I don't know if you can alter the speed of the reproduction from there, which would be great.
From my inexistent list of improvements, make it so that 2 video sources can be sent simultaneously, one for the speaker, another for a presentation video. That way you can see the person doing the course, while seeing the important bits, and see the code.
reply