Děti se v online světě pohybují naprosto přirozeně a svými technickými znalostmi často předčí své rodiče. Na druhou stranu jsou právě ony nejohroženější skupinou čelící útokům internetových predátorů a kyberšikaně. Rodiče často o hrozbách ani netuší. Vyzkoušejte si náš kvíz a zjistěte, jak jste na tom s digitálními znalostmi právě vy.

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.

Splácíte hypotéku, u níž se blíží zlomové datum fixace? Jak na to, když chcete brzy půjčku doplatit nebo ji refinancovat? A lze před doplacením využít odkladu splátek?

Nová zákon „Lex voucher“ stanovil pravidla pro vypořádání cestovních kanceláří s klienty. Na problematické situace, které mohou být s koupeným zájezdem spojeny, jsme se zeptali advokáta Ondřeje Vokála.

Mohlo by se zdát, že pojišťovny budou v koronavirové době zaznamenávat zvýšený zájem o sjednání životních pojistek. Zejména kvůli krytí rizika pracovní neschopnosti, což se vztahuje i na onemocnění infekcí covid-19. Praxe je ale zatím opačná.

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

まだあるんですよ。セルフタイマーで、真面目に撮りますよ。5、4、続きをみる

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

• 2 bananas, frozen and sliced ($.50)
• 1 cup frozen strawberries ($1.00)
• 4 tablespoons flax seeds, ground ($.40)
• 1 cup almond milk ($.45) 
• a few almonds, chopped

• In a blender, combine all ingredients and puree until very smooth.
• Garnish with a few chopped almonds, if desired.

• 3 bananas, sliced and frozen ($.60)
• 1 1/2 cups strawberries, frozen ($1.69)
• 1/2 cup blueberries, frozen ($.60)
• stevia and/or agave, to taste

Thanks to ambyr's rec, we watched Dukhtar ['Daughter'], (2014, directed Afia Nathaniel).

ambyr described this very well: it does include misogyny and violence, but ultimately it's a hopeful film. The film feels almost like a stage play; it is almost entirely about the characters, a mother trying to save her young daughter, and the roadster who reluctantly helps them. The camera doesn't dwell either on the beautiful scenery (there are mountains in the background, but no gorgeous cinematic shots) or on the violence; there are quite a few shootings in the film, but it's never gory because it's not about gun porn, it's about trying to escape from that violent world of gang / tribal violence. Quite a bit of it is filmed in shaky-cam style as if it were just incidental video of people's lives.

The characters are all really vivid, and I cared about them a lot, partly because the film is so careful to avoid piling on the drama. The tribal enforcers who go around shooting almost-random people in order to make people fear them are squalid, not glamorous. The elder who is desperate enough to sell his 10-year-old daughter for protection is basically pathetic rather than evil. The main character, Samiya Mumtaz' Allah Rakhi is beautiful and brave, but not really a heroine, she's desperate and runs away with her daughter with almost no plan for how they're going to survive. In other words she's really plausible for a barely literate woman married at 15 and sent to a remote, very patriarchal village in the mountains.

The romance between Allah Rakhi and Sohail is likewise really understated. He's not a white knight saving the princess, and in fact they even joke about how much he doesn't fit that romantic stereotype. He's a troubled person who has survived and escaped from the Taliban training camps, and he doesn't really want to get involved but can't just abandon a desperate mother and daughter to their fate. They have a certain amount of tenderness, but don't instantly fall in love and it's not clear whether their relationship will last, or whether it will end up being romantic or more friend-based. I also really liked that the dashing, handsome man who is avuncular with the kid and flirts with the mother in a rather aggressive way turns out to be a bad guy, not the love interest.

The ending is really odd. The credits just happen in the middle of a desperate car-ride taking the heroine to hospital bleeding from a gunshot wound. I think we're meant to infer that she survives but it's really not clear.

Next up: Nigeria, our first African country. Any recommendations of Nigerian films? Ideally from the 21^st century, and not primarily about violence or depressing real-world history.

comments

Nobody had any recs for Nigeria, so we poked around a bunch of internet best of lists and came up with Lionheart, (2018, dir Genevieve Nnaji), which turned out to be a great choice.

Lionheart is about a young business woman, Adaeze, who has to overcome sexism and save her father's struggling transport business. The director, Nnaji, also plays the title role and does a brilliant job. What I particularly loved about this film was that it undermined my genre expectations of feel-good feminist films. Adaeze doesn't have to outsmart and triumph over the sexist men, she has to learn to collaborate with people different from herself. And the company doesn't win by beating its rivals but by conducting a merger that at the start seemed unthinkable, requiring cooperation between her Igbo, Christian family and some Hausa (I think?) Muslims.

In particular, the eccentric uncle who is inexplicably appointed as acting MD when everybody knows it should have been Adaeze turns out to have some key strengths. He is in fact only annoying, and not a jerk. His people skills and intuition perfectly complement Adaeze's business acumen. (And how nice to have a female lead be the excessively competent and rational one!)

Adaeze does experience some sexism, particularly creepy men who expect sexual favours in return for investment in the business. But most of the antagonists are just nasty in a gender neutral way, like they want to sell the business to a conniving rival for quick money.

Anyway that was a really sweet date-night movie and I do feel our film project is back on track

Any recs for Bangladeshi films? We are most excited about 21^st century films not primarily about violence or depressing real-world history.

comments

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

Ugh, well, I still didn't finish the video I mentioned last post (it is just a video version of some of my chess papers from this last SIGBOVIK; don't get too excited), but I made a lot of progress on it this weekend. This one has a lot of custom software, some of which is hours of work for like 10 seconds on-screen. This approach is "fun" but not efficient. At least I have a good approach to the video so it's just a matter of turning the crank now.

I finished The Messenger. My verdict is that it is good. Some aspects of it are fantastic (8-bit graphics and writing) and most are very good, but the game was not very hard and the "metroidvania" aspects of it were mostly about retreading ground between distant teleports. I managed to get all the achievements, which I don't usually do, but there was just like one hard one left.

Speaking of hard ones, next up is/was Dead Cells, whose verdict is great. This is a grindy (lots of unlockables/upgrades) roguelike platformer with really excellent controls and "flow", almost feeling like a twitchy fighting game at times. It's no "Spelunky" or even "Crypt of the Necrodancer"; what set those apart for me is how the design of the random level generation really tended to create these interesting situations and puzzles. But this game has an impressive amount of content (the graphics and the sheer variety of weapons/powerups both stand out to me) and is just really fun to play, except when you die (which is always). Just now I finally beat the game on "Hard" (second boss cell) so it may be time to retire. I bought like 9 more games on the Steam summer sale, after all!

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 […]

Мексиканская авиакомпания InterJet полностью перешла на использование только российских самолетов Sukhoi SuperJet 100 (SSJ-100). По мнению руководства InterJet, SSJ-100 идеально подходят для перевозок в условиях пандемии коронавируса. В настоящее время российские самолеты обслуживают шесть оставшихся маршрутов.

It may be tempting at the start of a new project to create the first database tables manually, or write SQL scripts that you run manually, especially when you first have to spend a significant amount of time on sifting through all the migration libraries and then some more to get it working properly.

Going through this process did slow me down at the start of the project but I was determined to use a migration tool because hunting inexplicable bugs that only happen in production just to find out there is a definition mismatch between the production and development databases is not fun. Using such a tool also motivates you to write both the setup and teardown steps for each table while the current design is still fresh in your mind.

At first I considered a standalone migration tool because I expect them to be very good at that single task. However, learning the idiosyncrasies of a new tool and trying to make it fit seamlessly into my development workflow seemed like more trouble than it is worth.

I decided to stick with a Common Lisp library and found the following seven that work with PostgreSQL and/or Postmodern:

• Postmodern-passenger-pigeon
• database-migrations
• cl-migrations
• Mito
• Crane
• Orizuru-orm
• cl-mgr

I quickly discounted Crane and Mito because they are ORM (Object Relational Mapper) libraries which are way more complex than a dedicated migration library. Development on Crane have stalled some time ago and I don't feel it is mature enough for frictionless use yet. Mito declares itself as being in Alpha state; also not mature enough yet.

I only stumbled onto cl-mgr and Orizuru-orm long after making my decision so I did not investigate them seriously. Orizuru-orm is in any case an ORM which I would have discounted because it is too complex for my needs. CL-mgr looks simple, which is a good thing. It is based on cl-dbi which makes it a good candidate if you foresee switching databases but even if I discovered it sooner I would have discounted it for the same reason as CL-migrations.

CL-migrations looks very promising. It is a simple library focusing only on migrations. It uses clsql to interface with the database which bothered me because I already committed to using Postmodern and I try to avoid adding a lot of unused code to my projects. The positive side is that it interfaces to many different databases so it is a good candidate if you are not committed to using Postmodern. It is also a stable code base with no outstanding bug reports.

The two projects I focused on was Postmodern-passenger-pigeon and Database-migrations because they both use Postmodern for a database interface.

Postmodern-passenger-pigeon was in active development at the time and it seemed safer to use than Database-migrations because it can do dry runs, which is a very nice feature when you are upgrading your production database and face the possibility of losing data when things go awry. Unfortunately I could not get it working within a reasonable amount of time.

I finally settled on Database-migrations. It is a small code base, focused on one task, it is mature and it uses Postmodern so it does not pull in a whole new database interface into my project. There are however some less positive issues.

The first issue is a hindrance during development. Every time the migrations ASDF system (or the file containing it, as ASDF prefers that all systems be defined in a single file) is recompiled it adds all the defined migrations to the migrations list. Though each one will only be applied once to the DB it is still bothersome. One can then clear the list with (setf database-migrations::*migrations* nil) but then only newly modified migration files will be added. The solution then is to touch the .asd file after clearing the migrations list.

The second negative point is quite dangerous. The downgrade function takes a target version as parameter, with a default target of 0. This means that if you execute downgrade without specifying a target version you delete your whole database.

I am currently using Database-migrations and it works well for me. If for some reason I need to switch I will use cl-migrations.

Using Database-migrations

To address the danger of unintentionally deleting my database I created a wrapper function that does both upgrade and downgrade, and it requires a target version number.

Another practical issue I discovered is that upgrades and downgrades happen in the same order as they are defined in the migration file. If you create two tables in a single file where table 2 depends on table 1 then you can not revert / downgrade because Database-migrations will attempt to delete table 1 before table 2. The solution here is to use the def-queries-migration macro (instead of def-query-migration) which defines multiple queries simultaneously . If you get overwhelmed by a single definition that defines multiple tables the other option is to stick with one migration definition per file.

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

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

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

Jack-in-the-pulpit, another native with a great name.  And such an unusual appearance. The roots are apparently edible, but only with some serious treatment — you have to let them dry for at least six months, then roast them, then grind them to mix in with flour…otherwise, you can get severe irritation of the mouth. I’m having … Continue reading "Jack-in-the-pulpit"