Mark Tarver

To give credit, this a question I'm asking after reading this blog post, but a solution for the stifling unfairness of commercialization in open-source is something I've been thinking about for a good while. The essay "The Cathedral and the Bizarre" on https://marktarver.com is also worth reading, despite that I find some of the arguments to be in bad faith. https://pointless.one/my-next-project-wont-be-floss/

> This is why, across history, the tried and true method of learning a craft is an apprenticeship. And in our modern world, universities are still the best place for such apprenticeship. Not the ones per Mark Trevor's words (https://marktarver.com/professor.html), of course, but a self-respecting university will train their students with progressively challenging and practical assignments. We started with implementing simple data structures and algorithms and solving simple puzzles all the way to implementing toy OSes, databases, persistent data structures, compilers, CPUs, discrete simulations, machine learning models. We started with implementing functions and individual components and quicly to building things from scratch. I'm forever grateful to the training I received in my univerity.

> There was an essay about Lisp being a "language for smart people" Presumably, you are referring to The Bipolar Lisp Programmer[1], an HN classic[2]. [1] https://www.marktarver.com/bipolar.html [2] https://hn.algolia.com/?q=bipolar+lisp+programmer

The author, Dr. Mark Tarver, is perhaps best known for the essay The Bipolar Lisp Programmer: https://marktarver.com/bipolar.html If you want to jump straight into what makes Shen interesting, read Part 10 of the manual, starting with recursive types: https://shenlanguage.org/OSM/Recursive.html

This is the famous "Lisp curse" It was done in / seals its fate https://www.marktarver.com/bipolar.html I always thought this essay was a great take on Lisp, but it's interesting how those sort of statements eventually can self-perpetuate a couple negative events into a state of learned helplessness.

Are you suggesting that Zig never lets you just think about the problem? That's some terrible preoccupation with an idealized concept of a DSL. The swift code examples look kinda slick but it isn't a different paradigm any more than JSX is for building HTML. It seems like a form of The Bipolar Lisp Programmer. https://www.marktarver.com/bipolar.html > Lisp is like wielding an air gun with power and precision. Those Swift examples you show are very exciting, but it's best not to get carried away. It's the same as those that say that vim is terrible because it's modal and don't believe that vim programmers can think about the problem while they're typing because their brain is distracted with switching between modes.

> School needs to fundamentally change especially for adolescent males, it just stacks the decks against the high functioning learn by doing types. The point of school is to teach discipline and grit - the subjects in and of themselves are merely incidental. Do you really think that these "great minds" - the kids who can't sit through a lecture and half-ass everything off of natural talent alone - would be doing great things if it weren't for the evil school system getting in the way? "Smart but lazy" is probably the most insufferable combination of character traits. Nothing else even comes close. (See also: "The Bipolar Lisp Programmer" - http://www.marktarver.com/bipolar.html)

To me this illustrates that your CS undergrad school wasn't very good [1]. In my experience (CS at CMU), it's the undergrad years that are the most brutal and require the most (assuming you strive for excellence and not just passing). I've had friends and coworkers who went to MIT, Caltech and Stanford pretty much agree with this. Those of us who continued to graduate and postgraduate studies, have (generally) found the "mental effort" - not time investment - far reduced. [1] Mark Tarver has written a great essay on this: http://www.marktarver.com/professor.html

Thinking colleges don't matter at all in tech is another extreme. It's like saying one should not go to college at all because Carmack didn't and was very successful. Not everyone is autodidactic. Many people do need structured and well paced training. It is ordinary people who suffer in their career when schools lower their standard. See Mark Tarver's article on this: http://www.marktarver.com/professor.html And speaking of personal experience, mine is exactly opposite to yours. My university made me. If it were not for my university's rigorous training, I would squander my four years, and I would not be able to do what I enjoy today. I owe a great deal to my university, to say the least.

> Could you provide an actual example for this? Lists are given to the reader in angle brackets and come out in parentheses, or at least that's how it looks. I suppose the other possibility is that these are actually different types, but I'm not sure that's better. What is a "produce"? I've never heard this term so used before. How does it differ from a map? > Okay, now give me a break... this... is a "what"? Are you real now? A perfectly sensible and useful feature, a "what"? To be able to investigate function signatures and pass them around appropriately without constant hacking, is that bizarre? I guess airplanes are also bizarre to some... That I half expected something in this nature is what had me in two minds over whether to reply to your prior comment at all. I suppose I'm glad there's not more of it, but really, this kind of attitude adds nothing to the discussion, and it certainly doesn't help make anyone's case that Raku has a community worth trying to be part of. Function signatures, as opposed to functions, being first-class runtime values is objectively weird. Deriving one signature from another at compile time via reflection is unexceptionable and occasionally useful, sure. But the idea that a function's signature in isolation has meaning enough to treat as a runtime value in its own right is something I don't recall ever having seen in close to forty years of programming across a widely varied range of languages. I did some looking around the docs, and…

I think you should separate the concepts of Java (the language) and the JVM in your mind while making your decision. You can absolutely write Clojure without touching Java, but at some point if your app scales you are going to have to understand optimizing and tuning the JVM, that being said, it's no different than optimizing and tuning the underlying OS (from a conceptual standpoint), it just happens to be a virtual run-time. You are not writing Java to tune the JVM as most of it is set by parameters and config files. If you are dead set on no JVM there is always ClojureScript. For reference I have worked in Clojure, CL and a little Scheme, but would not claim to be an expert in the latter two. From my experience Clojure is a LISP built for building user centric apps, where many of the others are an assortment of projects of people scratching their itch. Some good, some bad, some complete and documented, some not. They are very powerful, but seem to have less stewardship to keep the project on focus to be a dev platform for building holistic applications for businesses. while it gets linked to a lot in discussions like this, it's worth noting the following article: http://www.marktarver.com/bipolar.html That is very much what CL and Scheme felt like to me. Also to note, I have never worked with any of the commercial offerings for CL, so take my opinion on the matter with the grain of salt that my exposure to them has been limited to open source offerings.

Lisp is a powerful language that allows one to mix multiple logical levels within a program (especially through it's homoiconicity). Shrdlu is perhaps the most classic illustration of Lisp's power[1], A classic program from 1968-70 that allowed natural language communication about a micro world. It was written in a version of Lisp even more free-form than today. When I looked at the source code a while back, it's parsing of natural language involved a wide-variety of on-the-fly fix-ups and such to take into account the multiple irregularities of human language. The thing about Lisp's power is it allows the production of complex program quickly but doesn't particularly have a standard way of gluing these programs together. The other classic Lisp work, The Bipolar Lisp Programmer[2], describes how Lisp has multiple partial implementations of important libraries and programs simply because it allows a certain type of personality to by themselves produce something that's remarkably good but doesn't encourage any particular group effort. Lisp is certainly evidence that "language matters" but not evidence that Lisp is where one should stop. [1] https://en.wikipedia.org/wiki/SHRDLU [2] http://marktarver.com/bipolar.html

The core thesis of this essay is reminiscent of the Lisp Curse [1] / Bipolar Lisp Programmer [2]. It's been a few years since I read these, but if I recall the argument there, it was that Lisp makes it so easy to build stuff and scratch exactly your own itch, that there's no real strong push for lisp programmers to come together and collaborate to build non-trivial and general purpose artifacts. And that is why the landscape of public lisp software is poorer as a result, compared to languages which demand much more effort to get anything substantial done. Armin seems to be making a very similar point about AI coding. [1] https://www.winestockwebdesign.com/Essays/Lisp_Curse.html [2] https://www.marktarver.com/bipolar.html

Here you go: https://www.marktarver.com/bipolar.html It's been discussed many times on HN.

It's actually more like the past 10 years? (Certainly was when I was in university back 8 years ago) Maybe longer. But, I like to reference https://marktarver.com/professor.html on the state of education in the UK.

Ah yes. More "Free" as in "Do As You're Told" from people who call their source more open than anyone else's. Coming up on a decade later, and if anything we have more to learn: https://marktarver.com/free-as-in-do-as-your-told.html

> There must be some reason Lisp is so popular on HN. sicp is a really good book, but also: https://marktarver.com/bipolar.html

See also: http://marktarver.com/free-as-in-do-as-your-told.html

Those companies are so high-profile, with so many people wanting to work for them, that they can do what they want, and the new hires will keep coming. But in an obscure company, especially one that's not very well funded, it may make sense to use a blub language so the company can attract programmers that it can afford. Of course, using a less powerful language will limit the productivity of those programmers. But having two or three moderately productive programmers is probably better than being dependent on one bipolar [1] programmer. [1]: http://www.marktarver.com/bipolar.html

Standards have been lowered. Here’s a perspective from someone who used to be a tenured lecturer in the UK: http://www.marktarver.com/professor.html

Nowhere did I claim ADHD was a personality quirk. Nowhere did I claim ADHD wasn't real. I'm not disputing the neurodevelopmental pathophysiology of ADHD. I'm questioning the labels society applies to people with such a disorder. I claimed it's not the "attention deficit" people think it is. People with ADHD are clearly able focus when the subject is interesting enough to them. That's a huge contradiction. The truth is probably that school is way too boring for them. I think signal to noise ratio is a good analogy. People with ADHD are easily distracted by noisy stimuli and need disproportionally high signal to focus. Society consistently fails to provide high enough SNR then labels neurodivergent people as problematic. ADHD discussions always remind me of this article: https://www.marktarver.com/bipolar.html I think the bipolar diagnosis is off the mark. Substitute bipolar with ADHD though and the profile fits quite well.

see https://www.marktarver.com/bipolar.html

It is perhaps useful to understand where the author is coming from. The author is very critical of open source on the whole. He has a series of articles detailing criticisms of open source software. http://marktarver.com/problems.html (The Problems of Open Source) http://marktarver.com/open.html (In Praise of Closed Source) He is the inventor of the Qi (later Shen) language (essentially a Lisp dialect with a configurable type system). He experimented with taking it open source. He was very underwhelmed by the results and has made later revisions closed source again. In particular as far as I can tell he felt he was losing creative control of the project and getting little to nothing back for it in terms of contributions and features (and in general very unimpressed with people's reaction to the language and the wider programming community's capability of understanding the language). He has also had at least one argument on Reddit about this (see the post by Mark_Tarver here https://www.reddit.com/r/programming/comments/57h33q/arguing_against_o… This is one article in a long series of events and thoughts for him that have played out over the past decade.

> the author claims that releasing derivative works of Shen under the GPL is copyright infringement Do you have a source for this? The closest I could find was this[1]: > Appropriating other people's work by copying the code and changing the license is IMO immoral. If this is indeed the source material, then I think your characterization isn't _necessarily_ correct. Saying it's immoral isn't the same as making a claim about law. The link provided[2] does indicate that de Raadt thinks it is a violation of copyright law however. Finally, I question whether there is actually a consensus on this matter at all. If you relicense BSD code as GPL, then consumers needn't abide by the GPL; they can simply opt to use the original license. Does that really mean a relicensing has occurred? Of course, in non-trivial cases, there's likely additional code that has been intermixed with the original code, which would make it impossible to separate. But the release of the GPL code would still technically need to comply with the BSD license itself. Even at that point, it doesn't feel like "relicense" is actually correct. (Note that I picked up on this because I firmly believe that such relicensing is indeed unethical, while simultaneously not knowing whether such relicensing is definitely a violation of copyright law or not, while also believing that copyright law shouldn't exist at all.) [1] - http://www.marktarver.com/fsf.html [2] -…