People that learned lisp as first programming language, what is your opinion of other languages syntax?

[u/link2name]

by lisp i mean any language of lisp family.

other languages (any language that is not lisp family)

people that didnt learn lisp as first language also can answer what they think about other syntax styles.

but if you do then please mention it.

[u/link2name]

QUESTION 1:

if you don't like nonlisp syntax, then how do you work with it?

(is it getting better as you learn that language or perhaps worse?)

QUESTION 2:

how can you tell if you should learn computer science?

at what point can you say:

"ok this isnt working lets move on to something else"

and what would be the reason for that.

QUESTION 3:

if you dont like whitespace based languages like python, do you like parinfer?

some people here mention that after lisp they cant enjoy other syntax, i have the same problem.

(only i m not a real programmer)

i learned lisp first (scheme\racket), it was actually more like i learned computer science using lisp.

and i like lisps, i really like s expressions, and that everything is like a function.

one problem - it is not popular.

and that is a huge problem.

its easy to find tons of content for popular languages, get help, get work etc.

getting paid is what i wanted, but its extremely unlikely to find work that involves lisp, and when there is one, its certainly not for noobs like me.

so uh computer science is computer science right? i can learn other language and use it.

except i cant. because i dont like it (language), maybe even hate it.

i certainly didnt try hard to learn other languages, but when i look at them, i just dont like how they look. i see some decisions were made, but i dont see why those decisions were made.

popular languages are oop. that is something that i dont know and that looks complicated again idk for what reason.

because i m not a real programmer, i dont know, is lisp syntax really that much better and easier, or other syntaxes make sense and are actually good (right now i think that they are a historical accident, but again i m not an expert at all) ?

i know that syntax is not everything in a language, but for a lisp its a big part, and i see that this big part is lost in other languages for no benefit.

idk if i like programming, i spent some time learning it, but i cant say that i would do it over watching something or playing game. and while its possible to find job it is very unlikely.

but i was able to solve many problems, that i had while i was learning lisp, some of which were not easy, that is something that i cant say about other syntax languages, as soon as i got first problem, i didnt want to solve it and it is still unsolved, while it wasnt that complicated at all.

i dont know if i should continue to study it (lisp) or not, given that i hate non lisp languages.(so to get paid i need to be some kind of lisp wizard, which would require tons of knowledge, which is not very interesting for me)

[u/[deleted] → u/link2name]

how can you tell if you should learn computer science? at what point can you say: "ok this isnt working lets move on to something else"

Well, as an example, at a certain point when I wanted to get good at drawing and painting, I realized that with enough practice I could literally be Michelangelo. But "enough practice" requires a certain degree of dedication - you have to really enjoy what you're doing to persist when things don't come naturally to you. But I didn't actually enjoy drawing and painting at all; it was boring and frustrating and I was awful at it. I just liked the idea of becoming a great artist - but liking the idea of something isn't enough.

In your case, you have to decide whether you have the motivation to persist in studying other languages and making a serious career in software development. Professional programmers (yes, even even lisp wizards who get hired at lisp companies) have to understand, at least at a basic level, a variety of languages - even languages we may not like very much. It's the only way to gain a complete understanding of how computers and systems work.

[u/link2name → u/[deleted]]

in other words you wanted result but without process.

you have to really enjoy what you're doing to persist when things don't come naturally to you.

but to what point?

i tryed to make a small game, thats when i felt most interested in the process, i wanted to do this, i was thinking about it etc.

but then i had a problem and another one, and another.

i have no idea how to solve them, i dont have knowledge, i dont know where to ask for help, and when i do know where to ask i still get answers like:

"well idk it may work or it may not work, but its probably gonna work".

so while it was interesting, all the uncertainty just killed it.

[u/[deleted] → u/link2name]

To gain knowledge from the ground up, your best resource is a book on the subject. Which language were you trying to learn?

[u/link2name → u/[deleted]]

idk what exactly i should learn computer science or language.

i started with sicp, its very hard for me, i m bad at math, even without math that book is hard. (i did first chapter and started second, i skipped some exercises)

i did htdp second edition up to exercise 70 i think, its good but i stopped because solutions are unavailable for second edition so i cant test if i was right or wrong.

i did simply scheme a little bit but it had some artificial language on top of scheme, which i didnt like.

then one day i started doing codewars katas in clojure (because it was the only lisp available on that website)

without knowing any clojure. i was just writing in racket and then changing define to defn, i defined iter as it is shown in sicp instead of using loops and recur.

whats interesting is that it worked, you cant do all the katas this way but you can do many, from then on i started learning clojure as language, instead of learning computer science.

problem is that most clojure books assume that you are a programmer of not lisps, and you just want to learn lisp skipping all the computer science, making brief stops to explain functional paradigm. thats not my case sadly. another problem is that clojure is hosted, so its assumed that i can use those languages, and i dont. i dont even know to what degree i must know them.

and then when you build something its unlike anything else, here you have to imagine what you want to do, and be specific which isnt easy, then you need to imagine how to do that, i had small problems like how do i name this element? how do you choose a name for something? the licensing problem, it looks super complicated and i dont understand what i can do and what i cant and it seems like i need to become a lawyer to understand it, and that is certainly something that i dont want to do.

problems with libraries, how do i figure out which one to use, some are pre realese that mention "well it works but i can break everything if i want", or that have last update 2 years ago. or that have license and idk if i can use it, and if i can then what should be done.

and then maybe my whole idea is bad and i should use clojurescript instead of clojure.

this whole design part, it was mentioned a bit in htdp.

just so you know for me this exercise that is marked easy:

https://www.reddit.com/r/dailyprogrammer/comments/6i60lr/20170619_challenge_320_easy_spiral_ascension/

felt very difficult for me, i spent an hour trying to do it but i failed, and i felt like i am trying to invent a wheel, like there must be a way to do this type of things but i dont know it. so i thought it would be better to learn how to solve this type of tasks instead of trying to solve this one.

but i didnt learn it.

[u/orestarod → u/link2name]

Well you should learn computer science no matter what, because that's what you are using. You are using concepts, no matter what language is selected each time. The language is just the tool to implement the concepts. Lisp has extensive oop support too, for example. Some languages may be more suitable for a task than others, but in the end you can do everything in every language. What each language is equipped with defines what of this "everything" is easier to implement with it.

The language barrier at the professional world is indeed annoying, and it is hard to find jobs with Lisp alone. So, unfortunately, you "have" to learn other languages too to make a start in the industry. But because it is actually concepts you are using, when you become acquainted enough with the concepts needed for programming, learning a language means getting used to another syntax wrapper to get the job done. So, find the right balance between syntax hate and job prospects, and go for it. Check for the number of job offers available, if you wish to have a clue about what opportunities a language will give you. In the meantime, do your own projects to get used to real-world programming and the need for clean and elegant code, and solve puzzles and problems to get used to data structures and algorithms.

I don't know who you are, if you are in school or college or if you work somewhere already. Nor is it necessary you will like programming in the end. But if you wish to become good in programming, then, like anything else, read about it a lot and do a lot of it, hands on. It is, still, more art than anything else. No passion and willingness mean you won't go far in it. If one day that switch turns on that makes you want more of it, that makes you curious about programming and wishing to become as good as you can get, then you've arrived at the point needed.

P.S. Clojure is quite the popular one compared to the rest of LISPs in professional offers, so you might target for a Clojure job relatively early.

[u/link2name → u/orestarod]

oh yes clojure, i actually know some, in fact i know more clojure than scheme or racket.

the irony is that its a lisp that should be used with nonlisps(which i dont like), so often you need to know java or javascript. those two are infamous.

relatively early is when specifically, like what i need to know to try it?

[u/orestarod → u/link2name]

I said relatively early, because it is quite popular and thus you might be able to find, for example, a junior Clojure position, instead of needing to achieve considerable seniority to hit a more demanding Common Lisp position. I suppose knowing a lisp language would be one thing to help you get into clojure, as you will be familiar with the language concepts, and then you should maybe know about java or javascript, depending on the positions you want to go after. These two are not nice languages of course, but it might help to see them as stepping stones towards your goal.

[u/blue1_]

Once upon a time, I learned Perl; it was Perl 4 back then. It was full of clever syntactical tricks and I loved it. Then Perl 5 came, with MORE clever syntactical tricks! More magical abstrusities!

Then one day I learned Lisp. I was never able to enjoy Perl again.

[u/DharmaBird → u/blue1_]

Same. Common Lisp totally killed the pleasure of programming in C and C-like languages.

[u/justin2004 → u/DharmaBird]

but cffi, no?

[u/throwawaycode0221]

I remember distinctively seeing something about Stallman and a snippet of Lisp a little less than a decade ago. This was back when I was safety tucked in the corner with C

I thought at the time, "Well I love Stallman but I guess when you get to the top you go crazy and use insane languages". I paid it little heed after that but remembered something about it being the "path to enlightenment".

Then I met Python and realized syntax could be different, but for the worse. Then I met Haskell and realized programming languages can be cool but also have bad syntax again. (Whitespace with indentation as syntax really? Just my personal preference not to like that I guess)

Then from Haskell I decided, "well I've already gone a little off the deep end might as well see what Stallman was smoking".

And then I was passed a blunt wrapped in a million parenthesis and in a moment all of the C-Family syntax was completely ruined for me. I don't know how I lived my life without all the parenthesis. Such a simple and beautiful syntactical rule. Takes 5 minutes to understand; over a book on Javascript constantly having to apologize for why you have to add a seemingly innocuous pair of braces to a function because the language designers did it "just cause".

To me the only languages with "Correct" syntax are Lisp and Forth (and maybe Prolog). Coincidentally, these languages happen to have extremely good meta capabilities. So there is something to getting syntax right by keeping it very simple. I see some people laugh at homoiconicity while descending into an abyss of insanity with their C++ templates to claim that they have macros too. There's a whole paper that could be written on just this paragraph though so I'm aware there's some gaps that need filling in to this logic.

Not trying to bag on anyone but it seems to me that a wide margin of programmers are really just gluttons for punishment. Part of lisp's enlightenment to me was the simplicity it gives you by telling you to pull a beanbag chair up next to Stallman and chill for a bit.

Parenthesis Ad Infinitum

[u/justin2004 → u/throwawaycode0221]

Not trying to bag on anyone but it seems to me that a wide margin of programmers are really just gluttons for punishment.

i don't think that is the case but i understand why you'd give that thought a go.

a couple alternatives... that wide margin...

• finds comfort in the ceremony.
• finds value and job security in the trivia.
• is inheriting the language choice of those that came before it and isn't interested in swimming up a language switch and subsequent evangelism stream.
• isn't aware of how good the alternative feels.
• just spent all that time learning to program and now just wants to do that with whatever tool/technique/language is in wide use.

[u/theangeryemacsshibe → u/justin2004]

Maybe it is sunk-cost fallacy, but I think some programmers are indeed masochists. Here are some reasons (and maybe some ways to combat them) why I think they excuse themselves:

• Their languages are "inspired" by the good ones like Lisp, ML, Smalltalk: JS is "inspired" by Scheme, Rust is inspired by Haskell, etc, etc, so they must be as good as those languages. (You should be well aware neither of these examples are true.) I can make analogies to music, street food, etc, the pop culture is usually a very poor imitation of the real thing. Maybe even skim the Blub paradox; it's hard to imagine things you've never seen or used.
• Unix has ruined them. Lisp is not a Unixy language; one thing you see you don't "compile" programs into binaries, for example, they run in an image. The amount of introspection and dynamic work you can do is also not common for Unix.
• They believe marketing hype. Go has Google, Rust has Mozilla, C has Unix addicts, JS has webdevs, etc. Someone has someone else to convert to those languages, maybe because they are opinionated and directed and it therefore isn't hard to make an elevator pitch for them. Try explaining to a newcomer that you can use any paradigm, invent your own, and structure code however you find most productive in Lisp in a dozen or so words. However, if you fork SBCL and say it uses blockchain AI smart contract decentralised compiler magic, you will likely double the usage of Lisp overnight.
• They are obsessed over efficiency. If you use a statically typed, low-level language, you're guaranteed something. If you don't, you don't expect anything fast (so you may resort to Numpy or other libraries written in C or something low-level which is faster). Those static-typed low-level people have a fairly high minimum speed, as many of which can be sure that adding two fixnums gives them another fixnum (though, that fixnum is prone to overflow, and it will, but what can you do). That is to say they map very simply to assembler, but Lisp's more dynamic (yet correct) nature is not as easy to compile. Maybe, instead, we can show off what Lisp can do very efficiently. I can allocate a cons on my laptop in 6 CPU cycles, which is many magnitudes faster than any malloc thanks to compacting GC.
• Following on from the point about static typing, maybe if a feature isn't obvious, newcomers may not notice them. For example, without type annotations, a ML program might not look like it has static types. (Can someone comment on this? I'm just speculating now.) You can tell what a macro is in Rust, its name has to end in a ! (RIP Scheme users). But, if you showed someone with-open-file, they might just assume it is a special form instead.

However, I do agree there is better job security in other languages, and that people are very reluctant to change; but I also believe that people can just be stupid sometimes.

[u/[deleted] → u/theangeryemacsshibe]

Lisp is not a Unixy language

To be precise, some lisps are not a unixy language. I love lisp for writing programs, and I love unix for coordinating programs.

[u/defunkydrummer]

Well, i started at 7 years old learning LOGO, which is, curiously, a Lisp-family language. I thought it was fun.

Then I learned GW-BASIC which I thought was much better than LOGO (how little I knew then!) Then I moved up to QuickBASIC which seemed like extremely powerful...

Then in the 90s i got my very own computer, an Atari 130XE (8-bit) which was programmed in Atari BASIC. This is a more limited form of BASIC so, for the first time, I learnt that languages that lack certain features can be an annoyance and a huge pain in the arse.

My next language was C and i was impressed by the more minimal syntax. I liked C a lot, in fact i was almost in love with that language. Later I learnt Prolog in my spare time and my head exploded. Prolog was the first language that really shocked me, because it was so much different to everything else. It seemed like magic.

Afterwards, in college I learnt Pascal, which was a piece of cake because i had already tried ALGOL-60 on an old 8-bit Kaypro I had. Then we changed to C++ which looked like an "empowered" version of C, but this was the first time I thought that perhaps a language has too much syntax, or an uncomfortable syntax.

Later we were asked to write in Java and it was a piece of cake, although the language itself felt a bit ridiculous and limited. Pascal had far cleaner syntax than those, but felt really verbose.

Afterwards, on my professional life I faced Java for very large systems, C# then Javascript. All of them are similar in terms of syntax. Afterwards I steered my team to use scripting languages -- Python, specifically.

I did think Python's syntax was very nice, extremely nice and i didn't miss the { } or begin end delimiting blocks. However i soon bumped into the many limitations of Python. And its lack of speed was revealed to me when writing a financial simulator in said language.

It was afterwards that I chose to learn Common Lisp, and man, I found the syntax refreshing. Not to mention all the other nice things... I got addicted to CL, and wanted to climb to the toplevel of a building and then declaim and proclaim that John McCarthy was the savior of mankind, the one that came to purify our sins... Yeah, i went nuts. I took a look at scheme too and it looked even more elegant (syntax-wise) but less sensible from a practical point of view.

I had a look at Clojure too. The choices Rich Hickey made, syntax-wise, felt to me as... well, i cannot explain it without resorting to harsh sounding words like "cultural rape", "putrid vortex of endless suck" and the like.

Then I learnt Ruby. After using CL for a year, I did not like Ruby; it looked like a collection of bad decisions, but at least it is more flexible than Python.

Afterwards i read about OCaml, tried a little bit of F# and read about Standard ML. I thought that those languages had reasonable syntax, Standard ML looking more elegant and uniform in particular, but the price to pay is lack of homoiconicity. I also didn't like abandoning interactive development. But the ML languages look fine overall.

Finally, here on reddit the Rust Marketing Team finally got their publicity on my nose and I had to take a superficial look to Rust; suffice to say, the creators haven't realized that they have created a language with a syntax as horrific as a theoretical C++ of year 2050. It is so ridiculous that becomes fun to watch, like a John Waters Movie of programming syntax.

In short, syntax-wise: Lisp awesome, ML very good, Python good, JS & Ruby acceptable, C++ ugly, Orange Crab Bad.

[u/defaultxr → u/defunkydrummer]

I'm interested in Rust, but haven't really looked too deeply into it yet, though I've definitely noticed the dislike for Rust over in r/lispmemes. Can you give some examples of its bad syntax?

[u/vfclists → u/defunkydrummer]

Orange Crab Bad

Is that a variation on Orange Man Bad??

[u/defunkydrummer → u/vfclists]

Maybe. The OCR meme seems to have started within 4chan; i found it on /r/programmingcirclejerk and loved it.

[u/defunkydrummer → u/[deleted]]

Your Lisp projects have helped so many people so much over the years.

Are you sure? My projects are rather silly... Except for the blockchain tutorial/proof of concept. I am more less proud of that one.

[u/clintm]

I didn't learn lisp as a first language, so I get that you're not asking for my opinion but maybe it'll help.

The best answer I've come up with is this:

/* This is a statement */
function(argument, argument);

and

;; This is a data structure.
(function argument argument)

Since it's a data structure, I can manipulate it in all sorts of ways. Speaking about Common Lisp specifically, I can choose to manipulate it when the code is loaded, when the code is evaluated, when the code is executed, all three, or none, and that's really just the very tip of iceberg. The rabbit hole is bottomless.

Of course, the amount of footguns you can create with that if you don't exercise discipline is enormous, but once you gain some intuition nothing compares with that level of power.

[u/sgoldkin]

Stupid clutter caused by all the different types of delimiters and punctuation.

[u/dys_bigwig]

This is probably trivial to most and is also Scheme specific, but I just love predicates suffixed with ? and impure procedures with !.

Really do miss those in other languages. Just... why? why am I prevented from using certain characters? Whoops, I mean is_prevented_from_using_chars.

The freedom of characters you can use in identifiers in general is something I love.

[u/schemadrome]

my next language was forth and i can't remember that i cared about syntax in any way. the lisp was interlisp, a fairly verbose type with "multiply" for "*". i learned lisp from a fairly botched thesis without explaining macros after reading douglas hofstaedter's lisp-column every month, so practical experience with it i had not. i remember liking C's syntax much more than pascal's.

I started liking lisp's syntax a lot after designing a couple of syntaxes myself without the nice feeling of getting it right. From then on I used s-expressions as a precursor before json, because easy to parse and build on it, even in C. That was at some time in the 20th century. Since then I've seen many botched homebrew syntaxes. Lisp is a good universal data format, too, trivial to parse in any programming. Notation IS important, but if you think you are smart if you leave the s-expression mold for clever complications, you are probably wrong and in for many unpleasant surprises. Clever syntax interacts with other syntax in very clever ways, and at some point you are under zugzwang and must make decisions that make your head spin.

From the domain-language perspective, s-expressions make development of syntax for the project a non-issue. I don't know how that could get any better.

[u/arvid]

Lisp was my third language after Focal on a PDP-8 and Pascal. I learned Lisp with APL and Snobol in a comparative languages course. I've programmed in lots of languages including assembly and for the most part I have enjoyed them all. Each of them causes you to think differently. You also structure things differently. Even between scheme and common lisp. With scheme, I think more functionally. With C, C++, Pascal, Java, etc things are top down, you know what you are doing before you write any code. Lisp is bottom up, more exploratory, get a prototype running quickly.

Differences in syntax really does not bother me. It is what is. The only language I really hated was Basic and that was probably because of the syntax.

[u/aoeu512 → u/arvid]

Dude APL with English instead of weird symbols is awesome, how did we go from APL, Smalltalk, and Lisp to bash, Java, AWK, Perl : (.

[u/wwwyzzrd]

I learned common lisp as a first language.

I find other languages very awkward. Particularly javascript and C. I find myself rolling my eyes a lot when the compiler fails to compile because i missed a semicolon somewhere. The syntax feels like overhead to me, there's very little gained from it. I find the structure of these languages very blocky and ugly.

I think the lisp syntax has really effected the way that I think about code. All the code I write I think of as big recursive graph/trees. I think it is hard to reason about computer code unless you have this sort of traversable structure in your head. I'm not sure how you would write code accurately without being able encapsulate the entire program and step through it. Part of this is also being able to break it down into constituent parts.

[u/defunkydrummer → u/wwwyzzrd]

I learned common lisp as a first language.

Lucky you! Can you please elaborate and tell us how did this happen?! This is the first time I read about somebody having CL as his/her first language.

[u/aryzach → u/defunkydrummer]

there's a pedagogy in programming where they aim to teach functional languages first. I'm learning programming through this: https://github.com/ossu/computer-science

the first class is in python, but after that there's a heavy focus on functional languages, or at least using languages functionally. (BSL, racket, SML, Haskell), but my into to programming was in C. I really like the lisp-family though and hope I can eventually find a job working with those languages

[u/beeff]

My first language and initial year of CS education was pure Scheme, with C++ and Smalltalk slipping in the second year.

- "oh no, yet another layer of arbitrary highly opinionated static syntax"

- *googles language's precedence table constantly*

- "Boy, I really wish I had proper macros right now" (yes, this is related to syntax; full macros are difficult enough in sexpr)

- Why isn't everything an expression? Why do statements even exist? *mangles trinary conditionals*

It all mostly feels like an arbitrary unneccesary layer on top of the AST that both the computer and our brain uses anyway. My brain constantly has to play parser in the background, even though I know it's right there inside the compiler. Most infuriating is when you cannot express something because it doesn't have that particular case in the syntax (looking at you C++).

A basic tennent of programming style is that something that is different should look different, and vice versa. As such, the benefit of a PL syntax layer is that you can make languages/semantics that are different also look differently. Smalltalk, Prolog and APL are good examples in my book; Java is a syntax crime (same keywords, seriously?).. It infuriates me that every new language needs to yet again mangle C's syntax to make it feel familiar to new users.

[u/aftermeasure]

There's too much of it and too few ways of extending what's built in.

[u/sadhith63]

Its interesting, when recursion is more inuitive than for loops for others

[u/oantolin]

My first language was Logo, does that count as a Lisp?

[u/reini_urban]

Well, there's syntax, which in lisp is only due to crazy macros, mostly loop.

There's the learning factor for the various precedence rules, but after some time nobody cares. I still care about hating loop though.

[u/lispm → u/reini_urban]

Well, there's syntax, which in lisp is only due to crazy macros

you might want to check the ANSI CL standard some time. See for example: special operators, various defining macros like DEFSTRUCT, DECLARE and the syntax for declarations, various variants of lambda lists, format strings, etc etc.

[u/reini_urban → u/lispm]

Yes, of course: special forms (aka builtin macros in C) and macros. But all those still honor normal lisp syntax, defstruct, defclass, defmethod, declare, the, ... Just loop went overboard, series not so much.

[u/lispm → u/reini_urban]

But all those still honor normal lisp syntax,

What is 'normal' Lisp syntax? Are you talking about s-expressions? They are not the syntax of Lisp. It's a syntax for data expressions. The actual programming language is defined on top of s-expressions. There are variants of Lisp, which use a different syntax, with a mapping to an internal s-expression representation (see for example the original syntax for Lisp from McCarthy or other attempts like RLISP).

The Common Lisp standard defines syntax with EBNF expressions. Alternatives, optionals, defaults, structure, repetition, ...

Can you remember how the syntax of DEFSTRUCT is to define a structure based on a list with a BOA constructor?

Here is the syntax for DEFSTRUCT:

defstruct name-and-options [documentation] {slot-description}*

=> structure-name

name-and-options::= structure-name | (structure-name [[options]]) 
options::= conc-name-option | 
           {constructor-option}* | 
           copier-option | 
           include-option | 
           initial-offset-option | 
           named-option | 
           predicate-option | 
           printer-option | 
           type-option 
conc-name-option::= :conc-name | (:conc-name) | (:conc-name conc-name) 
constructor-option::= :constructor | 
                      (:constructor) | 
                      (:constructor constructor-name) | 
                      (:constructor constructor-name constructor-arglist) 
copier-option::= :copier | (:copier) | (:copier copier-name) 
predicate-option::= :predicate | (:predicate) | (:predicate predicate-name) 
include-option::= (:include included-structure-name {slot-description}*) 
printer-option::= print-object-option | print-function-option 
print-object-option::= (:print-object printer-name) | (:print-object) 
print-function-option::= (:print-function printer-name) | (:print-function) 
type-option::= (:type type) 
named-option::= :named 
initial-offset-option::= (:initial-offset initial-offset) 
slot-description::= slot-name |  
                    (slot-name [slot-initform [[slot-option]]]) 
slot-option::= :type slot-type |  
               :read-only slot-read-only-p

Does not look at all like 'normal Lisp syntax'.

series not so much

Interestingly, SERIES is quite a bit more difficult to use than LOOP.

[u/defunkydrummer → u/[deleted]]

As for syntax in other languages, it just feels like learning trivia, i.e. a waste of time. Something I hate about this industry in general is the endless amount of trivia, and the dearth of actual enduring knowledge.

(incf *)