Alan Urmancheev's blog

Ищем Linux мастера для нового Flipper One Мы делаем новый Flipper One — это ARM-компьютер на Linux на базе процессора RK3576. Мы хотим слепить для него свой кастомный дистрибутив. Мы не хотим использовать устаревшие системны обновления вроде Debian APT. Почему классическая система обновлений APT нам не подходит: • Обновление легко может сломаться на середине и система станет не консистентна • Нельзя откатиться к предыдущей версии • Нельзя сбросить настройки в дефолтные Поэтому мы ищем спеца по Linux дистрибутивам, который спроектирует дистрибутив для Flipper One на основе модной модели с A/B-разделами, read-only корневым разделом и атомарными обновлениями. Хотим использовать наработки существующих проектов, типа SteamOS, OSTree, RAUC и т.д. Для пользовательских приложений хотим пакетирование типа — Flatpak, AppImage или Snap или подобного. Если вы умеете такое, приходите к нам — https://flipperdevices.com/jobs

More shell tricks: first class lists, jq, and the es shell On the web: https://alurm.github.io/blog/2025-08-07-first-class-lists-in-shells.html Preamble It's not a secret that most common shells don't have first class lists. Sure, you can pass a list to a program by passing each element in argv (e.g. with "$@" or "${list_variable[@]}"), but what if you want to *return* a list? There are a couple of options. The challenge As a more practical example of this, let's implement split-by-double-dash, a function (or a program) that would return two lists: args that come before -- and ones that come after. That's a common format used by command line utilities. So, for example, split-by-double-dash a b c -- d e f should return the lists [a, b, c] and [d, e, f], *somehow*. One possible use case for this would be a wrapper around a utility that accepts arguments in this form. The quoting way with jq Some utilities can return text quoted in the syntax of shell. For examples, getopt and jq can do that. getopt can indeed help us solve the problem of parsing cli options, but we'll focus on jq here. > Side note: jq is an amazing utility (in fact, a programming language) that can manipulate structured data in all kinds of ways. Here's an example:

jq -nr '["foo", "baz", "baz quux"] | @sh'
'foo' 'baz' 'baz quux'

We ask jq to turn a list into a string suitable for consumption with shell's eval. -n tells that there's no input to read, -r tells jq to output text, not JSON. So let's see how to use the output in the shell:

eval set -- "$(jq -nr '["foo", "bar", "baz quux"] | @sh')"
# Now, let's verify that arguments has been passed correctly, by printing each one on a separate line with printf.
printf 'arg: %s\n' "$@"
# Output:
# arg: foo
# arg: bar
# arg: baz quux

You might think: "wait, you can't use eval". But that's actually safe, since jq does the escaping for us. Actually, I don't think there's a way to do this without eval, since the list is dynamic and has to be interpreted by the shell. In fact, lists can be nested, which is what we want, since we want to return two lists. The outputs gets a bit unwieldy at this point though:

jq -nr '[["foo", "bar"], ["baz", "baz quux"]] | map(@sh) | @sh'
# Output:
# ''\''foo'\'' '\''bar'\''' ''\''baz'\'' '\''baz quux'\'''

What happens with | map(@sh) | @sh is that we first apply quoting to each of the lists to get a list of strings, and then we quote *that*. But, if we want to implement split-by-double-dash, we need a way to process the arguments passed to jq. Can we do this? Of course we can.

jq '$ARGS.positional' -n --args -- a b c
# Output: ["a", "b", "c"]

In fact, jq has much more (check out the manual), so I'll skip right ahead to the solution. We'll use the #!/usr/bin/env shebang and we'll pass -f to jq to make this a proper script:

#!/usr/bin/env -S jq -nrf --args --
# Usage: eval set -- "$(split-by-double-dash ...)"
# Or, in Bash: eval array=("$(split-by-double-dash ...)")
$ARGS.positional |
reduce .[] as $arg (
  {
    before: [],
    after: [],
    found: false,
  };
  if .["found"] then
    . | .after += [$arg]
  elif $arg == "--" then
    . | .found = true
  else
    . | .before += [$arg]
  end
) |
{ before, after } |
map(@sh) |
@sh

Here's how to use this (in Bash, but you can use this in sh as well):

eval array=("$(./split-by-double-dash a b c -- d e f)")
eval before=("${array[0]}")
eval after=("${array[1]}")
# Example:
printf '%s\n' "${before[@]}"
# Output:
# a
# b
# c

(Continued in the comments...)

Провёл лекцию про Nix в @f0rthsp4ce. Nix это такой язык программирования/пакетный менеджер/способ описывать окружения разработки. По-русски. https://youtube.com/watch?v=noEbul27dHE