Elevated pressure in the pancreatic gland is the central cause of pancreatitis following abdominal trauma, surgery, endoscopic retrograde cholangiopancreatography, and gallstones. In the pancreas, excessive intracellular calcium causes mitochondrial dysfunction, premature zymogen activation, and necrosis, ultimately leading to pancreatitis. Although stimulation of the mechanically activated, calcium-permeable ion channel Piezo1 in the pancreatic acinar cell is the initial step in pressure-induced pancreatitis, activation of Piezo1 produces only transient elevation in intracellular calcium that is insufficient to cause pancreatitis. Therefore, how pressure produces a prolonged calcium elevation necessary to induce pancreatitis is unknown. We demonstrate that Piezo1 activation in pancreatic acinar cells caused a prolonged elevation in intracellular calcium levels, mitochondrial depolarization, intracellular trypsin activation, and cell death. Notably, these effects were dependent on the degree and duration of force applied to the cell. Low or transient force was insufficient to activate these pathological changes, whereas higher and prolonged application of force triggered sustained elevation in intracellular calcium, leading to enzyme activation and cell death. All of these pathological events were rescued in acinar cells treated with a Piezo1 antagonist and in acinar cells from mice with genetic deletion of Piezo1. We discovered that Piezo1 stimulation triggered transient receptor potential vanilloid subfamily 4 (TRPV4) channel opening, which was responsible for the sustained elevation in intracellular calcium that caused intracellular organelle dysfunction. Moreover, TRPV4 gene–KO mice were protected from Piezo1 agonist– and pressure-induced pancreatitis. These studies unveil a calcium signaling pathway in which a Piezo1-induced TRPV4 channel opening causes pancreatitis.

Amazon is taking up to $100 off the Apple Watch Series 5 this week, with prices starting at $299.99 for the 40mm GPS models. Only the Gold Aluminum Case with Pink Sport Band is available at this price. If you order today, the Apple Watch should arrive sometime next week.

Note: MacRumors is an affiliate partner with Amazon. When you click a link and make a purchase, we may receive a small payment, which helps us keep the site running.

The Apple Watch Series 5 was released in September 2019 with a new OLED screen that supports an always-on feature, which represents the biggest change to the Series 5 models. The newest Apple Watch is available in 40mm and 44mm sizes, and it has the overall same design as the Series 4 models.

$100 OFF

Apple Watch S5 (40mm, GPS) for $299.99

If you're shopping for a cellular model, there are also a few solid discounts on Amazon for these devices. You can get the Gold Aluminum Case with Pink Sport Band (40mm) for $399.00, down from $499.00. Likewise, the Silver Aluminum Case with White Sport Band (40mm) is $399.00 right now.

For the 44mm cellular models, a solid deal is the Space Gray Aluminum Case with Black Sport Band at $429.00, down from $529.00. You'll find the same price on the Silver Aluminum Case with White Sport Band and the Gold Aluminum Case with Pink Sport Band.

Across the board, these sales are either new low prices on the Apple Watch Series 5, or they're matching previous low prices seen on these models on Amazon. There are a few other deals going on for different Series 5 models as well, including numerous 44mm cellular devices that are about $50 off Apple's original prices. Be sure to head to Amazon to check out the full sale before these prices expire, or the retailer runs out of stock.

Keep up with all of this week's best discounts on Apple products and related accessories in our dedicated Apple Deals roundup.
This article, "Deals: Apple Watch Series 5 Models Discounted by Up to $100 on Amazon" first appeared on MacRumors.com

Discuss this article in our forums

A great many people only experience science fiction by what my mother and millions of others referred to as "monster movies". From Frankenstein to Aliens and beyond, the unknown and the unexplored are often our undoing. Bleak Horizons, edited by Tarl Hoch, is a wonderful collection of 15 stories that mix SF and Horror with various levels of anthropomorphic settings and characters. And, full disclosure, one of those stories is mine. Happily, the mix includes more than just blood thirsty monsters and end of the universe scenarios.

Overall my favorite stories in this anthology are Hardwire, Pentangle, and The Ouroboros Plate. My least favorites are 4/13/2060 and Not Like Us. Below is a short review of all the pieces. I think you should snag a copy, if only to read my favorites and have a taste for this genre. However, I also really enjoyed Carmen Miranda's Ghost Is Haunting Space Station 3 so you have every right to question my taste.

read more

A new style of wooden fencing has begun to pop up around Sacramento homes

IBM y VON DER HEIDE, compañía especializada en servicios de consultoría de Recursos Humanos, informan que han firmado una importante alianza para expandir su oferta de servicios de Employee Engagement y HR Analytics en toda América Latina. Por medio de las tecnologías de IBM, esta alianza le permitirá a VON DER HEIDE brindar a sus clientes una oferta de consultoría única en el mercado, para transformar estrategias de talento en resultados de negocio.

Zoo and Aquarium Association Uses IBM Technology to Support Endangered Species Programme

佐野瑞樹さんを迎えて。餃子対決はまさかの餃子カルパッチョのワッシーに軍配。次回は21日22:00〜です。https://www.youtube.com/channel/UCOapEVZB3F6rctblyBigXog

Необычные социальные условия во время пандемии COVID-19 побуждают искать новые способы интеллектуального общения. И у нас есть хрестоматийный пример подобного поиска — это «Декамерон» Боккаччо. Как многие помнят, события «Декамерона» происходят во время чумы 1348 года. Чтобы ненадолго отвлечься от печальных мыслей, семь девушек и трое юношей уходят из Флоренции, охваченной эпидемией, собираются вместе в загородном имении и в течение десяти дней рассказывают друг другу истории…

昨夜お邪魔いたしました。15分間の続きをみる

『著作権保護のため、記事の一部のみ表示されております。』

(in-package #:cl-pestilence)

;;   This is _not_ a simulation. It's just a game. And any resemblance
;; to any world, real or imaginary, is entirely coincidental.

;;   You can copy/paste this post in its entirety into a Common Lisp
;; REPL and play around with it if you like. I'm documenting it where
;; possible, but it's just a small toy to poke at for the moment.

;;   I've been thinking a lot about asymmetric multiplayer games and
;; <gestures wildly to world at large> all this.
;; I'm not actively _trying_ to model it accurately, but it's probably
;; obvious what's been consuming my thoughts lately.

;;   Let's get right into this. I'll explain as I go, and tie a few things
;; together neatly at the end. I hope. Regardless, there will absolutely
;; be a repo sometime fairly soon.

;; A place can be tagged arbitrarily, and can contain occupants.
;; They also collect points.

(defclass place ()
  ((tags :initarg :tags :initform nil :accessor tags)
   (occupants :initarg :occupants :initform nil :accessor occupants)
   (points :initform 0 :accessor points)))

(defun place? (thing)
  (eq (find-class 'place) (class-of thing)))

(defun place (&key tags occupants)
  (make-instance 'place :tags tags :occupants occupants))

(defun gen-place ()
  (let ((tag (pick '(:apartment-building :house :cottage
		     :office-building :factory :store
		     :cafe :lounge :theater))))
    (place :tags (list tag))))

(defmethod details ((place place))
  (format nil "====================~%~a {~{~a~}}~%~{  ~a~^~%~}~%"
	  (first (tags place))
	  (rest (tags place))
	  (mapcar #'details (occupants place))))

(defmethod show ((place place))
  (format nil "~20@a ~5a [~{~a~}]~%"
	  (first (tags place)) (points place)
	  (mapcar #'show (occupants place))))

;; A peep goes places.
;; They have
;;  - their daily routine (a list of places to visit)
;;  - their todo (the part of their routine they still need to do;
;;                they are currently at the first place in this list)
;;  - their health (a number from 0 to 100)
;;  - a list of plagues
;; Finally, they _also_ collect points.

(defclass peep ()
  ((routine :initarg :routine :initform (list) :accessor routine)
   (todo :initarg :todo :initform nil :accessor todo)
   (health :initarg :health :initform 100 :accessor health)
   (plagues :initform nil :accessor plagues)
   (points :initform 0 :accessor points)))

(defun peep? (thing)
  (eq (find-class 'peep) (class-of thing)))

(defun peep (&key places)
  (make-instance 'peep :routine places :todo places))

(defun health->string (health)
  (cond ((>= health 90) "@")
	((>= health 80) "0")
	((>= health 70) "O")
	((>= health 50) "o")
	((>= health 30) ":")
	((>= health 1)  ".")
	(t "☠")))

(defmethod details ((peep peep))
  (format nil "[~a ~3d [~{ ~a~^ ->~}]]"
	  (health->string (health peep)) (health peep)
	  (mapcar
	   (lambda (place) (first (tags place)))
	   (routine peep))))

(defmethod show ((peep peep)) (health->string (health peep)))

;; A world is a list of places, occupied by peeps. The world we start
;; peeps in also determines their routine.

(defun gen-world (&key (num-places 20) (num-peeps 100))
  (let ((places (loop repeat num-places collect (gen-place))))
    (loop repeat num-peeps
       do (let* ((routine (loop repeat 5 collect (pick places)))
		 (peep (peep :places routine)))
	    (push peep (occupants (first routine)))))
    places))

(defmethod details ((world list))
  (format nil "~%~{~a~}~%" (mapcar #'details world)))

(defmethod show ((world list))
  (format nil "~%~{~a~}~%" (mapcar #'show world)))

(defmethod all-peeps ((world list))
  (loop for place in world append (all-peeps place)))

(defmethod all-peeps ((place place))
  (loop for o in (occupants place) if (peep? o) collect o))

;; `tick!`ing a world means moving every peep through their routine once.
;;   We `tick!` each peep, then `tick!` each place until all the peeps are
;; done. Then we reset their routines.
;; You can think of this as a turn in the game.

(defmethod tick! ((world list))
  (let ((peeps (all-peeps world)))
    (loop while peeps
       do (setf peeps
		(loop for p = (pop peeps) while p
		   for res = (tick! p)
		   if res collect res))
       do (mapc #'tick! world)
       do (format t "~a" (show world)))
    (loop for p in (all-peeps world)
       do (setf (todo p) (routine p))))
  world)

;; Don't worry about the details of how to `tick!` peeps or places yet.

;;   Ok, here's where it gets a bit darker. Although we _did_
;; foreshadow this in the definition of `peep`. And also in the title
;; of the accompanying blog post.

;; A plague is another living thing.
;; It has
;;  - a host (a peep that it's infecting)
;;  - a signature (a token representing its lineage and strain)
;;  - health (how well it's doing inside its host)
;;  - virulence (how likely it is to spread to another host)
;;  - efficiency (how efficient they are at feeding)
;;  - reproduce (a function that returns a new instance to push into a new host)
;;  - and a strategy (a function, possibly closed, that takes
;;    itself and its host peep and mutates)

;; Plagues do not collect points; they score differently.

(defclass plague ()
  ((host :initarg :host :initform nil :accessor host)
   (signature :initarg :host :initform "SIG" :accessor signature)
   (health :initarg :health :initform 10 :accessor health)
   (virulence :initarg :virulence :initform 10 :accessor virulence)
   (efficiency :initarg :efficiency :initform 0.2 :accessor efficiency)
   (reproduce
    :initarg :reproduce
    :initform
    #'plague
    :reader reproduce)
   (strategy
    :initarg :strategy
    :initform
    (lambda (plague peep)
      (feed! plague peep 30))
    :reader strategy)))

(defun plague ()
  (make-instance 'plague))

;; Plagues can `feed!` on peeps or plagues. To feed means to
;; take away some of the targets' health and add some to your own.

(defmethod feed! ((self plague) (peep peep) (amount integer))
  (decf (health peep) amount)
  (incf (health self) (* (efficiency self) amount)))

(defmethod feed! ((self plague) (plague plague) (amount integer))
  (decf (health plague) amount)
  (incf (health self) (* (efficiency self) amount)))

;; Plagues can also `infect!` peeps by `reproduce`ing into them.

(defmethod infect! ((self plague) (peep peep))
  (unless (infected-by? self peep)
    (let ((child (funcall (reproduce self))))
      (setf (host child) peep)
      (push child (plagues peep)))))

(defmethod infected-by? ((self plague) (peep peep))
  (member (signature self) (mapcar #'signature (plagues peep))
	  :test #'string=))

;;  `tick!`ing a plague causes it to weaken and also carry out its strategy.
;; This models the background effect of the immune system of its host.

(defmethod tick! ((plague plague))
  (decf (health plague) 1)
  (funcall (strategy plague) plague (host plague))
  plague)

;;  `tick!`ing a peep means moving them to their next place, and also
;; `tick!`ing any plagues they may have contracted. Also, peeps are
;; resilient; they heal a small amount each time they tick (to a
;; maximum of 100).
;;  If a peep dies, they no longer move. And their plagues probably
;; won't do well. Peeps like to go places. They score points for each
;; place they go to.

(defun dead? (thing) (>= 0 (health thing)))

(defmethod tick! ((peep peep))
  (unless (dead? peep)
    (let ((location (pop (todo peep))))
      (incf (points peep))
      (setf (occupants location) (remove peep (occupants location)))
      (push peep (occupants (or (first (todo peep)) (first (routine peep)))))
      (setf (health peep) (min 100 (+ 5 (health peep))))
      (mapc #'tick! (plagues peep))
      (unless (empty? (todo peep))
	peep))))

;; `tick!`ing a place causes it to score for each `peep` present. And it causes
;; any `plague`s on present `peep`s to try to `infect!` other nearby peeps.
;; Places also lose points for each dead peep they contain.

(defmethod tick! ((place place))
  (incf (points place) (length (occupants place)))
  (loop for peep in (all-peeps place)
     if (dead? peep)
     do (decf (points place) 2)
     else do (loop for plague in (plagues peep)
		do (loop for victim in (remove peep (all-peeps place))
		      if (>= (virulence plague) (random 100))
		      do (infect! plague victim))))
  place)

;;  So, now we've got the basic framework of the game in place. There are three
;; players in this game: places, peeps and plagues.
;;   A plague player automatically loses if they are completely cured, and
;; automatically wins if they manage to kill everyone. That's fairly simple.
;;   A place player wins if they manage to cure the plague. They automatically
;; lose if all the peeps die. Also, fairly simple.
;;   A peep player is trying to survive. If they manage to make it some numer
;; of turns before dying, then we have to score the game instead of declaring
;; an outright winner regardless of game state.

;;   A peep player's score is the total number of points plus remaining health
;; on all of their peeps, minus the number of active plagues on said peeps.
;;   A plague player's score is the total number of health of their plagues,
;; with a multiplier equal to the number of places fully infected by
;; their plague.
;;   A place player's score is the total number of points in their places.

(defun score (world)
  (list :peep (let ((score 0))
		(loop for p in (all-peeps world)
		   unless (dead? p)
		     do (incf score (+ (health p) (points p)))
		   do (decf score (length (plagues p))))
		score)
	:place (let ((score 0))
		 (loop for p in world
		    do (incf score (points p)))
		 score)
	:plague (let ((score 0))
		  (loop for victim in (all-peeps world)
		     do (loop for p in (plaguesvictim)
			   do (incf score (max 0 (health p)))))
		  (loop for target in world
		     if (every
			 (lambda (victim)
			   (not (empty? (plagues victim))))
			 (all-peeps target))
		     do (setf score (* 2  score)))
		  score)))

;;   I think that's all I've got for now. This is definitely an idea I want
;; to run with. At the moment, it's just a tiny, in-repl proof-of-concept,
;; and not particularly fun, but I'm going to try developing it further with an
;; eye towards turning it into an actual web game playable from this site.

;; As always, I'll let you know how it goes.

(defun pick (lst)
  (nth (random (length lst)) lst))

(defun empty? (lst)
  (null lst))

So recently, I had to use zippers at work. Specifically, the Clojure implementation. There were some close-to-arbitrary transformations I needed to do with some close-to-arbitrary trees and it turned out that zippers were more efficient than the alternatives¹.

Using them this way, combined with the general state of the world and my free time, finally tipped me into doing some more Common Lisp development. Before, I go any further, let me be clear about something.

I Like Clojure

Seriously.

Its logo is up top in the language bar, I was one of the inaugural members of the Toronto Clojure User Group, I recommend it as a first lisp you should learn, and have for about six years now. I'm also painfully aware of the shortcomings of Common Lisp, and make no excuses for them.

However.

• I don't like the JVM. It's slow as balls, its' deployment options are less than ideal for my purposes, its' error system is at best useless, and Clojure without it is unlikely.
• Clojurescript build incompatiblities are, if anything, worse².
• I don't like the underlying licensing decisions.

These are deep reasons to stay away. They're not the sort of thing I can paper over with a library or two. Fixing them would mean a superhuman amount of work poured into the underlying technical and social infrastructure, and I'm not into it. I wouldn't be into it even if the community was interested in heading that way, and near as I can tell, they're not particularly.

Whether or not I think you should learn Clojure as your first³ lisp, it definitely wasn't my first lisp. The more uniform, mostly-better-thought-out interface, lack of historical baggage and functional data structures are not enough to pull me all the way over.

It is enough for me to start plotting a smash-and-grab of as much of the stuff I like as I can carry. Which is exactly what clj represents. As of this writing, it defines and exports exactly four symbols: if-let, when-let, -> and ->>. This is a tiny beginning of the list, and I fully plan to put something more substantial together using cl-hamt, named-readtables, test-utils and possibly optima. Stay tuned to that repo if you're interested, but it's not the focus today.

cl-zipper

The thing that percipitated this thought was having used the Clojure Zipper implementation. So, obviously, this is something I want next time I need to manipulate trees in Common Lisp. The paper is here, and unless you have a terminal phobia of datastructures⁴, you should go read it. It's six pages, they're light, and one of them taken up by the intro and references.

The operations defined in the paper are left, right, up, down, insert_right, insert_left, insert_down and delete. There's a few conveniences defined for the Clojure version, and I've implemented some of my own stuff too. Lets go through the main file in almost-literate style.

First up, we have constructors.

(defstruct path
  (left) (path) (right))

(defstruct loc
  (node)
  (path)

  (fn-branch?)
  (fn-children)
  (fn-make-node))

;;;;;;;;;; Constructors
(defun zipper (branch? children make-node root)
  (make-loc
   :node root
   :fn-branch? branch? :fn-children children :fn-make-node make-node))

(defmethod make-zipper ((thing list))
  (zipper #'listp #'identity (lambda (node children) (declare (ignore node)) children) thing))

(defun make-node (zipper children)
  (funcall (loc-fn-make-node zipper) zipper children))

You can see influence from both clojure.zip and the paper here. I'm taking the lead from the paper by explicitly separating the path triple our from the loc definition. However, I'm not explicitly defining my own type tree the way that Huet does. Instead, I'm going to be dealing with assorted lisp trees. These could be implemented as lists, vectors, hashes, or any number of other formats. I'm going to implement a few type-distpatching built-ins, including the make-zipper list method above, but the basic zipper function just needs to take an interface as input in the form of branch?, children and make-node arguments. This is the same solution that the Clojure implementation went with, and I see no reason to go a different way. The only material difference is that theirs uses the Clojure metadata system, while I explicitly define slots in the loc structure.

Now that we can construct, we need to be able to select.

;;;;;;;;;; Selectors
(defun branch? (zipper) (funcall (loc-fn-branch? zipper) (loc-node zipper)))
(defun children (zipper)
  (funcall
   (loc-fn-children zipper)
   (loc-node zipper)))
(defun node (zipper) (loc-node zipper))
(defun path (zipper) (loc-path zipper))

(defun lefts (zipper)
  (when (loc-path zipper)
    (reverse (path-left (loc-path zipper)))))

(defun rights (zipper)
  (when (loc-path zipper)
    (path-right (loc-path zipper))))

The basic navigation is four functions; down, up, left and right

;;;;;;;;;; Navigation
;;;;;;;;;;;;;;; Basic navigation
(defun down (zipper)
  (when (children zipper)
    (let ((fresh (copy-loc zipper)))
      (setf (loc-node fresh) (first (children zipper))
	    (loc-path fresh)
	    (make-path
	     :left nil
	     :path (loc-path zipper)
	     :right (rest (children zipper))))
      fresh)))

(defun up (zipper)
  (when (path zipper)
    (let ((fresh (copy-loc zipper)))
      (setf (loc-node fresh)
	    (make-node
	     zipper (append
		     (reverse (path-left (path zipper)))
		     (cons (loc-node zipper)
			   (path-right (path zipper)))))
	    (loc-path fresh) (path-path (path zipper)))
      fresh)))

(defun left (zipper)
  (when (and (path zipper) (path-left (path zipper)))
    (let ((fresh (copy-loc zipper)))
      (setf (loc-node fresh) (first (path-left (path zipper)))
	    (loc-path fresh)
	    (make-path
	     :left (rest (path-left (path zipper)))
	     :path (path-path (path zipper))
	     :right (cons (loc-node zipper) (path-right (path zipper)))))
      fresh)))

(defun right (zipper)
  (when (and (path zipper) (path-right (path zipper)))
    (let ((fresh (copy-loc zipper)))
      (setf (loc-node fresh) (first (path-right (path zipper)))
	    (loc-path fresh)
	    (make-path
	     :left (cons (loc-node zipper) (path-left (path zipper)))
	     :path (path-path (path zipper))
	     :right (rest (path-right (path zipper)))))
      fresh)))

The main difference between this and the paper is that I've chosen nil as my Top representation, which lets me pull the trick of using when to check for the presence of a path, and its' non-Top-ness at the same time.

The bad news is that since Common Lisp doesn't have pervasive functional data structures, I have to explicitly copy locs while moving through a tree. The good news is that the copy is fairly light weight. Effectively, I'm copying out a set of 5 pointers, and could get that down to 3 by defining an intermediate struct.

Hm.

Which I probably should do. Note to self.

Out of those, we get three compound navigation functions. With more probably coming soon. Specifically, I found find useful for the work I did. It's easily externally definable, but would be even easier to bundle along. The ones I've already implemented are root, leftmost and rightmost.

;;;;;;;;;;;;;;; Compound navigation
(defun root (zipper)
  (if-let (z (while zipper #'up))
    (node z)))

(defun leftmost (zipper) (while zipper #'left))

(defun rightmost (zipper) (while zipper #'right))

Each of these involve an intermediate call to while. Which isn't a generic macro; it's a function defined in util.lisp

...
(defun until (zipper f)
  (let ((z zipper))
    (loop for next = (funcall f z) while next
       when next do (setf z next))
    z))
...

As you can see, all it does is repeatedly call a given function on a zipper and return the last non-nil loc result. That's loc, not node, so this doesn't run into the usual Common Lisp conflict of "Did you fail to find a thing, or find the element nil?".

That's the traversals done. Next up, we've got modification, without which this library is fairly useless. The basics are replace, delete and the insert/child twins.

;;;;;;;;;; Modification
(defun replace (zipper node)
  (let ((fresh (copy-loc zipper)))
    (setf (loc-node fresh) node)
    fresh))

(defun delete (zipper)
  (when (path zipper)
    (let ((fresh (copy-loc zipper))
	  (fresh-path (copy-path (loc-path zipper))))
      (cond ((rights zipper)
	     (setf (loc-node fresh) (pop (path-right fresh-path))
		   (loc-path fresh) fresh-path))
	    ((lefts zipper)
	     (setf (loc-node fresh) (pop (path-left fresh-path))
		   (loc-path fresh) fresh-path))
	    (t (setf (loc-path fresh) (path-path fresh-path))))
      fresh)))

(defun insert-child (zipper node)
  (replace
   zipper
   (make-node
    zipper
    (cond ((not (branch? zipper))
	   (list node (node zipper)))
	  ((children zipper)
	   (cons node (children zipper)))
	  (t (list node))))))

(defun append-child (zipper node)
  (replace
   zipper
   (make-node
    zipper
    (cond ((not (branch? zipper))
	   (list (node zipper) node))
	  ((children zipper)
	   (append (children zipper) (list node)))
	  (t (list node))))))

(defun insert-left (zipper node)
  (let ((fresh (copy-loc zipper))
	(fresh-path (copy-path (loc-path zipper))))
    (push node (path-left fresh-path))
    (setf (loc-path fresh) fresh-path)
    fresh))

(defun insert-right (zipper node)
  (let ((fresh (copy-loc zipper))
	(fresh-path (copy-path (loc-path zipper))))
    (push node (path-right fresh-path))
    (setf (loc-path fresh) fresh-path)
    fresh))

The paper defines an insert_down function. It fails on a Leaf node, and otherwise inserts a singleton branch at the given location. The insert/append child functions above also insert nodes at a lower level at the current loc. They give you a choice about whether to insert the new node as the leftmost or rightmost child, and additionally succeed on Leaf nodes by including the leaf value as a child of the new branch.

There are, thus far, three compound modification functions; edit, splice-left and splice-right.

(defun edit (zipper f &rest args)
  (replace zipper (apply f (node zipper) args)))

(defun splice-left (zipper node-list)
  (reduce #'insert-left node-list :initial-value zipper))

(defun splice-right (zipper node-list)
  (reduce #'insert-right (reverse node-list) :initial-value zipper))

edit takes a function instead of a new node, and replaces the node at loc with the result of running that function on the existing node. The splice-* twins are fairly self-explanatory; they're like insert-left/insert-right, but work on multiple nodes rather than single ones.

I haven't yet implemented next, prev and remove because these might relate to the different representation of the traversal end? state. The reason for this seems to be that next/prev/remove assume a depth-first traversal. The reason I'm being weasely here is that I haven't thought about it hard enough to be sure that the end? marker is really necessary. It also seems odd to privilege depth-first over breadth-first traversals; ideally, I think you'd want to be able to support either. Possibly interchangeably.

Minor Housekeeping

That wraps it up for this edition. My immediate intention is to do more work on the cl-zipper and clj libraries, as well as that game I mentioned last time. Ideally, I'd like to up my blogging output too. Probably not to the same volume as I had at my peak, but it was definitely helpful to keep some sort of written journal around for a while. The current state of the world is, hopefully, going to make it easy for me to get more programming time in. All things considered, I'd count that as a win.

1. Although admittedly, it does require me to explain the concept of zippers to a few other people for maintenance purposes. So ironically, this adds complexity despite being much more technically elegant than other options.↩
2. There's a reason that langnostic.js is a raw JS file, rather than compiled from clojurescript source, and that reason is like 90% that the compilation process is nontrivial to set up.↩
3. "First", not "only". You can probably make educated guesses about which other ones I think you should learn.↩
4. In which case, why are you here? This blog could kill you accidentally with an errant click or two. You should probably just go do something else.↩

1. Het laatste woord is nog niet gezegd: "Niet ondenkbaar dat KBVB en clubs zich burgerlijke partij stellen in strafonderzoek naar Moeskroen”  Het Laatste Nieuws
2. Peter Vandenbempt over Moeskroen: "Het failliet van de licenties"  sporza.be
3. BAS-arbiter die Moeskroen laat gaan was debutant  Het Nieuwsblad
4. Belgische voetbalbond: “Principieel oneens met beslissing BAS om Moeskroen licentie toe te kennen”  Het Laatste Nieuws
5. Verbazing alom over licentie voor Moeskroen: “Hier laat Westerlo het niet bij, de strijd barst nu écht los”  Gazet van Antwerpen
6. Hele verhaal bekijken via Google Nieuws

Motorrijder uit Zottegem overleden na zwaar ongeval in Zwalm, bestuurster auto zwaargewond  Het NieuwsbladHele verhaal bekijken via Google Nieuws

Noodnummer 1722 geactiveerd wegens slecht weer op zondag  Het NieuwsbladHele verhaal bekijken via Google Nieuws

LIVE. De Wever over eventuele tweede piek: “Normale quarantaine is er een van zieken, niet van gezonde mensen”  Het Laatste Nieuws

Experts, economen en politici: iedereen is nu al bezig met een tweede coronagolf. “Zolang er geen vaccin is, zal het nieuwe normaal blijven bestaan”  Het Nieuwsblad

There are dozens of articles Out There on "Zoom fatigue", with a wide range of ideas about causes and cures. Gianpiero Petriglieri offered the BBC a couple of hypotheses about why "Zoom calls drain your energy": Being on a video call requires more focus than a face-to-face chat, says Petriglieri. Video chats mean we need […]

Zombie Strippers has got to be hands down one of the cheesiet, oddest, zombie movies movies I have ever seen

1. Microsoft Responds To Xbox Reveal Criticism  Dark Horizons
2. PS5 FIRES BACK against Xbox Series X as EA lets slip PlayStation 5 secrets  T3 Australia
3. The Xbox Series X showcase was disappointing and Microsoft knows it  TechRadar
4. Microsoft "set some wrong expectations" with Xbox Series X gameplay reveal says Aaron Greenberg  GamesRadar+ AU
5. Xbox Series X set to DOMINATE PS5 with monthly reveals – while Sony stays quiet  T3 Australia
6. View Full coverage on Google News

The 'Curtain of Distraction' is well known at Arizona State University as a hilarious sports tactic. This time Michael Phelps came out Magic Mike style to prevent a few free throws. Just look at those sweet moves, the opposing team was bound to miss. 

From the darkness emerges a boot. An old leather, steel-toed, work boot. It shouldn’t be there resting on the seafloor nearly two kilometers deep. I’m…

The Deepwater Horizon disaster released approximately 4 million barrels of oil from the Macondo Wellhead over the course of 87 days in 2010.  Thus, becoming…

Ten years ago, April 20, 11 men on the Deepwater Horizon were incinerated when the BP/Transocean oil rig blew out and exploded. Just 17 months before the Deepwater Horizon destroyed 600 miles of Gulf Coast, BP covered up a

The post Deepwater Horizon: BP’s SECOND Blowout<div id='sec-title'>The Secret History - 10 Year Anniversary</div> appeared first on Greg Palast.

Children of Morta (PS4) - $15 [Amazon/Gamestop]

 

https://www.amazon.com/gp/offer-listing/B07STWQ38Z/ref=dp_olp_new?tag=cheapassgam08-20&ie=UTF8&condition=new

https://www.gamestop.com/video-games/playstation-4/games/products/children-of-morta/11095151.html

 

Been watching closely for this, first time the PS4 physical copy has breached below $20.

 

https://www.amazon.com/gp/product/B084MYKPDJ/ref=ox_sc_act_title_2?tag=cheapassgam08-20&smid=ATVPDKIKX0DER&psc=1

Arizona has reported 20 positive cases of COVID-19 as of Tuesday (March 17).

Exclusive offer from Giveaway of the Day and ToomkyGames! No third-party advertising and browser add-ons! Guide Kate Reed as she searches for the artifacts that can break the power of a cursed gem in House of 1,000 Doors: The Palm of Zoroaster! A cursed gem that has left a trail of smoldering bodies in its wake is threatening the residents of the House of 1,000 Doors, prompting the head of the mystical dwelling to once again summon Kate Reed to its aid. Guide Kate as she searches for the artifacts that can break the power of the gem!

As there have been countless cases of Zoombombing in the recent weeks, the security in the video conferencing platform Zoom has been doubted by its users. In response to this, Zoom finally announced on Thursday that they will be implementing and offering end-to-end encryption.

With the acquisition of Keybase, a New York-based startup specializing in encrypted messaging and cloud services, Zoom will finally be able to make good on its claims of offering end-to-end encryption.

“We are excited to integrate Keybase’s team into the Zoom family to help us build end-to-end encryption that can reach current Zoom scalability,” CEO Eric Yuan said in a Zoom blog post on Thursday.

Unfortunately, not all Zoom users will benefit from the company’s new move, as the end-to-end encryption feature will only be available to users who have paid plans (which start at $14.99/month, by the way) on the video conferencing platform.

If a meeting’s host has enabled this feature, participants will be barred from joining by phone and cloud-based recording will be disabled. In Thursday’s blog post, Yuan emphasized that the feature will not store the encryption key on Zoom’s servers, so the company will not be able to see any part of the call.

What are your thoughts about this one?

(Image Credit: Zoom/ Wikimedia Commons)

TAKE THAT!
Spruce up your next teleconference meeting with Ace Attorney backgrounds!
Perfect for adding a touch of legal proceedings to anything your agency does, or for having arguments about what those metal things with steps on them are called. pic.twitter.com/98N89kzymo

— Ace Attorney (@aceattorneygame) April 29, 2020

As even lawyers now work from home, and trials are now held via Zoom, I guess it would only be appropriate if they had a background that’s related to their job. And what background would that be other than the courtroom? But even if you’re not a lawyer, you can still use these Zoom backgrounds released last week by Capcom’s Ace Attorney, via Twitter. You can use the 2D background from the original trilogy, or opt for the 3D one from the more recent games.

Take that! And no objections, please.

(Image Credit: Ace Attorney/ Twitter)

Arizona has reported 20 positive cases of COVID-19 as of Tuesday (March 17).

Happy launch day to DIANA: PRINCESS OF THE AMAZONS, the newest in the DC Zoom line of graphic novels for middle graders. Written by Shannon & Dean Hale and illustrated by Victoria Ying. Thanks to Michele Wells at DC Kids for sending me a copy!

For more of my book collages, feel free to browse my BookADay Padlet as well as my BookADay and Book Recommendation archives. I read a lot more books than I have time to post, especially now that I've joined the Goodreads 2020 Reading Challenge!

This book contains essays from the 2016 postings of A Philosopher’s Blog. Subjects range from the metaphysics of guardian angels to the complicated ethics of guns. There are numerous journeys into the realm of political philosophy and some forays into …

Give your “home office” a virtual makeover with these free zoom backgrounds from IKEA. Just a few months ago, few of us imagined having a home office, let alone working from home full-time. But here we are. We’ve all probably sat in way too many zoom meetings … always tidying up before the call. Quickly, […]

The post IKEA free backgrounds for more stylish zoom calls appeared first on IKEA Hackers.

As global climate change leads to more hot and dry weather, the resulting droughts are stressing plants, making them less able to remove ozone — which at ground level is a dangerous pollutant — from the air.

WASHINGTON – Today, the U.S. Environmental Protection Agency (EPA) joined federal partners—including the U.S. Coast Guard, Department of the Interior, the U.S.

Took a drive and short boatride to Saguaro Lake during Everetts spring break in 2019.

Mijn eerste blog vanuit Leiden In dit tijdperk van Covid19 met iets minder bewegingsvrijheid dan we gewend zijn leek het mij leuk eens terug te kijken op al die bijzondere voettochten die ik heb gedaan. Je moet toch wat als die tocht van deze week niet

What do we really know about US time zones History.com When you run a railroad you need to maintain a schedule and that works a whole lot better when everyone agrees on what time it is including stations in farflung locations and crucially other

Europa es más que una coalición de ególatras. En una crisis como esta no existe alternativa para los eurobonos.

How should the design of incentives vary with agent time preferences? We develop two predictions. First, “bundling” the payment function over time – specifically by making the payment for future effort increase in current effort – is more effective if individuals are impatient over effort. Second, increasing the frequency of payment is more effective if individuals are impatient over payment. We test the efficacy of time-bundling and payment frequency, and their interactions with impatience, using a randomized evaluation of an incentive program for exercise among diabetics in India. Consistent with our theoretical predictions, bundling payments over time meaningfully increases effort among the impatient relative to the patient. In contrast, increasing payment frequency has limited efficacy, suggesting limited impatience over payments. On average, incentives increase daily steps by 1,266 (13 minutes of brisk walking) and improve health.

Eurozone ministers have formally approved €240 billion in credit lines to help European countries meet the crippling costs of fighting the coronavirus outbreak.

Out of nearly 20 bids at a public auction for the Norman Lykes House, the winning bid came from a man who lives out of state, Heritage Auctions told The Associated Press.

Many teachers have been relying on the videoconferencing platform to chat with students during remote learning.

Schools chancellor Richard Carranza put the kibosh on the app in early April, several weeks into the city’s seismic shift to remote learning, citing concerns about Zoom’s privacy and security features.