Is it really better than python for example? Is really the syntax the problem? C++ is ugly and it is still used today. Why would the world not use a good tool?

So, I don't have a computer science background. I've been self-taught through the LAMP stack and web technologies (PHP, SQL, javascript) since the late 90s. I've been intrigued by LISP for a long time, but haven't really dug into it yet.

In terms of LISP being a syntax tree itself, the question occurred to me-- does understanding LISP well help you understand "new" syntax you might see in another language? For instance, I see structures in haskell and [insert other languages here that slip my mind at the moment] and it would take some pondering and work on my part to fully grok them to the point where I could "wield" them.

Would learning LISP in a robust way first help me more quickly understand new syntax structures, especially unfamiliar ones, in other languages?

My journey with Emacs began with trying to learn Common Lisp. I first set up my Emacs development environment with SLIME and made myself familiar with some Emacs key sequences. A few months later I am still learning Emacs and I am beginning to love Emacs Lisp.

Emacs Lisp looks like a powerful language on its own. I can execute Emacs Lisp code from command line as a script using emacs --script foo.lisp. I want to know if anyone here uses Emacs Lisp as a full blown general purpose programming language.

[ Also x-posted to https://www.reddit.com/r/lisp/comments/lm03xe/is_it_worth_learning_common_lisp_for_writing/ ]

Notepad++ Markdown Literary Programming with live preview for Clojure (Lisp) that don't break the syntax of any programming language

• Babashka

  • Notepad++/tools/clj/mlp.clj: MLP Babashka script source file
  • Note: for lisp, update "language-clojure " to "language-lisp" in fenced-code-blocks function.

• Preview HTML plugin

  • Notepad++/plugins/Config/PreviewHTML/Settings.ini: file url
  • Notepad++/plugins/Config/PreviewHTML/Filters.ini: file url

• MLP example:

  • Notepad++/tools/MarkdownLiteraryProgramming/MLP_Clojure_Example.clj: source url

• Reference: Markdown Literary programming that don't break the syntax of any programming language

Markdown Literary Programming 01: Code with syntax highlighting

Markdown Literary Programming02: Mermaid flow chart

Markdown Literary Programming 03: Image

Markdown Literary Programming 04: UI + Javascript/Clojurescript (sci)

update: add Markdown Literary Programming 04: UI + Javascript/Clojurescript (sci) , power by https://borkdude.github.io/sci-script-tag/

Hello, I'd like to present you Orion: Orion is a lisp inspired, interpreted programming language.

It is statically and strongly typed and permises a powerful scripting with a simple syntax.

Performances time now: It computes an Ackermann(3, 3) in 7 milliseconds et pushes 1000 elements to array in 10 milliseconds.

It allows metaprogramming, with the macro keyword and the following syntax:

macro <pattern> {<to_replace>}

and pattern matching through the match function that can be used used as following:

(define a "foo") ; variable a with the "foo" value
(match a {
  (=> "bar" { ; executed if a equals "bar"
    (print "A is bar !")
  })
  (_ { ; the _ means "any pattern"
    (print (+ "A is not bar but it is " a))
  })
})

Of course, it comes with a well featured std, that contains mathematical functions, collections relative and files relative ones, etc.

It also comes with an out of the box debugger, that can be used through the breakpoint function.

The "getting started" and the documentation are both available on the repo: https://github.com/Wafelack/orion-lang

Thanks for reading.

I have only studied a bit of Algorithms but I've gone through a few intro programming courses. I struggle sometimes with seeing solutions to new or novel problems that I had not seen before. I'd like to become a better computational thinker and have heard functional programming may help with that.

So last month, I literally did not even know what Lisp was.

A month later, I'd built my own programming language (from scratch in Go), a Lisp dialect inspired by Scheme and Clojure

I also documented my entire journey so you can see the entire process from noob -> little less of a noob

Try it out 👉 lispy.amirbolous.com

Well-documented source: https://github.com/amirgamil/lispy

Journal/Blog post: https://amirbolous.com/posts/pl

I'm reading a book Clean Code by Uncle Bob (it was on my shelf of a while) and he describes Aspect Oriented Programming. Wikipedia say that ELisp advice function is implementation of AOP.

Does any of you was experimenting with Aspect Oriented Programming in lisp language? Does it give any advantage?

I am interested to study how the Logo programming language could be implemented using Lisp (especially Common Lisp).

I have only found cl-logo for now.

Are there any implementations of the Logo programming language in Lisp?

Hello ! I just finished the first version of my first programming language that I wrote in Rust.

It has some bugs (it is just an alpha version) so thanks to report those in an issue (:

It is not blazing fast (~ 200ms for an Ackermann(3, 3) ) but works pretty well.

The repo: https://github.com/Wafelack/nixt/

I'm open to constructive critics and all kinds of questions (:

I just published my new book https://leanpub.com/hy-lisp-python that uses Hy (Lisp built on Python) for deep learning, NLP, graph databases, knowledge graphs, and my tips for using the language.

I have been loving using the Hy Lisp language and so last fall I decided to write a book on the language. I find Hy to be a great hacking language and has super-easy interop with Python.

For my attempt at a beginner project in Programming Language implementation, I have been thinking of writing a small interpreter (and maybe a compiler later) for a Lisp like language(seems the easiest to implement) which would have the BLAS bindings[1] built in as part of the base language.

For BLAS bindings to make sense, the base language should have arrays.

My main source of reference is PLAI (which is why I am inspired to write the language in typed Racket), but it does not go over implementing arrays in a Lisp like language (I know Racket has arrays - https://docs.racket-lang.org/math/array.html). Could you kind readers perhaps suggest a source which would help me learn more about implementing arrays in Lisp like languages?

[1] I found BLAS bindings in Racket -

• https://github.com/soegaard/flmatrix
• https://github.com/farr/PLT-Racket-Linear-Algebra-Bindings

The plan is to bake these into the language as-is.

Hello, I'd like to present you Orion: Orion is a lisp inspired, interpreted programming language.

It is statically and strongly typed and permises a powerful scripting with a simple syntax.

Performances time now: It computes an Ackermann(3, 3) in 7 milliseconds et pushes 1000 elements to array in 10 milliseconds.

It allows metaprogramming, with the macro keyword and the following syntax:

macro <pattern> {<to_replace>}

and pattern matching through the match function that can be used used as following:

(define a "foo") ; variable a with the "foo" value
(match a {
  (=> "bar" { ; executed if a equals "bar"
    (print "A is bar !")
  })
  (_ { ; the _ means "any pattern"
    (print (+ "A is not bar but it is " a))
  })
})

Of course, it comes with a well featured std, that contains mathematical functions, collections relative and files relative ones, etc.

It also comes with an out of the box debugger, that can be used through the breakpoint function.

The "getting started" and the documentation are both available on the repo: https://github.com/Wafelack/orion-lang

Thanks for reading.