
Ultralisp: A fast-moving Common Lisp software distribution - lerax
https://ultralisp.org/
======
nextos
Slightly tangential, but I wish some Lisp would make a serious comeback and
challenge mainstream languages. For this purpose, libraries are essential. So
better tooling would help, and that's why Ultralisp and Quicklisp are
interesting.

Clojure is very nice. I have used it for several projects. But sometimes I
would prefer not to rely on Java libraries so much, and cleaner stack traces.

Racket may get some critical momentum now, with the whole merge with Chez.

I don't have high hopes for a Common Lisp implementation, as the ecosystem has
become too fragmented and stagnant. But I wish I could be surprised here. Shen
introduced some great ideas to make a powerful static typing an option in Lisp
[1].

[1] [http://www.shenlanguage.org/](http://www.shenlanguage.org/)

~~~
andrenth
Re statically typed Lisp, I’m keeping an eye on Carp [1] which seems to be a
quite active project.

[1] [https://github.com/carp-lang/Carp](https://github.com/carp-lang/Carp)

~~~
simias
Common lisp meets Rust, I'm intrigued.

All these new exciting programming languages over the past ~5 years or so are
quit exciting. I'm starting to believe that in the not so far future we'll
look back on that time period between the late 90s up to the mid 2010s as some
kind of a dark age for programming, where we kept using those inelegant,
inefficient, hacky languages carried by Moore's law and an incredible demand
for new software being written in huge quantity extremely fast, quality be
damned.

Now that the gold rush starts to cool down there seem to be a lot of very
interesting work to take a few steps back and do it right.

~~~
neilv
I think your dark age and gold rush theory has some truth to it. The whole
industry culture and practices changed during that period, _but_ we're
starting to see things like people interested in Rust, even though it's not
pitched as a faster way to make slicker generic Web sites and phone apps.

I'm also hoping that Racket (which is is like a secret oasis community) will
get more attention, and someone will dust off some old Paul Graham writings
about startups and Lisp, and some startups (probably ones who're not just
doing another cookie-cutter madlibs startup) will decide to use Racket
initially. (Disclosure: I have an interest in promoting Racket, because I'd
love to help build startups in Racket, and also recruit top programmers with
Racket as a carrot.)

~~~
andrenth
What do you think are good learning resources for learning racket for an
experienced (functional) programmer? Is there a book that isn’t focused on
learning to program?

~~~
neilv
For an FP person, you might want to instead start with skimming, for half an
hour, the R5RS or R7RS Scheme paper, for the base language from which Racket
grew (don't worry about the first-class continuations unless you want to).
Then go to the Racket Guide or Racket Reference table of contents, to look for
things that you might be looking for from your past FP experience, like
`match` (though it's maybe not used as much as you're familiar with). Then
look into some of the strengths of Racket, like syntax extension and `#lang`.
(If you want additional treatment of syntax extension and `#lang`, see things
like Hendershott's "Fear of Macros", and Butterick's book.) Also skim the
large list of add-on packages, to get a sense of what's there. Eventually read
through the Guide and Reference at your leisure.

There's an imposing wall of manuals at: [https://docs.racket-
lang.org/](https://docs.racket-lang.org/)

Racket isn't purely FP, but it can be used that way, even with the base
language. There's also at least one lazy `#lang`, and you can make more.

~~~
neilv
Oh, you might like another difference between Racket and R5RS Scheme: Racket
has changed some basic Scheme types, like pairs/lists, to be immutable by
default. And various additional Racket types, like `struct`s, also have both
immutable and mutable variants and parts.

------
jlarocco
I'm not sure this is a great idea.

I have a couple projects in QuickLisp, and more than once I've broken them
after I pushed incremental or non-working changes to my repo, didn't go back
and fix them in time, and QL pulled the broken code.

Developing in branches would solve the problem, but not everybody does that on
smaller informal projects.

On the other hand, I've also been annoyed waiting for bug fixes to trickle
through to Quicklisp, so it's not an entirely bad idea...

~~~
phoe-krk
The bleeding edge isn't for everyone.

But then again, neither are monthly releases.

~~~
svetlyak40wt
Pinning libraries using Qlot solve the issue of being on the bleeding edge.

------
dreamcompiler
I don't understand what problem this solves.

~~~
phoe-krk
In the contemporary Common Lisp ecosystem, software is distributed via
Quicklisp[1], which is a centralized software repository, where, once a month,
a new software distribution is created, encompassing the most recent releases
of all software included in the dist. This means that changes in software can
take up to a month to be reflected in Quicklisp.

Ultralisp is a Quicklisp-compatible distribution, except it's a bleeding-edge
one. Each time a piece of software included in it releases a new
version/release/commit, a new dist is created, and the modified software is
available in Ultralisp within minutes.

[1] [https://www.quicklisp.org/](https://www.quicklisp.org/)

~~~
dreamcompiler
Ah. Understood. I solve this problem by forking every Quicklisp repo I use,
and telling ASDF to look in my local clones first. This also solves the
problem of making it easy to submit a pull request when I fix a bug in a
Quicklisp library.

Also -- and this is very important to me -- it means I'm in control of which
version of every library I use. I've been burned too many times by Quicklisp
"updating" a library that was previously working which doesn't any more. Now I
have direct git control over my version coherency and I'm a happy camper.

~~~
taeric
Is this as easy to do as it sounds? Any chance you have documented any curves
along the way?

~~~
dwringer
I have been doing this for a while by following a pattern found here[0]. I
typically follow this and copy every asdf package dependency into the working
directory of whatever project I'm working on [setting the _subdir-search-
registry_ to (list (truename "./asdf-systems/")) and placing the files into a
subdirectory of that name] .This way I have the option to make changes in them
without affecting anything else on the system depending on the same package.
In general this means I use Quicklisp as a (huge) convenience in finding
packages when programming interactively in the REPL, but not in deployment. I
think this setup is also nice because it is dead simple to drop in copies of
asdf packages from the web that aren't found in the Quicklisp library.

[0]
[https://en.wikibooks.org/wiki/Common_Lisp/External_libraries...](https://en.wikibooks.org/wiki/Common_Lisp/External_libraries/ASDF/Configuring_ASDF#Alternative_to_symlinks,_search_directories_recursively)

~~~
dreamcompiler
I do it like this because the asdf central-registry variable (which I can't
write here because of asterisk problems) is supposedly deprecated:

    
    
      (asdf:initialize-source-registry
        (:SOURCE-REGISTRY
         (:EXCLUDE "exclusion-string1" "exclusion-string2")
         (:TREE #P"/Users/me/Lisp/my-repos/")
         (:TREE #P"/Users/me/Lisp/quicklisp-repos/")
         (:TREE #P"/Users/me/main-project/src/")
         :IGNORE-INHERITED-CONFIGURATION))

------
kristianp
Are there any kind of Semantic-Versioning like controls?

~~~
svetlyak40wt
Quicklisp and ASDF do not support semver. But you can use Qlot to pin some
libraries to a particular version.

------
dang
Url changed from
[https://github.com/ultralisp/ultralisp](https://github.com/ultralisp/ultralisp)
to the project page.

------
rini17
uses:

\- docker

\- mailgun

\- s3

 _facepalm_

~~~
dang
" _Please don 't post shallow dismissals, especially of other people's work. A
good critical comment teaches us something._"

" _Don 't be snarky._"

[https://news.ycombinator.com/newsguidelines.html](https://news.ycombinator.com/newsguidelines.html)

