The Badminton World Federation said the 2021 world championships will run from Nov. 29-Dec. 5 to avoid a schedule conflict with the Tokyo Olympics.

ESPN highlights the stories of athletes, coaches and other sports figures managing their mental health and well-being.

Sports Minister Kiren Rijiju said the first priority for this would be given to those who have qualified for the Olympics.

ESPN will be releasing two brand new 30 For 30 documentaries in Africa in May and early June, telling the stories of cyclist Lance Armstrong and martial artist Bruce Lee.

Professional and high-performance athletes in Spain were allowed to return to practice, but some were jeered for doing so during the coronavirus pandemic.

At least 70% of U.S. Olympic sports organizations have applied for government funds during the coronavirus pandemic, a stark financial reality that underscores the frailties within the world's most dominant Olympic sports system.

Posted by: icon_uk

In the comments to these weekly posts (and only these posts), it's your chance to go as off topic as you like. Talk about non-comics stuff, thread derail, and just generally chat among yourselves.

The EU hosted a summit where over 40 countries and global organisations promised a starting figure of over $8 billion to the development of a covid-19 vaccine.

Much of the world is starting to experiment with opening up again in a new sort-of-post-Covid19 world, with places like Germany and Spain relaxing, gradually, some of the lockdown protocols, with strong limitations and provisos.

In New Zealand, consistent reminder that competent politicians exist Jacinda Ardern has suggested that the country may not have open borders for a long time to come.

In the UK, a phone app is being developed for contact tracingM and notification of people you may have been in contact with who develop Covid19, though in true current UK style, it's going against every other countries developed app by not using the personalised data storage method (Where your information never leaves your phone), but a centralised database, which is raising some concerns about the storage and disposal (or not) of this data.

The US government is planning on borrowing around 3 TRILLION dollars in the next quarter to pay for pandemic support initiatives. That's 3,000,000,000,000 (Which I only mention because I've never had a reason to type an actual number that big in a real world context!)

The US is also starting to open up in places, though the wisdom of this is being called into question by... well, pretty much everyone else on the planet, and a goodly number of the local population of course.

The Clone Wars seventh and final season came to an end with a frankly spectacular arc which saw Ahsoka Tano facing off against Darth Maul in the sort of iconic fight scene that, truth be told, the sequel trilogy was mostly completely lacking, at least on an emotional level), and giving us a chance to see the impact of General Order 66 from the point of view of Ahsoka, as well as the actual Clone Troopers who we have got to know and care about over the years of this series. THIS is how you do it!

The long overdue, repeatedly delayed, New Mutants movie was briefly appearing as forthcoming video on demand from Amazon, though without a release date, but it has now disappeared again. This DOES seem to suggest it might go straight to digital with no cinema release.

Also a new image of a new baddies form the movie have been released in the shape of the Smiley-Men.

And I've clearly been watching waaaay too much anime, or at least listening to too many anime soundtracks when a random video from something called Argonavis (A games based anime from what I can see) popped up and I thought "Gosh that sounds like Unison Square Garden" (who did "Orion o Nazoru", the belter of an OP for Tiger and Bunny) only to discover it's not, but it was written and arranged by two of the members.

In terms of podcasts, alongside old favourites like "Jay and Miles X-Plain the X-Men" (pretty much what it says on the tin and currently looking at Age of Apocalypse), "The NoSleep Podcast" (Horror fiction) and "The Arkham Sessions" (An actual qualified clinical psychologist, Dr Andrea Letamendi, examined, firstly "Batman the Animated Series" and is now looking at the "Doom Patrol" TV series for their depictions of mental conditions), I've just started Mockery Manor, a horror/mystery/drama set at a gloriously awful (and thankfully fictional) British theme park in the late 1980's.

So today's extra curricular activity for the community: What podcasts are you currently listening to that you'd recommend to others?


comments

Posted by: history79

( Read more... )

comments

Posted by: brerrabbit

( Read more... )

comments

Místo zájezdu nové brýle a namísto pravidelné masáže konzultace s lékařem na dálku. Vládní opatření proti koronaviru změnila také čerpání zaměstnaneckých benefitů. Na rozdíl od výplat je však firmy nekrátí.

Kvůli koronavirové pandemii pracují z domova tisíce lidí. Home office má však určitý pracovně-právní rámec, což tuší málokdo. Jaká jsou práva a povinnosti zaměstnanců a co musí zaměstnavatel udělat, aby neporušil zákoník práce? Ve spolupráci s právníky Bořivojem Líbalem a Markem Poloni přinášíme praktický servis rad pro zaměstnance a zaměstnavatele.

Sněmovna schválila návrh zákona o některých opatřeních ke zmírnění dopadů epidemie koronaviru. Jaké úlevy se dočkají dlužníci a jaké jsou podmínky pro zastavení exekuce, vysvětluje právník Adam Stawaritsch.

Kvůli koronavirové pandemii lze očekávat silnou recesi. Česká národní banka proto v březnu dvakrát snížila základní úrokovou sazbu z 2,25 procenta na jedno procento. Některé banky na to už zareagovaly razantním snižováním úrokových sazeb na spořicích účtech, což zamíchalo žebříčkem nejlepších spořicích účtů. Ve spolupráci s Finparádou jsme zmapovali aktuální trend a sestavili nový žebříček.

Firmy i finanční trhy mají za sebou první letošní kvartál. Bilance obou není z důvodu preventivních vládních opatření proti šíření nákazy covid-19 nikterak růžová. To potvrzuje i Partners index podílových akciových fondů.

Současná koronavirová krize otřásla finančními trhy, zlevněné akcie jsou příležitostí, jak zhodnotit investici. Jenomže kdy je správná chvíle investovat? Už se trhy odrazily ode dna, nebo přijde další propad? A jak snížit riziko špatného načasování? Nad tím se zamýšlí Michal Valentík, investiční analytik společnosti Broker Trust.

Práci z domova u zaměstnanců soukromých firem nelze jednostranně nařídit, vzniká jen na základě dohody obou stran. U pedagogických pracovníků a zaměstnanců škol však platí trochu jiná pravidla. Ve spolupráci s právníky Bořivojem Líbalem a Markem Polonim přinášíme odpovědi na nejčastější dotazy pedagogů.

Turmeric is a root related to ginger. It's a little hot and spicy, which makes it delicious. It's active ingredient, curcumin, is also a powerful antioxidant and anti-inflammatory that could improve all sorts of things from arthritis to diabetes. Buy the fresh root and use peeled and grated, or buy the dried powder which is available at most groceries. I found mine at my local farmer's market.

Like most foods, it works synergistically. The absorption of curcumin is greatly enhanced by black pepper and it boosts the absorption of omega-3s, so I've added some pepper and flax oil. If you don't have flax oil on hand, substitute olive oil or just omit. 

This delicious and super healthy turmeric dressing can be used over any salad, as I've done here, but is also delicious on just about anything else from mixed veggies to rice bowls. It also works as a great vegetable dip.

ingredients

dressing

• 3 tablespoons tahini ($.30)
• 4 tablespoons lemon juice ($.60)
• 1 tablespoon maple syrup or agave (can substitute stevia or omit) ($.10)
• 2 tablespoons balsamic vinegar ($.10)
• 1 tablespoon flax oil ($.20)
• 1 teaspoon soy sauce ($.10)
• 1 teaspoon turmeric ($.10)
• 1 teaspoon onion powder ($.10)
• 1 teaspoon garlic powder 
• 1 teaspoon cilantro flakes
• 1/2 teaspoon dried basil
• 1/4 to 1/2 teaspoon cayenne
• 1/4 teaspoon ginger 
• 1/2 teaspoon salt (or to taste)
• 1/2 teaspoon pepper (or to taste)

salad

• 1 head romaine or other lettuce ($1.80)
• 2 tomatoes ($1.00)
• 1 cucumber ($.50)
• 1 small onion, sliced ($.20)

• 2 bananas, sliced and frozen ($.60)
• 1/2 cup almond milk ($.40)
• 2 tablespoons raw cacao powder or cocoa powder
• pinch salt
• few drops of stevia, if more sweetness is desired

• 1/4 cup melted coconut oil ($.80)
• 1/4 cup raw cacao powder or cocoa powder ($.80)
• 1/4 cup finely ground coconut palm sugar ($.80)
• pinch salt 
• 2 tablespoons chopped pistachios ($.40)

1. Place all fudgesicle ingredients into  blender and puree until very smooth. Add more almond milk or water if needed to facilitate blending. 
2. Pour into popsicle molds and freeze for several hours until fully frozen. 
3. Prepare the chocolate shell coating. 
4. Place all the chocolate shell coating ingredients into a small bowl and stir well until smooth.
5. Remove the fidgesicles from the freezer and pop them out of their molds.
6. Dip the fudgescicles into the hard chocolate shell, or drizzle it over them to coat. 
7. Just heating the coconut oil up enough to melt it and not any warmer will yield the best results. If needed, gently remelt the chocolate hard shell. 
8. Add a sprinkle of chopped pistachios or other chopped nut, if desired. Cacao nibs also work well.
9. Any leftovers can be wrapped and stored in the freezer for a week or so.

• 1 cup carrots, cut into chunks
• 1 banana, sliced and frozen
• 1 cup almond milk 
• 1 teaspoon cinnamon
• 1/2 teaspoon ginger
• 1/4 teaspoon allspice
• pinch nutmeg
• 1/2 cup chopped dates
• 1/4 cup chopped pecans or other nuts
• 1 cup chopped apples

directions

1. In a high powered blender, puree the carrots, banana, and almond milk until very smooth.
2. Add in the cinnamon, ginger, allspice, and nutmeg and pulse a few times to blend well.
3. Pour into a bowl and add the chopped dates, pecans, and apples. A sprinkle of coconut flakes goes well, too!

Tumeric is famously anti-inflammatory and can be enjoyed many different ways, including juiced raw. But today, I wanted to pass on this super easy tea (psst, it's not raw!).

I've been drinking it almost every morning for a couple months now and it's still delicious to me, which is a good thing. Turmeric has so many beneficial qualities ... let us count the ways (scroll below for the tea how-to).

1. Anti-inflammatory.
Turmeric, the brightly colored spice that gives curry it's intense color, contains beneficial compounds that have positive health benefits. The main compounds are the curcuminoids and the most important of these is curcumin. One of the most beneficial things curcumin can do is lessen inflammation, which is implicated in most Western diseases.

To be fair, inflammatory responses are a good thing. We wouldn't be able to wage a defense against bacteria and viruses, or injuries, for example, without a strong inflammatory response. However, too much of a good thing can cause problems. Chronic inflammation has been implicated in many diseases that plague us today, including heart disease, diabetes, Alzheimer's, and obesity. Curcumin can reduce inflammation as effectively as some anti-inflammatory medications, but without the side effects. One of the ways it does this is by inhibiting (NF)-kB.  
 
2. Antioxidant
Oxidation is a chemical reaction that produces free radicals. Free radicals have unpaired electrons. These lonely little fragments damage cells and wreak havoc and destruction wherever they go. Antioxidants, like curcumin, terminate the chain reactions that lead to unpaired electrons and, therefore, free radicals and the damage they cause. Seriously, it's the radicals, man.
 
3. Heart Health
Almost 50% of Americans will die prematurely from heart disease. Heart disease and chronic inflammation are so closely linked that inflammation is thought to be an atherogenic response (atherogenic means it causes atherosclerosis, aka, cardiovascular disease, heart disease, and is also peripheral artery disease). It's even thought possible that the slight benefit sometimes derived from statins could be due to their anti-inflammatory properties. Reducing inflammation is a vital key to reducing heart disease.Curcumin is a potent COX-2 inhibitor, that

4. Cancer
Curcumin is being investigated as prevention and treatment for cancers such as that of the colon and pancreas. Chronic inflammation and free radicals promote cancer. Reducing those conditions can be preventive and curcumin works well at both. 
  
5. Arthritis
 Inflammation is an important mechanism in arthritis. Curcumin acts as a COX-2 inhibitor in the same way pharmaceutical drugs such as Celebrex do, but without the dangerous side effects. The tea below, as well as curcumin supplements can ease the pain of arthritis and rejuvenate mobility.

7. Alzheimer's 
India has a low incidence of Alzheimer's, possibly linked to higher intake of curcumin. Because inflammation plays such a big part in most disease, including Alzheimer's, it can be protective and preventative.

8. Brain Function
Alzheimer's is not the only thing that can go awry in brain function, and again, inflammation is implicated. In this case, it's known as neuroinflammation, or inflammation specifically in the brain and reducing that can help overall brain function. 
   
9. Depression
Depression and anxiety are often linked to brain inflammation (this is why going gluten free can help mood, as well). It seems to offer some improvement and relief to those who have depression.

10. Gall Bladder Function 
Curcumin causes the gall bladder to contract, which stimulates bile formation and gall bladder emptying and a freely flowing gallbladder is a happy, healthy one (unless you have a stone blocking the exit, which can cause a painful gallbladder attack).

11. Pepper
I can't talk about turmeric and curcumin without also mentioning black pepper. The Piperine in black pepper increases the absorption of curcumin by 2000% (that's 20x). So, add a little bit of black pepper to whatever you make with turmeric for the greatest benefit. It tastes good, too.

*Do not use turmeric or curcumin if you are using blood thinners such as Warfarin or if you have existing gall bladder disease.




 This tea (and this salad dressing, too) are delicious ways to get a healthy dose of turmeric.


ingredients

• 1 orange, peeled and chopped ($.70)
• 1 teaspoon powdered tumeric ($.10)
• 1 teaspoon caraway seeds($10)
• a few black peppercorns, or pinch of black pepper
• stevia or sweetener, if desired ($.10)

directions

1. Place the orange, turmeric, and caraway seeds in a large saucepan with four cups water. 
2. Bring to a boil over high heat and continue to boil for about five minutes. This will reduce any bitterness in the turmeric.
3. Add the peppercorns or pinch of pepper and steep for a minute or two. 
4. Strain through a fine mesh strainer into mugs and and the sweetener of your choice, if desired. 

Continued from Day Four. (From the beginning.) On Friday we packed all of our stuff back up and headed out.  We were barely out of the resort when: This tire is flat. Apparently all that gravel out to Horne Lake Caves the day before also included a small screw.  We limped around the corner to … Continue reading Summer Horrification — Day Five — Englishman River and Rathtrevor

View on Instagram https://ift.tt/2mPe4Ss

I’ve had some requests to show details of how I arrange the buttons in order to shorten my long skirts for bicycling. Well like this: Clear as mud? Let’s take a closer look. Disclaimer: I’ve been wearing both of these skirts for years and it shows in these detail shots. First that plaid walking skirt … Continue reading Bustled for Bicycling

I’m not sure if it’s depression or just life catching up but I’ve been having a lot of quicksand days.  Those times when you feel like you’re moving in slow-motion and things that should take 10 minutes for a normal … Continue reading →

Did one of the most difficult things I’ve ever done: I cut up my mother’s wedding dress. Now, Mom always *loathed* her wedding dress. Her mother talked her into a waltz length, ballerina-y dress, and she never enjoyed looking at her wedding pictures. She put it in her cedar chest and never looked at it. […]

I’ve been working a regular, 40-hour week since December now. Before that, I had Fridays “off”–I worked on client work, yes, but I also ran all the errands and did all the chores, leaving me both weekend days pretty much to myself.   What I’ve discovered, in the past three months, is that I resent […]

(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))

New projects:

• anypool — General-purpose pooling library — BSD 2-Clause
• avl-tree — An implementation of the AVL tree data structure. — MIT
• cl-aubio — Aubio bindings for Common Lisp — GPLv3
• cl-interval — Intervals, interval trees — NewBSD, LLGPL
• cl-liballegro — Allegro 5 game programming library bindings for Common Lisp — Allegro 5 - http://alleg.sourceforge.net/license.html
• cl-mime-from-string — A one function library to return a mime-type based on the file extension found at the end of a string. ie abc.txt -> text/plain. The common types implemented are from https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/MIME_types/Common_types — MIT
• cl-telegram-bot — Telegram Bot API, based on sovietspaceship's work but mostly rewritten. — MIT
• dns-client — A client for the DNS protocol. — zlib
• feeder — RSS, Atom and general feed parsing and generating — zlib
• perceptual-hashes — Perceptual hash algorithms for images — 2-clause BSD
• portable-condition-system — A portable condition system for Common Lisp — CC0
• ten — Template System for Common Lisp — MIT
• trivial-custom-debugger — Allows arbitrary functions to become the standard Lisp debugger — MIT
• trivial-with-current-source-form — Helps macro writers produce better errors for macro users — GPLv3
• vom-json — A json-formatted logger for vom — MIT
• vp-trees — Perceptual hash algorithms for images — 2-clause BSD

Updated projects: 3b-bmfont, 3bgl-shader, 3bmd, 3bz, a-cl-logger, alexandria, april, async-process, bdef, bp, ccldoc, chunga, cl+ssl, cl-ana, cl-capstone, cl-cffi-gtk, cl-collider, cl-containers, cl-environments, cl-gamepad, cl-gserver, cl-inotify, cl-markless, cl-pack, cl-patterns, cl-python, cl-rdkafka, cl-shlex, cl-sparql, cl-str, cl-tui, cl-utils, cl-webkit, clinenoise, clip, closer-mop, concrete-syntax-tree, croatoan, cserial-port, dartscltools, defenum, deploy, dexador, diff-match-patch, dissect, djula, doubly-linked-list, easy-routes, eclector, escalator, fast-generic-functions, fast-io, flexi-streams, flexichain, float-features, fset, fucc, functional-trees, fxml, gendl, graph, gtirb, hu.dwim.computed-class, hu.dwim.def, hu.dwim.perec, hu.dwim.presentation, hu.dwim.quasi-quote, hu.dwim.walker, hu.dwim.web-server, hunchentoot-multi-acceptor, ironclad, keystone, lispqr, literate-lisp, maiden, maxpc, mcclim, mmap, modularize, mutility, nodgui, numcl, numpy-file-format, origin, osicat, overlord, parachute, patchwork, petalisp, petri, phoe-toolbox, plump, policy-cond, polisher, postmodern, pzmq, qtools, quilc, qvm, roan, rpcq, s-graphviz, s-http-client, s-http-server, s-sysdeps, s-utils, sanity-clause, scalpl, sealable-metaobjects, sel, select-file, serapeum, sketch, skippy-renderer, snappy, softdrink, spinneret, staple, stumpwm, sucle, swank-client, swank-crew, tooter, trace-db, trivial-features, trivial-file-size, vgplot, woo.

Removed projects: cl-password-store, fomus, rfc3339-timestamp, rpc4cl.

All the removed projects are removed because they no longer build. For the first two (cl-password-store and fomus), I was unable to get a response from the authors. The other two (rfc3339-timestamp, rpc4cl) the author was responsive, but has abandoned the projects.

To get this update, use (ql:update-dist "quicklisp"). Enjoy!

A number of people support Quicklisp with a monthly contribution through PayPal. I recently set up a Quicklisp Patreon page as an alternative - if you are interested in supporting Quicklisp, feel free to check it out.

It's a new month, and that usually means I'm supposed to write a monthly update on the progress with Kandria. Thinking about that though made me feel very depressed because I realised that I hadn't really done anything at all for the game, all of April.

I can blame however much I want of that on the quarantine and university stress, or whatever else, but it won't change the fact that there has not been much progress on any front. While I have been slacking a lot, it's not like I haven't been working at all - plenty of time has gone into Courier, after all.

When I had this realisation yesterday, I tried my best to push myself to work on the game any way I could, but I failed to find anything that I could actually convince myself to do. That isn't to say that there aren't things to do; god forbid there's a tonne of things! Tuning combat, drawing animations, writing the UI, fixing dialogue, starting on enemy AI, optimising performance - just to name a few. And yet, despite the breadth and depth of things to do, there was absolutely nothing that looked appealing to me.

This kind of feeling is nothing new to me. It's a creative block, and happens more often that I'd like to admit. It's also why I often don't like to start long running projects, because I'm afraid of a creative block that would ruin it. The worst part about the creative block is that there's no remedy for it. You just get stuck in a rut, and it sucks a whole lot for a completely unpredictable amount of time. Often what I end up doing, whether consciously so or not, is switching to another project and just working on that.

So far that project has been Courier, but that's at its end and I'm also starting to feel burnt out on it, too. I don't have any other projects queued up that I'd like to tackle, or new ideas on what to do at the moment, so I'm just... stuck.

I suppose the right thing to do in this situation is to take it easy and not fret too much over it, since that's often one of the many factors causing the block. I've never been good at actually doing that, though. Maybe I should try to take a break from programming in general? I don't know.

You may be wondering why I'm writing this all to begin with. Well, partly I feel like I promised to do monthly and weekly updates, and I really hate to break that promise without notice. Another part is that I just feel like I owe you the discretion to tell you what's going on with me. I'm very thankful for the email replies and general responses I've gotten for Kandria so far, I really am! Because of that genuine interest, I feel all the more pressured not to disappoint. Since I have nothing to show though, I thought the only proper course of action is to just be open and direct about it. So I'll just say it again: aside from updating the public demo, no progress has been made at all.

Maybe it would help me to have a more open discussion about this topic in general, instead of just it being me telling you that I'm in a bad place. So please, let me know: have you been in similar situations before? What helped you deal with them? Is there something in Kandria I could try to focus on that you, personally, would like to see?

You can reach me at shinmera@tymoon.eu.

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.↩

I had a small dip in productivity this week. I think I mentioned that at the end of last summer I had shingles. It was a super mild case, but I wound up with something called “post-herpetic neuralgia” which is basically nerve pain. It’s super well-controlled with gabapentin, which also has some positive effects on […]

It was all I could do, when I was reading the Futel Party Line zine, to not just call up their operator and say “I want a free pay phone. In Randolph.” Because, hey, that would be cool. But realistically, someone would have to manage that project. And, if I am being honest, I am […]

Все знают, коллектив MusicAeterna и его художественный руководитель Теодор Курентзис с декабря 2019 года активно работают над проектом культурно-образовательного центра Р. А. Д. И. О. в Санкт-Петербургском Доме Радио. Но карантин вносит в эту работу свои коррективы, и в конце апреля было объявлено об открытии digital platform — виртуальной творческой резиденции MusicAeterna. В скором времени на ней будет доступна онлайн-версия перформанса Алексея Ретинского «Слышать», посвященный Людвигу ван Бетховену. Анонсируем это событие статьей Анны Самсоненко, побывавшей на единственном представлении в феврале.

The office formerly known as the U.S. Grand Lodge Ombudsman has been renamed to Ombuds. The purpose of this office remains as described on the U.S.G.L. Government Contacts page: The office of the U.S. Grand Lodge Ombuds serves as an official liaison between the general membership of O.T.O. within the United States and the various …

Continue reading

To all local bodies within U.S. Grand Lodge: For all official gatherings, please observe all guidance issued by the CDC, and by state or local health authorities, pertaining to sanitation, hygiene, and event attendance related to the new Coronavirus.

Event cancellations at local bodies due to COVID-19 will reduce revenue, but not rent and other fixed expenses. Many local bodies already operate on extremely tight margins and struggle to pay their bills even during normal times. All members are encouraged to continue to financially support their local bodies, even if there are no events …

Continue reading

The Grand Master Sabazius has provided some useful information and advice to O.T.O. members about how to respond to the COVID-19 pandemic.

The Worst Things For Sale is Drew's blog. It updates every day. Subscribe to the Worst Things For Sale RSS!