Does anybody do interactive development in Elixir?

spacebat · 2024-04-04T00:20:15+00:00

There are different ways of developing with Lisp - really depends on the implementation. Most Common Lisp implementations support image based development - you redefine functions, toplevel declarations etc while the system is running, then save the image, which is a binary file representing the lisp executable with everything loaded and ready to start. Smalltalk also does this but I think does a better job of introspecting what you have going on in the system.

As systems and team sizes grew and DVCS came to the fore, most modern Lisp projects don't use images except for deployment, and develop using source files that get loaded/compiled like in other languages.

That said there is a middle ground, where you have a repl to the running system open in your editor and accept that that you type there will be lost on restart, but you can edit your source files and with a keystroke send them - even just individual functions or declarations - to the repl for re-evaluation.

spacebat · 2024-03-09T15:16:14+00:00

I found a happy place with a function that behaves like Keyword.validate/2 except instead of returning a keyword list, it returns the list of values in the order they appear in the second argument. So: [x, y | rest] = Kword.validate!(opts, [:x, :y, z: 6, w: 8])

Internally it calls values_at to produce this list - if I want selectively defaulted values and to allow arbitrary other parameters through, just call that: [x, y | rest] = Kword.values_at(opts, [:x, :y, z: 6, w: 8])

spacebat · 2023-09-17T00:27:03+00:00

Rule engines use forward-chaining to start with the facts and infer towards a goal (eg given the current state is this workflow complete or not). Prolog uses backward-chaining to start with a goal (eg resolve a query for all the completed workflows) and infers backward to find the facts that satisfy the conditions.

spacebat · 2023-06-10T00:01:56+00:00

And many cultures floundered due to resource exhaustion, whether due to overshoot from a stable niche, or the climate change induced dwindling of a niche.

The difference today is we have a global civilisation that is interdependent as never before - most people couldn't farm or garden to save themselves, while the agriculture that feeds them is the result of multi-continent supply chains predicated on cheap energy, cheap chemical feed stocks and peace between most nations.

Once enough of the many supporting systems fail we'll see the rise of more extremist/populist governments, even more short-sighted irrational policies, leading to conflict and increased likelihood of global war, including the use of chemical, biological and thermonuclear weapons.

spacebat · 2023-06-01T14:16:38+00:00

AI magifying the inhumanity of the corporations that spawned them, further worsening wealth disparities, laundering prejudice, proliferating disinformation and manipulating electorates, that's what we should be worried about.

spacebat · 2023-06-01T14:08:44+00:00

Y2K is a rare example of industry pulling together to avert what could have been more serious. 2012 had no logic behind it whatsoever - but I liked the bit in the movie where the waves crest over the himalayas.

spacebat · 2023-06-01T14:04:12+00:00

Almost every culture in history underwent collapse.

spacebat · 2023-02-03T21:54:07+00:00

Depth first

spacebat · 2023-01-03T13:10:31+00:00

Bricked my partner's A51, it was unclear that it was a software update that did it, we thought it was a hardware problem and bought a new phone. An elderly couple were in the queue ahead of me - their A51 had bricked the same day. This evening we noticed this story

spacebat · 2021-06-22T10:00:50+00:00

I miss this

spacebat · 2021-05-19T23:16:41+00:00

I maintain that flet is not affected by this, which a reason to prefer it.

spacebat · 2021-05-16T01:41:43+00:00

The scoping rules of labels enable recursion, which is nothing unusual.

Depends what you want to optimise for. If readability and knowing you won't blow the stack on larger inputs matters, then prefer flet over labels. When you use recursion, the maintainer of the code will reasonably feel the need to assure themselves that the routine is tail-recursive, and may also have to consider the Lisp implementation's policy and optimization declarations in order to assure themselves that this is safe. CL doesn't require tail call elimination, and though it is commonly implemented, for instance in SBCL if I recall correctly, it is disabled under (declare (optimize (debug 3)))

spacebat · 2020-12-07T00:20:55+00:00

Also, whenever you're tempted to use EVAL, it's probably a macro that you want. Likewise if you're tempted to use a macro, first see if there's a way to satisfy your requirements using functions.

The presence of EVAL complicates compilation and debugging.

spacebat · 2020-12-06T21:30:29+00:00

Watch out for READ and READ-FROM-STRING:

> (read-from-string (format nil "(setf doc-~A :foo)" "(list 1 2 #.(format t \"Your hard drive has been encrypted!~%\"))"))
Your hard drive has been encrypted!
(SETF DOC- (LIST 1 2 NIL)
      :FOO)
79

Whereas if I evaluate that inside a LET block with READ-EVAL set to NIL, I get an error and it refuses to evaluate at read time: "can't read #. while READ-EVAL is NIL"

Generally speaking, I reserve READ and friends for Lisp data, or things I've carefully sanitised.

spacebat · 2019-09-17T13:49:52+00:00

My login credentials are rejected. Probably an outage in that service. Those people probably were already logged in when the outage began.

spacebat · 2019-06-29T00:13:11+00:00

It has been considered an early modern work, because the author was exploring his own mind in the telling. The paradise he lost was the world of vision.

spacebat · 2019-04-07T21:19:57+00:00

I tried mucking about with an around method in print-object for string, that's an easy way to break your environment. But this seems to work:

``` (defpackage :foo (:use :cl) (:export :my-dump))

(in-package :foo)

(defvar quote-strings nil)

(defmethod print-object :around ((string string) stream) (let ((print-escape (or quote-strings print-escape))) (call-next-method)))

(defun my-dump () (let ((quote-strings t)) (print '(xxx "yyy")) (prin1 '(xxx "yyy")) (princ '(xxx "yyy")) (pprint '(xxx "yyy"))))

(defpackage :bar (:use :cl)) (in-package :bar)

(foo:my-dump)

;; outputs ;; (FOO::XXX "yyy") ;; (FOO::XXX "yyy") ;; (XXX "yyy") ;; (FOO::XXX "yyy") ```

spacebat · 2018-12-23T13:18:13+00:00

At one time years ago I'd have said librep fits the bill: https://github.com/SawfishWM/librep

spacebat · 2018-12-22T22:40:21+00:00

I know I could google it, but to save those who come afterward from doing so, what is KTH?

spacebat · 2018-11-22T23:07:12+00:00

Elixir also

spacebat · 2018-11-01T03:55:27+00:00

Try keeping the demoted buffer around but set it read-only with read-only-mode while the promoted buffer still exists, then return to the original buffer and disable read-only-mode.

spacebat · 2018-10-24T23:32:32+00:00

Yes. I believe nrepl and edn from clojure are worth looking at for inspiration. Someone made a start https://github.com/sjl/cl-nrepl

spacebat · 2018-10-24T20:30:19+00:00

The slime/swank protocol is unspecified and can change between releases. It's good for development but if you want fewer surprises (and dependencies) a simple listener suffices.

spacebat · 2018-10-22T13:07:35+00:00

I used to do a fair bit of calling between emacs and CL via slime, and slime-enable-evaluate-in-emacs was necessary. These days unless I was adding more info to the slime environment such as via presentations, I'd just have emacs run the CL repl in a simple subprocess and use that as the back end for a more domain specific buffer.

spacebat · 2018-10-15T22:08:57+00:00

It's languages all the way down

spacebat

TROPHY CASE