Bermudian distance runner Sean Trott said he is delighted with his performance at the TCS New York Marathon on Sunday [November 3]. Trott, a four-time runner-up in the Bermuda Half-Marathon Derby, finished 468th out of 55,508 finishers in 2hr 41min 48sec, shaving 1:16 off his previous personal best. “What an experience!” Trott wrote on social […]

The fictional ‘Stormtrooper’ from Star Wars is displayed in the Hamilton Princess hotel lobby, created by artist Daniel Arsham using minerals like selenite, blue calcite, and hydrostone. A spokesperson said, “The fictional ‘Stormtrooper’ soldier made famous in filmmaker George Lucas’ Star Wars movie appears to be standing guard in the left corner of the hotel lobby […]

Apple today seeded the second beta of an upcoming visionOS 2.2 update to developers for testing purposes, with the beta coming a little over a week after the first visionOS 2.2 beta.


visionOS 2.2 can be installed by going to the Software Update section of the Settings app on the Vision Pro and opting into Beta Updates.

The visionOS 2.2 update adds a new feature for the Mac Virtual Display option, allowing it to be set to Wide and Ultrawide. The Ultrawide setting is equivalent to two 4K displays side-by-side, and it is a notable improvement over the current Mac Virtual Display that's available in visionOS 2.1.

The Mac Virtual Display allows the Vision Pro to be connected to a Mac with the Vision Pro serving as the display for the machine. The virtual Mac desktop works just like a standard desktop with an external display, but Vision Pro does not support multiple displays. As a solution, Apple has added the option for a wider display to maximize space.

Earlier this year, I started working through the online book Ray Tracing In One Weekend (Book 1). I have been following along with it in Common Lisp, and I have been extending it all from 3-dimensional to n-dimensional.

I reproduced 4-dimensional versions of all of the book images which you can see on my weekend-raytracer github page.

Here is the final image. This is a 250-samples-per-pixel, 640x360x10 image plane of three large hyperspheres (one mirrored, one diffuse, one glass) atop a very large, diffuse hypersphere. Also atop this very large hypersphere are a bunch of smaller hyperspheres of varying colors and materials. The image is rendered with some defocus-blur.

Caveat: This depends on a patched version of the policy-cond library that is not in the current Quicklisp distribution but should be in the next.

 New projects: 

• adp-github — ADP extension to generate github markdown files. — MIT
• adp-plain — Add Documentation, Please... using plain text. An extension of ADP to generate files with barely additional features. — MIT
• allioli — Alliolification — MIT
• alternate-asdf-system-connections — Allows for ASDF system to be connected so that auto-loading may occur. This is a fork of asdf-system-connections and incorporates a load-system-driven mechanism for loading dependencies and also loads the dependencies of the connections. — MIT
• cbor — CBOR encoder/decoder — MIT
• charje.documentation — Documentation is an opinionated yet customizable docstring parsing library. — AGPL V3 or any later version
• chipi — House automation bus in Common Lisp — Apache-2
• cl-aseprite — Aseprite file format parser — GPLv3
• cl-astar — A heavily optimized yet flexible A* pathfinding algorithm implementation — MIT
• cl-ceigen-lite — A Common Lisp wrapper around CEIGEN-LITE - which is itself a C wrapper around the C++ Eigen library. — MIT
• cl-cf — Computations using continued fractions — GPL-3
• cl-concord — CONCORD implementation based on Common Lisp — LGPL
• cl-duckdb — CFFI wrapper around the DuckDB C API — MIT License
• cl-fastcgi — FastCGI wrapper for Common Lisp — BSD License
• cl-flx — Rewrite emacs-flx in Common Lisp — MIT
• cl-frugal-uuid — Common Lisp UUID library with zero dependencies — MIT License
• cl-gog-galaxy — A wrapper for the GOG Galaxy SDK — zlib
• cl-lc — List comprehensions — MIT
• cl-naive-ptrees — Functions to make it easier to work with plist(s) and plist trees. Works with plist(s) pairs as units and not as individual list items. — MIT
• cl-qoa — An implementation of the Quite Okay Audio format. — zlib
• cl-reddit — Reddit client api library — BSD
• cl-resvg — An up-to-date bindings library for the resvg SVG rendering library — zlib
• cl-trivial-clock — Common Lisp library to get accurate wall-clock times on multiple platforms — MIT License
• clack-cors — A Clack middleware to set CORS related HTTP headers. — Unlicense
• clack-prometheus — Clack middleware to serve stats in Prometheus format. — Unlicense
• clith — Common Lisp wITH macro. A general WITH macro. — MIT
• clj-arrows — Implements Clojure-styled threading/transformation macros. — MIT
• clos-encounters — A collection of OOP patterns benefiting from the CLOS MOP. — Unlicense
• coalton — An efficient, statically typed functional programming language that supercharges Common Lisp. — MIT
• cocoas — A toolkit library to help deal with CoreFoundation, Cocoa, and objc — zlib
• com.danielkeogh.graph — A fast an reliable graph library. — MIT
• fast-mpsc-queue — Multi-Producer Single-Consumer queue implementation. — MIT
• file-finder — File finder. Enable rapid file search, inspection and manipulation. — GPL3+
• golden-utils — A utility library. — MIT
• hiccl — HTML generator for Common Lisp — MIT
• hsx — Hypertext S-expression — MIT
• hunchentoot-stuck-connection-monitor — Monitors hunchentoot connections and logs the connections stuck in the same state for a long time (due to slow or inactive clients and network stream timeouts that hunchentoot tries to utilize not working properly). Offers an option to shutdown the stuck connections sockets manually or automatically, thus unblocking the connection threads and preventing thread and socket leak. See https://github.com/edicl/hunchentoot/issues/189 — BSD-2-Clause
• incless — A portable and extensible Common Lisp printer implementation (core) — BSD
• inravina — A portable and extensible Common Lisp pretty printer. — MIT
• invistra — A portable and extensible Common Lisp FORMAT implementation — BSD
• knx-conn — KNXnet/IP implementation in Common Lisp — GNU GPL, version 3
• machine-state — Retrieve machine state information about CPU time, memory usage, etc. — zlib
• myweb — simple web server written in common lisp for educational reasons — LGPLv3
• noisy — Perlin noise for arbitrary numbers of dimensions. — MIT
• nontrivial-gray-streams — A compatibility layer for Gray streams including extensions — MIT
• open-with — Open a file in a suitable external program — zlib
• openai-openapi-client — Openai API client — AGPLv3+
• openrpc — CI for Common Lisp OpenRPC library. — BSD
• parse-number-range — Parses LOOP's convenient "for-as-arithmetic" syntax into 5 simple values: from, to, limit-kind (:inclusive, :exclusive or nil if unbounded), by (step) and direction (+ or -)). Further related utilities are provided. Intended for easy implementation of analogous functionality in other constructs. — Public Domain
• precise-time — Precise time measurements — zlib
• pregexp — Portable regular expressions for Common Lisp — MIT-like
• progressons — Display a progress bar on one line. — MIT
• quaviver — A portable and extensible floating point string library — MIT
• quilc — A CLI front-end for the Quil compiler — Apache License 2.0 (See LICENSE.txt)
• qvm — An implementation of the Quantum Abstract Machine. — Apache License 2.0 (See LICENSE.txt)
• random-sampling — Functions to generate random samples with various distributions — zlib
• rs-dlx — Knuth's Algorithm X with dancing links. — Modified BSD License
• scrapycl — The web scraping framework for writing crawlers in Common Lisp. — Unlicense
• smoothers — Statistical methods to create approximating functions that attempt to capture important patterns in the data, while leaving out noise or other fine-scale structures/rapid phenomena. — MS-PL
• trivial-adjust-simple-array — A tiny utility to change array size ensuring it is simple. — MIT
• trivial-system-loader — A system installation/loading abstraction for Common Lisp — MIT
• trivial-toplevel-commands — Trivial Toplevel Commands allows to define toplevel commands available on most implementations in a portable fashion. — BSD-3 Clause
• trivial-toplevel-prompt — Portability library to customize REPL prompts. — BSD-3 Clause
• utf8-input-stream — A UTF-8 string input stream over a binary stream for Common Lisp — MIT
• whereiseveryone.command-line-args — Automatically create a command-line-argument parser for a given Common Lisp function definition. — AGPL v3 or any later version

Updated projects: 3b-bmfont, 3bgl-shader, 3bmd, 3d-math, 3d-spaces, 40ants-asdf-system, 40ants-slynk, access, acclimation, action-list, adhoc, adopt, adp, agnostic-lizard, alexandria, alexandria-plus, anatevka, anypool, april, arc-compat, architecture.builder-protocol, array-utils, arrow-macros, assoc-utils, async-process, atomics, auto-restart, aws-sdk-lisp, babel, bdef, bike, binary-structures, binding-arrows, birch, blackbird, bordeaux-threads, calm, carrier, caveman, ccldoc, cephes.cl, cepl, cerberus, cffi, cffi-object, cffi-ops, chanl, chunga, ci, ci-utils, ciao, cl-6502, cl-algebraic-data-type, cl-all, cl-ansi-term, cl-async, cl-atelier, cl-autowrap, cl-base32, cl-bmas, cl-bmp, cl-bnf, cl-brewer, cl-buchberger, cl-cmark, cl-collider, cl-colors2, cl-confidence, cl-containers, cl-cookie, cl-csv, cl-custom-hash-table, cl-cxx-jit, cl-data-structures, cl-dbi, cl-digraph, cl-dot, cl-enchant, cl-environments, cl-fast-ecs, cl-fbx, cl-fluent-logger, cl-form-types, cl-forms, cl-freetype2, cl-gamepad, cl-github-v3, cl-gltf, cl-gobject-introspection, cl-graph, cl-grip, cl-gserver, cl-hamcrest, cl-hash-util, cl-html-readme, cl-i18n, cl-info, cl-ini, cl-ipfs-api2, cl-kanren, cl-lib-helper, cl-liballegro, cl-liballegro-nuklear, cl-log, cl-markless, cl-marshal, cl-migratum, cl-mixed, cl-modio, cl-mount-info, cl-mpg123, cl-mssql, cl-mustache, cl-mysql, cl-neovim, cl-netpbm, cl-oju, cl-opengl, cl-opensearch-query-builder, cl-opus, cl-patterns, cl-plus-ssl-osx-fix, cl-ppcre, cl-project, cl-protobufs, cl-pslib, cl-pslib-barcode, cl-rashell, cl-readline, cl-sat.minisat, cl-sdl2-image, cl-sdl2-mixer, cl-sdl2-ttf, cl-sendgrid, cl-sentry-client, cl-skkserv, cl-smtp, cl-ssh-keys, cl-steamworks, cl-str, cl-svg, cl-telegram-bot, cl-threadpool, cl-tiled, cl-torrents, cl-tqdm, cl-transducers, cl-transit, cl-unicode, cl-unification, cl-unix-sockets, cl-utils, cl-vectors, cl-vorbis, cl-wavefront, cl-webdriver-client, cl-webkit, cl-webmachine, cl-who, clack, clack-pretend, clad, classimp, clast, clath, clavier, clazy, clerk, clgplot, climacs, clingon, clip, clj-con, clj-re, clobber, clog, clog-ace, clog-collection, clog-plotly, clog-terminal, clohost, closer-mop, clss, cluffer, clunit2, clx, cmd, codata-recommended-values, codex, coleslaw, collectors, colored, com-on, common-lisp-jupyter, commondoc-markdown, compiler-macro-notes, conduit-packages, consfigurator, contextl, croatoan, ctype, cytoscape-clj, damn-fast-priority-queue, dartscluuid, data-frame, data-lens, datafly, dbus, decompress, defenum, definer, definitions, deflate, defmain, deploy, depot, deptree, dexador, dissect, djula, dns-client, doc, docs-builder, dsm, dufy, easter-gauss, easy-audio, easy-macros, easy-routes, eclector, equals, erjoalgo-webutil, erudite, esrap, event-emitter, external-program, external-symbol-not-found, fare-csv, fare-scripts, fast-http, fast-websocket, file-attributes, file-notify, file-select, filesystem-utils, fiveam, fiveam-matchers, flexi-streams, float-features, flow, fn, fset, functional-trees, fuzzy-dates, gadgets, generic-cl, github-api-cl, glfw, glsl-toolkit, harmony, hashtrie, helambdap, http2, hunchentoot, imago, in-nomine, inferior-shell, introspect-environment, ironclad, jose, js, json-mop, jsonrpc, jzon, khazern, lack, lass, lemmy-api, letv, lichat-protocol, lichat-tcp-client, linear-programming, lisp-binary, lisp-chat, lisp-critic, lisp-pay, lisp-stat, lispcord, lla, local-time, log4cl-extras, logging, lru-cache, magicl, maiden, maidenhead, manifolds, math, mcclim, memory-regions, messagebox, method-combination-utilities, mgl-pax, misc-extensions, mito, mk-defsystem, mmap, mnas-package, mnas-string, moira, multiposter, mutility, mutils, named-closure, ndebug, neural-classifier, new-op, nibbles, nibbles-streams, ningle, nodgui, north, numerical-utilities, nytpu.lisp-utils, omglib, ook, open-location-code, openapi-generator, orizuru-orm, overlord, papyrus, parachute, parse-number, pathname-utils, petalisp, phos, picl, plot, plump, plump-sexp, pngload, policy-cond, polymorphic-functions, postmodern, ppath, prometheus-gc, psychiq, purgatory, py4cl, py4cl2, py4cl2-cffi, qlot, qoi, query-fs, quick-patch, quickhull, quri, random-state, reblocks, reblocks-auth, reblocks-file-server, reblocks-lass, reblocks-navigation-widget, reblocks-parenscript, reblocks-prometheus, reblocks-typeahead, reblocks-ui, reblocks-websocket, rove, s-dot2, sandalphon.lambda-list, sb-fastcgi, sc-extensions, sel, select, serapeum, shasht, shop3, si-kanren, sketch, slime, slite, sly, snooze, spinneret, staple, static-vectors, statistics, stepster, stmx, stripe, swank-crew, swank-protocol, sxql, symath, system-locale, taglib, teddy, ten, testiere, tfeb-lisp-hax, tfm, tiny-routes, tooter, trivia, trivial-arguments, trivial-clipboard, trivial-file-size, trivial-gray-streams, trivial-main-thread, trivial-octet-streams, trivial-package-locks, trivial-package-manager, trivial-sanitize, trivial-shell, type-templates, typo, uax-15, uiop, usocket, vellum, vellum-binary, vellum-csv, vellum-postmodern, verbose, vernacular, vom, websocket-driver, winhttp, with-branching, with-contexts, woo, xhtmlambda, xml-emitter, yason, zippy, zpb-ttf.

Removed projects: abstract-arrays, ahungry-fleece, cl-cheshire-cat, cl-darksky, cl-epoch, cl-naive-store, convolution-kernel, dense-arrays, extensible-compound-types, extensible-optimizing-coerce, fast-generic-functions, flac-metadata, freebsd-ffi, listoflist, luckless, one-more-re-nightmare, postmodern-localtime, stumpwm-dynamic-float, stumpwm-sndioctl, unicly.

To get this update, use:

 (ql:update-dist "quicklisp")

Sorry this update took so long. My goal is to resume monthly releases.

Enjoy!

It's no secret that I'm an aficionado of Lisp. It's my go to language, especially when I don't know what I'm doing. I call it research and prototyping, but it's really just playing around until something works.

We had a need for some auditing of some of our databases at work. They ought to agree with each other and with what GitHub and CircleCI think. It took a couple of weeks part time to prototype a solution in Common Lisp. It showed that the databases were in 99% agreement and found the few points of disagreement and anomalies that we ought to fix or look out for.

I want to integrate this information into a dashboard on one of our tools. I prototyped this by spinning up a Common Lisp microservice that returns the information in JSON format.

But management prefers that new services are written in golang. It would be easier for me to rewrite the service in golang than to try to persuade others to use Common Lisp. It also gives me the opportunity to compare the two languages head to head on a real world problem.

No, this is not a fair comparison. When I wrote the Lisp code I was exploring the problem space and prototyping. I'm much more experienced with Lisp than with golang. The golang version has the advantage that I know what I want to do and how to do it. In theory, I can just translate the Common Lisp code into golang. But then again, this is a “second system” which is not a prototype and has slightly larger scope and fuller requirements. So this cannot be a true head to head comparison.

The first point of comparison is macros (or lack thereof). I generally don't use a lot of macros in Common Lisp, but they come in handy when I do use them. One macro I wrote is called audit-step, which you can wrap around any expresion and it prints out a message before and after the expression is evaluated. The steps are numbered in sequence, and nested steps get nested numbers (like step 2.3.1). If you wrap the major function bodies with this macro, you get a nice trace of the call sequence in the log.

Golang doesn't have macros, but it has first class functions. It's easy enough to write a function that takes a function as an argument and wraps it to output the trace messages. In fact, the macro version in Common Lisp just rewrites the form into such a function call. But the macro version hides a level of indentation and a lambda. In golang, my major functions all start with

func MajorFunction (args) int {
        return AuditStep("MajorFunction", "aux message", func() int {
                // body of MajorFunction
                // Actual code goes here.
        })    
}

The bodies of all my major functions are indented by 16 spaces, which is a little much.

I like higher order functions. I can write one higher order function and parameterize it with functions that handle the specific cases. In my auditing code, one such workhorse function is called collate. It takes a list of objects and creates a table that maps values to all objects in the list that contain that value. To give an example, imaging you have a list of objects that all have a field called foo. The foo field is a string. The collate function can return a table that maps strings to all objects that have that string in the foo field.

collate is very general. It takes a list of objects and four keyword arguments. The :key argument is a function that extracts the value to collate on. The :test argument is a function that compares two keys (it defaults to eql if not specified). The :merger argument is a function to add the mapped object to its appropriate collection in the table (it defaults to adjoin). The :default argument specifies the initial value of a collection in the table (it defaults to nil).

The :merger function is the most interesting. It takes the key and the object and the current value of the table at that key. It returns the new value of the table at that key. The default merger function is adjoin, which adds the object to the collection at the key if it is not already there. But you can specify a different merger function. For example, if you want to count the number of objects at each key, you can specify a merger function that increments a counter.

The functional arguments to the collate function are often the results of other higher order functions. For example, the :key argument is often the result of composing selector functions. The :merger argument is often the result of composing a binary merge function with a unary transformer function. The transformer function is often the result of composing a number of primitive selectors and transformers.

In Common Lisp, it is quite easy to write these higher order functions. We can compose two unary functions with the compose2 function:

(defun compose2 (f g)
  (lambda (x) (funcall f (funcall g x)))

and then compose as many functions as we like by fold-left of compose2 starting with the identity function:

(defun compose (&rest fs)
  (fold-left #'compose2 #'identity fs))

We can compose a binary function with a unary function in three ways: we can pipe the output of the binary function into the unary function, or we can pipe the output of the unary function into one or the other of the inputs of the binary function.

(defun binary-compose-output (f g)
  (lambda (x y) (funcall f (funcall g x y))))

(defun binary-compose-left (f g)
  (lambda (x y) (funcall f (funcall g x) y)))

(defun binary-compose-right (f g)
  (lambda (x y) (funcall f x (funcall g y))))

The collate function can now assume that a lot of the work is done by the :key and :merger functions that are passed in. It simply builds a hash table and fills it:

(defun collate (item &key (key #'identity) (test #'eql) (merger (merge-adjoin #'eql)) (default nil))
  (let ((table (make-hash-table :test test)))
    (dolist (item items table)
      (let ((k (funcall key item)))
        (setf (gethash k table) (funcall merger (gethash k table default) item))))))

(defun merge-adjoin (test)
  (lambda (collection item)
    (adjoin item collection :test test)))

So suppose, for example, that we have a list of records. Each record is a three element list. The third element is a struct that contains a string. We want a table mapping strings to the two element lists you get when you strip out the struct. This is easily done with collate:

(collate records
  :key (compose #'get-string #'third)
  :test #'equal      ; or #'string= if you prefer
  :merger (binary-compose-right (merge-adjoin #'equal) #'butlast))

The audit code reads lists of records from the database and from GitHub and from CircleCI and uses collate to build hash tables we can use to quickly walk and validate the data.

Translating this into golang isn't quite so easy. Golang has first class function, true, but golang is a statically typed language. This causes two problems. First, the signature of the higher order functions includes the types of the arguments and the return value. This means you cannot just slap on the lambda symbol, you have to annotate each argument and the return value. This is far more verbose. Second, higher order functions map onto parameterized (generic) types. Generic type systems come with their own little constraint language so that the computer can figure out what concrete types can correctly match the generic types. This makes higher order functions fairly unweildy.

Consider compose2. The functions f and g each have an input and output type, but the output type of g is the input type of f so only three types are involved

func Compose2[T any, U any, V any](f func(U) V, g func(T) U) func(T) V {
	return func(x T) V {
		return f(g(x))
	}
}

If want to compose three functions, we can write this:

func Compose3[T any, U any, V any, W any](f func(V) W, g func(U) V, h func(T) U) func(T) W {
	return func(x T) W {
		return f(g(h(x)))
	}
}

I don't see a way to write an n-ary compose function. It would have to be dynamically parameterized by the intermediate types of all the functions it was composing.

For the collate function, we can write this:

func Collate[R any, K comparable, V any](
	list *Cons[R],
	keyfunc func(R) K,
	merger func(V, R) V,
	defaultValue V) map[K]V {
	answer := make(map[K]V)
	for list != nil {
		key := keyfunc(list.Car)
		probe, ok := answer[key]
		if !ok {
			probe = defaultValue
		}
		answer[key] = merger(probe, list.Car)
		list = list.Cdr
	}
	return answer
}

We have three types to parameterize over: the type of the list elements (i.e. the record type) R, the type of the key K, and the type of the value V. The key type is needs to be constrained to be a valid key in a map, so we use the comparable constraint. Now that we have the types, we can annotate the arguments and return value. The list we are collating is a list of R elements. The key function takes an R and returns a K. The merger takes an existing value of type V and the record of type R and returns a new value of type V.

The magic of type inference means that I do not have to annotate all the variables in the body of the function, but the compiler cannot read my mind and infer the types of the arguments and return value. Golang forces you to think about the types of arguments and return values at every step of the way. Yes, one should be aware of what types are being passed around, but it is a burden to have to formally specify them at every step. I could write the Common Lisp code without worrying too much about types. Of couse the types would have to be consistent at runtime, but I could write the code just by considering what was connected to what. In golang, the types are in your face at every function definition. You not only have to think about what is connected to what, you have to think about what sort of thing is passed through the connection.

I'm sure that many would argue that type safety is worth the trouble of annotation. I don't want to argue that it isn't. But the type system is cumbersome, awkward, and unweildy, especially when you are trying to write higher order functions.

It is taking me longer to write the golang version of the audit service than it did to write the Common Lisp version. There are several reasons. First, I am more experienced with Common Lisp than golang, so the right Common Lisp idioms just come to mind. I have to look up many of the golang idioms. Second, the golang code is trying to do more than the Common Lisp code. But third, golang itself introduces more friction than Common Lisp. Programs have to do more than express the algorithm, they have to satisfy the type system.

There are more points of comparison between the two languages. When I get frustrated enough, I'll probably write another post.

Last week I finished a new service written in Common Lisp. It now runs in production© every mornings, and it expands the set of services I offer to clients.

It’s the 4th service of this kind that I developed: - they are not big - but have to be done nonetheless, and the quicker the better (they each amount to 1k to 2k lines of Lisp code), - they are not part of a super advanced domain that requires Common Lisp superpowers - I am the one who benefits from CL during development, - I could have written them in Python - and conversely nothing prevented me from writing them in Common Lisp.

So here lies the goal of this post: illustrate that you don’t need to need a super difficult problem to use Common Lisp. This has been asked many times, directly to me or on social media :)

At the same time, I want to encourage you to write a little something about how you use Common Lisp in the real world. Sharing creates emulation. Do it! If you don’t have a blog you can simply write in a new GitHub repository or in a Gist and come share on /r/lisp. We don’t care. Thanks <3

We’ll briefly see what my scripts do, what libraries I use, how I deploy them, what I did along the way.

Needless to say that I dogfooded my CIEL (beta) meta-library and scripting tool for all those projects.

Table of Contents

• Scripts n°4 and 2 - shaping and sending data - when you can write Lisp on the side
  • SFTP
  • Deploying
  • Script n°2 and simple FTP
• Scripts n°3 and 1 - complementary web apps
• Lasting words
• Links

Scripts n°4 and 2 - shaping and sending data - when you can write Lisp on the side

My latest script needs to read data from a DB, format what’s necessary according to specifications, and send the result by SFTP.

In this case I read a DB that I own, created by a software that I develop and host. So I could have developed this script in the software itself, right? I could have, but I would have been tied to the main project’s versioning scheme, quirks, and deployment. I rather had to write this script on the side. And since it can be done on the side, it can be done in Common Lisp.

I have to extract products and their data (price, VAT...), aggregate the numbers for each day, write this to a file, according to a specification.

To read the DB, I used cl-dbi. I didn’t format the SQL with SxQL this time like in my web apps (where I use the Mito light ORM), but I wrote SQL directly. I’m spoiled by the Django ORM (which has its idiosyncrasies and shortcomings), so I double checked the different kinds of JOINs and all went well.

I had to group rows by some properties, so it was a great time to use serapeum:assort. I left you an example here: https://dev.to/vindarel/common-lisps-group-by-is-serapeumassort-32ma

Dates have to be handled in different formats. I used local-time of course, and I still greatly appreciate its lispy formatter syntax:

(defun date-yymmddhhnnss (&optional date stream)
  (local-time:format-timestring stream
                                (or date (local-time:now))
                                :format
                                '((:year 4)
                                  (:month 2)
                                  (:day 2)
                                  (:hour 2)
                                  (:min 2)
                                  (:sec 2)
                                  )))

the 2 in (:month 2) is to ensure the month is written with 2 digits.

Once the file is written, I have to send it to a SFTP server, with the client’s codes.

I wrote a profile class to encapsulate the client’s data as well as some functions to read the credentials from either environment variables, the file system, or a lisp variable. I had a top-level profile object for ease of testing, but I made sure that my functions formatting or sending data required a profile parameter.

(defun send-stock (profile &key date) ...)
(defun write-stock (profile filename) ...)

Still nothing surprising, but it’s tempting to only use global parameters for a one-off script. Except the program grows and you pay the mess later.

SFTP

To send the result through SFTP, I had to make a choice. The SFTP command line doesn’t make it possible to give a password as argument (or via an environment variable, etc). So I use lftp (in Debian repositories) that allows to do that. In the end, we format a command like this:

lftp sftp://user:****@host  -e "CD I/; put local-file.name; bye"

You can format the command string and run it with uiop:run-program: no problem, but I took the opportunity to release another utility:

• https://github.com/vindarel/lftp-wrapper

First, you create a profile object. This one-liner reads the credentials from a lispy file:

(defvar profile (make-profile-from-plist (uiop:read-file-form "CREDS.lisp-expr"))

then you define the commands you’ll want to run:

(defvar command (put :cd "I/" :local-filename "data.csv"))
;; #<PUT cd: "I/", filename: "data.csv" {1007153883}>

and finally you call the run method on a profile and a command. Tada.

Deploying

Build a binary the classic way (it’s all on the Cookbook), send it to your server, run it.

(during a testing phase I have deployed “as a script”, from sources, which is a bit quicker to pull changes and try again on the server)

Set up a CRON job.

No Python virtual env to activate in the CRON environment...

Add command line arguments the easy way or with the library of your choice (I like Clingon).

Script n°2 and simple FTP

My script #2 at the time was similar and simpler. I extract the same products but only take their quantities, and I assemble lines like

EXTRACTION STOCK DU 11/04/2008
....978202019116600010000001387
....978270730656200040000000991

For this service, we have to send the file to a simple FTP server.

We have a pure Lisp library for FTP (and not SFTP) which works very well, cl-ftp.

It’s a typical example of an old library that didn’t receive any update in years and so that looks abandoned, that has seldom documentation but whose usage is easy to infer, and that does its job as requested.

For example we do this to send a file:

(ftp:with-ftp-connection (conn :hostname hostname
                                   :username username
                                   :password password
                                   :passive-ftp-p t)
      (ftp:store-file conn local-filename filename))

I left you notes about cl-ftp and my SFTP wrapper here:

• https://dev.to/vindarel/ftp-and-sftp-clients-for-common-lisp-1c3b

Scripts n°3 and n°1 - specialized web apps

A recent web app that I’m testing with a couple clients extends an existing stock management system.

This one also was done in order to avoid a Python monolith. I still needed additions in the Python main software, but this little app can be independent and grow on its own. The app maintains its state and communicates it with a REST API.

It gives a web interface to their clients (so my clients’ clients, but not all of them, only the institutional) so that they can:

• search for products
• add them in shopping carts
• validate the cart, which sends the data to the main software and notifies the owner, who will work on them.

The peculiarities of this app are that:

• there is no user login, we use unique URLs with UUIDs in the form: http://command.client.com/admin-E9DFOO82-R2D2-007/list?id=1
• I need a bit of file persistence but I didn’t want the rigidity of a database so I am using the clache library. Here also, not a great activity, but it works©. I persist lists and hash-tables. Now that the needs grow and the original scope doesn’t cut it any more, I wonder how long I’ll survive without a DB. Only for its short SQL queries VS lisp code to filter data.

I deploy a self-contained binary: code + html templates in the same binary (+ the implementation, the web server, the debugger...), with Systemd.

I wrote more on how to ship a standalone binary with templates and static assets with Djula templates here:

• https://lisp-journey.gitlab.io/blog/lisp-for-the-web-build-standalone-binaries-foreign-libraries-templates-static-assets/

I can connect to the running app with a Swank server to check and set parameters, which is super helpful and harmless.

It is possible to reload the whole app from within itself and I did it with no hiccups for a couple years, but it isn’t necessary the most reliable, easiest to set up and fastest method. You can do it, but nobody forces you to do this because you are running CL in production. You can use the industry’s boring and best practices too. Common Lisp doesn’t inforce a “big ball of mud” approach. Develop locally, use Git, use a CI, deploy a binary...

Every thing that I learned I documented it along the way in the Cookbook ;)

Another app that I’ll mention but about which I also wrote earlier is my first web app. This one is open-source. It still runs :)

In this project I had my friend and colleague contribute five lines of Lisp code to add a theme switcher in the backend that would help him do the frontend. He had never written a line of Lisp before. Of course, he did so by looking at my existing code to learn the existing functions at hand, and he could do it because the project was easy to install and run.

(defun get-template(template &optional (theme *theme*))
  "Loads template from the base templates directory or from the given theme templates directory if it exists."
  (if (and (str:non-blank-string-p theme)
           (probe-file (asdf:system-relative-pathname "abstock" (str:concat "src/templates/themes/" theme "/" template))))
      ;; then
      (str:concat "themes/" theme "/" template)
      ;; else :D
      template))

He had to annotate the if branches :] This passed the code review.

Lasting words

The 5th script/app is already on the way, and the next ones are awaiting that I open their .docx specification files. This one was a bit harder but the Lisp side was done sucessfully with the efficient collaboration of another freelance lisper (Kevin to not name him).

All those tasks (read a DB, transform data...) are very mundane.

They are everywhere. They don’t always need supercharged web framework or integrations.

You have plenty of opportunities to make yourself a favor, and use Common Lisp in the wild. Not counting the super-advanced domains where Lisp excels at ;)

Links

• https://lispcookbook.github.io/cl-cookbook/
• awesome-cl
• companies using Common Lisp in production (at least the ones we know)
• Common Lisp course in videos – it helps me, and you ;) I added 9 videos about CLOS last month, and more are coming. It’s 86 minutes of an efficient code-first approach, out of 7+ hours of total content in the course. After this chapter you know enough to read the sources of the Hunchentoot web server or of the Kandria game.

I have done some preliminary Common Lisp exploration prior to this course but had a lot of questions regarding practical use and development workflows. This course was amazing for this! I learned a lot of useful techniques for actually writing the code in Emacs, as well as conversational explanations of concepts that had previously confused me in text-heavy resources. Please keep up the good work and continue with this line of topics, it is well worth the price! [Preston, October of 2024]

A comment on my previous post said,

The most difficult thing when coming to a different language is to leave the other language behind. The kind of friction experienced here is common when transliterating ideas from one language to another. Go (in this case) is telling you it just doesn't like to work like this.

Try writing simple Go, instead of reaching for Lisp idioms. Then find the ways that work for Go to express the concepts you find.

That's not at all how I approach programming.

A friend of mine once paid me a high compliment. He said, “Even your C code looks like Lisp.”

When I write code, I don't think in terms of the language I'm using, I think in terms of the problem I'm solving. I'm a mostly functional programmer, so I like to think in terms of functions and abstractions. I mostly reason about my code informally, but I draw upon the formal framework of Lambda Calculus. Lambda Calculus is a simple, but powerful (and universal) model of computation.

Programming therefore becomes a matter of expressing the solution to a problem with the syntax and idioms of the language I'm using. Lisp was inspired by Lambda Calculus, so there is little friction in expressing computations in Lisp. Lisp is extensible and customizable, so I can add new syntax and idioms as desired.

Other languages are less accommodating. Some computations are not easily expressable in the syntax of the language, or the semantics of the language are quirky and inconsistent. Essentially, every general purpose fourth generation programming language can be viewed as a poorly-specified, half-assed, incomplete, bug-ridden implementation of half of Common Lisp. The friction comes from working around the limitations of the language.

Keeping your refrigerator's water dispenser clean ensures that the water you drink is fresh and safe. But let's face it, cleaning it can be a bit tricky. I've got the lowdown on the simplest and most effective way to get the job done.

The post Easy Guide: Clean Your Fridge Water Dispenser appeared first on Unclutterer.

Discover efficient methods on how to clean and maintain your garbage disposal. Keep it running smoothly with our expert cleaning tips and routine maintenance guide. Understand the importance of a well-maintained garbage disposal and how it can save you from costly repairs.

The post How to Clean and Maintain a Garbage Disposal: Your Ultimate Guide appeared first on Unclutterer.

LG Display has made a groundbreaking announcement by unveiling the world's first stretchable display capable of expanding by 50%. This innovative technology was showcased at LG Science Park in Seoul on November 8, 2024, during a gathering of over 100 industry experts, researchers, and academics involved in a national project aimed at developing stretchable display technologies.

The post LG Unveils Newest Stretchable Display appeared first on ThinkComputers.org.

Paperback – November 21, 2023

Euphoric Whispers This event is free, but a ticket is required to attend. To reserve a ticket, use the University Ticketing website. This concert features a rare NJ appearance of Ali Akbar Moradi and Pejman Hadadi, two of Iran’s most renowned musicians. Moradi is the greatest living master of the tanbour, an ancient 2-stringed long-necked fretted lute traditionally used in religious ceremonies. Hadadi is the innovative percussionist (tombak, daf) who has been a member of the Dastan Ensemble for over 20 years and has collaborated with countless master musicians in Persian and world traditions. They will perform ecstatic and trance-inducing Kurdish music from western Iran – music that is little known in the US. Featured are meditative improvisations based on the repertoire of the Yarsan people, and the beauty and complexities of the art of this region. “Love, spirituality, intoxication with the divine and the power of music…With one string providing a drone, everything else rides on a single string of the tanbour, and in Mr. Moradi’s hands, that string encompasses an expressive universe.” - New York Times "The masterful Hadadi delivers an astonishing array of sounds." - Los Angeles Times Aliakbar Moradi Aliakbar Moradi, often hailed as “the best tanbour player alive” (Songlines Magazine, Issue 26, 2004), was born in 1957 in Guran, near Kermanshah, the central city of Kermanshah Province, Iran. Encouraged by his grandfather and father, he began studying the Tanbur at the age of six. Under the guidance of masters such as Sayyed Hachem Kafashyan, Sayed Mahmoud Alavi, Ali Mir Darvishi, Allah Morad Hamidi, and Sayyed Vali Hosseyni, he not only mastered the instrument but also delved deeply into the Kurdish maqam repertoire. Moradi gave his first recital at the age of 14 in Kermanshah. A year later, he established the first Tanbur group within the cultural department of Kermanshah. He then embarked on tours across Iran and later co-founded the renowned Shams Tanbur Ensemble. In 1991, he won first prize at the String Instrument Festival. Starting in 1992, he conducted extensive research on the ancient maqams of the Tanbur, resulting in a significant publication: a set of four CDs and a booklet released in 2002 by Maison des Cultures du Monde. Over the years, Moradi has published more than 23 recordings and books. He has collaborated with numerous esteemed musicians, including Shahram Nazeri, Kaykhosro Pournazeri, Kayhan Kalhor, Ardeshir and Bijan Kamkar, Pejman Hadadi, Erdal Erzincan, Ulaş Özdemir, Pezhham Akhavass, Mehdi Bagheri, and Arash and Kourosh Moradi. In addition to his research, recordings, and performances, Moradi teaches Tanbur in Tehran and Kermanshah. Currently residing in Kurdistan, Iran, he founded the cultural center The House of Tanbur in Guran. This center offers year-round music classes and hosts annual Tanbur and Kurdish music festivals to preserve and promote the rich cultural heritage of the region. Pejman Hadadi Pejman Hadadi, a renowned percussionist from Tehran, Iran, began his musical journey at age 10, studying under Master Tombak player Assadollah Hejazi. Influenced by greats like Bahman Rajabi and Hossein Tehrani, he later mastered the Daf, inspired by Bijan Kamkar’s recordings. Moving to the US in 1989, Pejman began his professional career in 1991, collaborating with notable musicians such as Hossein Alizadeh, AliAkbar Moradi, Kayhan Kalhor, Shahram Nazeri, and joining the Dastan Ensemble in 1995. He co-founded ZARBANG, the pioneering Iranian percussion ensemble, in 2000. Pejman’s innovative techniques on the Tombak, including tunable frame drums, and his partnership with REMO to develop synthetic-skin Dafs, have significantly expanded the instruments’ global reach. Dedicated to education, he established Neyreez World Music Institute and has received the Durfee Foundation Master Musician Award twice. Pejman’s compositions span dance and film, including soundtracks for Prince of Egypt and Prince of Persia.

A Malaysian security department needed a system that their programmers could incorporate Q management control with digital signage software. They display Repeat Signage on their screens to show live TV, the counter and announcements, in this case study.

7-minute video shows you how to filter and display data in a datagrid as part of your digital signage software presentations for display on any screen, anywhere. This feature is available in Repeat Signage Corporate or Media Wall editions and is ideal for corporate offices to help keep staff updated on relevant information

7-minute video shows how you can a single line of text from either a .txt file or a database, for example, displaying name of duty manager. The ability to display database information is available in the Corporate and Media Wall editions of Repeat Signage digital signage software. Ideal for displaying company information on any screen anywhere.

In Savings and Trust, historian Justene Hill Edwards tells the story of the Freedman's Bank. Created for formerly enslaved people following the Civil War, its collapse cost depositors millions.

LG’s latest prototype screen is stretchy. Shown off at LG’s Science Park in Seoul, the company demonstrated the new type… Continue reading LG gives glimpse into the future with stretchy display

The post LG gives glimpse into the future with stretchy display appeared first on ReadWrite.

The MK Party continued its campaign against accountability for corruption, with its deputy leader, John Hlophe, suggesting National Director of Public Prosecutions Shamila Batohi was "misleading the nation" about the Guptas' extradition.

The inositol 1,4,5-trisphosphate (IP3) receptors (IP3Rs), which form tetrameric channels, play pivotal roles in regulating the spatiotemporal patterns of intracellular calcium signals. Mutations in IP3Rs have been increasingly associated with many debilitating human diseases such as ataxia, Gillespie syndrome, and generalized anhidrosis. However, how these mutations affect IP3R function, and how the perturbation of as-sociated calcium signals contribute to the pathogenesis and severity of these diseases remains largely uncharacterized. Moreover, many of these diseases occur as the result of autosomal dominant inheritance, suggesting that WT and mutant subunits associate in heterotetrameric channels. How the in-corporation of different numbers of mutant subunits within the tetrameric channels affects its activities and results in different disease phenotypes is also unclear. In this report, we investigated representative disease-associated missense mutations to determine their effects on IP3R channel activity. Additionally, we designed concatenated IP3R constructs to create tetrameric channels with a predefined subunit composition to explore the functionality of heteromeric channels. Using calcium imaging techniques to assess IP3R channel function, we observed that all the mutations studied resulted in severely attenuated Ca2+ release when expressed as homotetramers. However, some heterotetramers retained varied degrees of function dependent on the composition of the tetramer. Our findings suggest that the effect of mutations depends on the location of the mutation in the IP3R structure, as well as on the stoichiometry of mutant subunits assembled within the tetrameric channel. These studies provide insight into the pathogenesis and penetrance of these devastating human diseases.

Addressing Russia’s use of forced displacement in Ukraine 7 November 2024 — 12:30PM TO 2:00PM Anonymous (not verified) 17 October 2024 Chatham House and Online

Experts consider the role international law could play in responding to Russia’s forcible movement of people during its war against Ukraine.

In the two and a half years since its full-scale invasion of Ukraine, evidence has emerged of Russia’s use of forced deportation and forcible transfer. Russia has also employed arbitrary detention as a tool of war and occupation.

Much attention has been on the International Criminal Court’s arrest warrants against Russian President Vladimir Putin and his children’s commissioner Maria Alekseyevna Lvova-Belova. These warrants were issued in relation to the alleged war crimes concerning the unlawful deportation of children from Ukraine to Russia and the unlawful transfer of thousands of children from occupied areas of Ukraine.

Meanwhile, Ukrainian citizens are being arrested and sent to Russia to serve prison sentences. They are often detained without charge and conviction.

This panel discussion explores:

• What evidence is emerging of Russia using unlawful deportation and transfer of children, and the arbitrary detention of civilians?
• What is the role and significance of international law on these issues?
• What challenges might these practices create for later peace negotiations, as well as the securing of justice?
• What is the process of releasing illegally detained Ukrainians, and Ukrainian children in particular, and reuniting them with their families? How do Russian volunteers inside Russia cooperate with Ukrainian NGOs to facilitate family reunification?

The event includes a screening of part of the documentary After the Rain: Putin’s Stolen Children. 

The institute occupies a position of respect and trust, and is committed to fostering inclusive dialogue at all events. Event attendees are expected to uphold this by adhering to our code of conduct.

As the ruling party claims victory in Georgia’s disputed election, Western condemnation is no longer enough Expert comment LToremark 29 October 2024

As tens of thousands take to the streets to protest the election results, Georgia faces a familiar crisis – with a few key differences.

As the people of Georgia went to the polls on 26 October, many were hoping not only for a democratic change of government but also for an end to one-party dominance and a return to the path of European integration. The previously weak and divided opposition had grouped itself into four major electoral centres, promising a coalition government and framing these elections as a choice between Europe and Russia. 

Ahead of the election, President Salome Zourabishvili had put forward the Georgian Charter, a blueprint for a stable and democratic transition to a new style of governance and for initiating reforms to fulfil conditions for EU accession. It was signed by all pro-European and pro-Western opposition parties. 

The official election results gave the ruling Georgian Dream party a 54 per cent majority in contrast with exit polls that gave the opposition a 10 per cent lead. President Zourabishvili and the opposition parties refuse to recognize the results, beginning a long process of contestation with allegations of fraud and street protests. As the disappointment sets in and the streets once again replace the ballot box as a conduit for democratic change, there is a sense of déja vu.

Georgia has seen this before. A party sweeps to power on the tide of popular protest, initiates reforms to meet public expectations but, by the end of its second term, it takes an authoritarian turn. As it overstays its welcome, it starts manipulating elections to cling to power. People once again take to the streets and a new party wins by a landslide only to repeat the same cycle. But with each turn, the grip the ruling elites have on power gets stronger and the methods they use become more sophisticated. State security becomes equated with regime stability, leaving no space for normal democratic contestation or expressions of dissent. 

Although what is happening in Georgia fits this familiar pattern, there are some consequential differences. 

First, these were the first fully proportional elections. Previously, a mixed system of representation meant that the incumbency always had an advantage by dominating majoritarian districts. A new electoral system had created a not unreasonable expectation that these elections, if held freely, would result in a coalition government. The hope was this could help break the vicious cycle of Georgian politics, sustained by an extreme form of majoritarianism and a winner-takes-all political culture.

The Georgian Dream party was contesting its fourth consecutive term against a backdrop of falling popularity and growing societal mobilization in opposition to its authoritarian inclinations. Despite all this, it secured – some would insist manufactured – an absolute majority in elections that international observers say were marred by serious irregularities and fell short of democratic standards. 

The second important difference is that these elections were not only about saving Georgia’s democracy but also about rescuing its European perspective. Since Georgia was granted EU candidate status in December 2023, its parliament has adopted Russian-style laws on foreign agents and combating LGBTIQ+ ‘propaganda’. 

It has also adopted a strongly Eurosceptic political discourse, pushing back on international criticism and accusing EU and US officials of interference in domestic affairs and disregard for Georgia’s sovereignty. In response, the EU has suspended accession talks with Georgia indefinitely while the US has imposed targeted sanctions on high-ranking Georgian officials and judges. 

Georgia’s democratic backsliding at home and its pivot away from the West are both simultaneous and interrelated. It was widely hoped these elections would be a course correction and return Georgia to the path of European and Euro-Atlantic integration. The election results, if they stick, will prevent this from happening. A Georgian Dream government will not work to fulfil conditions for EU accession, viewed as a challenge to its hold on power. 

The third and final difference is that these elections took place in the context of heightened geopolitical confrontation. The Georgian Dream ‘victory’ is a win for anti-liberal, conservative forces around the world championed, among others, by Hungary’s Viktor Orbán. He was the first to congratulate Georgian Dream for its declared success and even visited Tbilisi in a show of solidarity and ideological alignment. 

The election result is also a win for Russia. It strengthens Moscow’s influence in the South Caucasus, which has waned as a result of the war in Ukraine and the fall of Nagorny-Karabakh. Russian officials and propagandist were quick to congratulate Georgian Dream, wishing them success in standing up to Western pressures and offering help in case things got tough. 

From Moscow’s perspective, Georgia’s elections are part of a global hybrid war. They represent a local battle in the ongoing geopolitical contest between Russia and the West, between the rules-based global order and competitive multipolarity. 

As Georgia repeats a familiar pattern, what do the election results mean for its future? While clear predictions are difficult at this stage, it is worth bearing in mind that as the democratic resilience of the Georgian society has strengthened over time, so too has the state capacity to supress and control. 

The Future of Investment Dispute Settlement Regimes 30 June 2020 — 2:00PM TO 3:30PM Anonymous (not verified) 9 February 2021 Online

This event is part of the Inclusive Governance Initiative, which is examining how to build more inclusive models and mechanisms of global governance fit for purpose in today’s world.

Is an ‘atomized’ approach to cross-border investment dispute resolution inevitable? Has the multiplicity of mechanisms helped or hindered inclusivity in and transparency in governance? Is there a need for, and scope to, increase the international coordination of dispute resolution mechanisms? If so, what form should it take? What could be the implications for international economic law?

Reliable, specific polyclonal and monoclonal antibodies are important tools in research and medicine. However, the discovery of antibodies against their targets in their native forms is difficult. Here, we present a novel method for discovery of antibodies against membrane proteins in their native configuration in mammalian cells. The method involves the co-expression of an antibody library in a population of mammalian cells that express the target polypeptide within a natural membrane environment on the cell surface. Cells that secrete a single-chain fragment variable (scFv) that binds to the target membrane protein thereby become self-labeled, enabling enrichment and isolation by magnetic sorting and FRET-based flow sorting. Library sizes of up to 109 variants can be screened, thus allowing campaigns of naïve scFv libraries to be selected against membrane protein antigens in a Chinese hamster ovary cell system. We validate this method by screening a synthetic naïve human scFv library against Chinese hamster ovary cells expressing the oncogenic target epithelial cell adhesion molecule and identify a panel of three novel binders to this membrane protein, one with a dissociation constant (KD) as low as 0.8 nm. We further demonstrate that the identified antibodies have utility for killing epithelial cell adhesion molecule–positive cells when used as a targeting domain on chimeric antigen receptor T cells. Thus, we provide a new tool for identifying novel antibodies that act against membrane proteins, which could catalyze the discovery of new candidates for antibody-based therapies.

Connexin (Cx) protein forms hemichannels and gap junctional channels, which play diverse and profound roles in human physiology and diseases. Gap junctions are arrays of intercellular channels formed by the docking of two hemichannels from adjacent cells. Each hexameric hemichannel contains the same or different Cx isoform. Although homomeric Cxs forms have been largely described functionally and structurally, the stoichiometry and arrangement of heteromeric Cx channels remain unknown. The latter, however, are widely expressed in human tissues and variation might have important implications on channel function. Investigating properties of heteromeric Cx channels is challenging considering the high number of potential subunit arrangements and stoichiometries, even when only combining two Cx isoforms. To tackle this problem, we engineered an HA tag onto Cx26 or Cx30 subunits and imaged hemichannels that were liganded by Fab-epitope antibody fragments via atomic force microscopy. For Cx26-HA/Cx30 or Cx30-HA/Cx26 heteromeric channels, the Fab-HA binding distribution was binomial with a maximum of three Fab-HA bound. Furthermore, imaged Cx26/Cx30-HA triple liganded by Fab-HA showed multiple arrangements that can be derived from the law of total probabilities. Atomic force microscopy imaging of ringlike structures of Cx26/Cx30-HA hemichannels confirmed these findings and also detected a polydisperse distribution of stoichiometries. Our results indicate a dominant subunit stoichiometry of 3Cx26:3Cx30 with the most abundant subunit arrangement of Cx26-Cx26-Cx30-Cx26-Cx30-Cx30. To our knowledge, this is the first time that the molecular architecture of heteromeric Cx channels has been revealed, thus providing the basis to explore the functional effect of these channels in biology.

The bacterial enhancer-binding protein (bEBP) FlrC, controls motility and colonization of Vibrio cholerae by regulating the transcription of class-III flagellar genes in σ54-dependent manner. However, the mechanism by which FlrC regulates transcription is not fully elucidated. Although, most bEBPs require nucleotides to stimulate the oligomerization necessary for function, our previous study showed that the central domain of FlrC (FlrCC) forms heptamer in a nucleotide-independent manner. Furthermore, heptameric FlrCC binds ATP in “cis-mediated” style without any contribution from sensor I motif 285REDXXYR291 of the trans protomer. This atypical ATP binding raises the question of whether heptamerization of FlrC is solely required for transcription regulation, or if it is also critical for ATPase activity. ATPase assays and size exclusion chromatography of the trans-variants FlrCC-Y290A and FlrCC-R291A showed destabilization of heptameric assembly with concomitant abrogation of ATPase activity. Crystal structures showed that in the cis-variant FlrCC-R349A drastic shift of Walker A encroached ATP-binding site, whereas the site remained occupied by ADP in FlrCC-Y290A. We postulated that FlrCC heptamerizes through concentration-dependent cooperativity for maximal ATPase activity and upon heptamerization, packing of trans-acting Tyr290 against cis-acting Arg349 compels Arg349 to maintain proper conformation of Walker A. Finally, a Trp quenching study revealed binding of cyclic-di-GMP with FlrCC. Excess cyclic-di-GMP repressed ATPase activity of FlrCC through destabilization of heptameric assembly, especially at low concentration of protein. Systematic phylogenetic analysis allowed us to propose similar regulatory mechanisms for FlrCs of several Vibrio species and a set of monotrichous Gram-negative bacteria.

Editing and/or saving an action column can take up to a minute to display a window. There are no workarounds identified at this time.

In SAS Retail Space Management, it should be possible to click on any location object, then Show Properties, and change the location fill color. This can be done on the gray-filled objects. However, w

Adaptive thermogenesis is highly dependent on uncoupling protein 1 (UCP1), a protein expressed by thermogenic adipocytes present in brown adipose tissue (BAT) and white adipose tissue (WAT). Thermogenic capacity of human and mouse BAT can be measured by positron emission tomography-computed tomography quantifying the uptake of ¹⁸F-fluodeoxyglucose or lipid tracers. BAT activation is typically studied in response to cold exposure or treatment with β-3-adrenergic receptor agonists such as CL316,243 (CL). Currently, it is unknown whether cold-stimulated uptake of glucose or lipid tracers is a good surrogate marker of UCP1-mediated thermogenesis. In metabolic studies using radiolabeled tracers, we found that glucose uptake is increased in mildly cold-activated BAT of Ucp1^–/– versus WT mice kept at subthermoneutral temperature. Conversely, lower glucose disposal was detected after full thermogenic activation achieved by sustained cold exposure or CL treatment. In contrast, uptake of lipoprotein-derived fatty acids into chronically activated thermogenic adipose tissues was substantially increased in UCP1-deficient mice. This effect is linked to higher sympathetic tone in adipose tissues of Ucp1^–/– mice, as indicated by elevated levels of thermogenic genes in BAT and WAT. Thus, glucose and lipoprotein handling does not necessarily reflect UCP1-dependent thermogenic activity, but especially lipid uptake rather mirrors sympathetic activation of adipose tissues.

α-Synuclein (α-Syn) is a protein implicated in the pathogenesis of Parkinson's disease (PD). It is an intrinsically disordered protein that binds acidic phospholipids. Growing evidence supports a role for α-Syn in membrane trafficking, including, mechanisms of endocytosis and exocytosis, although the exact role of α-Syn in these mechanisms is currently unclear. Here we investigate the associations of α-Syn with the acidic phosphoinositides (PIPs), phosphatidylinositol 4,5-bisphosphate (PI(4,5)P2) and phosphatidylinositol 3,4-bisphosphate (PI(3,4)P2). Our results show that α-Syn colocalizes with PIP2 and the phosphorylated active form of the clathrin adaptor protein 2 (AP2) at clathrin-coated pits. Using endocytosis of transferrin as an indicator for clathrin-mediated endocytosis (CME), we find that α-Syn involvement in endocytosis is specifically mediated through PI(4,5)P2 levels on the plasma membrane. In accord with their effects on PI(4,5)P2 levels, the PD associated A30P, E46K, and A53T mutations in α-Syn further enhance CME in neuronal and nonneuronal cells. However, lysine to glutamic acid substitutions at the KTKEGV repeat domain of α-Syn, which interfere with phospholipid binding, are ineffective in enhancing CME. We further show that the rate of synaptic vesicle (SV) endocytosis is differentially affected by the α-Syn mutations and associates with their effects on PI(4,5)P2 levels, however, with the exception of the A30P mutation. This study provides evidence for a critical involvement of PIPs in α-Syn–mediated membrane trafficking.

Ankylosing Spondylitis (AS) is a common, inflammatory rheumatic disease, which primarily affects the axial skeleton and is associated with sacroiliitis, uveitis and enthesitis. Unlike other autoimmune rheumatic diseases, such as rheumatoid arthritis or systemic lupus erythematosus, autoantibodies have not yet been reported to be a feature of AS. We therefore wished to determine if plasma from patients with AS contained autoantibodies and if so, characterize and quantify this response in comparison to patients with Rheumatoid Arthritis (RA) and healthy controls. Two high-density nucleic acid programmable protein arrays expressing a total of 3498 proteins were screened with plasma from 25 patients with AS, 17 with RA and 25 healthy controls. Autoantigens identified were subjected to Ingenuity Pathway Analysis in order to determine patterns of signalling cascades or tissue origin. 44% of patients with Ankylosing Spondylitis demonstrated a broad autoantibody response, as compared to 33% of patients with RA and only 8% of healthy controls. Individuals with AS demonstrated autoantibody responses to shared autoantigens, and 60% of autoantigens identified in the AS cohort were restricted to that group. The AS patients autoantibody responses were targeted towards connective, skeletal and muscular tissue, unlike those of RA patients or healthy controls. Thus, patients with AS show evidence of systemic humoral autoimmunity and multispecific autoantibody production. Nucleic Acid Programmable Protein Arrays constitute a powerful tool to study autoimmune diseases.

Cooking in Displacement Settings: Engaging the Private Sector in Non-wood-based Fuel Supply Research paper sysadmin 22 January 2019

In displacement settings, providing cooking solutions that reduce negative impacts on the environment and health remains a challenge for local governments, humanitarian agencies, businesses and refugees.

Summary

• Providing adequate cooking fuel and clean-burning, fuel-efficient stoves in displacement settings has long been a major challenge for local authorities, humanitarian agencies, non-governmental organizations, local communities and refugees themselves. Refugees generally have limited access to modern cooking solutions. Most either depend on insufficient humanitarian agency handouts of ‘in-kind’ firewood or have to travel long distances to collect firewood.
• There is significant potential for private-sector engagement in this context – which, though largely overlooked to date, could result in win-win scenarios for all stakeholders. Refugee camps and other displacement settings present opportunities for private-sector cooking fuel companies to expand their customer bases, with the added advantage for vendors of offering concentrated demand and scope for economies of scale.
• For the Kakuma refugee camp complex in Kenya, the Moving Energy Initiative (MEI) decided to engage with the private sector directly. The MEI requested expressions of interest from local private-sector companies for expanding sales and distribution of fuels in the complex through the concession. The winning company – National Oil Corporation of Kenya – is to receive a prize of $50,000 for its proposed concession to supply liquefied petroleum gas both to refugees in the Kakuma complex and to the surrounding host community.
• The MEI also conducted interviews with various stakeholders in other contexts and countries who are engaged in efforts to develop market-based approaches to providing clean, fuel-efficient cooking solutions to refugees.
• Based on the interviews and the concession process, the MEI recommends greater donor investment and longer-term guaranteed funding for cooking interventions. This is needed to allow sufficient time to build sustainable markets and secure the requisite engagement and investments from the private sector.
• Larger, longer-term investments by the private sector – supported through partnerships with donors and humanitarian agencies – in infrastructure and demand creation (both in and outside the refugee community) can reduce the price of alternative solutions and support a gradual transition away from subsidies.

Adopting a Market-based Approach to Boost Energy Access in Displaced Contexts Research paper sysadmin 25 March 2019

This paper evaluates the market-based approaches adopted in the MEI projects in Kenya and Burkina Faso. It articulates how such commercial strategies can be applied to the delivery of energy in displacement settings and compares this to real world examples.

• Development of long-term energy solutions in displacement settings tends to be perceived as investment that falls outside the remit of emergency responses. In addition, when emergency energy supply measures are implemented they often result in expensive, unreliable and unhealthy energy provision for those in protracted or recurrent crises.
• There is widespread agreement among humanitarian and development experts that an effective refugee response should include long-term development solutions as well as emergency relief.
• The energy access imperative is more pronounced when considering the need for effective energy distribution in practically all camp activities and basic necessities: pumping and treatment of clean water; heating and cooling for food storage and cooking; energy for livelihood activities; and provision of light for schooling, hospitals and the prevention of violence against women and children.
• Minor shifts in household energy use to basic solar lighting options and non-wood fuels would save $303 million annually on refugee fuel costs.
• Within refugee contexts in Kenya and Burkina Faso, the MEI sought to examine opportunities to use market interventions, rather than in-kind distributions, to improve clean energy access over the long-term and test the delivery of market-based approaches.

Infrastructure Management Contracts: Improving Energy Asset Management in Displacement Settings Research paper sysadmin 17 April 2019

This paper highlights a number of options for managing electricity infrastructure in refugee camps and outlines the challenges, opportunities and operational implications associated with them. It takes the Kalobeyei settlement in Kenya as a case study.

• Building and maintaining electricity infrastructure to power offices, businesses, households and other operations in displacement settings is difficult. It is especially challenging for the Office of the United Nations High Commissioner for Refugees (UNHCR) and its partner agencies, because supplying electricity is not their core business.
• Private-sector companies exist that are willing and able to develop infrastructure management contracts to provide energy as a service in displacement settings. However, institutional barriers within humanitarian agencies persist, with short budgeting cycles in particular preventing humanitarian agencies from entering into the sorts of long-term service agreements required by the private sector.
• A number of options exist to leverage the expertise of the private sector through ‘public–private partnership’ (P3) structures. Such mechanisms can promote more efficient management of infrastructure by drawing on private-sector experience and expertise, incentivizing appropriate risk-sharing and providing options to leverage private capital in project development.
• Field work from the Kalobeyei settlement in Kenya suggests that a solar/diesel hybrid mini-grid solution was the most economical option to power camp services and infrastructure there. Compared to distributed diesel generation, the annual savings in operating costs were estimated at $49,880, with the additional investment paid back within 3.6 years.
• Humanitarian agencies need to be willing to change their policies to enable long-term service agreements. Alternatively (or, more likely, in conjunction with this option), financial mechanisms such as partial risk guarantees need to be developed to offset some of the risks. This change will need high-level support from donors and humanitarian agencies.
• Once the first infrastructure management contracts can be signed and tested in displacement locations (through the use of donor funding or otherwise) and associated data collected, it will ease the way for future investments in these types of projects.

Bispecific antibodies (bsAbs) are engineered to target 2 different epitopes simultaneously. About 75% of the 16 clinically approved bsAbs have entered the clinic internationally since 2022. Hence, research on biomedical imaging of various radiolabeled bsAb scaffolds may serve to improve patient selection for bsAb therapy. Here, we provide a comprehensive overview of recent advances in radiolabeled bsAbs for imaging via PET or SPECT. We compare direct targeting and pretargeting approaches in preclinical and clinical studies in oncologic research. Furthermore, we show preclinical applications of imaging bsAbs in neurodegenerative diseases. Finally, we offer perspectives on the future directions of imaging bsAbs based on their challenges and opportunities.

Mattel has apologized after inadvertently directing customers of its new line of Wicked dolls to a pornographic website, stating it is taking action to remove the misprinted toys' packaging.

Mattel has apologized after inadvertently directing customers of its new line of Wicked dolls to a pornographic website, stating it is taking action to remove the misprinted toys' packaging.

A federal judge has blocked a new bill in Louisiana that would require the Bible's Ten Commandments to be displayed in the state's publicly-funded schools.

North Carolina officials' switch in reading-test vendors just weeks before the new school year got underway is spotlighting the often murky process of contracts and procurements for K-12 services.

The supreme court put an end to five years of legal wrangling that landed the state's public school system with millions more dollars from the state and teachers with a pay raise.

It is well established that holding information in working memory (WM) elicits sustained stimulus-specific patterns of neural activity. Nevertheless, here we provide evidence for a distinct class of neural activity that tracks the number of individuated items in working memory, independent of the type of visual features stored. We present two EEG studies of young adults of both sexes that provide robust evidence for a signal tracking the number of individuated representations in working memory, regardless of the specific feature values stored. In Study 1, subjects maintained either colors or orientations across separate blocks in a single session. We found near-perfect generalization of the load signal between these two conditions, despite being able to simultaneously decode which feature had been voluntarily stored. In Study 2, participants attended to two features with very distinct cortical representations: color and motion coherence. We again found evidence for a neural load signal that robustly generalized across these distinct visual features, even though cortically disparate regions process color and motion coherence. Moreover, representational similarity analysis provided converging evidence for a content-independent load signal, while simultaneously showing that unique variance in EEG activity tracked the specific features that were stored. We posit that this load signal reflects a content-independent "pointer" operation that binds objects to the current context while parallel but distinct neural signals represent the features that are stored for each item in memory.

Four hundred years ago, escaped slaves formed the village of Palenque. The town’s younger generations have reconnected with their African roots through cultural traditions handed down from their ancestors (Kenneth Fletcher/SmithsonianMag.com). Read more at http://www.smithsonianmag.com/travel/colombia-dispatches.html