11–20 of 226 posts
Take a look at deep learning, Kay. (In a sense, building models is a new type of programming, solving problems that are difficult to describe.)
Or maybe something a little closer to home, like Rust. It vastly improves the state of the world at the boundaries of the software layer.
Earlier quoted context omitted.
Try learning J in a day. It...won't go well -- but in a good way. :-) As you say, for many languages the paradigm is some variation of C, and the concepts are largely interchangeable. Then you approach something like J, where (trivial example) +/%# returns the average of a list by composing three functions: + sums; % divides; # counts; with a modifier / that distributes + throughout the list; and you begin to realize…
J is essentially APL. I think the point is that J is functionally equivalent with many other languages, only differing in syntax but not in paradigm.
This is at least part of the reason that reasonably strong engineers can learn a new programming language in under a day. The paradigms just aren’t that different. I realize there’s a cottage industry of folks creating new languages all the time. But when you read the docs they all bucket into a few categories, and the differences are syntax, tooling and how system services are accessed. All that being said, these th…
Try learning J in a day. It...won't go well -- but in a good way. :-) As you say, for many languages the paradigm is some variation of C, and the concepts are largely interchangeable. Then you approach something like J, where (trivial example) +/%# returns the average of a list by composing three functions: + sums; % divides; # counts; with a modifier / that distributes + throughout the list; and you begin to realize…
Instead, not knowing J, the only† thing that’s weird about that J expression to me, is that both +/ and # are receiving the same implicit vector argument, without any Forth-like “dup” operator needing to precede them.
Are these operators defined to take an implicit single receiver vector? (Maybe whichever one’s on top of a “vector result stack” separate from a “scalar result stack”? Maybe the first one passed to the implicit lambda expression this code would be wrapped in?) Or is syntax sugar here hiding the argument, the way Smalltalk hides the receiver in successive expressions chained using ; ?
What would a compact-as-possible J expression look like, to sum up the contents of one vector, and then divide the result by the cardinality of a different vector?
—————
† Well, there is one other, more technical thing that’s “weird” about the expression above: it’s the fact that, unless +/ is a identifier separate from +, then the lexeme-sequence + / has to either derive its AST by lookahead, or by + being a stack literal and / an HOF. But then % is, seemingly, a binary infix operator. You don’t usually find both of those syntax features in the same grammar, both operating on arbitrary identifier-class lexemes, as it would usually cause an LALR parser for the language to have shift-reduce ambiguity. Unless, I suppose, the lexeme / isn’t lexed as “an identifier” terminal, but rather its own terminal class—and one that’s illegal anywhere but postfix of an identifier.
That's too broad, because it includes the formula =A1*2 in Excel. But at some greater level of complexity, an Excel spreadsheet transforms from "a couple formulas" to "a structured tool designed to keep track of our orders and invoices" -- in other words, a program.
On that basis, the recent advances include spreadsheets, database tools, and JavaScript along with other scripting languages.
Also the amount/cost of memory has improved so that we can use immutable datastructures and functional style in many contexts, which definitely feels like a 'level-up'.
Concurrency has been getting easier too, with many languages supporting coroutines/async and/or threads. Reference capabilities are exciting as in Pony, Rust, or Clean.
In general there's a great convergence where ergonomics are improving (editors, compilers, build/package systems) and each language evolves to adopt features of other languages.
I just dabbled into the Sorbet type checker after not writing any C++ since the 90s, and it was surprisingly browseable/readable and could copy/paste the concepts based on recent Ruby, Java/Go knowledge.
Earlier quoted context omitted.
J is essentially APL. I think the point is that J is functionally equivalent with many other languages, only differing in syntax but not in paradigm.
I would say that you have to think in a different style so would classify as a different paradigm and not just syntax.
Earlier quoted context omitted.
Try learning J in a day. It...won't go well -- but in a good way. :-) As you say, for many languages the paradigm is some variation of C, and the concepts are largely interchangeable. Then you approach something like J, where (trivial example) +/%# returns the average of a list by composing three functions: + sums; % divides; # counts; with a modifier / that distributes + throughout the list; and you begin to realize…
Definition by function/combinator composition isn’t weird to a modern programmer (Haskell does a lot weirder); and vector processing isn’t really weird either — even Java programmers are familiar with chaining transformations and reductions on Streams these days. Instead, not knowing J, the only† thing that’s weird about that J expression to me , is that both +/ and # are receiving the same implicit vector argument,…
J programmers just think differently.
I think Kay's complaint about engineering rigor ignores the explosive growth of programming. Sure, bridge-builders have rigor; there's also probably about the same number of them today as there were 50 years ago. The number of programmers has grown by at least two, maybe three orders of magnitude over the last half century. And more importantly, almost anyone can do it. A kid whose closest approach to structural engi…
If any of the terms that a term depend on change, the result is updated, and all it's dependencies, etc. You can use the system clock as a term, thus have a chain of things that update once a second, etc.
Being able to use both reactive and normal programming together without breaking your brain is a whole new level of power.
It's brilliant stuff, and it seems to have been yoinked from the internet. 8(
Here's a previous thread about it: https://news.ycombinator.com/item?id=27555940
Earlier quoted context omitted.
Try learning J in a day. It...won't go well -- but in a good way. :-) As you say, for many languages the paradigm is some variation of C, and the concepts are largely interchangeable. Then you approach something like J, where (trivial example) +/%# returns the average of a list by composing three functions: + sums; % divides; # counts; with a modifier / that distributes + throughout the list; and you begin to realize…
Definition by function/combinator composition isn’t weird to a modern programmer (Haskell does a lot weirder); and vector processing isn’t really weird either — even Java programmers are familiar with chaining transformations and reductions on Streams these days. Instead, not knowing J, the only† thing that’s weird about that J expression to me , is that both +/ and # are receiving the same implicit vector argument,…
Almost all verbs can be binary or unary, sometimes with surprising (to me, a newbie) consequences. I have no idea how it gets handled underneath the hood.