11 ms·
Stages of Denial
- raldi 5y agoI guess the ending is supposed to be a joke, but because the piece never explains what | means, I couldn’t figure it out.
- galkk 5y agoI guess it means "max" or something like that (comparison operation?), and |/ means "max of an array". Author builds this up by showing how long is writing "max" function with other approaches (iteration, reduce). Can be wrong though
- revolvingocelot 5y agoExactly. From the K2 manual [0] referred to in the article, |/ is "Max-Over". The ostensibly-unreadable K manages in two characters what the article's subject and coworker need either three lines of boring loop or one line of a more cognitively-demanding lambda to accomplish. ...FWIW my understanding of the language is such that I would have suspected the last line of the article to read "|/ list". I thought Max-Over needed an argument. [0] pg36, http://web.archive.org/web/20050504070651/http://www.kx.com/technical/documents/kreflite.pdf http://web.archive.org/web/20050504070651/http://www.kx.com/...
- LAC-Tech 5y agoSo are array languages polish notation? +/!100 feels like the opposite way you'd write it in some kind of RPN concatenative language 100 ! [ + ] /
- Jtsummers 5y agoNot quite. + isn’t the last thing done (which it would be in Polish notation). Instead it’s done during the / operation. Polish notation would be lisp (or the notion most people have for lisp, special forms and macros break it up a bit).
- LAC-Tech 5y agoLisp is polish notation for trees of variable arity. hence all the parens - you need some way to group them. So in some K flavoured LISP I think it would be ((/ +) (! 100))
- CraigJPerry 5y agoYou read it strictly right to left, weird idea to me but it’s common in the array languages - j and APL do it this way too. I believe the reasoning is something like Iverson (or maybe Whitney) didn’t like the complexity of PEMDAS in maths so decided on this rule.
- razetime 5y agoIverson wanted consistent symbols and rules for math notation. So it's math first, then programming language next. Makes it extremely strong with describing algorithms, but gets a bit complicated for programming.
- tzs 5y agoIn Polish notation all the operators are prefix operators. In APL family languages there are infix operators and prefix operators. Prefix operators take as their operand the result of everything to their right. Infix operators take as one operand everything to their right and take as their other operand the first thing on their left.
- jitl 5y agoMath.max(...list)
- arthurcolle 5y agoEnum.max(...list) ;)
- LAC-Tech 5y agoHuh, I had no idea that function had variable arity. Thanks.
- creata 5y agoFunnily enough, that variable arity is mentioned in the article as a nuisance: > ... wincing slightly at the lambda notation you need to avoid running afoul of JavaScript’s variadic Math.max()...
- goto11 5y agoIt is a typical language-comparison strawman. He is writing list.reduce((x,y)=>Math.max(x,y)) To get the max number in a list. And he is "winching" because he can't write: list.reduce(Math.max) Because the variable arity of max does not play well with reduce. But because of the variable arity he can write: Math.max(...list) Which is even simpler. So he deliberately writes overly complex JavaScript code to show how the other language is more concise.
- LAC-Tech 5y agoIIRC the spread syntax only works with relatively small arrays, because it's function application at the end of the day. So worthwhile keeping in mind that the nice JS code falls apart.
- goto11 5y agoFair point. In any case, if you wanted to do more than trivial array processing in JS, you would use a library like lodash which have an array max function. And if you think lodash is still to verbose, you can define your own: const å = list => list.reduce((x,y) => Math.max(x, y)); Now you can write å(list) to get the max value of an array!
- smoldesu 5y agoOne important thing to remember about esolangs like this is that theory != implementation. Just because Brainfuck "theoretically" exists as a language doesn't automatically solve issues like memory management or extensibility. Sure, maybe it is more ergonomic to write some functions in K. But, as with most code-golfing languages, the goal isn't to build a better language, it's to build a faster one. Maybe K can run those programs faster than Lisp/C/$FAV_LANG, but it's ultimately up to a much smarter programmer to implement that bit.
- wging 5y agoK is not an esolang and was not designed for golf; it has real users. https://en.wikipedia.org/wiki/K_(programming_language) https://en.wikipedia.org/wiki/K_(programming_language) Also, the primary goal is not always speed... runtime speed or speed of development. There are other things we trade off for all the time.
- the_af 5y agoIt should be noted that, according to Wikipedia, the K language isn't a toy language like Brainfuck but an actual language successfully used for a suite of financial software. It was developed for this purpose, not for code golf.
- TeMPOraL 5y agoK language and APL family languages are serious business, though. And they get a head start on "extensibility" and other nice practical properties - notice how all those single-character operations are inherently and extremely composable.
- anyfoo 5y agoI'm torn. Not about the conciseness of the language overall, but about using symbols vs. names. I do see how the symbols make things more concise, less clutter, and can even make it easier to grasp a piece of code if you are deeply familiar with them[1]. On the other hand, there might be a limit. I do know how it is to use the Haskell lens package only occasionally, and then having to lookup again what the operators read out loud as "percent-percent-at-squiggly" and "hat-dot-dot" stand for (withIndex and toListOf respectively). But arguably, the ones that are long and seldom used need looking up anyway, and their name is not that much more useful maybe? [1] Also compare "2+2*8" with "sum 2 to the product of 2 and 8", or even just "sum(2,prod(2,8))".
- initplus 5y agoThe trouble in Haskell is that an operator like %%@~ is just an arbitrary name. In languages like K or APL, the combination of symbols is the actual definition.
- anyfoo 5y agoAs APL shows, you then need quite a large alphabet of symbols, though. But I'm not strongly in either camp. A few common branches of mathematics taken together have quite a large alphabet of symbols, too, and we work well with it. It feels like symbolic notations can seem obtuse at first and be hard to get into, but once you're used to it the alternative may appear worse.
- neolog 5y ago> As APL shows, you then need quite a large alphabet of symbols, though. I count 71, which doesn't seem like a lot.
- still_grokking 5y agoThat's more than key-words in most languages, I think.
- chiph 5y ago{x#x{x,+/-2#x}/0 1} I'm sure if you used K for a year or so, that would be obvious and understandable at a single glance. But all I can think of is that I used to see that in my terminal session right after my modem got disconnected.
- rak1507 5y agoBeen doing k for a bit (under a year). A single glance is optimistic, but probably only took me a few seconds. Almost certainly faster than any equivalent code in any other language. It's even easier if you give it a nice name, like "fib".
- pabs3 5y agoWhat kind of projects does K get used in?
- rak1507 5y agoI don't use it professionally or anything like that but most of the real world use as far as I know is in finance stuff.
- WillDaSilva 5y agoMainly time-series data processing through kdb+. There's an IDE and language tools for q (which is a thin layer over k) that is primarily written in q called: https://code.kx.com/developer/ https://code.kx.com/developer/ Unfortunately it's closed source so I can't share much about the world of application and library development with q/k. If you want to learn more about how it's used though, I'd recommend checking out KX and kdb+.
- razetime 5y agoThis website has a few companies which use K: https://github.com/interregna/arraylanguage-companies https://github.com/interregna/arraylanguage-companies
- travisjungroth 5y ago
- tarxzvf 5y agoJust replace K and JavaScript with German and English to see the vacuity of this argument. Either of several possible representations can become native to one’s thinking. The question is which is a better aid in reaching some non-arbitrary goal. The only merit of K presented and emphasized here was the supposed brevity of its programs. Personally I’ve found the habitable zone somewhere that allows for more air between ideas.
- nlitened 5y agoHow about this: K is an interpreted language, but your whole program's source code plus the interpreter plus the whole database engine fits inside your server's L1 cache, so K programs tend to be faster than their C equivalents (in addition to all the array operations being highly optimized). And you don't get to waste time scrolling, your typical module's code fits on your single screen.
- mlochbaum 5y agoI know it's all been said before, but the performance take here is somewhere between misleading and wrong. K runs code quickly for an interpreter because it has a simple grammar and a small number of types, but you don't get up to compiled speed just by reducing overhead, so it will lose to C, Javascript, or LuaJIT in this regard. If you can concentrate the program's work in a few operations on large arrays (not always possible), then K might beat idiomatic C. I don't think I've ever seen an example of this. Anything about the L1 cache and K is just wrong, usually. At 600KB the K4 database engine is much too large to fit in L1 (K9 from Shakti is somewhat smaller but still a few times too large). And L1 instruction cache misses aren't a bottleneck for other languages, so there's little benefit in reducing them even to the extent K does it. The long version: https://mlochbaum.github.io/BQN/implementation/kclaims.html https://mlochbaum.github.io/BQN/implementation/kclaims.html
- gjulianm 5y ago> but your whole program's source code plus the interpreter plus the whole database engine fits inside your server's L1 cache, so K programs tend to be faster Is that really the bottleneck? I've done quite a lot of profiling on high performance code and I've almost never hit a bottleneck in the instruction cache. Data access bottlenecks or branching hit performance harder and sooner than instruction fetching. > And you don't get to waste time scrolling, your typical module's code fits on your single screen. How much of the time you save scrolling is spent on decoding an array of symbols and remembering what those symbols are?
- dmor 5y agoWow, this is art Wonder how many people did not skip to the end and then skim back
- Anunayj 5y agoWait... How did that happen.
- BugsJustFindMe 5y ago> a more direct translation into another language might look like: range(100).reduce(plus, 0) That's...uhh...one way to do it. But it's a lot shittier to read than sum(range(100)).
- rak1507 5y agoYes, a direct translation. (Using the reduction)
- jasonwatkinspdx 5y agoYeah, ever since running into this little snippet eons ago, I've found the symbols are better argument for APL style languages quite weak: http://nsl.com/papers/kisntlisp.htm http://nsl.com/papers/kisntlisp.htm Since the arity of all the primitives are known there's less parens than lisp. That seems like the clear sweet spot to me. And I think this is born out with K the product. One of the things they added with Q is a more text oriented syntax. The big a-ha in APL style languages is shifting from thinking about loops and iterating over single elements to transforming tensor like objects. It's a powerful approach no matter what language and syntax you use.
- nope96 5y agoalso posted previously as Stages of denial in encountering K, March 9, 2020, 422 comments https://news.ycombinator.com/item?id=22504106 https://news.ycombinator.com/item?id=22504106
- peterburkimsher 5y agoThe uncanny rapport I feel by reading "lazy Tuesday afternoon, visiting The Orange Website, self-consciously averting your eyes from the C compiler output in a nearby terminal" builds enough trust that I'm willing to pay attention to what John Earnest (IJ or RtG) has to say about this. He's a great writer. Naming things is hard. It's one of the 2 most difficult problems in CS, along with cache invalidation and off-by-one errors. Of course, in this context I mean "CS" as "Computer Science", not "CouchSurfing". For the K programming language, meanings are specifically defined. In the article: "The word “ordinal” can mean anything, but the composition << has exactly one meaning." That's fine for the K compiler, but not for Google Search, or grep. I use "<<" to mean a bit shift to the left, presumably because I was taught C in university. Unique names are more useful for addressing (e.g. IPV6) but common names are more memorable (e.g. a URL. Translators (e.g. DNS) can't be perfect when there's a one-to-many or many-to-one correlation, but they try their best. K does well to enforce structure, but in the process, makes it very hard for the programmer to find examples and other documentation. I guess that's why the language hasn't become as popular as other languages, whose syntax is sufficiently familiar to be legible and memorable but unique enough to be searchable.
- z3t4 5y agoI already have problems reading arrow/inline functions... for example where a method is called with a function that returns a function... if there is one more (async) call in there my brain starts smoking.
- razetime 5y agoIt's all up to preference, really. It took me a while to get around my muscle memory from general imperative programming by the time I started using languages like K competently. Getting that motivation is definitely hard.
- still_grokking 5y agoIt's likely a mater of what you're used to. I start to feel uncomfortable when I see an explicit loop. But that's actually very weird as I write Scala a lot where you use "for" (instead of "do-notation") for monadic computations. My brain starts smoking when someone uses a "for" as an regular loop! That causes usually a few seconds of complete confusion. :-D
- gHosts 5y agoThis is either the most important paper in Computer Science.... or a trivial side effect of representing function composition by string concatenation... http://nsl.com/papers/rewritejoy.html http://nsl.com/papers/rewritejoy.html
- compressedgas 5y agoI have come to call: [A] a = A [A] b = [[A]] [A] [B] c = [A B] [A] d = [A] [A] [A] e = [A] [B] f = [B] [A] This the minimal Joy. [[db]fbcabc[da]cfc]da This program is one I most like. Vg vf gur cnenqbkvpny pbzovangbe.
- eevilspock 5y agoHint: K is the name of the central character in Franz Kafka's The Castle, as well as that of The Trial. > "The term "Kafkaesque" is used to describe concepts and situations reminiscent of Kafka's work, particularly Der Process (The Trial) and Die Verwandlung (The Metamorphosis). Examples include instances in which bureaucracies overpower people, often in a surreal, nightmarish milieu that evokes feelings of senselessness, disorientation, and helplessness. Characters in a Kafkaesque setting often lack a clear course of action to escape a labyrinthine situation. Kafkaesque elements often appear in existential works, but the term has transcended the literary realm to apply to real-life occurrences and situations that are incomprehensibly complex, bizarre, or illogical." ~ https://en.wikipedia.org/wiki/Franz_Kafka#%22Kafkaesque%22 https://en.wikipedia.org/wiki/Franz_Kafka#%22Kafkaesque%22
- turbinerneiter 5y agoI recently started using rust-analyzer with vscode. One common sight is this: thing .stuff() .other() .whatevs() Each of the calls returns a different type. Rust-analyzer displays the return type of each call to the right of it. I imagine something similar could reconcile the benefits of terseness with readability and discoverabilty. The blog post already has the prototype: + / ! 100 plus reduce range 100 Imagine the second line being added in by your ide in a light gray.
- goto11 5y ago> Imagine the second line being added in by your ide in a light gray. So what would be the benefit compared to just writing `plus reduce range 100`?
- DanielR31D 5y agoless keystrokes
- leprechaun1066 5y agoAnd easier to spot patterns in the source files. Whether someone finds that beneficial or not is subjective I guess, but I think it's useful to be able to immediately recognise what something like +/! is doing whenever you see it in source after using it once or twice.
- gjulianm 5y agoIt's a very weak benefit. I don't know about you but most of my time programming is spent thinking about the program, not writing it. In fact, this would only increase the time I need to think about how to write things (what was the symbol for reduce again?)
- turbinerneiter 5y agoI'm not sure, but imagine once you learned it you parse the sentence like a word. Like some of the Asian alphabets?
- TheAceOfHearts 5y agoThis is a category of cursed knowledge which causes psychic damage to the reader. When you go down certain rabbit holes you develop a fascination with obscure forms of programming and start to realize it has some powerful benefits of which you can never take advantage because it isn't widely adopted. To free yourself from this curse write ten regular for-loops in C and say a prayer to K&R while tighly holding your copy of The C Programming Language.
- mqpasta 5y agoAh, true!
- DonHopkins 5y agoCan I write one regular for loop to ten around one regular for loop, instead of ten regular for loops?
- goto11 5y agoI find it rather weird to compare K to C. In what circumstances would the choice be between K and C? A more reasonable comparison would be between say Python with numerical libraries and K.
- danwills 5y agoI know it's a joke but I don't really agree that this area is cursed! It just delves way deeper into syntactical terseness than many programmers will tolerate.. even compared to assembler it's quite a different beast. I think still potentially very interesting if you're keen on expressing the most computation using the smallest number of characters though!
- goto11 5y agoSo it is a language with single-character symbols for the most common array operations like map, filter etc. I think the article tries to make it sound more mysterious and groundbreaking than it really is.
- mr_vile 5y agothe symbols compose in both directions and are aware of tacit parameters, so I don't really think your summary is even remotely correct
- goto11 5y agoBy "compose in both directions" you mean like arithmetic operators like + and * ? No doubt it is useful to have built-in operators for array operations if you have to do a lot of array operations.
- kubb 5y agoI love the bit about junior stanford educated Google employees :)
- deleted 5y ago[deleted]
- pdimitar 5y agoProgramming language syntax is very much like the human languages themselves: it (re-)shapes your thinking. I want to learn things that shape my thinking in a way that makes me more efficient, and in a way that makes it easier to express ideas. If your language isn't giving me that then it's bye bye. I get the appeal but squinting your eyes at a string of single-character symbols is taking it too far. The whole thing has to be somewhat ergonomic as well.
- nine_k 5y ago> Does giving a K idiom a name make it clearer, or does it obscure what is actually happening? There's a balancing act around that. It's called "abstraction". At some point, you cannot afford to know what's actually happening. If you try, the entire problem won't fit in your head. So you cut the thing you're working with to a name and an interface, and forget what's "actually happening". You do that right in the K code, because you e.g. cut your understanding of `/` to "fold the array with the preceding operation", and totally don't think about the way it's implemented in the machine code. This, of course, does have a cost; the simplest case is inefficiency, worse are circuitous ways to arrive to logically the same result, when a much simpler way exists. I'd argue that `/` or `+` are very much names, of the same nature as `fold` or `add`, just expressed shorter. So if you prefer point-free style, you can likely do a very similar thing in, say, Haskell (and some people do). I'd hazard to say that APL and J are DSLs for array / matrix numeric code. They allow to express certain things in a very succinct way. What APL traditionally had, mmm, less than ideal experience was I/O, because the language is not optimized for the branchy logic required to handle it robustly. K is a next step that allows to escape into "normal-looking" language with long names, explicit argument passing, etc when you feel like it. Also, I love this idea: «APL has flourished, as a DSL embedded in a language with excellent I/O. It's just got weird syntax and is called Numpy.» (https://news.ycombinator.com/item?id=17176147 https://news.ycombinator.com/item?id=17176147) The ideas behind APL / J / K are more interesting than the syntax, and haven't been lost.
- vintermann 5y agoYou certainly can do points-free programming in Haskell. It's the first place I ever heard of it. Ironically, points-free programming in Haskell has a lot of '.' in it.
- kleene_op 5y agoIn my opinion, the conceal feature in Vim provides the best of both world to the name vs symbol problem. When you want to review your code, you just go into normal mode, concealing all lengthy but frequent names into appealing symbols. When you want to write code, you switch to editing mode and all symbols on the editing line turn back into names I use this feature mostly with python code. One liners making proficient use of lambdas, maps, reduces, and other functional treats are satisfyingly condensed, reducing the amount of attention required to parse each line. No need for custom keyboards. People don't have to parse arbitrary symbols to understand what I wrote because the underlying code remains vanilla. A drawback is that the apparent conciseness tricks me into writing very big one-liners difficult to parse when all terms are expanded.
- gjulianm 5y agoI remember a discussion on HN on this language like a year ago or so. In the end what I got was some extremely weird snippets for very specific little quizzes that someone claimed were faster than with other languages, the argument that "it's shorter" and "but I can work with it". So yeah, if you like it, I get it, go enjoy it. But this smugness of "it's actually better and I'm better for knowing it", it irks me. One of the most important aspects of programming languages is that they need to be used, and K is the single hardest language that I've tried to understand, even with documentation on the other screen and reading just short snippets. A language that people will ignore because they don't even know where to start reading is not that good of a language.
- rak1507 5y agoWhere to start reading: https://github.com/JohnEarnest/ok/blob/gh-pages/docs/Manual.md https://github.com/JohnEarnest/ok/blob/gh-pages/docs/Manual.... maybe If you ever feel like trying it again, and get stuck on something, https://chat.stackexchange.com/rooms/90748/the-k-tree https://chat.stackexchange.com/rooms/90748/the-k-tree is the place to ask :)
- vanderZwan 5y ago> list.reduce((x,y)=>Math.max(x,y)) Honestly, while I like the clarity, I would still dislike it in JavaScript for performance reasons, because in JavaScript reduce is not optimized at all. And yes, I do work on a code-base where that difference is significant. Also, that loop can still be cleaned up a bit in modern JS: let max = list[0]; for (const v of list) { if (v > max) max = v; }
- marrowgari 5y agoA slightly more verbose (less abstract) version of k would be q. Kx (proprietary owners of k/q) have a nice reference page if you're interested in learning more about the language, e.g., where it's used and how it's used... https://code.kx.com/q/ref/ https://code.kx.com/q/ref/
- chronolitus 5y agoMaybe the issue is that the symbols we readily accept are the ones we grew up with when learning Mathematics, + - * / ^ % = .. If 'reduce' and 'map' had widely used symbols, which were taught in school / university as part of the standard curriculum, how different would coding look today?