Lmst

whoa there's a new #homebrew package called:

`config-file-validator`

and it can scans a variety of config files for errors:

#yaml, #editorConfig #plist (apple's flavor included), #CSV, #ini, #json, #xml #toml #env #hcl AHHHHHHHHH

I'm making shell functions for this thing already. (#zsh thanks for asking)

https://boeing.github.io/config-file-validator/

With macOS and app sandboxing, and (a lack of) full disk access for Terminal app (and the defaults command), and Hilarity Ensues…

…or…

How the security-related pieces of macOS can sometimes fit together in unexpected and unhelpful ways:

https://lapcatsoftware.com/articles/containers.html

This particular case for Safari browser, but most any sandboxed app will follow this pattern.

#macos #safari #security #fulldiskaccess #plist #sandbox

A very helpful description of the binary list format is available at scribe.rip/@karaiskc/understanding-apples-binary-property-list-format-281e6da00dbd

@wader

#PList #BinaryPList #BPList

TIL a nice way to tell which setting does what in #macOS Settings by diff'ing the `defaults` output before and after un/ticking the related checkbox in the Settings app:

```bash
defaults read > defaults.pre.txt
# *make a change in Settings*
defaults read > defaults.post.txt
diff defaults.pre.txt defaults.post.txt
```

Source: https://github.com/sickcodes/osx-optimizer

PS: Another nice way is https://github.com/catilac/plistwatch, BTW
#dev #plist #bash

Oh, great!

The day after the #macOS 13.2.1 updates solves a problem … ?

#Safari freezes to the point I have delete its #plist files!

I’ve not had to do that for a few years!

#Ventura #Apple #iMac

JUST as a thought … ?

Does anyone know where the #plist files are in #macOS #Ventura … ?

Key-value data in Common Lisp

tags: #commonlisp #keyvalue #plist

I enjoy using key-value data in dynamic languages. For example, in Python, I can create key-value data for storing the metadata of a document as shown below. I don’t discuss why I don’t use struct, class, named tuple in this post.

doc_metadata = {"title": "The Rust Programming Language",  
                             "type": "book", 
                             "number-of-pages": 584, 
                             "authors": ["Steve Klabnik", 
                                                "Carol Nichols", 
                                                "contributions"]}

I can code read/write a value easily, for example:

# Write
doc_metadata["type"] = "text book"

# Read
print(doc_metadata["type"])

In Perl and Ruby, we can use Hash, which is almost the same thing as Dict in Python. In JavaScript, we can use an object.

Common Lisp is different. We can use a hash table, but it is not as convenient as Dict in Python.

(let ((doc-metadata (make-hash-table)))
  (setf (gethash :title doc-metadata) "The Rust Programming Language")
  (setf (gethash :type doc-metadata) :BOOK)
  (setf (gethash :number-of-pages doc-metadata) 584)
  (setf (gethash :authors doc-metadata) '("Steve Klabnik"
                                                                      "Carol Nichols" 
                                                                      "contributions")))

Besides construction, printing a hash table is not so convenient. Maybe one can create a function or macro to make creating/printing a hash table convenient. I still felt that I abused Common Lisp.

My code is usually too buggy when I keep mutating the same variable. So I prefer using an immutable data structure to prevent me from messing things up. Moreover, my key-value data usually do not have more than five keys. So I don’t strictly need to use an efficient data structure, namely, hash table or binary search tree. So I use alist (assosiation list). I can construct a list like below:

(setq doc-metadata '((:title . "The Rust Programming Language")
                     (:type . :BOOK)
                     (:number-of-pages . 542) 
                     (:authors . '("Steve Klabnik"
                                   "Carol Nichols" 
                                   "contributions"))))

IMO, it looks concise and convenient. We can retrieve key-value pair with a specific key using the assoc function, which I suppose it does linear search. Linear search can be slow. However, my alist doesn’t have a lot of keys.

Instead of replacing a value with another value, I can add a new key-value pair with an existing key, for example:

(setq another-doc-metadata (acons :type :TEXT-BOOK doc-metadata))

By retrieving the value of :type using assoc, we get the new value because assoc function retrieves the first key found in alist, for example:

(cdr (assoc :type another-doc-metadata))
;; OUTPUT => :TEXT-BOOK

However, with function calls instead of number/string literal, alist doesn’t look concise anymore, for example:

(list (cons :title (get-title x y z))
       (cons :type (get-type x))
       (cons :number-of-pages (get-number-of-pages a b c)) 
       (cons :authors (get-authors c d)))

plist looks much more concise, for example:

(setq doc-metadata (list :title (get-title x y z)
       :type (get-type x)
       :number-of-pages (get-number-of-pages a b c) 
       :authors (get-authors c d)))

I can retrieve a value corresponding to a key easily by getf function. For example:

(getf doc-metadata :type)

A new value can be replaced the old value by setf, example:

(setf (getf doc-mentadata :type) :TEXT-BOOK)

setf is different from acons since acons doesn’t mutate the existing list, setf does. Therefore plist is not exactly what I’m looking for.

Maybe the best way is using an Alexandria function for converting plist ot alist as Michał “phoe” Herda suggested.

#plist

Client Info