Post about programming, interesting repos, learning to program, etc. Let's try to keep free software posts in the c/libre comm unless the post is about the programming/is to the repo.
Do not doxx yourself by posting a repo that is yours and in any way leads to your personally identifying information. Use reports if necessary to alert mods to a potential doxxing.
Be kind, keep struggle sessions focused on the topic of programming.
I get dizzy looking at C-like languages
It's the exact opposite for me. C is one of the few languages that just clicks in my brain, it just feels so natural to me. I've been keeping a close eye on Hare as well, it's very neat.
Everything this just so verbose
At least it's not Rust! I like Rust in concept because of the problems it tries to solve, but hell is it extremely verbose...
Hare is cool to see, I'm personally following Zig as well because of its "No hidden control flow" pledge which is like music to my lisp ears.
At least it's not Rust!
For C-likes at least it should be Rust and not archaic like Java or JS without TS.
I'm personally following Zig as well because of its "No hidden control flow" pledge which is like music to my lisp ears.
I do want to note that Zig is not unique in that regard, however, and Lisp is a language with hidden control flow at least by virtue of having a classic GC.
I tried Lisp (out, at least, Clojure) a while ago, and I find C-like languages (including Rust) more readable.
Also, Lisp has a mandatory runtime, so it can't replace performant languages that do not have such (like C, C++, Rust).
Also, how would a website backend look in Lisp? What about GUI? Communicating with a DB?
Lisp can be compiled down to machine code.
how would a website backend look in Lisp? What about GUI? Communicating with a DB?
The same that it does in any language in broad strokes but with key differences. For GUIs, for example, Lisp s-expressions could represent the widgets of a particular view with callbacks on the widgets to perform actions (you can use macros to build an entire widget/GUI language). Database calls are just s-expressions which transforms themselves into a value when evaluated.
See https://spritely.institute/news/building-interactive-web-pages-with-guile-hoot.html which uses Scheme. There's also the Guix Project
Also s-expressions can be used to model other data such as XML. Scheme has Scheme XML (SXML) which can allow you to write, for example, HTML programmatically in scheme, utilizing the benefits of the scheme language in tandem with the markup. Following that example, for static site generators in C-like languages they have to invent their own DSL for creating templates but for Lisp you don't have that separation.
Also this isn't a dig at C or C-replacement languages like C++ or Rust, but to higher level languages that are "like C" in the sense that they are at a higher level of abstraction but use the same metaphor (idk this is hard to explain, basically not Lisp's "data as code"). Basically my gripe is with things like Python or Java and not with C or its replacements itself.
Lisp can be compiled down to machine code.
However, the fact that Lisp relies on a ('classic' GC) means that it will had a mandatory runtime.
AFAIK, Go is compiled, but it does have a runtime nevertheless, so just being (non-JIT) compiled is not enough.
~~I do not have the time to engage with the rest of the reply just yet.~~
EDIT:
Don't really have much to comment on the rest of the reply itself, so, for clarity's sake I'd like to address the following first:
I am taking another look at Lisp's syntax since more than a decade, and I think I understand why I find Lisp rather confusing to look at (or, at least, I can put my finger on one of the factors). The units of code (so to speak) in Lisp are mostly separated by whitespaces, while, in most of the languages that I have dealt with, they are largely separated by punctuation (including parentheses/brackets; with parentheses being an optional separator in some cases). Also, the fact that functions are also only separated from their arguments by whitespaces (rather than anything else) makes code harder to read.
Following that example, for static site generators in C-like languages they have to invent their own DSL for creating templates but for Lisp you don't have that separation.
I'm not sure how this is different from composing HTML code as a string directly (instead of using a template) in C-like languages.
Also this isn't a dig at C or C-replacement languages like C++ or Rust, but to higher level languages that are "like C" in the sense that they are at a higher level of abstraction but use the same metaphor (idk this is hard to explain, basically not Lisp's "data as code"). Basically my gripe is with things like Python or Java and not with C or its replacements itself.
Going to just mention that I have not used Java, but I do dislike Python for its (lack of a) typing system.
"data as code"
Not sure what this means (in the sense of 'how is it different from other languages?').
I'm not sure how this is different from composing HTML code as a string directly (instead of using a template) in C-like languages.
The difference is that in that case the HTML is programmatically distinct from your programming code. For example, Hugo uses Go as its backend but has its own DSL for creating templates which allows you to use variables set by your sites configuration file as well as do loops and other programatic behavior. Using raw HTML isn't as flexible. Most C-likes have libraries for converting HTML to a data structure that can be manipulated by the language but SXML allows for treating HTML as part of your code with zero abstraction in between because the XML structure works great for s-expressions.
The units of code (so to speak) in Lisp are mostly separated by whitespaces, while, in most of the languages that I have dealt with, they are largely separated by punctuation (including parentheses/brackets; with parentheses being an optional separator in some cases). Also, the fact that functions are also only separated from their arguments by whitespaces (rather than anything else) makes code harder to read.
I find the opposite is true, Units of code in Lisp are symbolic expressions that are delimited by a opening and closing symbol. You really only have to follow the indentation to know when an expression ends or which expressions belong to each other. If you understand the rules of list notation then you can parse any Lisp code everywhere and anywhere (sans un-hygenic macros).
This is lisp's "hello world"
(defun factorial (n &optional (acc 1))
(if (zerop n) acc
(factorial (1- n) (* acc n))))
;; < ... >
Not sure what this means (in the sense of 'how is it different from other languages?').
It refers to https://en.wikipedia.org/wiki/Homoiconicity and it's true that all languages at a basic level are homiconic, but lisp specifically emphasizes that property to allow users to extend the language to any domain they want without having to fundamentally recompile the language to a new specification. The main draw of Lisp is interactive programming where you're writing the program itself within said running program and to me feels like the most free way to program.
The difference is that in that case the HTML is programmatically distinct from your programming code. For example, Hugo uses Go as its backend but has its own DSL for creating templates which allows you to use variables set by your sites configuration file as well as do loops and other programatic behavior. Using raw HTML isn't as flexible. Most C-likes have libraries for converting HTML to a data structure that can be manipulated by the language but SXML allows for treating HTML as part of your code with zero abstraction in between because the XML structure works great for s-expressions.
Not sure what you mean by 'programmatically distinct from programming code'.
I'm honestly still not seeing a significant difference between using an SXML structure (and having to also convert it later, according to the sxml->dom example from the provided Guile Hoot page), and building a string with HTML code in C-likes. Though, I dislike both approaches, and prefer templates, due to the fact that the environment can assist with HTML syntax that way.
I find the opposite is true, Units of code in Lisp are symbolic expressions that are delimited by a opening and closing symbol. You really only have to follow the indentation to know when an expression ends or which expressions belong to each other. If you understand the rules of list notation then you can parse any Lisp code everywhere and anywhere (sans un-hygenic macros).
I mean, in your example, the first line features several keywords/variables/etc. They are separated by whitespaces (and parentheses), with no punctuation in-between to make their separation clearer, and with no apparent way to discern what sort of thing they are. If I didn't know the context of what factorials are, I would not be able to tell what n was supposed to be, for example.
I think that this criticism has actually been voiced by BeanisBrain here.
Parsing C-like code seems to be much easier.
How readable do you find Lisp in codebases with thousands of lines of code?
but lisp specifically emphasizes that property to allow users to extend the language to any domain they want without having to fundamentally recompile the language to a new specification.
Is this not achievable by just defining functions in most languages?
Also, with regards to metaprogramming, have you taken a look at defining arbitrary syntax via Rust macros?
The main draw of Lisp is interactive programming where you're writing the program itself within said running program and to me feels like the most free way to program.
I have, so far, not found REPL to be more than a novelty, to be honest, and, as far as REPL goes, I prefer Jupyter Notebook (which supports several languages, including Python, C++, Rust; not sure if it supports Lisp or its dialects, though) to the default Lisp REPL. Even then, I quite dislike it.
How do you do debugging big projects with REPL?
How do you do debugging big projects with REPL?
For CL (and SBCL specifically): If youre program is running and youve got slynk or slime or similar loaded into it (neccessary for connecting to e.g. emacs) then when you hit an unhandled condition it will break to an interactive debugger in emacs or whatever text editor is connected. You can then evaluate whatever code you want in whatever stack frame you want, including changing function definitions, and select a restart to call (or just restart from a specific stack frame). Its a very fluid experience, you dont lose program state so i find it good for big projects where you might end up deep in the program and have to rerun it from the toplevel.
I'm curious about a couple of points:
including changing function definitions
Is one forced to do it with the standard CLI REPL, or can one edit the code more selectively like how it's done with text editors?
and select a restart to call (or just restart from a specific stack frame)
Do I understand it correctly, that the following scenario is possible:
break is evaluatedIs one forced to do it with the standard CLI REPL
In emacs, you interact with the image in a smoother fashion than typing at the repl; you write your code in a file like any normal project, and then you can load either that file or a single top level form into the image. While this happens using the repl (or the slynk/slime equivalent) it is done with a single keystroke. So youre working in the files and sending definitions to the image.
Do I understand it correctly, that the following scenario is possible:
- Some function is called
- Somewhere during its execution a
breakis evaluated- A programmer redefines the function
- The programmer resumes the program's execution from the point where the problematic function (which is now redefined) was called?
Close. You cant restart from within a function; if you redefine a function you have to restart from that functions call point in the function that called it. Normally instead of doing this programmers establish restarts (a thing that says how to restart from a certain point, which should handle any cleanup thats needed, etc.). But resuming execution is exactly what happens.
error, signal, break, etc.)Jupyter notebook is not the same sort of repl that I'm referring to, its more accurately a literate programming app. REPL is when you load your entire program and then are able to introspect everything while it's running and make changes. It's kind of like having a debugger that you use in tandem with writing new code.
with regards to metaprogramming, have you taken a look at defining arbitrary syntax via Rust macros?
They took inspiration from lisp, but yes rust has macros but they're also hard to understand just like in Lisp if you don't understand them.
How readable do you find Lisp in codebases with thousands of lines of code?
Reading/understanding Lisp codebases is actually easier imo because you can load into a REPL and interactively study each section of the codebase.
I would not be able to tell what
nwas supposed to be, for example.
This is just a comment about liking static typing and there exists lisp dialects that are statically typed. I've omitted the Docstring but usually that would tell you what the parameters are.
Also like in non statically typed languages, you can infer that n is a number type because it's being used in procedures like '1-' which are for numbers.
For example, just remove all the paranthesis from the lisp snippet and see if you cant get the basic structure.
and building a string with HTML code in C-likes. Though, I dislike both approaches, and prefer templates, due to the fact that the environment can assist with HTML syntax that way.
I've been trying to say that lisp can create these templates automatically just by having things like SXML. I don't understand what you mean by "building a string with HTML code"
You can have a iterative loop inside SXML and it follows the same rules as the rest of your lisp code. You have to build a DSL in C-likes.
REPL is when you load your entire program and then are able to introspect everything while it's running and make changes. It's kind of like having a debugger that you use in tandem with writing new code.
As in, LISP programs are commonly made to run in parallel with their REPL interfaces? I was under the impression that REPL usually requires for a program to finish executing prior commands.
They took inspiration from lisp
Apologies, I have tried looking this up, but I have been unable to find anything that would support this claim. Would you mind directing me to a source?
This is just a comment about liking static typing and there exists lisp dialects that are statically typed. I've omitted the Docstring but usually that would tell you what the parameters are.
It's not just static typing. In an expression like (a b c) the a seems to be able to be a function call, or a variable, and I do not see a way to determine that at a glance, compared to something like a(b, c) or [a, b, c].
Also, do docstrings enforce the types, or are they just comments?
Also like in non statically typed languages, you can infer that n is a number type because it's being used in procedures like '1-' which are for numbers.
Sure, but that is still more troublesome than type enforcement, and it's better for relevant bugs to be caught at the stage of development, instead of being discovered in production.
For example, just remove all the paranthesis from the lisp snippet and see if you cant get the basic structure.
That would make things even worse, I would argue. Comparing expressions (a b ((c d) e)) and a b c d e, the former actually informs me of the structure at least somewhat.
Also, on the note of parentheses, I would much prefer for functions to be called like f(x), rather than (f x). A factor that contributes to that is the fact that, with the former syntax, I can tell that that is a function call, and not just two items of some types in a list.
I've been trying to say that lisp can create these templates automatically just by having things like SXML. I don't understand what you mean by "building a string with HTML code"
Not sure how I can rephrase it, but what I have been talking about is composing HTML code the way one would be composing any sort of string, potentially with some additional structures with their methods for manipulating their contents and/or transforming them into the resulting code.
You can have a iterative loop inside SXML and it follows the same rules as the rest of your lisp code. You have to build a DSL in C-likes.
Why is running a similar loop over the contents of a structure in a C-like language not enough in this context?
It's not just static typing. In an expression like (a b c) the a seems to be able to be a function call, or a variable, and I do not see a way to determine that at a glance, compared to something like a(b, c) or [a, b, c].
Now I understand your confusion better: (a b c) is a symbolic expression which evaluates to something else and will always be read a function call of a with args b and c.
If you wanted to set (a b c) as a list value in of it self you would write (quote (a b c)) or '(a b c) as the syntactic shorthand. This is also an s-expression.
When you write lisp, you're writing s-expressions that will be evaluated later. There are no statements in lisp, only expressions.
Also, do docstrings enforce the types, or are they just comments?
No, they don't enforce types via the interpreter, but they are not comments because they appear in documentation. Lisp has comments in addition to docstrings similar to Python.
Comparing expressions (a b ((c d) e)) and a b c d e, the former actually informs me of the structure at least somewhat.
Yes this is confusing because you have taken out the indentation
(a b
((c d)
e)
)
a b
c d
e
This is still unclear, but this is just to demonstrate how to follow lisp code.
Apologies, I have tried looking this up, but I have been unable to find anything that would support this claim. Would you mind directing me to a source?
I can't dig into the specific source, but the macro_rules name comes from scheme's syntax-rules it wasn't an original invention by Rust or taken from C/Cpp. Lisps have also influenced design decisions like functions as first class citizens and closures (lambda expressions).
As in, LISP programs are commonly made to run in parallel with their REPL interfaces? I was under the impression that REPL usually requires for a program to finish executing prior commands.
Nope, the REPL is an evolving, adaptive environment that represents the totality of your program/project. So for example, you have a repl loaded while writing lisp code and you can evaluate an s expression at your cursor and the output will be computed by the repl. It encourages prototyping and iterating on smaller and smaller procedures to create larger ones.
This very much lends itself to favoring functional programming, but imperative lisps can also use the REPL to great effect.
This doesn't mean unit testing/integration tests/debuggers etc are not used, but the Lisp REPL is an example of interactive programming that isn't replicated by other C-likes unless you have heavy IDE support.
When you write lisp, you're writing s-expressions that will be evaluated later. There are no statements in lisp, only expressions.
Apologies for nitpicking, but did you mean that all statements are expressions in Lisp? If there were no statements, surely it would be impossible to actually make things that do anything other than calculate some results, wouldn't it?
No, they don't enforce types via the interpreter, but they are not comments because they appear in documentation. Lisp has comments in addition to docstrings similar to Python.
Yeah, that is what I did mean when I referred to the possibility of docstrings being mere 'comments'. I excluded their role in documentation, as I was only concerned with their direct effect on the code.
Yes this is confusing because you have taken out the indentation
This seems to contradict the formatting used for examples that I see on the Guile Hoot page, as well as your prior factorial example. Wouldn't that mean that that example should have been formatted as something like the following?
(defun factorial
(n &optional
(acc 1))
(if
(zerop n)
acc
(factorial
(1- n)
(* acc n))))Re: readability
(defclass request ()
((url :reader request-url
:initarg :url
:type string
:documentation "Request URL.")
(method :reader request-method
:initarg :method
:initform :get
:type keyword
:documentation "Request method, e.g :get, :post.")
(parameters :reader request-parameters
:initarg :parameters
:initform nil
:type association-list
:documentation "The request parameters, as an association list."))
(:documentation "A general HTTP request."))
Also OOP can be used in lisp in addition to imperative and functional.
Apologies for nitpicking, but did you mean that all statements are expressions in Lisp? If there were no statements, surely it would be impossible to actually make things that do anything other than calculate some results, wouldn't it?
The Interpreter produces the side effects required when the program starts (it does the syscalls, state changes, etc) Haskell is a pure functional programming language that is not a lisp that has no statements but it can also make web applications, data crunching tools, and games.
Lisp can be used in an imperative context with mutability, so it's not locked into one style of programming or the other.
This seems to contradict the formatting used for examples that I see on the Guile Hoot page, as well as your prior
factorialexample. Wouldn't that mean that that example should have been formatted as something like the following?
https://lisp-lang.org/style-guide/
Special forms like "if" and "defun" are highlighted in your editor. There also exists editor plugins that will let you edit lisp through s-expressions (being able to swap two s expressions rather than deleting one and then putting it in the desired place)
This is not the only style guide, each dialect has their own style guide.
The unreadable soup that lisp is may seem to be are macros (which requiring understanding the macro first before using). But macros without context are difficult in any language, not just lisp.
Going back to SXML, there is no special sauce that makes SXML what it is. It simply is a quoted representation of XML tags. There is no API or anything (outside of evaluating SXML to convert it into another representation)
People's brains just work so differently; you roll the dice when you are born, and you are either a functional programmer or an OOP programmer.
Meanwhile every time I've tried to use Lisp it has only deepened my conviction that I never want to use Lisp.
The thing about only using one type of bracket is that it makes it much harder for me to match opening brackets to closing brackets. I see a "[", I only have to check for "]" to find the closing bracket, whereas when every opening bracket is a "(", I have to find one ")" in a sea of ")".
What didn't work for you? I'm curious to know what non-lispers think.
Everything looks the same. Lists look like arithmetic operations look like function calls look like class declarations. I have to sit there and stare at a piece of code for a good moment to even figure out what category of operation it falls under, and the fact that everything is parentheses makes it much harder to tell where something begins or ends. Picking out a discrete instruction and figuring out what exactly is in its scope is like trying to find a needle in a stack of needles.
Lists look like arithmetic operations look like function calls look like class declarations
Well everything is a list 
the uniformity (minus caveats like the quasiquote and quote symbols not being s-expressions but special syntax) is something I really like.
and the fact that everything is parentheses makes it much harder to tell where something begins or ends.
I've also dealt with this when starting out, well formatted lisp code should be understandable if you take out all the parenthesis and indentation is super key.
I really like lisp's emphasis on interactive programming which feels really natural to me compared to the compile-run loop of C-likes.
To me the uniformity just makes everything everything into an unreadable soup, lol. Closest analogy I can give is that it feels like trying to read a book where chapter headings, tables of contents, text, charts, etc. are all written in the same font without any variation in spacing, margins, or text alignment.
Me reading ebooks in .txt format
Dafuq is an S expression
A list of space-separated strings in parentheses
Literally everything in Lisp is one of these
A list is space-separated items in parentheses
A variable assignment is space-separated items in parentheses
A function call is space-separated items in parentheses
A function definition is space-separated items in parentheses
If you want to put one of these inside another (For example, a function call inside a variable assignment) you have to put a parentheses list inside another parentheses list
It makes everything a hellish homogenate soup that's the equivalent of a video game where key interactable objects are the same color and texture as the background
It also has weirdly aggressive advocates. One of them treated my dislike of it as though it couldn't possibly be legitimate, insisting that I hadn't taken the time to properly understand it (I took a semester-long class on it, in which I got an A), while another on this very site wanted to outlaw using any other language to the tune of 51 upvotes.
It makes everything a hellish homogenate soup that's the equivalent of a video game where key interactable objects are the same color and texture as the background
At least it's only one structure to memorize and is consistent with all dialects. Meanwhile C-likes have invented an innumerable amount of special jargon unique to each of them and them only.
A list of space-separated strings in parentheses
Also this is straight up wrong. Atoms are s expressions but not lists.
(I took a semester-long class on it, in which I got an A),
This is a unfair thing to say considering we know nothing about what your semester long class on it was or how that grade somehow makes your assessment more objective. My HS taught racket for its intro CS course and every student hated it and thought lisp sucked ass and were happy to use Python next semester, myself included.
Turns out the curriculum sucked ass (3 weeks to teach a strict functional lisp and then they switch to a modeling language called netlogo that is far away from being a lisp).
None of the students could explain what a cons cell was, or what a linked list was.
I get that you personally don't find it easy to parse, but that doesn't mean that the language itself is unparseable
Of course my assessment isn't objective. Talking about a programming language based on aesthetics and readability is inherently subjective, as I'd hope anyone reading this could figure out for themselves. If you like LISP, keep using LISP. My perspective is my own.
This is a unfair thing to say considering we know nothing about what your semester long class on it was or how that grade somehow makes your assessment more objective.
I understood LISP well enough to get a high grade in a 300-level college course dedicated entirely to teaching LISP under a school and a professor that were both highly rated for teaching comp sci. I learned LISP. I applied LISP. I did not like LISP.
I knew another guy who insisted that I hadn't given LISP enough of a chance, that the only way to properly learn it was through a book called Practical Common LISP. I read this book. I worked through it. It gave very little attention to drilling basic concepts. It introduced macros almost immediately. It did not make it any easier for me to parse LISP code. I did not find it helpful. I still did not like LISP.
Yet another LISP advocate told me that I only thought I didn't like LISP because both of the above methods were bad, and the only proper way to learn LISP was through the book Structure And Interpretation Of Computer Programs. Maybe I'll try that one someday, but I'm getting a bit tired of trying to learn the language only to be told I'm doing it wrong.
I'm sorry, it wasn't right of me to berate you like that.
My first real intro to lisp was using Emacs, so writing lisp had a direct practical advantage to being able to customize and run tools in the editor.
I also read SICP as well. The first few chapters do help in understanding lisp in relation to it being a metaphor for organizing computer programs but it isn't a deep dive into the language itself.
I just felt unreasonably frustrated when people bring up the paranthesis (Language of Idiotic Superfluous Paranthesis) since balancing sexps is a very surface level view of the language that basically never comes up after the growing pains stage (and using an editor that automatically balances parens and allows you to manipulate sexps as a unit). It would be like deriding all of Python because it uses indentation to separate blocks of code and calling it unreadable.
I'm sorry, it wasn't right of me to berate you like that.
We're cool 
Java is home to some of the most verbose syntax, so it's partly that.
"You have to count paranthesis in Lisp" - my well meaning but infuriating instructor.
Meanwhile I'm fighting for my life trying to match braces, parenthesis, angle brackets and a dozen different keywords in one single line.