Відео

Sounds like Erlang if is like Lisp cond, using a condition for every branch. Haskell does something similar with the constant "otherwise", which is simply True. The main use is as a final catch all guard. Example: collatz n | even n = n ˋdivˋ 2 | otherwise = 3*n+1

There are a few interesting approaches to interpretation. For instance, Forth is an interpreted language with an embedded compiler you're absolutely expected to use, mostly through the : word. Forth doesn't even have a concept of invalid syntax; you just have a different vocabulary after making definitions. And you can freely switch between interpretation and compilation. E.g.: : two [ 1 1 + ] literal ; ( Pauses compilation to calculate 1+1, then takes the result from the stack and puts it in the compiled word two. ) Note that ( isn't syntax. It is a word that consumes input until it finds a ). While defining a word, it's not active in the dictionary, so to recurse you use the control word recurse. Compare rec in ML (and thence O'Caml and F#) or 𝕊 in BQN. GHCI and Hugs make hacks to read Haskell line by line. Because one definition in Haskell often has the shape of independent declarations, you have to add grouping to them for interactive entry. Compare to Python's interpreter requiring a blank line after a block statement. E.g.: :{ countdown :: Int -> [Int] countdown 0 = [] countdown n = n : countdown (n-1) :} If you didn't group them, the interpreter would rebind countdown to only the last definition with no base case, as if each binding was a separate let. Golang is also used in a scripting mode, compiling before execution. Fish is a more regular shell language (somewhat simplified rules for quoting etc). Xonsh is a strange hybrid blending shell and Python. Unix lets you make scripts with things that really don't expect it (easiest with languages that use # for comments). I'm probably digressing again. I'll likely comment again.

Cool discussion! Was enjoyable listening to it.

The primary reason pattern matching is better than IsSome is that you get a scope where the value inside really exists. It prevents accidental access to None.Value (which raises NullReferenceException). We see the same pattern with TryParse, where i only exists if it is valid.

I thought of an analogy for symbols for a programming language in Chinese: the literacy rates are similar but correct writing ability is lower, on the other hand, it allows people who speak different languages to communicate in writing for little additional complexity.

Maybe if you start the translation, the appropriate title will become evident.

C does not predate concurrency; it was written to port Unix, and Unix itself is a pun on Multics, another time-sharing operating system. It's more a matter of layering; C allowed the operating system to be largely abstracted from the details of the particular computer, and the operating system in turn implemented concurrency for users and processes, via tools like pipe, fork, wait, select and alarm. They were codeveloped. Later the standard library abstracted from the particular operating system.

Multithreading fundamentally isn't platform independent; it restricts your platforms to ones where threading exists, and it's platform dependent how they function as well. E.g. most GPUs implement lock-step SIMD threads, preferring to have small cores in thousands of instances, while an XMOS XS1 processor requires a minimum of 4 threads to run at full instruction rate, but cannot host more than 8. Few languages implement a model of their own for it, e.g. multiuser Forth. Most thinly wrap system level APIs. That said, OpenMP is widely supported in C compilers and provides language level multiprocessing. Concurrency is yet another topic (see e.g. AIO, nonblocking IO, select and poll). The core strength of C always was the ability to port programs to different machines. Shoving in too much platform specific stuff into the language is counter to this.

I didn't hear the joke about what would be idiomatic in PHP at 40:22, the captions didn't help 😅

In maths it's called "nabla" (read as if it was italian or spanish) It stands for differential gradient operator

19:05 This is an important life lesson. Interest is a driving force, which can transform work from drudgery to fun. The distinguishing mark of a great teacher isn't field knowledge, it's nursing that interest.

1:04:02 This resembles the Python idiom of "if __name__=='__main__'", but it's additionally required because J has an active IO stream like a Commodore computer; and it's in use for reading the program, like it might be in Forth. It's like using a shell here-document by accident.

34:58 While APL, BQN and J all picked different names for their operands, there's logic to each: APL: Alpha is the first letter, and omega the last. BQN: Functions are often f(x), so x is the monadic argument. w is the letter left of x in the alphabet. J: Same ordering, but x is the optional left operand. A second function is often g(y). Running out of letters is a bit messy. For instance, in GLSL 4-vectors are xyzw, where w is out of order. Even more confusingly those might hold quaternions with the unit order 1ijk.

I'd be delighted to have a chat about Haskell, though the first thing to note is the bye bye hello world program is far from idiomatic. I'll send a GNU Forth version shortly; it matches Scheme nicely with the minimal syntax, but has a totally different view on parenthesis and types.

Bob’s stories resonate with me. The winding paths to J. As a newly minted manager, I understand the pull of programming languages that change the way you think.

Listening to this really highlights the importance of education. We desperately need universal higher education in Canada. Education is too important. They always say we can't afford it and they are ALWAYS lying.

Great stuff! I'm excited to come along for the ride as you embark on your journey into the exiting realm of programming languages. Thank-you!

F# for Fun and Profit is an excellent resource. Have you considered inviting and expert in the language that you are trying out on to provide constructive critique of your solutions? I think that could be both entertaining and educational.

Love this podcast and the whole series. Please keep an eye out for small font size. In long stretches of this there is relevant code on the screen that is unreadable even in full screen and max resolution.

I disagree with the focus on things in stdlib here. The stdlib model makes sense for older languages before packaging, but package managers have changed what's considered effectively part of the "base" language. Also, as another note, basing this example on what C can do at a starting point while not allowing external libraries is extremely limiting from a real code base. As a major example, the lack of a hash map limits you heavily. I think you should likely reconsider this spec to allow some base external libraries to then let the C version use a hashmap.

Really like the cleaned up screen split : ) less noisy and easier to focus on the code

00:01:45 Sure 😀

I have now confirmed that UA-cam shadowbans comments containing BQN or APL on a video regarding BQN and APL, there's no option for the video creator or commenter to do anything about it, and UA-cam simply lie about having a review process. This isn't fixable. All switching the moderation settings did was change from silent deletion to "shadow" deletion. Both are automated and uncorrectable by UA-cam's design. Let me emphasize that. UA-cam is by design making its heuristics, including ML based ones, uncorrectable. They *prefer broken over managable*.

A few BQN notes: •term.Flush and •term.OutRaw to avoid those undesired newlines •ParseFloat to parse the number ⊑×´{𝕩∊"0123456789"}¨ could be ∧´∊⟜"0123456789" UA-cam silently deleted the first comment containing these. And shadowbanned this one, congratulations if anyone other than me ever gets to see it.

I liked this explanation of the value of symbols from the documentation for the goal array language. “In most programming languages, operators work on scalar immutable values (also called atoms), like numbers and sometimes strings too, but containers are handled using loops, higher order functions or explicit recursion. This means that such languages do not need many operators: there aren’t that many interesting basic operations when working with scalars.”

Nice video. Would be interested to see this in Dyalog APL. Looking forward to @abrudz's response video : )