pepper_sauce

I would argue Clojure gets close to it, especially in combination with Meander [0], a lib for declarative/functional data transformation.

Unfortunately, I don't know if Meander is used in any production systems.

[0] https://github.com/noprompt/meander

The definition of liberal in North America is different to the rest of the world. Liberal is not left wing or socialist elsewhere.

And to confuse matters further, I imagine GP is saying 'left wing' and 'socialist' in NA are somewhat diluted compared to the rest of the world.

What's your definition of "low level"? You keep using that word, I do not think it means what you think it means

Really though, I felt similarly to OP until I read On Lisp[0] and Let Over Lambda[1]. They are chock full of explicit examples. You can only learn so much from StackOverflow questions and Quora answers.

I also hear good things about Paradigms of AI Programming, but I haven't read it yet. From Peter Norvig's retro on the book[2], here are the lessons in it which involve macros:

Design patterns can be used informally, or can be abstracted into a formal function, macro, or data type (often involving higher-order functions). [p. 177]

We can write a compiler as a set of macros. [p. 277]

If you can understand how to write and when to use once-only, then you truly understand macros [p. 853]

A word to the wise: don't get carried away with macros [p. 855]

[0] http://www.paulgraham.com/onlisp.html [1] https://letoverlambda.com/index.cl/toc [2] https://norvig.com/Lisp-retro.html

One example that I feel most devs can appreciate is the elimination of "boilerplate" code. How often in your non-macro language do you find yourself repeating the same lines of code with minute differences?

Think about JavaScript before and after destructuring was implemented. How many lines of code and mental effort are saved!

In Common Lisp this is just a macro, DESTRUCTURING-BIND (http://www.lispworks.com/documentation/HyperSpec/Body/m_dest...). Not a fan of the syntax? Just write a macro to modify how you use it.

Macros allow you the programmer to do similar things, but with anything you want. You don't have to wait for a language committee to agree on something, and then a third party to write a convoluted pre-processing system to 'transpile' the code to work. It's built into the language.

I don't think that holds, given the potential scale and severity of memory safety bugs in systems programming.

I'm not saying Rust is the right answer but not paying attention to, or worse, putting our heads in the sand, when it comes to our tools is not the answer.

JavaScript is surpassing everything. The world is a cold, dark place.

+1 Rust, but be warned: the learning curve is high. I work with similar language to you and Rust not only sheds light on low level concerns and safety, but also has an excellent type system. Programming Rust by Blandy and Orendorff, the online Rust Book, and the Rust By Example website are all good resources.

Rust is a lot more verbose than a language like Elixir so it might feel like wading through mud for a while.

I'm also throwing out the suggestion of a Lisp. Homoiconic macros are interesting and difficult. I'm currently reading Let Over Lambda by Doug Hoyte and it's like there's a whole world of technique I had no idea existed.

If you're in the EU, read up on PSD2. It's opening up payments significantly.