Cyrus' New Completely Useless Blog

SBCL 1.4.7 released Lisp

And the train keeps on rollin'. Another SBCL release is out, SBCL 1.4.7. You can find it here, as usual.

Some of the new goodies in SBCL 1.4.7:

  • The core has shrunk by another ~300 Kb (38,149,792 bytes vs 38,444,800 on x86-64 in SBCL 1.4.6). Well done!

  • Various sb-cover (code coverage contrib module) fixes

  • Various sb-sprof (the statistical code profiler contrib module) fixes

  • Lots of bug fixes

  • Various compiler speedups

  • Better support for stack allocation (dynamic extent) of, e.g., functions passed to higher order functions

  • More simplification/cleanup of the host/target code split

As usual, thanks to Stas Boukarev, Douglas Katzman, Jan Moringen, for countless contirbutions, and to Christophe Rhodes for his ceaseless release engineering efforts.

SBCL 1.4.6 Lisp

Like clockwork, another month, another SBCL release. This time it's SBCL 1.4.6. You can find it here, as usual.

Some of the new goodies in SBCL 1.4.6:

  • The core has shrunk by another ~60 Kb (38,444,800 bytes vs 38,510,336 on x86-64 in SBCL 1.4.5).

  • for immobile code, the assembly routines have gotten smaller and more efficient.

  • (write-sequence vector broadcast-stream) has been optimized.

  • the usual batch of compiler fixes to bugs uncovered by pfdietz's random tester (thanks to Stas Boukarev for whacking these bugs nearly as quickly as Paul's tester finds them).

  • the compiler now handles multi-argument /= (that's the not equals function) better.

  • we now stop the finalizer-thread before calling fork.

  • sb-dynamic-core is now supported on arm64.

  • Douglas Katzman's shrinkwrapped binary creation support been improved.

  • on x86-64 thread-base-tn now uses r12 instead of r13, allowing for a more compact encoding of instructions, and a 96K reduction in size of the lisp image.

  • Jan Moringen has optimized the structures and routines used to deal with the compiler's various storage classes.

  • DEF!CONSTANT has been removed.

  • MAP-STACK_REFERENCES (used by ROOM) is now more efficient and less CONSy.

  • The build order of various bits of compiler functionality has once again been improved.

  • The statistical profile (sb-sprof) has seen a number of improvements.

  • More GC optimizations and cleanups.

  • A precise allocation profiler has been added, although it is not yet advertised as being ready for public use, other than by those who wish to live on the bleeding edge.

  • getaddrinfo is now enabled on x86-64. Apparently my comment about this being broken back in 2007 is no longer operative. That's good.

  • test code has been cleaned up.

  • multiple-value-call has been optimized on x86-64.

  • the compiler has seen some fixes for declaring functions not-inline.

As usual, thanks to Stas Boukarev, Douglas Katzman, Jan Moringen, for countless contirbutions, to Guillaume LE VAILLANT for the the stream patches, and to Christophe Rhodes for his tireless release engineering efforts.

Fun with Docker: Passing Arguments to Shell Scripts General

So it's 2018 and it's still a pain to pass arguments to shell scripts. Or at least that's how it seems to me. In putting together the davical-docker stuff, I realized that I wanted to be able to call my file with (potentially anyway) some arguments. In particular, I wanted an argument for a container to initialize the docker database, otherwise, not. There are a million ways to handle this and one obvious alternative would be to use environment variables to pass this sort of info. But I wanted to be able to say "docker run ... sly/davical davical --initialize" and have the right thing happen.

So, after some googling, I came up with following:


# -temporarily store output to be able to check for errors
# -e.g. use “--options” parameter by name to activate quoting/enhanced mode
# -pass arguments only via   -- "$@"   to separate them correctly
PARSED=$(getopt --options=$OPTIONS --longoptions=$LONGOPTIONS --name "$0" -- "$@")
if [ $? -ne 0 ]; then
# e.g. $? == 1
#  then getopt has complained about wrong arguments to stdout
exit 2
# read getopt’s output this way to handle the quoting right:
eval set -- "$PARSED"

# now enjoy the options in order and nicely split until we see --
while true; do
case "$1" in
            case "$2" in
                "") initdavical=true ; shift 2 ;;
                *) initdavical=$2 ; echo $@ ; shift 2 ;;
            case "$2" in
                "") updatedb=true ; shift 2 ;;
                *) updatedb=$2 ; echo $@ ; shift 2 ;;
            echo "Error!"
            exit 3

if [ ${initdavical} = true ];
    echo "running database setup scripts"
    psql -qXAt -U ${DAVICAL_DBA_USER} -h ${DAVICAL_DB_HOST} ${DAVICAL_DB_NAME} < /usr/share/awl/dba/awl-tables.sql 
    psql -qXAt -U ${DAVICAL_DBA_USER} -h ${DAVICAL_DB_HOST} ${DAVICAL_DB_NAME} < /usr/share/awl/dba/schema-management.sql
    psql -qXAt -U ${DAVICAL_DBA_USER} -h ${DAVICAL_DB_HOST} ${DAVICAL_DB_NAME} < /usr/share/davical/dba/davical.sql 

if [ ${updatedb} = true ];
    echo "updating database"
    /usr/share/davical/dba/update-davical-database \
        --dbname ${DAVICAL_DB_NAME} \
        --dbuser ${DAVICAL_DBA_USER} \
        --dbhost ${DAVICAL_DB_HOST} \
        --dbpass ${DAVICAL_DBA_PASSWORD} \
        --appuser ${DAVICAL_APP_USER} \
        --nopatch --owner ${DAVICAL_DBA_USER}

if [ ${initdavical} = true ];
    echo "finishing configuration"
         < /usr/share/davical/dba/base-data.sql 
    psql -qXAt -U ${DAVICAL_DBA_USER} -h ${DAVICAL_DB_HOST} \
         -c "UPDATE usr SET password = '**${DAVICAL_ADMIN_PASSWORD}' WHERE user_no = 1;" \

Arghhh... there's a bug in cl-markdown that is causing underscore characters to be displayed as or as appropriate. Hopefully that will get fixed one day.

Fun With Docker: davical and davical-db General

So one thing I've been working with on and off over the past few months is getting a docker-ized setup for Davical going. I've finally published pushed my Dockerfiles and related files to github. There's davical-docker and davical-db-docker which are images for the Davical server and Davical postgres database respectively.

One of these days I'll get around to pushing images to docker hub.

SBCL 1.4.5 Lisp

And now... SBCL 1.4.5 has been released. You can find it here, as usual.

Also as usual, 1.4.5 has lots of new goodies:

  • The core has once again gotten smaller (38,510,336 bytes vs 39,952,344 on x86-64 in SBCL 1.4.4).

  • Foreign calls now have one less register to load.

  • More use of DEFGLOBAL instead of DEFVAR allows for more efficient code in the compiler itself.

  • Lots more compiler bug fixes from stassats that address bugs uncovered by pfdietz's random tester.

  • The heap is now relocatable on platforms that use the Cheney GC.

  • Target compiler error handling code has been moved out of the host compiler.

  • host compiler-specific specialized array code is now restricted to the host compiler.

  • finalzers are now run in a background thread which, presumably, reduces GC latency in some circumstances.

  • lots of x86{-64} and ARM microoptimizations.

  • various set utility enhancements that, presumably, make the compiler faster and use less memory.

  • more judicious use of defconstant-eqx instead of defglobal and defglobal instead of defparameter, as appropriate, allows the compiler to generate more efficient code.

  • The usual batch of GC fixes (race conditions, corner cases, etc...)

  • There's a new editcore feature that allows for the building of "shrinkwrapped" SBCL executables are a single ELF binary file that don't require a separate core file. There were some key bug fixes that make this work for me that were committed post 1.4.5, so expect to hear more about this in the 1.4.6 time frame.

Great work to all of the SBCL developers, particularly Douglas Katzman, Stas Boukarev, and, of course, Christophe Rhodes for keeping the release train rolling, and P. F. Dietz for continuing to find obscure compiler bugs that Stas keeps fixing just as fast as P F. finds them!

SBCL 1.4.4 Released Lisp

SBCL 1.4.4 has been released. You can find it here.

And now Gilead's YESCARTA Science

Just a month and a half after the FDA's approval of KYMRIAH, the FDA has approved Gilead's (via their purchase of Kite) YESCARTA (axicabtagene ciloleucel, or axi-cel), another adoptive T cell therapy, but this one is approved for the treatment of Non-Hodgkin lymphoma.

See the FDA's announcement.

With YESCARTA, as with KYMRIAH, a patient's T cells are extracted, genetically engineered to a express a Chimeric Antigen Receptor (CAR) that targets the CD19 protein, then reintroduced to the patient's blood.

Novartis CAR T Therapy Kymriah Approved Science

Today the FDA announced approval of Novartis' new drug Kymriah. This is a major accomplishment that builds on decades of research. A cancer patient's own T Cells are genetically modified to express a novel receptor designed to bind antigens present on the surface of the cancer cells. This was science fiction not too long ago.

It's back General

Nuclblog is dead. Long live nuclblog. But, I have a new blog, based on Eitaro Fukamichi's excellent Caveman2 web framework. More details to come.

R devtools library General

The R devtools library is something I had been missing in R for a long time. The problem I was having was that I couldn't figure out to put code into a package, edit the code in the package, and then reload the edited package code into a (still-)running R session. I knew there had to be a better way than quitting R, re-installing the package with R CMD INSTALL, and then restarting R.

It turns out that the devtools library lets you do just that with:


Much better.

Previous 1 2 3 4 5 6 7 Next