20 March, 2026 01:48 PM

cat mm-cbm-part-convert 
Description: partial apply of https://gitlab.freedesktop.org/mobile-broadband/ModemManager/-/merge_requests/1432/diffs?commit_id=3745ab3b296293908bc4000f893485edec03be7d
 This is a partial apply to unblock CB by using guido's code from https://gitlab.freedesktop.org/mobile-broadband/ModemManager/-/merge_requests/1432/diffs?commit_id=3745ab3b296293908bc4000f893485edec03be7d
Author: Guido Gunter
Origin: upstream, https://gitlab.freedesktop.org/mobile-broadband/ModemManager/-/merge_requests/1432/diffs?commit_id=3745ab3b296293908bc4000f893485edec03be7d
Reviewed-by: Boris Shtrasman <[email protected]>
Last-Update: 2026-03-04
---
This patch header follows DEP-3: http://dep.debian.net/deps/dep3/
--- a/src/mm-cbm-part.c
+++ b/src/mm-cbm-part.c
@@ -190,9 +190,24 @@
                                log_object,
                                error);
     if (!text) {
+        int i;
+        for (i = len; i > 0; i--) {
+            text = mm_sms_decode_text (&pdu[offset],
+                                       i,
+                                       cbm_part->encoding,
+                                       0,
+                                       log_object,
+                                       NULL);
+            if (text) {
+                break;
+            }
+        }
+    }
+    if (!text) {
         mm_cbm_part_free (cbm_part);
         return NULL;
     }
+    g_clear_error (error);
     cbm_part->text = g_steal_pointer (&text);
 
     return cbm_part;

06 March, 2026 01:44 PM

$ cat /sys/bus/thunderbolt/devices/domain0/security
user

$ cat /sys/bus/thunderbolt/devices/domain0/iommu_dma_protection
1

$ sudo mkdir -p /usr/lib/dracut/modules.d/99thunderbolt-auth

$ sudo tee /usr/lib/dracut/modules.d/99thunderbolt-auth/99-thunderbolt-auto-auth.rules <<'EOF'
ACTION=="add", SUBSYSTEM=="thunderbolt", ATTR{authorized}=="0", ATTR{authorized}="1"
EOF

$ sudo tee /usr/lib/dracut/modules.d/99thunderbolt-auth/module-setup.sh <<'EOF'
#!/bin/bash
check() { return 0; }
depends() { return 0; }
install() {
    inst_simple "$moddir/99-thunderbolt-auto-auth.rules" \
        /etc/udev/rules.d/99-thunderbolt-auto-auth.rules
}
EOF

$ sudo chmod +x /usr/lib/dracut/modules.d/99thunderbolt-auth/module-setup.sh

add_dracutmodules+=" thunderbolt-auth "

$ sudo dracut --force

04 March, 2026 05:13 PM

ברשומה הקודמת כתבתי על האופן בו אני מפתח באמצעות Claude Code. הפעם אני רוצה לדבר על מה שאני חושב שהוא האתגר המרכזי בפיתוח עם LLM: העומס הקוגניטיבי.

‏Claude Opus 4.6 ביחד עם Claude Code מאפשרים לי לדחוס שבועות של עבודה לימים. אבל יש תקרה, והיא לא בכלי – היא בראש שלי.

אני לא כותב שורת קוד אחת. במקום זה אני קורא, מתקן ומאשר: מסמכי מחקר, החלטות ארכיטקטוניות, תכניות מימוש, הגדרות ממשקים, בדיקות וקוד סופי. כל אחד מהם עובר כמה סבבי תיקונים.

במילים אחרות – אני נושא את כל האחריות של מפתח, ולמעשה של צוות פיתוח שלם, בלי לכתוב את הקוד בעצמי.

מהניסיון שלי, המגבלה ברורה: לא יותר משניים־שלושה נושאים במקביל, ואם אחד מהם גדול – הוא חייב לבוא לבד.

עם הזמן אני רוכש מיומנות. קורא מהר יותר, מזהה מה קריטי, מזרז סבבי אישור. אבל המיומנות הזו לא מורידה את העומס – היא מאפשרת לי לדחוס עוד יותר לתוך אותו זמן, ובכך דווקא מגבירה אותו.

הכלי לא צוואר הבקבוק. אני צוואר הבקבוק. מאה סוכנים שרצים במקביל לא יפתרו את זה – הם רק ייצרו יותר פלט שאני צריך לקרוא ולאשר.

מה שכן יעזור הם כלים שמצמצמים את מה שאני צריך לבדוק ידנית: linters מותאמים שאוכפים את הכללים שקבעתי (למשל – אכיפת מגבלה הפניה/קריאה/יבוא של חלק אחד בתכנה לחלק אחר), בדיקות אוטומטיות, אימות של ממשקים בין שכבות. ככל שיותר דברים נבדקים אוטומטית – אני יכול למקד את הקריאה שלי במה שבאמת דורש שיקול דעת.

אבל גם עם כל הכלים האלה, המגבלה נשארת. פיתוח עם LLM הוא לא „כתיבת קוד מהר יותר” – הוא תפקיד ניהולי. אני מנהל מפתח מאוד מהיר, מאוד פרודוקטיבי, שלפעמים טועה. וכמו כל מנהל, יש גבול למספר האנשים שאתה יכול לנהל בו־זמנית.

24 February, 2026 08:24 AM

$ sudo tee /etc/udev/rules.d/99-power-profile-switch.rules >/dev/null <<'EOF'
# AC plugged in
SUBSYSTEM=="power_supply", ATTR{type}=="Mains", ENV{POWER_SUPPLY_ONLINE}=="1", ACTION=="change", RUN+="/usr/bin/powerprofilesctl set performance"

# On battery
SUBSYSTEM=="power_supply", ATTR{type}=="Mains", ENV{POWER_SUPPLY_ONLINE}=="0", ACTION=="change", RUN+="/usr/bin/powerprofilesctl set power-saver"
EOF

$ sudo udevadm control --reload-rules
$ sudo udevadm trigger --subsystem-match=power_supply

$ powerprofilesctl get

15 February, 2026 07:54 PM

בוקר טוב.

מזה זמן רב שלא כתבתי כאן, והנה – סוף סוף חזרתי. הפעם בנושא שונה מ־GNOME. אני רוצה לשתף תובנות מתהליך פיתוח באמצעות Claude Code.

לפני חצי שנה התחלתי לפתח בזמני הפנוי מערכת ניווט מבוססת תמונות ב־Go. כיוון שהזמן הפנוי שלי מוגבל, החלטתי לפתח באופן בלעדי בסיוע AI/LLM, גם כניסוי – לראות אם זה אפשרי. כבר בתכנון הראשוני לקחתי את זה בחשבון, והחלטתי לעבוד ב־DDD עם Clean Architecture לכל דומיין. המטרה הייתה לאפשר לי למקד את ה־LLM בכל שלב במשימה קטנה עם הקשר (Context) מצומצם ככל הניתן. בדיעבד, זו הייתה החלטה נהדרת.

כמה ימים אחרי תחילת התכנון (שביצעתי ברצינות עם Claude – מסמכי ADR, תכנון ארכיטקטורה ב־C4, ישויות ולוגיקה עסקית), גיליתי את Claude Code. בתור מפתח שה־IDE שלו הוא vim עם המון הרחבות, התלהבתי מהכלי. הוא באמת מדהים. עד היום אני מפתח איתו.

שבוע של תכנון, שלושה שבועות לצד שרת, שבועיים וקצת לצד לקוח – וזהו, היה לי MVP באוויר. שם בערך עצרתי, בתחילת החגים. לפני שבועיים חזרתי לפרויקט והתחלתי לפתח שרת קטן שמבצע עיבוד תמונה (אימות, פענוח, זיהוי פנים ולוחות זיהוי, טשטוש והעלאה לשרת).
בכל הפיתוח, כמעט לא כתבתי שורת קוד אחת בעצמי. למדתי המון, עשיתי לא מעט טעויות בדרך, וכמובן למדתי גם מהן.

לפני שאמשיך, חשוב לי להתייחס לתופעת „הפיתוח האוטונומי” – להקות של סוכנים (Agents) שעובדים במקביל על משימה גדולה ובונים פרויקט לבד. אני לא מאמין בזה! מהניסיון שלי (ובאמת ניסיתי), כדי לקבל קוד איכותי, קריא וניתן לתחזוקה, כזה שלא נצטרך לשכתב כל שנה, חייבים לעבוד אחרת: בצעדים קטנים ומדודים.

לשיטתי, תפקיד המפתח הוא לתכנן, לקבל החלטות, לכוון ולאשר כל דבר. התוצאה היא קוד איכותי מאוד, במהירות מדהימה.

אני לא ממציא את הגלגל; מרבית העקרונות נמצאים בהמלצות הרשמיות של אנת׳רופיק, עם התאמות וקפדנות יתרה שלי.

לפני שנצלול לשיטה, קצת על המגבלות: ל־LLM יש מגבלת זיכרון (חלון הקשר של כ־200K טוקנים), אין לו זיכרון לטווח ארוך, הוא נוטה להזות כשמערבבים נושאים, והוא אומן על מידע לא מושלם.

כדי לקבל קוד איכותי ומדויק צריך לעבוד בצורה שיטתית:

1. ניהול זיכרון – סטטי, דינמי וכלכלת הקשר: הבסיס לשיטה הוא ההבנה שלמודל אין זיכרון בין שיחות. הפתרון:
   • זיכרון קבוע (CLAUDE.md): קובץ שנטען תמיד ומכיל מידע בסיסי שהמודל חייב לדעת (ארכיטקטורה, פקודות, סטנדרטים).
   • זיכרון דינמי (ai-docs/‎): תיקייה עם מסמכים לפי נושא. אם עובדים על נושא X, טוענים רק את מסמך האפיון שלו. זה מונע „בלבול” מעודף מידע.
   • ניקוי רעשים: סיימנו שלב? מוחקים היסטוריה. תוכנית הסתיימה? הקובץ נמחק (git rm) כדי לא לבלבל את המודל עם הוראות ישנות.
2. סוכנים (Agents) כ„חלון זיכרון”: אחת הבעיות הגדולות היא „זיהום הקשר” – פלט של פקודות בנייה ושגיאות שממלאים את הזיכרון. הפתרון: כמעט כל משימה מתבצעת בתוך Agent משלה. הסוכן משמש מעין חלון זיכרון מבודד. צריך לחקור ספרייה? פותחים Agent מחקר. צריך לממש פונקציה? פותחים Agent מימוש. הסוכן רץ בלולאה של ניסוי וטעייה, וחוזר לשיחה הראשית רק עם השורה התחתונה: „השלמתי, הנה השינויים”. כך השיחה הראשית נשארת נקייה וממוקדת בקבלת החלטות.
3. תהליך הפיתוח בתמצית: SDD (פיתוח מונחה אפיון) -> IDD (פיתוח מונחה ממשקים) -> TDD (פיתוח מונחה בדיקות).

בשילוב עם ארכיטקטורה מודולרית והפרדה קשיחה, מקבלים שיטה סדורה לייצור קוד איכותי.

התהליך בפירוט:

1. מחקר ואפיון: כתיבת מסמך מפורט בזיכרון ארוך הטווח (ai-docs/research/‎).
2. תיעוד החלטות: כתיבת מסמך ADR במידה והתקבלה החלטה במהלך המחקר (ai-docs/adr/‎).
3. תכנון מימוש מפורט: כתיבת מסמך תכנון על בסיס מסמך המחקר (ai-docs/planning/active/‎).
4. מימוש:
   1. כתיבת ממשקים (Interface): הגדרה מראש של מה רוצים לממש (חתימת פונקציה, קלט/פלט, שגיאות).
   2. כתיבת בדיקות (Tests): כתיבת בדיקות כושלות מול הממשק.
   3. מימוש הממשקים: כדי שהבדיקות יעברו.
   4. שיפור: תוך שמירה שהבדיקות עוברות.

הערה: בשלב המימוש אני משלב כלי קריטי – בדיקות סטטיות (Static Analysis). כל קוד חייב לעבור בדיקות קפדניות. התוצאה היא לולאת משוב שבה ה־Agent מתקן את עצמו עד שהקוד תקין לחלוטין. בנוסף, עם כל שינוי מתבצעת הרצה של כל הבדיקות של הפרויקט כולו, לוודא שלא שוברים שום דבר בדרך.

הדבר החשוב ביותר הוא שאני כמפתח מאשר כל תוצר בכל שלב לפני התקדמות לשלב הבא: מסמך מחקר, תוכנית, ממשק, בדיקות וקוד. הניסיון לימד אותי שהשקעה בקריאת התוצרים מחזירה את עצמה; איפה שחיפפתי – שילמתי ביוקר.

למעשה, התפקיד שלי השתנה לחלוטין. אני כבר לא „כותב קוד”, אלא מתכנן, מקבל החלטות ומבקר איכות.

וכדי לעשות את זה טוב, צריך ידע וניסיון רב. להבין לעומק Clean Architecture ו־DDD, להבין טיפול בשגיאות, IDD ו־TDD – דורש הבנה מעמיקה.

לסיכום, יש לי תובנה ברורה: גם עם המודלים המתקדמים ביותר (כמו Claude Opus 4.6), אנחנו עדיין צריכים מפתחים. אבל איזה מפתחים? כאלה שמבינים ארכיטקטורה, ניהול מערכת גדולה וקבלת החלטות, וכן כאלה שיכולים להכיל ולהבין כמויות מידע גדולות מאד בזמן קצר. מפתחים עם הידע הזה והכישורים האלה יכולים היום לבנות מערכות גדולות ומורכבות באיכות גבוהה ובזמן קצר. מי שאין לו את הידע הזה ולא ישכיל ללמוד אותו בהקדם, ימצא את עצמו בבעיה בשלב כזה או אחר.

מצורף קישור למסמך טכני יותר שכולו נכתב על ידי Claude Code, באנגלית.

12 February, 2026 08:30 AM

שוחררה rusmux 0.8.5 עם man page חדש וקיצורים חדשים לפקודות run ו־stop.

10 February, 2026 11:40 AM

Using the first element of an array without additional checks is a common mistake.

function getMyThing() {
  const things = getMyThings(...);
  return things[0];
}

The code above assumes that there is at least one element in things. Unfortunately, it doesn’t do anything about the situation when this assumption is not true. The following fix (or something similar) is common:

function getMyThing() {
  const things = getMyThings();
  if (things.length == 0) {
    return null;
  }
  return things[0];
}

Despite the (most likely) intent of getting the only element in the array, the example above fails to handle multiple elements in things. Correct handling of having more than one element is rarely seen. If things are sorted and it’s intentional then there is no problem. This is rarely the case though. Choosing random first element is not the correct or intended behavior in most cases.

I do recommend that if you assume having exactly one element in things and you either think it won’t happen or just not ready to handle this situation – add assertion that would both signal the intent and prevent incorrect execution when this situation happens.

import assert from "node:assert";

function getMyThings() {
  return [2,3];
}

function getMyThing() {
  const things = getMyThings();
  assert.equal(things.length, 1, "Expected to have exactly one thing"); // Throws here
  return things[0];
}

console.log(getMyThing());

You can of course to opt for separate checks for length being zero and length being more than one and have more precise error messages… but this is not supposed to happen, right?

I recommended using assertion above to convey a programming error. Don’t use assertions if:

• If things are input to the program then use if(...) { throw } or consider some input validation framework (like zod) that would eliminate the need for code like above.
• If no other part of the code uses assertions then stay consistent with that.

Some languages provide specialized facilities for dealing with exactly one element instead of the more generic assert(). Examples: Enumerable.Single in .NET, the_one in NGS.

This is the first in series of posts about common mistakes in programming. Stay tuned.

Hope this helps. Have a nice $TIME_OF_DAY!

09 February, 2026 05:14 AM

Background

I’ve noticed that I’m using and recommending to use assert() in our TypeScript projects. Particularly, to be used in runtime, including input validation sometimes, as opposed to the common use case which is in tests. While one colleague was fully onboard, another one noted that use of assert() in runtime is non-idiomatic and is therefore confusing and we should use differently-named function(s). While partially agreed, I didn’t think these statements were so clear cut and started digging.

My Opinion

… on use of assertions by use case, after some research (see research results below).

Tests

That’s the natural habitat of assertions and where they should be used freely. I don’t think this idea is a surprise to anybody.

Runtime – Programming Errors

In context of languages that keep assertions in production (ex: JavaScript/TypeScript)…

Yes, I do recommend using assertions for catching programming errors at runtime. Assertions here express the intent clearly and concisely. They are explicit assumptions. Failed assertion means a programming error caught at runtime. In context of an HTTP(S) server, these failed assertions should return HTTP status 500 Internal Server Error.

This includes deployment/configuration errors. For example, if there is an environment variable that is required for your code to run – you should assert() that it was passed. Side note: do it as soon as possible and fail the initialization if it’s missing.

I tend to include invalid data fetched from database in this category too.

Runtime – Input Validation

Assertions are not a good match for input validation. A more elegant and appropriate solution should be used. In TypeScript, for example, it could involve zod or some other validation libraries. For HTTP(S) server side code, input validation failure should return HTTP status 400 Bad Request.

If you are short on time, you can stop here. Below goes some interesting information about assertions though.

Research Results

I have looked into sources of Node.js and undici (deps/undici in Node.js), and vscode, and others for some “authoritative” answers. I have found:

• Extensive use of assert() at runtime for asserting invariants. This runtime usage is still aligned with the semantics of assert() in tests: failed assertion means programming error.
• Specifically, these projects, do not use assert() for arguments validation (with the exception of one borderline case).
• Node.js
  • Uses a bunch of validateFoo functions for argument validation: validateNumber, validateString, validateOneOf, etc that throw appropriate errors. What makes them special and different from assert() is that they produce messages meaningful for argument validation. For that, validateFoo functions have name parameter. And of course, validateFoo functions they convey different intent.
  • States “AssertionErrors are a special class of error that can be triggered when Node.js detects an exceptional logic violation that should never occur. These are raised typically by the node:assert module.”
• vscode defines and uses functions such as assert(), assertFn() and assertType().
  • Interestingly enough, assertMarkdownFiles() in extensions/github/src/pushErrorHandler.ts doesn’t actually assert anything but filters (I opened GitHub issue).
• NestJS
  • Defines and uses assertFoo methods NestApplicationContext#assertNotInPreviewMode() and RouterResponseController#assertObservable()at runtime.
  • Uses Channel#assertExchange()method from amqplib. Here, “assert” is used in a sense of “make sure something exists”, which is named “ensure” in some other contexts. TODO: google “ensure”. use of “ensure” in programming
• assert-plus, a transitive dependency of NestJS, is a wrapper around assert() but specifically for arguments validation. Given around 10M weekly downloads as of writing, it can’t be dismissed.

It looks like some are using “assert” in the broader sense of “this situation was not supposed to happen”, including argument validation while others use “assert” in the stricter sense of catching programming errors.

What is assert()?

I’m intentionally mixing different sources here to provide broader view.

Node.js documentation says:

The node:assert module provides a set of assertion functions for verifying invariants.

C# documentation (for Microsoft.VisualStudio.TestTools.UnitTesting Namespace, Assert class) says:

A collection of helper classes to test various conditions within unit tests. If the condition being tested is not met, an exception is thrown.

C# documentation (for Debug.Assert Method) says:

Checks for a condition; if the condition is false, outputs messages and displays a message box that shows the call stack.

…

By default, the Debug.Assert method works only in debug builds. Use the Trace.Assert method if you want to do assertions in release builds. For more information, see Assertions in Managed Code.

C++ online reference says:

The definition of the macro assert depends on another macro, NDEBUG, which is not defined by the standard library.

If NDEBUG is defined as a macro name at the point in the source code where <cassert> or <assert.h> is included, the assertion is disabled: assert does nothing.

Java spec says:

An assertion is an assert statement containing a boolean expression. An assertion is either enabled or disabled. If an assertion is enabled, execution of the assertion causes evaluation of the boolean expression and an error is reported if the expression evaluates to false. If the assertion is disabled, execution of the assertion has no effect whatsoever.

… assertions should not be used for argument checking in public methods. Argument checking is typically part of the contract of a method, and this contract must be upheld whether assertions are enabled or disabled.

JUnit documentation says:

Assertions is a collection of utility methods that support asserting conditions in tests.

Lisp documentation says:

assert assures that test-form evaluates to true. If test-form evaluates to false, assert signals a correctable error

… and goes on to provide (assert ...) example for arguments validation

C2 wiki says:

An assertion is a boolean expression at a specific point in a program which will be true unless there is a bug in the program.

How Assertions are Used?

The use cases from above range widely:

• Tests only (C#, JUnit)
• Runtime during development only (C#, C++, Java), no-op in production code
• Runtime (C#, Lisp)

Yes, C# has all three variations as separate facilities.

Some examples from Node.js follow.

Tests

Node.js, node/test/abort/test-abort-backtrace.js

Note that this form gets both of the actual result and the expected result. It can therefore print both when there is discrepancy.

const child = cp.spawnSync(`${process.execPath}`, [`${__filename}`, 'child']);

const stderr = child.stderr.toString();
assert.strictEqual(child.stdout.toString(), '');

...
assert(jsStack.some((frame) => frame.includes(__filename)));

Catching Programming Error at Runtime

Node.js, node/lib/_http_agent.js, expressing intent using assert.fail() rather than just throwing an error.

function createConnection(...args) {

  ...

  // This should be unreachable because proxy config should be null for other protocols.

  assert.fail(`Unexpected proxy protocol ${proxyProtocol}`);

};

Asserting Invariant at Runtime

Node.js, node/lib/_http_client.js

function socketOnData(d) {

  const socket = this;

  const req = this._httpMessage;

  const parser = this.parser;


  assert(parser && parser.socket === socket);

  ...

}

“It’s complicated”

Node.js, node/lib/https.js

In this case, the phrasing suggests catching internal programming error but createConnection() – the caller – “custom agents may override this method to provide greater flexibility,” so assert() here can be seen as (borderline) argument validation.

function getTunnelConfigForProxiedHttps(agent, reqOptions) {

  ...
  
const requestHost = ipType === 6 ? `[${reqOptions.host}]` : reqOptions.host;
const requestPort = reqOptions.port || agent.defaultPort;
const endpoint = `${requestHost}:${requestPort}`;
  
// The ClientRequest constructor should already have validated the host and the port.
  
// When the request options come from a string invalid characters would be stripped away,
  
// when it's an object ERR_INVALID_CHAR would be thrown. Here we just assert in case

  // agent.createConnection() is called with invalid options.
  
assert(!endpoint.includes('\r'));

  assert(!endpoint.includes('\n'));
  ...
}

Interesting Findings Along the Way

Type Checking

Some of these assert()s in JavaScript code check for correct types at runtime and wouldn’t be needed in TypeScript which would check these statically, ahead of time.

Custom Exceptions

In Node.js, the message parameter can be an instance of Error and in this case, it’s thrown instead of the usual AssertionError with the string message message. It was introduced in 2017 to “support a way to provide a custom Error type for assertions. This will help make assert more useful for validating types and ranges.”

??= for caching

Node.js, lib/internal/assert.js

Elegant use of ??= for caching.

let error;

function lazyError() {

  return error ??= require('internal/errors').codes.ERR_INTERNAL_ASSERTION;

}

ThrowIfNull

C# has ArgumentNullException.ThrowIfNull, which I find interesting language design choice – static method on the exception that throws conditionally.

Hope it was interesting and enjoyable. What’s your opinion on the topic? Leave your comment below. Have a nice day!

19 January, 2026 06:35 AM

There’s a popular podcast produced by the New York Times: Hard Fork. It talks about technology, and since a lot of people these days find it difficult to talk about technology without mentioning “AI”, the two Hard Fork hosts make two disclaimers in almost every episode: That the New York Times is suing OpenAI, and that the boyfriend of one of the hosts works for Anthropic, which makes the Claude conversation simulator.

There is, however, another thing that is common to both the New York Times and Anthropic, and it has nothing to do with “AI”. It’s that Android apps made by these two companies have the same bug, and this bug is mindbogglingly silly.

This bug makes countless Android apps partially or completely broken for anyone whose phone interface is set to Hebrew, Arabic, Persian, Urdu, or any other right-to-left (RTL) language. The most frustrating part? This widespread problem, which affects hundreds of millions of users globally, can be fixed by changing one line of code.

The Problem: When English Apps Go RTL

I use my Android phone with a Hebrew interface because, well, Hebrew is my language. I don’t expect all English-language apps to support Hebrew. The New York Times, for example, publishes almost everything in English, and that’s OK. The Claude app’s user interface is in English and hasn’t been localized to Hebrew, at least yet, and that’s not too bad either. I know English, and when I choose an English-language app, I just want it to work well in English.

What’s not fine is when these apps break because they’re trying to adapt to right-to-left languages when they have no business doing so. Apps try to do this because they see that my phone asks for Hebrew user interface. They are trying—and failing. The results are grim.

In the NYT Cooking app, recipe reviews get hidden behind star ratings, English text awkwardly aligns to the right, and ellipsis marks appear on the wrong side of photo captions. The app becomes harder to use despite being entirely in English.

The Claude AI app suffers from similar problems—interface elements flip inappropriately, making the English-language interface confusing and sometimes unusable.

Perhaps most dramatically, in 2019, I captured a screenshot from the Delta Air Lines app that showed a flight appearing to go from Atlanta to JFK when it was actually going from JFK to Atlanta.

While Delta seems to have fixed its app since 2019, it illustrates how RTL bugs can be genuinely misleading.

The Root Cause: Android Studio’s Default Behavior

The real culprit isn’t individual app developers—it’s Google’s Android development ecosystem. When developers create new Android apps using Android Studio, the most popular development tool, the default configuration includes android:supportsRtl="true" in the app’s configuration file, AndroidManifest.xml.

This setting tells Android to automatically flip the app’s layout for RTL languages. Google wants to encourage and simplify RTL language support for developers, but it goes too far: developers don’t even think that they need to do anything, and the result is broken.

The irony is that we’re living in an age of incredibly sophisticated AI and machine learning, yet this simple localization bug—which has nothing to do with advanced computer science—causes daily frustration for hundreds of millions of people.

The Scale of the Problem

This isn’t a niche issue. Consider the numbers:

• Arabic: more than 400 million speakers
• Urdu: more than 200 million speakers
• Persian: more than 110 million speakers
• Hebrew speakers: about 9 million speakers
• And there are other RTL languages: Punjabi, Uyghur, Yiddish, and more.

We’re talking about hundreds of millions of people who experience degraded app performance through no fault of their own. They’re not asking for their native language support—they just want English apps to work properly when their phone’s system language happens to be RTL. Because of problems like this, many of those people choose to use their phones in English and get all the apps in English, even though many of them don’t actually know English very well.

So please don’t tell me to switch my phone to English—it’s not actually a solution.

There’s another bitter irony in this situation. Hebrew speakers, Arabic speakers, and Persian speakers, are often divided by geopolitics and conflict. Yet we’re all united by the same stupid software bugs in the support for the languages that we speak, read, write, and love.

I’ve spoken with Palestinians, Saudis, Iranians, and Pakistanis about this issue. We all face the same broken apps, the same UI frustrations, the same feeling of being an afterthought in software design. Perhaps instead of fighting each other, we should unite in fighting these bugs—with code and constructive feedback, of course.

My Quixotic Quest for Fixes

I’ve become something of a Don Quixote in this fight, reporting this bug to dozens of companies. The responses have been telling:

• Most companies, including Anthropic: Complete silence.
• Some companies, including The New York Times, as well as Dave & Busters, italki, Citizens Bank, and many, many others: Promised to fix it, but didn’t.
• A few apps, like Dunkin’ Donuts and Podcast Addict, actually got fixed as a result or my emails.
• One company, Drive Less, a local Rhode Island biking app, not only fixed it, but also sent me a $20 gift card.
• One more company, the Massachusetts Bay Transportation Authority, also known as the MBTA or “the T”, published the source code of its Android app on GitHub under a Free Software license, so I sent a fix, and they quickly merged it and released an update!¹

Despite the few positive examples at the end of this list, the pattern is clear: this is a fixable problem, but most companies don’t prioritize it because it doesn’t affect English-speaking decision-makers.

The Absurdly Simple Solution

Here’s the fix that would solve this problem in almost all affected apps:

In the AndroidManifest.xml file, change the line android:supportsRtl="true" to android:supportsRtl="false".

That’s it. One line.

This tells Android: “This app doesn’t support RTL layouts, so don’t try to flip anything.” The app will continue working normally in English, regardless of the user’s system language.

Apps that genuinely want to support RTL languages—which is commendable!—should keep the setting as "true", but then properly implement RTL layouts with appropriate testing and design considerations.

How to Make an Even Bigger Change

While individual app developers can fix it in their products, this is not really scalable. The real, big solution needs to happen at the platform level. Most importantly, Android Studio should change its defaults: New projects shouldn’t include RTL support unless developers explicitly opt in. I’m not sure how to fix it in all the existing apps, but at least in theory, it’s possible.

So What Can You Do

If you’re an Android developer, check your app’s RTL behavior. If you’re not intentionally supporting RTL languages, please set supportsRtl="false".

If you work at Google or influence Android development tools, please consider changing the default behavior to be opt-in rather than opt-out.

If you’re a user affected by these issues, don’t suffer in silence. Report bugs to app developers. Many don’t even know these problems exist. At least some of them will fix them.

Technology should work for everyone, regardless of which language they speak or which direction their language is written. This bug represents a small but important way that our interconnected world still fails to accommodate its own diversity.

The fix is simple. The impact would be enormous. All it takes is the will to change one line of code—and one default setting—at a time.

¹ Notably, the NJ Transit and the New York MTA’s TrainTime apps still have this bug, even though I’m quite sure that I reported it to them. In the battle of the state transportation agencies for not giving broken apps to people who use their phones in RTL languages, Massachusetts’ MBTA wins big time for now!

01 December, 2025 03:18 PM

הטקסט המלא

02 November, 2025 02:15 PM

תרגום להמון שפות, לעיתים קרובות שפות ממש לא צפויות, הוא קטע שמאפיין הרבה דתות, או זרמים בתוך דתות גדולות יותר. מורמונים, ג׳הווז ויטנסז, סיינטולוגיה, הארה קרישנה, אחמדיה – כל אלה עושים המון תרגום.

גם בברית המועצות, במיוחד בשנות ה־20, נעשתה עבודת תרגום ענקית של כתבי לנין ומרקס להמון שפות, שבחלק מהן מדברים פחות מעשרת אלפים אנשים. מרקסיזם־לניניזם הוא רעיון אתאיסטי כשלעצמו, אבל שמעתי סוציולוגים רבים שמתארים אותו בתור תנועה מעין־דתית, שהחליפה את הדבקות של ממשלת רוסיה המונרכית בנצרות אורתודוקסית.

וככל שאני חושב על זה יותר, תרגום להמון שפות הוא לא דבר הגיוני כל־כך, לפחות לא לפי הגדרות מסוימות של היגיון. תרגום לכמה שפות גדולות ושימושיות הוא דבר מתבקש במקרים רבים, אבל אפילו את זה מוסדות שמתנהלים לפי היגיון עסקי טהור עושים רק כשיש בזה צורך אמיתי.

נגיד, הניו יורק טיימס פרסמו פעם מהדורות שלמות בסינית ובספרדית, שהן שפות גדולות ומבוקשות לכאורה, והחליטו לוותר על זה. היום הם מפרסמים כתבות בשפות שאינן אנגלית רק כשיש קשר בין השפה לבין נושא הכתבה וגם זה במקרים מיוחדים ונדירים. אותי זה מצער, אבל ליעדים העסקיים שלהם זה כנראה טוב. ויש לי עוד הרבה דוגמאות לחברות שתמכו בתרגום מסיבי וצמצמו את זה או ויתרו לגמרי: טוויטר, מדיום, קווֹרה ואפילו דואולינגו.

אז כשם שאמונה דתית היא לא דבר הגיוני לגמרי, ככה גם תרגום מסיבי.

וזה מסביר למה ויקיפדיה יכולה להיות מה שהיא רק בתור מוסד ללא כוונת רווח. היא ממש לא ארגון דתי, אבל היא כן מבוססת על רעיון ללא כל מטרה עסקית: 100% ידע חופשי ו־0 הכנסות לבעלי מניות. כלומר, פשוט אין שם בעלי מניות. הרעיון הזה הומני לגמרי, ועצוב לי לומר שהומניזם הוא דבר „לא הגיוני”, כי זה אמור להיות הדבר הכי הגיוני שיש. בגלל זה כתבתי „לפי הגדרות מסוימות של היגיון”. אילו היה בה רעיון עסקי, לא היו בוויקיפדיה יותר מ־300 שפות, אלא 20 במקרה הטוב, או 1 במקרה הכי סביר.

16 August, 2025 11:47 AM

I was wondering: In which languages, user interface translations tend to be longer, and in which ones they are shorter?

The intuitive answers to these questions are that Chinese and Japanese are very short, English tends to be shorter than the average, Hebrew is shorter than English, and the longest ones are Turkish, Finnish, German, and Tamil. But what if I try to find a more precise answer?

So I made a super-simplistic calculation: I checked the average length of a core MediaWiki user interface message for English and the 150 languages with the highest number of translations.

I sorted them from the shortest average length to the longest. The table is at the end of the post.

Here’s a verbal summary of some interesting points that I found:

1. The shortest messages are found, unsurprisingly, in Chinese, Japanese, and Korean.
2. Another group of languages that surprised me by having very short translations are some Arabic-script languages of South Asia: Saraiki, Punjabi, Sindhi, Pashto, Balochi.
3. Three more languages surprised me by being at the shorter end of the list: Hill Mari (mhr) and Northern Sami (se), which are Finno-Ugric, a family known for agglutinative grammar that tends to make words longer; and Armenian, about which I, for no particular reason, had the impression that its words are longish.
4. English is at #22 out of 151, with an average length of 38.
5. Hebrew is slightly above English at #21, with 37.9. This surprised me: I was always under the impression that Hebrew tends to be much shorter.
6. The longest languages are not quite the ones I thought! The longest ones tend to be the Romance languages: Lombard, French, Portuguese, Spanish, Galician, Arpitan, Romanian, Catalan.
7. Three Germanic languages, namely Colognian, German and Dutch, are on the longer end of the list, but not all of them. (Colognian is the longest in my list. The reason for this is not so natural, though: The most prolific translator into it, User:Purodha, liked writing out abbreviations in full, so it made many strings longer than they could be. He passed away in 2016. May he rest in peace.)
8. Other language groups that tend to be longer are Slavic (Belarusian, Russian, Bulgarian, Polish, Ukrainian) and Austronesian (Sakizaya, Ilokano, Tagalog, Bikol, Indonesian).
9. Other notable, but not easily grouped languages that tend to be longer are Irish, Greek, Shan, Quechua, Finnish, Hungarian, Basque, and Malayalam. All of them have an average length between 45 and 53 characters.
10. Turkish is only slightly above average with 44.1, at #88.
11. Tamil is a bit longer, with an average length of 44.6, at #94. Strings in its sister language Malayalam are considerably longer, 49.1.
12. The median length is 43, and the average for everyone is 42. Notable languages at these lengths are Mongolian, Serbian, Welsh, Norwegian, Malaysian, Esperanto, Georgian, Balinese, Tatar, Estonian, and Bashkir. (Esperantistoj, ĉu vi ĝojas aŭdi, ke via lingvo aperas preskaŭ ĝuste en la mezo de ĉi tiu listo?)

One important factor that I didn’t take into account is that, for various reasons, translators to different languages may select to translate different messages, and one of those reasons may be that people choose to translate shorter messages first because they are usually easier. I addressed this in a very quick and dirty way, by ignoring strings longer than 300 characters. Some time in the (hopefully near) future, I’ll try to make a smarter way to calculate it.

And here are the full results. Please don’t take them too seriously, and feel free to write your own, better, calculation code!

The Python 3 code I’ve used to create the table. You can run in the root directory of the core MediaWiki source tree. It’s horrible, please improve it!

import json
import os
import re

languages = {}
code_re = re.compile(r"(?P<code>[^/]+)\.json$")


def process_file(filename):
    code_search = code_re.search(filename)
    code = code_search.group("code")
    if code in ('qqq', 'ti', 'lzh', 'yue-hant'):
        return

    with open(filename, "r", encoding="utf-8") as file:
        data = json.load(file)
        del(data['@metadata'])
        average_unicode_length(code, data)


def average_unicode_length(language, translations):
    total_translations = len(translations)
    if total_translations < 2200:
        print('Language ' + language + ' has fewer than 2200 translations')
        return

    total_length = 0

    for translation in translations.values():
        if len(translation) < 300:
            total_length += len(translation)

    # Calculate the average length
    average_length = total_length / total_translations
    languages[language] = average_length

root = "./languages/i18n/"
for file in os.listdir(root):
    if file.endswith(".json"):
        path = os.path.join(root, file)
        process_file(path)

sorted_languages = sorted(
    languages.items(),
    key=lambda item: item[1]
)

# Print the sorted items
for code, length in sorted_languages:
    print(code, '\t', length)

11 August, 2025 08:05 PM

הטקסט המלא

31 July, 2025 07:30 AM

For a long time our company used hybrid mail setup, with regular developers having mailboxes on linux mail server (postfix) and manager types - on office365. As they share same domain, Office365 connectors are used. This setup enabled significant cost savings as only users requiring shared calendar or Microsoft Office license had to be put on office365.

Recently, the company decided to rebrand and change primary mail domain. All managers got another new mailbox and mailboxes on old domain no longer required office365 features.

To save costs, we decided to migrate the expensive mailboxes to Linux, but it turned out to be very hard task:

• Outlook has no way to "export" mailboxes. PST (and NST) files are useless in this regard.
• Paid options allowed backup and restore back to office365. Also, they prevented mailbox to be used during the backup.
• New outlook requires IMAP accounts to be authenticated using Oauth protocol (citing security issues, usual EEE tactics). It also seems O365 is throttling IMAP connections (and favoring their proprietary MAPI/EAS protocols)

So we did the migration in several stages:

1. Set up  Thunderbird (one profile per account), subscribe to all folders, switch to offline mode (that will cause it to download all subscribed folders). The Thunderbird keeps folders in mbox format, that might be converted into Maildir and served by dovecot
2. Set up keycloak SSO with LDAP backend and mailcow client, to provide Oauth protocol
3.  Imported the Thunderbird mailboxes into mailcow using custom scripts

 If there is interest in details of the solution above, or scripts used - post in comments.

23 July, 2025 09:40 PM

Here is business idea on how to multiply amount of EV chargers

Many homeowners are in position to provide EV charging points (power connection, parking places), even if they are not interested in EV vehicle at the moment. Some of them are willing to monetize the possibility, but don't want to deal with clearinghouse headaches and the necessary initial investment in expensive charger. Lack of the solution prevents many to share their existing EV charging point even with their next door neighbors.

So we need to invent:

1. infrastructure that would incentivize (reimburse) home owners to expose their power to any EV consumer.
2. Adapter device that is as cheap as possible, for every EV owner to buy.

How?

1. Create portable adapter that transforms home 3 phase power to NACS or CCS. Car driver will purchase and register the adapter with clearinghouse (see below) and carry it in the car.

 

 

2. Create DIY kit for homeowner to wire a standard 3 phase power socket (IEC 60309) in a rain-proof way on their parking place (or accessible from street) and stick "provider" RFID tag (received from clearinghouse). Should be doable by any certified electrician.

3. Create software infrastructure to charge consumers and reimburse homeowners, with secure producer-consumer authentication. The adapter will have a chip that reads RFID tag embedded into the power socket and calculate reimbursement amounts.

General notes:

• It would be nice if the adapter  cooperates with the car's computer/SIM to communicate with the clearinghouse using cellular network
• Homeowners should be able to set rates, down to zero to certain adapters (EV car owners), see who is connected at any given time and contact details of EV drivers.
• Some amount expected to be taken by clearinghouse for infrastructure support
• The adapter variations could be with embedded 3G SIM, charge indicator, anti theft device

11 July, 2025 10:11 AM

לאחר הפסקה עקב שחיקה, חזרתי לתרגם את Django עם שחרור 5.2‎ Beta 1. נכון ל־4 במרץ התרגום העברי של django, django-formtools, django-contrib-comments ו־django-people עומד על 100%. נשארו שוב בחוץ: django-localflavor, ־django-docs ו־djangoproject.com.

04 March, 2025 09:31 AM

היום מלאו 14 שנים עבריות לאירוע מכונן בחיים שלי, אבל אני מרשה לעצמי לחשוב שזה אירוע, טוב, אולי לא מכונן, אבל חשוב למדי בהיסטוריה של השפה העברית.

בז׳ בכסלו תשע״א, 14 בנובמבר 2010, השלמתי את התרגום לעברית של כל ממשק המשתמש של ויקיפדיה ושל מיזמים שקשורים אליה (ויקימילון וכיו״ב). לא עשיתי את זה לבד. היו אנשים שעשו את זה לפניי: רותם דן ורותם ליס (שרק במקרה יש להם אותו שם פרטי), אסף ברטוב, ירון שהרבני, אגבד, ערן רוזנטל ואחרים. אני התחלתי להבין איך עובדת מערכת תרגום הממשק מתישהו ב־2008. ב־2010 התחלתי להבין אותה טוב יותר וקלטתי את הדבר הכי חשוב: התרגום לעברית לא נמצא על 100%. הוא צריך להיות על 100%. החלטתי להביא אותו ל־100%. והבאתי.

זה לקח לי… לא זוכר כמה זמן. כמה שבועות. אולי כמה חודשים. אפשר לחפור ביומנים, אבל אין לי כוח וזה לא חשוב כל־כך.

מה שחשוב יותר הוא הדבר הבא: מאז אותו יום ב־2010, אני בודק את אחוז התרגום לעברית יום־יום, ואם הוא לא 100%, אני מחזיר אותו ל־100%. יום־יום. ארבע־עשרה שנים. כמעט בלי הפסקות. היו רק שתי הפסקות משמעותיות – בתשע״ה (2014) ובתשע״ט (2018). בשני המקרים זה קרה כי נולדו לי ילדים. ויקיפדיה היא אתר חשוב מאוד בכל השפות, ובפרט בעברית, אבל טיפול בתינוקות שלי הוא דבר חשוב יותר מהתרגום לעברית של ממשק המשתמש שלה. אבל זהו, חוץ מטיפול בתינוקות, אין כמעט דבר חשוב יותר. אז בשני המקרים האלה, היו הפסקות של כמה חודשים שבהם התרגום היה תשעים ומשהו ולא 100%. ואחר־כך הוא חזר להיות 100%.

התוכנה משתנה כל הזמן ונוספים אליה מחרוזות לתרגום (בעגה שלנו אנחנו גם קוראים להן „הודעות”). אז בוקר־בוקר, האחוז של התרגום יורד ל־99%. ואז אני מחזיר אותו ל־100%. אז, לפני ארבע־עשרה שנים, היה צריך לתרגם בסביבות עשרת אלפים הודעות כדי להשלים את כל הממשק. עכשיו זה בסביבות שלושים אלף. לפעמים אנשים אחרים עוזרים לי. חלק מהם כבר הזכרתי ברשימה לעיל. ויש עוד. אפשר למצוא רשימה מלאה של תורמים לתרגום בעברית. אבל אני די בטוח שאין עוד אף אחד מלבדי שבודק בוקר־בוקר ומוודא שהאחוזים חוזרים ל־100%.

וגם אין עוד שפה שבמשך ארבע־עשרה שנים, כמעט בלי הפסקה, חזרה יום־יום ל־100%. צרפתית מגיעה לזה לעיתים קרובות, אבל פחות מעברית. אינטרלינגואה קרובה לזה מאוד רוב הזמן (זאת שפה שמעט מאוד אנשים משתמשים בה, אבל אחד מהם מתמיד בתרגום הממשק של ויקיפדיה). עוד כמה שפות שקרובות לזה הן הולנדית, סינית (מנדרינית, גם מופשטת וגם מסורתית), נורווגית, גרמנית, טורקית, אוקראינית, מקדונית, סלובנית, ערבית, פורטוגלית, ספרדית, פולנית ועוד.

אבל אף אחת מהן לא מתמידה על 100% כמו עברית.

אם אתם קוראים את זה, אתם כנראה משתמשים בוויקיפדיה העברית. ואתם כל הזמן רואים שכל התפריטים וכל הכפתורים בה בעברית. לולי עשיתי את מה שאני כבר ארבע־עשרה שנים, חלק מהם כנראה היו כתובים באנגלית. זה מה שקורה בכל השפות האחרות. אתם כנראה בכלל לא תמהים: „מי בעצם דואג לכך שזה יהיה כתוב בעברית?” וזה בסדר, זאת כל הכוונה שלי שזה יהיה שקוף ופשוט לשימוש וסוג של מובן מאליו. אבל הנה, הגעתם לקרוא את זה, ועכשיו אתם יודעים שזה עבדכם הנאמן ועוד כמה מתנדבים נהדרים.

ואני משתדל לדאוג לא רק לעברית. לכך שאני מתרגם את הכול לעברית יש עוד השלכות. כדי לתרגם הכול לעברית, אני צריך לקרוא הכול באנגלית. לפעמים אני מוצא שגיאות במחרוזות המקוריות באנגלית ומתקן אותן. לפעמים אני מציץ לתרגומים בשפות אחרות ומצליח לראות שיש בתרגומים אליהן שגיאות. כשאני רואה את זה, אני מנסה לתקן גם אותן או למצוא מישהו שיודע את השפה ויכול לתקן. הפכתי לתומך חצי־רשמי במתרגמי הממשק של ויקיפדיה לכל השפות, לא רק לעברית.

אוסיף איזה מאמר מוסגר ברוח הזמן הנוכחי. בערך לפני שנה, כמה אנשים נזפו בי שאני לא עושה מספיק כדי לקדם בוויקיפדיה באנגלית את הצד הישראלי בסיפור על המלחמות במזרח התיכון. אז תראו, מי שרוצה לשכנע את העולם שישראל היא הצד הצודק במלחמה על־ידי כתיבת ערכים בוויקיפדיה באנגלית – בכיף, כדאי מאוד לעשות את זה, במיוחד אם עושים את זה תוך כדי הקפדה על בדיקת עובדות וציטוט מקורות, כפי שדורשים כללי הכתיבה בוויקיפדיה (באנגלית הרבה יותר מאשר בעברית). לי אין מספיק ידע או זמן לעשות את זה הרבה, אבל כן יש לי ידע וזמן לדאוג לכך שהתוכנה של ויקיפדיה תעבוד באופן מושלם בעברית וגם לעזור לאנשים שכותבים בשפות אחרות לעשות את זה. אז זה עוד משהו שאני מרשה לעצמי: לחשוב שזה מחזק אנשים שמדברים עברית לא פחות מוויכוחים על ניסוחים בנושא מלחמות בוויקיפדיה באנגלית. תרגישו חופשיים לא להסכים; לא ממש אכפת לי.

אבל מה שחשוב יותר הוא שאף שאני עושה את זה באופן קבוע כבר ארבע־עשרה שנים ולא מתכוון להפסיק כל עוד אני נושם ויש לי חיבור לאינטרנט, אני לא חייב להיות היחיד שבודק יום־יום אם יש משהו חדש לתרגם. גם אתם יכולים. עושים את זה באתר translatewiki.net, אז פשוט צרו חשבון ותתחילו להוסיף תרגומים ולתקן את התרגומים שלי כי אני בטוח עושה טעויות. גם אם לא תעשו את זה, מותר לכם להיות גאים בכך שאתם יודעים לקרוא בשפה היחידה שהממשק של ויקיפדיה מתורגם אליה במלואו. אבל אם כן תעשו את זה, תוכלו להיות גאים עוד יותר כי יהיה לכם חלק בזה. היום קצר והמלאכה מרובה.

19 November, 2024 08:01 PM

This blog post describes how to mount an encrypted array of bcachefs disks at boot time. continue reading...

25 March, 2024 02:45 PM

For the full article visit Meet-OS, the first public version

04 January, 2024 08:58 AM

For the full article visit 🎂 The first 100 articles on Rust Maven 🦀

04 January, 2024 07:23 AM

3 years and 3 months ago, I signed up for maintaining Pipenv in Gentoo. This work made me co-maintainer of pipenv. I finally closed a long standing bug in Gentoo's pipenv. Due to this work, pipenv now ships less vendored packages, and is about 20% smaller in size. continue reading...

28 October, 2023 02:15 PM

בשנים האחרונות אני רואה המון "תלונות" על שפת golang וכמה התחביר שלה נוראי.

אישית אני מאוד אוהב את השפה, ומעדיף לכתוב בה המון דברים.
יותר מזה, קשה לי מאוד עם מרבית הפוסטים השונים המביאים "תלונות".

הסיבה ל"קושי" הזה, היא שהתלונות אינן ענייניות, אלא תלונות בסגנון של "אני רגיל לבצע לולאת while ובשפת go יש רק לולאת for המחליפה הכל".

במידה והתלונה היתה "אני זקוק ללולאת while כי הצורה לבצע איטרציה עם לולאת ה for ב go מונעת ממני לבצע …", הייתי מאוד שמח לביקורת שכזו, כי היא יכולה לתרום להתפתחות השפה ומתן מענה למקרים שכנראה כיום צריך לעקם אותם בשביל להשיג את אותה המטרה.

אז החלטתי לאחר כ11 או 12 שנים עם השפה לכתוב מה אני פחות אוהב, ואני מפריד בין שפה, ספריות המגיעות עם השפה (יש המון כאלו) וכן גישה או אפילו בעיות תיעוד.

זו לא רשימה מלאה, אבל כן רשימה שלדעתי מפריעה להרבה אנשים במצבים שונים.

עבודה עם channels

כאשר חושבים על coroutines (ב go השם או המונח הוא goroutines) יש יכולות לקבל יכולת לתקשר בצורה מאובטחת (מבחינת threads) עם משתנה מסוג channel שעליו מרכיבים טיפוס נתונים כלשהו.

זוהי מחסנית של מידע, אשר נהפת לזמינה רק כאשר יש מה לקבל, וכל עוד אין, הthread במצב של blocking (יש יכולת להתמודד גם עם זה).

ניתן "לסגור" את ה channel ואז ההקצאה שלו למעשה משוחררת וניסיון לעבוד איתו יגרום ל runtime error.

עד כאן הכל בסדר.
מה שמפריע לי זה שאין יכולת לבדוק האם channel סגור ללא לקחת את המידע ממנו.

כלומר אני רוצה להשתמש ב channel רק אם channel לא סגור, ואם ה channel סגור, אני למשל רוצה לצאת מפונקציה או ללכת למקום אחר בקוד או לא משנה מה… העיקר שאוכל לבדוק את המצב הזה ללא חילוץ מידע.

שימוש ב Interface

בשפת Go יש משהו הנקרא interface. למונח של interface מספר שימושים שונים, אלו הם העיקריים שבהם:

1. יצוג טיפוס נתונים משתנה- לפעמים מוכר בשם variant בעולם התכנות.
2. ליצור מבנה המייצג פונקציות למבנה נתונים או במילים אחרות ABI.
3. יצירת הגדרה של Generics.

מי שמכיר שפות תכנות מונחה עצמים, מרביתן מכילות סוג "מחלקה" שהוא interface המתאר מה מבנה מחלקה אמור לממש בשביל להחשב שתומך באיקס. למעשה זה זהה לסעיף השני שציינתי.

הבעיה הראשונה היא שלא תמיד ידוע מראש איזה טיפוס נתונים מממש איזה interface. יותר מזה, בזמן כתיבה לא יודע אם טיפוס נתונים מימש בכלל את ה interface כמו שצריך – דבר שמגלים בזמן ריצה אם הקומפיילר לא תופס את זה בזמן קימפול.

אם בתיעוד אני לא אכתוב במפורש אודות המימוש, "אני" המתכנת לא יודע אם יש מימוש interface אלא אם פונקציה מסויימת מצפה ל interface כזה ובמקרה לטיפוס המידע שברשותי יש גם את כל פונקציות שיש בסוג ה interface שמצפים לו – דבר שאומר כי הוא מימש את אותו ה interface.

בעיה שנייה אני לוקח כערבון מוגבל, כי יכול להיות שאני מפספס משהו בהבנה שלי של המימוש של Generics (שהוא חדש מאוד בשפת Go) בשפה.

יש מצב שבו ניתן לקבל JSON שהוא מחרוזת בודדת, או רשימה של מחרוזות (אל תשאלו למה – משהו שנכפה עלי להתמודד איתו).
לא ניתן ליצור מערכת כזו עם Generics. כלומר ניתן ליצור הכרזה של תמיכה לזה, אבל הכרזה של Struct לא תדע להתמודד עם הנושא, ולכן צריך לממש struct אחד לכל סוג המקרים ולבצע המון "עיקומים" להתמודדות עם הנושא.
כלומר לא ניתן לדעת מראש מה ה JSON שיתקבל ואיך הוא יגיע אותו, ולמעשה ה generics לא פתר את הבעיה.

מה שניתן לעשות זה עדיין צריך להשתמש ב interface גנרי ולא ב Generics אשר תומך בשני המקרים, ואז צריך לעבוד המון עם reflection (התמיכה שיש ב Go היא מדהימה) בזמן ריצה ולבצע משחקים ולהחליט איך לתרגם את המצב הזה.

או במילים אחרות, למרות שיש תמיכה ב Generics הוא לא פתר את כל מצבי ה reflection שהיו עד אז בשפה, אלא רק חידד מצבים בהם לא צריך להשתמש ב reflection בזמן ריצה. ולדעתי התיעוד/לימוד של הנושא אינו נכון ומבלבל בין הסרת חוסר ב reflection לבין יצירת איזון מתי כל אחד צריך להגיע וכיצד לזהות את המצבים האלו.

ביצוע Binding

אסיים את הפוסט בנושא הזה.

כאשר רוצים לדבר עם ספרייה חיצונית (דבר שמאוד לא מומלץ על פי יוצרי השפה – בעיה ראשונה), ניתן לבצע binding באמצעות "חבילה" ווירטואלית בשם C. ה"חבילה" הזו מתממשקת למשהו הנקרא cgo ואיכשהו במטה קסם יש סוג של binding.

יש עם זה כל כך הרבה בעיות שרק זה דורש סדרת פוסטים משל עצמו.

אבל הנה מספר רשימות קטנות:

• ניהול זיכרון זה דבר נורא, ולא כזה ברור מה ואיך קורה במצבים מסוימים.
• "מחרוזות" זו עוד בעיה קשה ולא ברורה תמיד איך להמיר נכון בין תווי Go ותווי C ואיך המערכת תגיב באופן כללי כאשר יש תווי utf-8 (מחרוזות Go מקודדות ב UTF-8) וכו'. התיעוד לא מספק מענה לכלל המצבים שמגלים אותם רק תוך כדי עבודה על ביצוע ה binding.
• כיצד לבצע נכון data alignment של מידע, למשל union, או "שמירת מקום" בתוך struct במבנה נכון. זה כן אפשרי, אבל לא תמיד בצורה פשוטה, וזה תלוי מצב של קוד C.
• תרגום של macro לא תמיד כזה פשוט או ברור, וגם לא תמיד נחוץ, וקשה מאוד לדעת מראש את זה.
• הפניות מעגליות. כאשר מדובר ב C ו C++ אין namespace של קבצים (האחרון עוד יודע איכשהו ליצור namespace של קוד), וביצוע include בנקודה מסויימת פשוט שופך את התכולה של הכל. זה גורם למצב שבו יש בקוד C שורות עם ifndef להגדרה שתהיה מתחתיה שכל הקוד יהיה תחת אותו ifndef.
  העניין הוא שב go אנחנו יוצרים "חבילות" ולפעמים יש סמתוכה של תלויות מעגליות שצריך לחשוב ולתכנן איך להתמודד איתן.
• אין בשפת Go יכולת להגדיר calling convention.
  לפעמים צריך לכתוב wrapper בC שיתמודד עם זה בשבילי, אם כי לא בכל מצב. לפעמים זה תלוי אפילו בסוג הקומפיילר של C שיהיה בשימוש בזמן ביצוע ה binding ולפעמים צריך לבחור בקומפיילר אחר של Go, דבר שמסבך מערכות בגלל צורך מסוים בספרייה חיצונית.

הרשימה לא מסתיימת כאן, אלא כמו שאמרתי, ניתן ליצור סדרת פוסטים שלמה בנושא עם הדגמות.

סיכום ביניים

עוד לא התחלתי לדבר על כל הדברים שמפריעים לי, וניתן לראות שהם קיימים.
הפוסט עצמו נהיה ארוך, ואולי אעשה חלק שני או יותר עבורו (עוד לא החלטתי נכון לכתיבת פוסט זה).

העניין הוא שבניגוד להמון פוסטים שתוקפים את Golang שעובד שונה מהשפה האהובה בשם כלשהו, או כי הוא מבצע דברים בצורה שונה, הפוסט הזה מנסה להציג דברים שבאמת מפריעים בעצמם מימוש השפה (ואם אבצע עוד פוסט אז יהיו דברים יותר על מימוש חבילות) עצמה ומקומות שדורשים לדעתי שיפורים משמעותיים.

תכנות נעים

28 September, 2023 10:41 AM

Hey all,

In the past years I have had an ongoing project – I wanted an ultra-light modifiable electric violin. And finally I can share it with you.
This violin, weighs with all the parts on just 500 grams, which is the same as my acoustic violin. Moreover, the center of mass is close to the player making the violin feel lighter than an acoustic when playing.
This is made possible by an innovation I came up with, and have not seen anyone else do – The violin uses a truss like the one in a guitar neck, letting you balance the weight of the strings and tune the neck. This means that the violin can be printed with just a 15% infill making it ultra light (pegboard box at 20%).
I am not planning to start a violin-building business, so I see no reason to keep this to myself and I am releasing it. I ask you to give me some attribution, and consider releasing your design too. And perhaps a violin

This is the end result

The design

I made the design with the help of several mechanical engineers that I want to thank – Tal Reindel, Michael Lev-Ari Layoush, Itai Meshorer, and Don Corson. Also want to take the opportunity to thank Yair Grinberg, Oleh Shevchuk. It’s also based on the ElVioin v2 which is under the Creative Commons – Attribution – Share Alike license. So you can use it, share it, modify it and even sell it. But our particular design must also be released under the same license.

You can download the design files here.

The Pickup

You could use other pickups, however I found Oleg’s magnetic pickup l sounding just amazing, and clear. I think it was worth the money and transforms this instrument to one with a professional quality of sound.

The parts

You will need the following parts. I tried adding links so you know what to get, but it does not have to be from these sources.

1. 3D printed parts – I recommend using ABS because it means your violin is heat resistant. Print the body parts at 15% infill with the peg-box at 20%.
2. A ukulele truss 330mm in length – the link is to the exact one I used.
3. Guitar tuning keys
4. 6 Pin Toggle Switch
5. 1/4 inch audio jack
6. ACRIFIX 1R 0192 glue (it’s a reactive cement really) – which is amazing and means you need no screws for the body. I found it here for sale and not online.
7. Electric wire to fit in the tunnel
8. Copper paper to sit on the string
9. Double Sided Conduct Copper Foil Tape
10. Oleg’s pickup (contact)
11. Shoulder rest
12. Screw and nuts for chin-rest
13. screws for shareholder rest attachment
14. Smooth-on XTC-3D for smoothing
15. Metal-core violin strings (cheap ones seemed to do fine, but you could use D’Addario Hellicore too).

The Build

1. Sand any parts you want smooth, or use smooth-on XTC-3D.
2. Thread the truss along the body
3. Thread the electrical wire along the body and make sure to have slack on both sides

4. Glue the parts together using the glue. Do this outside.
5. At this point it’s a good time to smooth the neck using the Smooth-on XTC-3D for smoothing., although I only did that later in the build.
6. Add the tuning keys and screw them in to place. You might need to drill the hole for the screws to go in smoothly.
7. Add in the chin rest and shoulder rest attachment.
8. I’d recommend a test run with the strings to see that the tension holds at this point –
   • thread in the strings and see that it holds together. Make sure to add some nylon or paper under the E and A strings so they don’t cut though the bridge.
   • You also need to file a groove in the nut for the strings to keep in place, otherwise you get a buzzing sound. You could use a file, but I found nail scissors also work.
   • I personally like placing the lower G string on the tuning key closest to the player and then D, A and E. I know it’s not the normal way but I find it comfortable. You can pick any order you like
9. This is the cool part about this violin – you can now adjust the truss to compensate for the strings warping the neck.

10. Electronics – electric shield the box, install the pickup and solder the components using this diagram:

At this point, you can re-install the strings and you should have a functioning electric violin that is light, sounds good and is customizable. I really like how silent it is, and that I get only the signal of the violin when it’s plugged in.

How does it sound?

• Here is a video of me playing it
• Here is a video of me playing it with a wah wah pedal (also on youtube)

3D parts

Here is a link to the 3D parts on printables and (soon on thingiverse).

I would really appreciate any input to the design. Here is a list of things that I know could be done better

Things to improve

• It’s not easy to thread new stings
• The chin rest is not static and can hit the tuning peg to it. I might fix that myself
• The electronics box screws are too small and I had to use 2mm inserts

In memory of Yair Grinberg

I also want to note that the violin tuning keys were donated from Yair Grinberg’s workshop. I never met Yair, but I was invited by his family to take parts from his workshop after he passed away. There were a lot of cool things and half-made inventions there. Among the parts where the tuning keys which are part of this violin. I only wish I could have met him exchange ideas and show the violin to him.

Contributions are welcome

As always, if you have any input, suggestions or want help to build a violin like this you are welcome to comment.

Full text

10 September, 2023 11:31 AM

אני נתקל בכל כך הרבה מידע מוזר על הנושא של eSIM, ומאמרים של עיתונות לאנשים טכניים בארץ שמציגים מידע לא נכון על העולם הזה, שלא לדבר על גישה אשר לדעתי היא ילדותית בסגנון של "אני רוצה, אבל לא מביאים לי".

אז החלטתי לנסות ולעשות קצת סדר בנושא.

למען גילוי נאות: בשנתיים האחרונות אני נציג של חברה מסחרית בועדת תקינה בנושא של eSIM (ועוד מספר תחומים) ומנסה לכתוב כהסבר טכני מופשט במטרה להסביר את הבסיס והרעיון בלבד.

מהו SIM בפשטות?

ובכן SIM הוא כרטיס "חכם" הנקרא גם java-card ומכיל מספר יכולות – כדוגמת מידע "צרוב" קבוע, ומידע צרוב שיכול להשתנות וכתוב בשפת Java עם ספריות יעודיות עבורה המיוצרות על ידי חברת אורקל והחומרה מיוצרת על ידי מספר קטן של חברות.

גם כרטיס אשראי הוא סוג של java-card ברעיון דומה, אך עם מידע שונה (אין לי ידע בנושא הזה ולכן לא יכול להרחיב).

כאמור, עבור כרטיס ה SIM ישנן מספר קטן של יצרניות בעולם (אשר נכנסו גם לעולם ה eSIM – אכנס לזה בסעיף של eSIM בפוסט).

כל ספק סלולרי מספק מפתחות הצפנה לשיחות הצרובות בכרטיס ועוד מספר דברים, כולל תוכנות והגדרות עבור מכשיר הטלפון.

כאשר מכשיר הטלפון עולה הוא "פותח" את המידע הזה מחלק נעול בכרטיס, קורא ומגדיר דברים בהתאם.

לאחר העליה המתאימה, ניתן לבצע פעולות כדוגמת Provisioning על ידי שימוש בהודעות SMS אשר המכשיר יודע לקרוא, ורובן לא מגיעות לבני האדם לקריאה. פעולה זו של שליחת המידע נקראת OTA – Over The Air.

ה OTA מעדכן גם את כרטיס הSIM כולל הגדרות ואפילו תוכנות שונות.
היות ו SMS מכיל מעט מאוד מידע יחסית, זה יהיה ב chunks שונים בהתאם לסוג ותוכן המידע, וכך גם מקבלים גרסה חדשה לדברים בהתאם לצורך.

השימוש ב OTA זו הסיבה מדוע הודעות SMS כל כך חשובות ברשת סלולרית, והסיבה לבקשת אתחול טלפון לאחר מכן, היא לפתוח מחדש את כל המידע – דבר אשר אינו מתבצע עם Flight-mode.

מהו eSIM בפשטות?

המונח eSIM הוא מונח לכרטיס פיזי היושב על מודם סלולרי (לרבות טלפונים). האות E בנושא היא עבור המילה Embedded.

למעט הצורה הזו, הוא נועד לבצע את אותה הפעולה כמו כרטיס ה SIM, אבל בצורה מעט שונה (ללא תוכנות נלוות עד כמה שאני יודע, אבל כן להגדרות).

ישנן שני "מסלולים" עבור מערכת ה eSIM:

• מערכת OTA משתנה – כאשר ניתן לקבל מערכת אינטראקטיבית (התערבות אנושית).
• מערכת OTA צרובה – כאשר לא ניתן לקבל מערכת אינטראקטיבית (למשל IoT).

היות וישנם שני מסלולים, ההתנהלות לכל מסלול מעט שונה.
כאשר ה OTA היא במערכת אינטראקטיבית, חייבים גישה כלשהי לרשת האינטרנט על מנת "להוריד" פרופיל ולהפעיל אותו.

זוכרים את יצרניות כרטיסי ה SIM? ובכן, הן מספקות מערכת OTA לשם כך, ולוקחים כסף על כל "הורדה" של פרופיל שכזה דרכם.

כאשר מדובר במערכת אשר אינה יכולה לקבל התערבות אנושית, הפרופיל נצרב בכרטיס ה eSIM ולא משתנה לאחר מכן.

בד"כ ה OTA מתבצע על ידי קריאה של מחרוזת המסופקת על ידי QR-Code.

המחרוזת היא URI של פרופיל הנקרא LPA – Local Profile Assistants.
הדבר הבא במידע יהיה כתובת מערכת ה provisioning עם איזשהו מפתח שהמערכת (SM-DP+‎) תזהה את הבקשה.

הצלחה של "הורדת" ההגדרות, מחוייבת לרוב בתשלום על ידי ספקיות חיצוניות לספק הסלולרי שלכם, ובמידה ויש בעיה, לרוב חוסמים את האפשרות להוריד בשנית (או לאחר כמות מוגדרת) את הבקשה, או מחייבים את הלקוח בהורדה נוספת.

לאחר ההורדה, המכשיר יאפשר להפעיל את הספק החדש.

iSIM

עבור מערכת IoT קטנות במיוחד הדורשות System On a Chip, נוצר תת מעבד של eSIM בשם iSIM שהוא למעשה eSIM לכל דבר, אבל עבור סביבה מוגדרת. האות i מייצגת את המילה Integrated.

משום מה, iSIM מוגדר על ידי כל כך הרבה כ"מתחרה" של eSIM – אבל הוא למעשה עדיין מאותו "בית" (ארגון gsma) ואותו סטנדרט של eSIM, רק החומרה עצמה שונה לגמרי עבור צרכים אחרים מאשר הכרטיס הרגיל אשר עומד בפני עצמו, ואינו שייך ל SoC כלשהו.

זהו בקצרה ובפשטות על הנושא.

03 September, 2023 09:14 AM

Hey all,

The past year I’ve been playing pretty active on federated social networks. This led me to try and write a federated social network group system. Although this group system is far from being complete since Fedigroup is currently in pre-alpha level. I think it is worth sharing what I have learned, and also explain a bit why, if you met me during the past three years. I’ve been going about federated social networks.

You are also welcome to join a server I maintain here, Hayu.sh is the second largest Hebrew-speaking instance.

What is a federated social network?

A federation in servers means everyone can run their own server which is autonomous. And it can communicate with other servers too. Creating a large network. The first protocol on the internet is actually federated too – email.

There is no one central email server, or single email software. In social networks this means that you join a server, and follow and interact with everyone else. Even though your server could be, like in my case, hosted in your own home, with you owning all the data. You can also join a any other server, and switch between them.
For Hebrew speakers, I gave a small TED lecture about it, which is hosted on a federated video server. You can watch it here (Hebrew).

The Fediverse is the servers using the a W3C Standard that does just that

What made the Fediverse possible is the standard that was passed to describe it. The protocol is called ActivityPub 2.0. And it lets social networks share status messages (notes), shares (boosts) and favorites across different servers. It was created by a group of people who cared, not large companies. Despite some of them being members of the W3C. Its also worth mentioning that one of the major adopters of the ActivityPub 2.0 protocol was Mastodon, a type of social network server, which resembles twitter. And that really help gain critical mass.

Why didn’t I hear about this?

I was asked this by other developers and power users. It makes people dismiss the Fediverse as a passing or niche thing.

Unlike Facebook, Twitter even if you’re been avoiding social networks, their marketing will reach you, your news channel, municipality and country are likely using them. Their existence depends on it that you use and browse on their site. However, in the Fediverse does not have a business model that demands it. Or a marketing team. Its just people. You are welcome to join, but no ones income depends on it.

The Fediverse is growing though, by word-of-mouth, or text-in-blog. Recently even celebrities and others. The latest are the BBC, PNAS, George Takei, Neil Gaiman, Stephen Fry and the European Commission.

Not to be confused with crypto – Which lacks moderation

I think one of the strength of the Fediverse is that it’s actually not going with the blockchain trend now, which is where a lot of effort is going to distribute things.

The Fediverse does not run using the now trendy crypto stuff. The advantage of it is that it costs far less to run. A small server for a few tens of people + a domain and you are good to go.

Another thing is that having an admin means you have a moderator, which is becoming critical for social networks. Large companies today are unable to moderate the volumes of messages on their social networks, resulting in many bad decisions, people getting blocked by algorithms and others who should roam freely. Many social networks today still don’t have moderation-by-design in mind. Even less in a trust-less network that uses crypto.

What is Fedigroup

Fedigroup is a server type that allows users to create a group and share it across the Fediverse. When a user creates a group, they can specify the topics they want to discuss, and the group, when mentioned, will automatically boost their posts related to those topics. This helps increase visibility for posts within the group and attract more members. Additionally, Fedigroup stores the contents of the group for future reference, making it easier for members to find and access previous discussions. Currently, there is also a web interface available that allows users to search through the contents of groups they belong to (the search button though is not implemented yet). Overall, Fedigroup provides a convenient way for users to create and participate in specialized communities within the Fediverse with group memory.

Features

• Federated – you can mention a group and it will boost the message if you are following it
• Has a responsive UI written in NiceGUI
• You can log in using your Mastodon/Pleroma or any MastodonAPI compatible account
• You can use your federated account to create group and then you have access to moderate it
• Posts in the group are archived in a database that can be searched (search not implemented)
• See all the posts in the groups you follow

Unimplemented (roadmap in theory)

• Use your MastodonAPI-compatible account to comment and preform tasks on the WebUI
• Search history of the group

I stopped developing it because it was far too much work only for me. It might pick up if someone joins me, but alone I will not manage to make it as good as others out there. It has potential as being a place to search for history on the Fediverse which is a little challenging today.

Also I think the recent migration of Reddit users show that the Fediverse is handling groups pretty well.

Still, Fedigroup was a good learning experience on how the technology works, and I think its worth sharing if you want to build a Federated instance that uses python, FastAPI and PostgreSQL.

If anyone wants to pick up where I left they are welcome. The source code is available on GitHub.

There is a running instance at: https://fedigroup.party
You welcome to try it out and as always – code contributions are welcome

Full text

07 August, 2023 10:25 AM

תודה לכל מי שנרשם לקבלת כרטיסים, וברכות לזוכים המאושרים!

אם לא זכיתם בכרטיס חינם, מוזמנים לרכוש כרטיס ב-10% הנחה, כאן:
https://ti.to/hamakor/core-cpp-2023/discount/last-minute

השנה הכנס בהשתתפות ממציא שפת ++C, ביארנה סטרוסטרופ, בנוסף לשורה ארוכה של מרצים מעולים. לתוכניה המלאה: https://corecpp.org/schedule/
(הכנס מתקיים ביוני, 5-7 בסנימטק תל אביב, רחוב הארבעה 5)

מומלץ למהר ולרכוש, כי נותרו כרטיסים אחרונים בהחלט!

The post הסתיימה חלוקת כרטיסים חינם מעמותת "המקור" לכנס Core C++ 2023! first appeared on המקור.

01 June, 2023 01:20 PM

שלום לחברי וחברות עמותת המקור, ידידים וידידות, ושותפים ושותפות לדרך,

בתאריך 28.5.23, ביום ראשון בשעה 18:00 (בתחילת מיטאפ "המקור") תכונס אסיפה כללית של עמותת המקור – עמותה ישראלית לתוכנה חופשית וקוד מקור פתוח (ע"ר). 

שימו לב: האסיפה פתוחה לכלל חברי העמותה, ולא רק למשתתפי המיטאפ

האסיפה תתקיים:

1. בחלל Brain Embassy (רחוב השלושה 2) בתל אביב, בשעה 18:00 ביום ראשון ה-28.5
   (מגדל Adgar360, קומת קרקע מגדל A, אולם כנסים)
2. אונליין דרך זום – קישור להתחברות לזום

לוח זמנים:

• 18:30 – פתיחת האסיפה
• 18:40 – 18:30 – הצגת פעילות העמותה
• 19:00 – 18:40 – הצגת הדוחות הכספיים לשנת 2022 ואישורם
• 19:20 – 19:00 – דיון פתוח בנושא יוזמות לפעילות העמותה
• 19:20 – סיום ופתיחת המיטאפ

במידה ובמועד שנקבע לא יהיה קוורום (רבע מכלל חברי העמותה), האסיפה תדחה בשעה ותתקיים באותם אמצעים, בכל הרכב שהוא (במקרה כזה הלו"ז מעלה עשוי להשתנות).

פרטים טכניים:

טיוטות הדוחות יועברו לעיון החברים לפני האסיפה. אנו מקווים שדיון עליהם, או על כל נושא אחר בסדר היום, יתקיים בפורומים של העמותה, בכתב, לפני האסיפה. זאת, הן משיקולי אסינכרוניות והן משיקולי חיסכון בזמן באסיפה.

הצבעות יתקיימו באופן גלוי לחלוטין, משיקולי זיהוי. משתתפים פיזית – תתבצע הצבעה בהרמת יד. 

משתתפי אונליין – לא תתאפשר הצבעה ללא הזדהות ויזואלית בוידאו, לכן, אנא בידקו את המצלמה טרם תחילת האסיפה.

חבר/ת עמותה שירצו להשתתף בהצבעות אך לא יוכלו להשתתף באסיפה, יוכלו לשלוח הודעת ייפוי כח לועד, המפרטת את ההצבעות, עם חתימתם (כן, הפיזית, מצולמת, על הדף שבו כתובות ההצבעות. לא חתימה דיגיטלית). למען הסר ספק, משתתפים באמצעות ייפוי כח לא יספרו לצורך קוורום, אלא רק יחשבו בהצבעות.

אנו מזכירים לכולם לשלם את דמי החבר לעמותה. הודעה על מצב התשלום תצא לחברי וחברות העמותה. 

לנוחיותכם קישור להצטרפות כידידי/חברי העמותה ולשדרוג מעמד מידיד/ת לחבר/ת העמותה.

בברכה,

ועד עמותת המקור

The post הזמנה לאסיפה כללית של העמותה – 28.5.23 first appeared on המקור.

28 May, 2023 01:04 PM

Foreign keys are an important database construct, that let you keep an aspect of data integrity within your relational model. Data integrity has many faces, most of which are application-specific. Foreign keys let you maintain an association integrity between rows in two tables, one being the parent, the other being the child. I’ve personally mostly avoided using foreign keys in MySQL for many years in my professional work, for several reasons. I’d like to now highlight things I find to be wrong/broken with the MySQL implementation.

But, first, as in the past this caused some confusion: when I say I’m not using foreign keys, that does not mean I don’t JOIN tables. I still JOIN tables. I still have some id column in one table and some parent_id in another. I still use the benefit of the relational model. In a sense, I do use foreign keys. What I don’t normally is the foreign key CONSTRAINT, i.e. the declaration of a CONSTRAINT some_fk FOREIGN KEY ... in a table’s definition.

So here are things I consider to be broken, either specific to the MySQL implementation, or in the general concept. Some are outright deal breakers for environments I’ve worked with. Others are things to work around. In no particular order:

No binary log entries for cascaded writes

I think there are many people unaware of this. In a way, MySQL doesn’t really support foreign keys. The InnoDB engine does. This is old history, from before InnoDB was even officially a MySQL technology, and was developed independently as a 3rd party product. There was a time when MySQL sought alternative engines. There was a time when there was a plan to implement foreign keys in MySQL, above the storage engine level. But as history goes, MySQL and InnoDB both became one with Oracle acquiring both, and I’m only guessing implementing foreign keys in MySQL became lower priority, to be eventually abandoned.

Alas, the fact foreign keys are implemented in the storage engine level has dire consequences. The engine does not have direct access to the binary log. If you create a foreign key constraint with ON DELETE|UPDATE of SET NULL or CASCADE, you should be aware that cascaded operations are never written to the binary log. Consider these two tables:

CREATE TABLE `parent_table` (
  `id` int NOT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB;

CREATE TABLE `child_table` (
  `id` int NOT NULL,
  `parent_id` int DEFAULT NULL,
  PRIMARY KEY (`id`),
  KEY `parent_id_idx` (`parent_id`),
  CONSTRAINT `child_parent_fk` FOREIGN KEY (`parent_id`) REFERENCES `parent_table` (`id`) ON DELETE CASCADE
) ENGINE=InnoDB;

insert into parent_table values (1);
insert into child_table values (1, 1);
insert into child_table values (2, 1);

If you were to DELETE FROM parent_table WHERE id=1, then the two rows in child_table are also deleted, due to the CASCADE rule. However, only the parent_table deleted row is written in the binary log. The two child_table rows are deleted internally by the InnoDB engine. The assumption is that when a replica applies the DELETE on parent_table the replica’s own InnoDB engine will likewise delete the two relevant child_table rows.

Fair assumption. But we lose information along the way. As Change Data Captures are becoming more and more common, and as we stream changes from MySQL to other data stores, the DELETEs on child_table are never reflected and cannot be captured.

Online DDL, aka online schema changes

I’ve written about this at length in the past. But even that write up is incomplete!

MySQL is pushing towards INSTANT DDL, which is a wonderful thing. With 8.0.29, even more schema change operations are supported by ALGORITHM=INSTANT. But, there’s still quite a lot of operations unsupported yet, and until such time that INSTANT DDL supports all (or at least all common) schema changes, Online Schema Change tools like gh-ost, pt-online-schema-change, and Vitess (disclaimer: I’m a Vitess maintainer and actively developing Vitess's Online DDL), are essential when it comes to production changes.

Both Vitess and gh-ost tail the binary logs to capture changes to the table. In light of the previous section, it is impossible to run such an Online Schema Change operation on a foreign key child table that has either SET NULL or CASCADE rule. The changes to the table are never reflected in the binary log. pt-online-schema-change is also unable to detect those changes as there’s nothing to invoke the triggers.

Then, please do go ahead and read The problem with MySQL foreign key constraints in Online Schema Changes, as it goes deep into what it otherwise means to deal with FK constraints in Online DDL, as it cannot fit in this post.

Locked data types

In the above table definitions, id and parent_id are int. As data grows, I might realize the choice of data type was wrong. I really should have used bigint unsigned.

Alas, it is impossible to change the data type in either parent_table or child_table:

> alter table parent_table modify column id bigint unsigned;
ERROR 3780 (HY000): Referencing column 'parent_id' and referenced column 'id' in foreign key constraint 'child_parent_fk' are incompatible.

> alter table child_table modify column parent_id bigint unsigned;
ERROR 3780 (HY000): Referencing column 'parent_id' and referenced column 'id' in foreign key constraint 'child_parent_fk' are incompatible.

It’s impossible to do that with straight-DDL (never mind INSTANT), and it’s impossible to do that with Online DDL. InnoDB (not MySQL) flatly refuses to accept any change in the related columns’s data type. Well, it’s not really about changing them as it is about having an incompatibility. But then, we can’t change either. The column type changes are only made possible if we modify the child table to remove the foreign key constraint, then alter both parent and child to modify the respective columns types, then re-add the foreign key constraint. There are four different ALTER TABLE statements. Neither removing nor adding a foreign key constraint is supported in INSTANT algorithm, so you can expect a long time in which the foreign key relationship simply does not exist!

CREATE TABLE … LIKE

One of those quirks that come with InnoDB owning the foreign key definition, is that CREATE TABLE ... LIKE does not generate foreign keys. I think this is mostly an oversight. A SHOW CREATE TABLE statement does produce foreign key output, so I’m not sure why CREATE TABLE ... LIKE doesn’t. Continuing our above child_table example:

> create table child_table_copy like child_table;
Query OK, 0 rows affected (0.06 sec)

> show create table child_table_copy \G
*************************** 1. row ***************************
       Table: child_table_copy
Create Table: CREATE TABLE `child_table_copy` (
  `id` int NOT NULL,
  `parent_id` int DEFAULT NULL,
  PRIMARY KEY (`id`),
  KEY `parent_id_idx` (`parent_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

Unique constraint names

I know this is ANSI SQL, and so I won’t fault MySQL for this. I do think this is one of those scenarios where deviating from ANSI SQL would be beneficial. A foreign key constraint has a name (if you don’t provide one, one is auto-generated for you). And, that name, according to ANSI SQL, has to be unique across your schema. It means the following table conflicts with our original child_table:

CREATE TABLE `another_child_table` (
  `id` int NOT NULL,
  `parent_id` int DEFAULT NULL,
  PRIMARY KEY (`id`),
  KEY `parent_id_idx` (`parent_id`),
  CONSTRAINT `child_parent_fk` FOREIGN KEY (`parent_id`) REFERENCES `parent_table` (`id`) ON DELETE CASCADE
) ENGINE=InnoDB;

You can’t have two foreign key constraints both named child_parent_fk.

I never understood that limitation. See, it’s just fine the tables both have a key named parent_id_idx. No conflict about that. Why do foreign keys have to have unique names?

Maybe, in ANSI SQL, foreign keys can be independent constructs, living outside the table scope. Meh, even so this could be technically solved using some sort of namespace. But, in MySQL this isn’t the case in the first place. Foreign keys are part of the table definition.

This is again just painful for Online DDL, or for any automation that tries to duplicate tables on the fly.

Lack of declarative-only definitions

This is more of a “I wish this existed” rather than “this is wrong”. One of the greatest benefits of foreign keys is the graph. Given a schema with foreign keys, you can formally analyze the relationships between tables. You can draw the dependency graph. It’s really educating.

What I wish for is to have a declarative-only foreign key definition. One that does not actually enforce anything. Merely indicates an association. Something like so:

CREATE TABLE `child_table` (
  `id` int NOT NULL,
  `parent_id` int DEFAULT NULL,
  PRIMARY KEY (`id`),
  KEY `parent_id_idx` (`parent_id`),
  DECLARATIVE FOREIGN KEY (`parent_id`) REFERENCES `parent_table` (`id`)
)

The declarative foreign key could still enforce the existence of the parent table and referenced column, definition-wise, but do nothing at all to enforce relationship of data.

Anyway, just a wish.

SET FOREIGN_KEY_CHECKS

I love that we have set foreign_key_checks. But it’s a bit inconsistent. Basically, set foreign_key_checks=0 lets you override foreign key constraints. You can do any of the following:

• INSERT data to a child table even if the parent table does not have matching values.
• With NO ACTION/RESTRICT rule, DELETE data from a parent table even if children tables have matching rows.
• With SET NULL/CASCADE rule, DELETE data from a parent table without even attempting to cascade the change to children tables.
• CREATE TABLE child_table that references parent_table even if parent_table does not exist.
• DROP TABLE parent_table even if child_table exists and is populated.

But, why oh why, will set foreign_key_checks=0 not let me:

• alter table parent_table modify column id bigint unsigned;(column type relationship are still enforced)
• Swap a new parent table using a RENAME TABLE statement (wishful feature, would really help Online DDL)

Limited to server scope

This one becomes obvious as your data grows. If you use foreign keys and you rely on their behavior (e.g. your app relies on a DELETE to fail if there’s dependent rows in children tables), and your data set grows such that a single server does not have the write capacity, you’re in trouble.

You may attempt to do functional sharding. You will hopefully find two subsets of your schema’s tables, that are not connected in the foreign key graph. If so, you win the day. But if it’s all connected, then you have to break some relationships. You’d have to audit your app. It previously assume the database would take care of data integrity, and now, for some relationships, it wouldn’t.

Or you may want to have horizontal sharding. If you mean to keep foreign key constraints, that means you need to find a way to co-locate data across the entire dependency graph. Unless this was pre-designed, you will probably find this to be impossible without a major refactor.

Vitess is looking into FOREIGN KEY implementation. It will attempt to address some of the above limitations. See https://github.com/vitessio/vitess/issues/11975 and https://github.com/vitessio/vitess/issues/12967 for some preliminary write ups and tracking.

02 May, 2023 04:01 AM

לפני

root@cucomania:~# cat /etc/debian_version  
10.13

אחרי:

root@cucomania:~# cat /etc/debian_version  
11.6

השרת Next cloud אצלי גם שודרג מגרסה 23 אל 25 – וזה היה האתגר לשינוי. אני צריך את האפליקציה הזאת ב־next cloud והיא לא הייתה זמינה. גם לא קיבלתי עדכונים – כי גרסת php שלי הייתה נמוכה מדי..

השידרוג של דביאן היה פשוט. רק עדכנתי את /etc/apt/sources.list ואז עשיתי

apt dist-upgrade --auto-remove --purge

הבעייה היחידה שלי הייתה בהגדרות של nginx שבה הייתי צריך לשנות מיקום של php-fcm socket (היה טריויאלי).

לעומת זאת – שידרוג של next cloud כרגיל מאוד לא ישיר (קפצתי שתי גרסאות, וזה אומר לבצע שני שדרוגים..) ואחרי כל אחד מהם ללכת לשורת הפקודה ולייצר אידקסים של בסיס נתונים (occ עושה את זה…) ואז לאט לאט להשתיק את ההמצלות שלו… מעניין אם זה מעיק בכוונה תחילה.

הטקסט המלא

18 February, 2023 03:12 PM

לא יודע מתי תקראו את זה בעתיד, אבל פעם הייתה רשת חברתית סגורה אבל חביבה עלי בשם טוויטר. בא איש אחד בשם מאסק וקלקל אותה ופרחה לה בחזרה רשת מבוזרת כמו בימים הטובים של התחלת האינטרנט. מסטודון היה קילר אפפ שהופיע בדיוק בזמן לקלוט את חובבי המיקרובלוגינג שברחו מטוויטר וטאמבלר וצירף אותם לרשת סטטוסנט/אקטיביטי פאב שכבר כללה כמה תוכנות ניהול נוד רשתי (המקבילה של שרת דואר ברשת SMTP או שרת IRC וכולי). עכשיו אפשר לקרוא את הפרסומים שלי בתור הודעות ברשת הזו בזכות תוסף וורדפרס.

אז אם אתם מחפשים אותי כי לטוויטר אני נכנס פחות ופחות, אני @I

שרתי אקטיביטיפאב בעברית (מתוך אלפים שהוקמו) הם נכון להיום בעיקר על בסיס מסטודון אבל לא רק:

• תותים
• לפטודון
• היוש
• רשת סושיאל
• קשקוש
• הדים
• פרסמתי

ועוקב אחרי כולם אתר פיד עברי.

בקיצור, בעוד רגע אלחץ פה על "פרסום" והפוסט יופיע פה. יאללה, תעקבו, נראה מה זה שווה?

29 January, 2023 04:52 PM

Those days I am moving my website from Apache2.4 to Nginx.

So I googled for “convert apache rewrite to nginx”. I found the folllowing articles:

• Converting Apache Rewrite Rules to NGINX Rewrite Rules
  Read it.
• Converting rewrite rules
  Shorter but complements the above article. Read it, too.
• How to Convert htaccess Rewrite Rules to Nginx Rewrite Directives
  If you prefer this style of writing, read it in lieu of the above articles.
• Convert .htaccess to Nginx Directives
  Read it if you need to see yet another example of conversion from Apache2.4 into Nginx.
• Convert Apache configuration to Nginx [closed]
  Has references to SaaS websites for converting from Apache2.4 into Nginx (see below).
• Nginx – Convert apache rewrite rules to nginx
  Mentions Apache2.2 and PHP-5, so the relevant information may be obsolete. Skip it.
• rewrite rules from apache to nginx
  One cannot be sure if the answer is correct – skip it.
• How To Enable mod_rewrite In Nginx
  Waste of your time – skip it.

In addition to the aforementioned articles, I found the following SaaS services for converting Apache2.4 configuration files into Nginx configuration files.

• https://winginx.com/en/htaccess
  htaccess to nginx converter. Does good job.
• https://htaccess2nginx.toolpie.com/
  Htaccess to nginx Apache rewrite rule convert to nginx.
  This website actually uses winginx.com to perform the conversion. At bottom of the page, you’ll find that it links to several SaaS conversion services, one of which is the above winginx.com service.
• https://www.getpagespeed.com/apache-to-nginx
  Apache .htaccess to NGINX converter. Does good job and warns when some rule cannot be converted.
• https://labs.gidix.de/nginx/
  nginx-Apache-Rewrite-Converter. Was buggy when I tried it. However, it claims to be in beta. Caveat emptor.

I recommend that you run your conversion in both winginx.com and getpagespeed.com, review and edit the resulting Nginx configuration file.

19 December, 2022 12:44 PM

את הבלוג הזה אני כותבת שנים רבות (כולל גירסת הארכיב) – עוד משנת 2006 (עוד מהימים שהנאיביות שלי היתה בשיאה…). כתיבה בבלוג הזה עזרה לי ולאחרים מבחינת שיתוף מידע, מבחינת עבודה ומבחינות נוספות, ואם מאן דהו ישאל אותי איך הוא יכול לקבל חשיפה יותר גדולה בשביל העסק שלו או בשביל עצמו – אני עדיין יאמר שבלוג הוא פתרון מעולה, אם כי כדאי לחשוב גם על אופציות כמו יוטיוב ואולי אפילו אינסטגרם או טיקטוק, תלוי בתחום..

הגעתי למצב שבו יש לי בכל זמן נתון כ-9 בלוגים שאני מתחזקת, חלקם פתוח לציבור וחלקם מיועד לסקטורים מסויימים והתוכן לא זמין, ולכן החלטתי להתחיל לאחד דברים כך שאוכל להקדיש את זמני הפנוי לתכנים בכמות קטנה של ערוצים, ולהלן הסדר החדש:

• בלוג זה – זה יהיה הפוסט האחרון. רשמית, "חץ בן חמו" כבר לא קיים יותר, אני בתהליך ולכן יש לי בלוג חדש שמתייחס לנושאים שכתבתי עליהם פה + דברים שקשורים למגדר ונושאים נוספים. אתם מוזמנים להוסיף אותו ל-RSS שלכם: הבלוג של דורין.
• בלוג הארכיב ירד מהמערכת בעוד מספר חודשים.
• בלוגים על מחקר מנועי משאיות, ועל טכנולוגיות הדפסת איפור – יפסקו מלהתקיים
• בלוג – ירקות אחרים – גם הוא ירד.
• בלוג העסק – ישאר כבעבר.

ערוצי יוטיוב

אני מודה כי בעבר עשיתי סלט שלם מבחינת קליפים ומיקומם בערוצים השונים, ולכן גם כאן דברים ישתנו:

• ערוץ התאמה מגדרית – ירד בקרוב ויאוחד עם הערוץ החדש "הפינה של דורין" (חלק מהקליפים בערוץ הישן יוקלטו מחדש, תודה לכל הפידבק)
• ערוץ "כמה מילים ברשותכם" – ירד מיוטיוב.
• ערוץ "חץ ביז" – בניגוד למה שלא מעט חושבים, הערוץ לא בא לקדם את העסק שלי אלא בא לשתף מידע ותוכן על טכנולוגיות, פלטפורמות וכו' (ברוב המקרים העסק שלי אף אינו מוכר שרותים לחלק מהדברים המוצגים) – ערוץ זה ישאר
• ערוץ Server Techs –  ערוץ היוטיוב הטכני שלי בשפה האנגלית, גם כאן – מדובר על קליפים בנושאים טכנולוגיים בלבד ומיועד לצופים מכל העולם
• ערוץ הפינה של דורין – זה הערוץ שיחליף את הערוץ "כמה מילים ברשותכם".

לסיכום: ערוצים ירדו, ערוצים אחרים יעודכנו, ואתם תוכלו לפי הדברים שמעניינים אתכם – לקבל את המידע ממני בכמות קטנה של אתרים וערוצים.

ברצוני לנצל הזדמנות זו בכדי להודות לכל הקוראים והמגיבים והמשתתפים. בלעדיכם – זה לא היה קיים, ולכן – תודה לכם

הטקסט המלא

13 December, 2022 12:17 PM

# -avHAX:
# -a = archive (equivalent to -rlptgoD)
#      -r = recurse into directories
#      -l = copy symlinks as symlinks
#      -p = preserve permissions
#      -t = preserve modification times
#      -g = preserve group
#      -o = preserve owner (requires sudo)
#      -D = --devices --specials
#           --devices = preserve device files (requires sudo)
#           --specials = preserve special files
# -v = verbose
# -H = preserve hard links
# -A = preserve ACLs
# -X = preserve xattrs
#
# Before actual work, you may want to use --dry-run.
sudo rsync -avHAX --progress --exclude-from=- $SRCDIR $DESTDIR <<EOF
- /temp/***
- /trash_script.sh
EOF

11 December, 2022 08:13 PM

בעבר רציתי שעון חכם וקניתי שעון חכם שתומך ב־AsteroidOS. זה התברר בתור דבר פשוט מיותר… והחלטתי למכור את השעון. אני לא ממליץ על המערכת הפעלה הזאת, היא פשוט לא טובה.

אז יש בחור שהתחיל לעשות מכשיר חכם מאפס מאפס. קוראים לו פאול.

המיזם זמין בכתובת https://open-smartwatch.github.io . יש תרשימים סכימטים, קוד למערכת ההפעלה, קבצים למדפסות תלת מימד ועוד. יש גם חנות שבה אפשר לקנות את החומרה מוכנה – https://www.makerfabs.com/open-smartwatch.html . אני לא ממליץ – זאת הגרסה הראשונה שנראית מגעילה. הגרסה השקופה, בצבע שחור נראית לי הכי יפה, אבל גם הגרסה הלבנה (הדקיקה עם המסך ה”רגיל”) נראית משהו בהחלט שמיש.

רב התיעוד שמצאתי נמצא בווידאו הזה: https://www.youtube.com/watch?v=a6kkrQ26h_4 . נראה שפשוט צריך לבנות את הדבר הזה בעצמך נכון לעכשיו, זה מצריך גישה למדפסת תלת מימד בשביל המארז עצמו, להזמין כמה חלקים מדוד עלי, כלי הלחמה וסבלנות. חומרי הגלם עולים בערך 300₪. אם מישהו קונה ורוצה לבנות לי אחד – צרו קשר!

הטקסט המלא

11 December, 2022 08:02 PM

כנס GIS בקוד פתוח 2022 למגזר הציבורי, נובמבר 2022

כנס GIS בקוד פתוח חושף את המגזר הציבורי לפתרונות הקיימים וליוזמות של גופים מקבילים. הדוברים/ות בכנס יציגו מגוון רחב של פרויקטים העושים שימוש בכלים השונים.

בשנים האחרונות אנחנו רואים מגמה של אימוץ GIS בקוד פתוח על ידי גופי ממשלה וגופים מוניצפאלים רבים, זאת בין היתר בעקבות האתגרים שהציבה מגיפת הקורונה לצד יתרונות טכנולוגיים ועסקיים בנושאי הסרת מגבלות רישוי תוכנה.

בכנס נדבר על מהו GIS בקוד פתוח והרלוונטיות לתפקידים שונים ברשויות המקומיות, וכיצד איך הוא בא לידי ביטוי בגופי הממשלה. מה ההבדל בין קוד פתוח למידע פתוח ואיך פותחים את המידע לציבור בצורה הנכונה. נציג פרוייקטי GIS שנעשו בזכות פתיחת מאגרי מידע לציבור.  נראה גם יוזמות ממשלתיות בנושא מעקב והנגשת מידע אודות תחבורה ציבורית, כולל יכולת תחקור עבור כל הרשויות בארץ. כל אלה לצד היתרונות של קוד פתוח במעבר לענן הממשלתי (נימבוס).

מתי: רביעי, 9.11.22 9:00-13:00

מיקום: תל-אביב  או בזום (לבחירתכם)

הרשמה בקישור: https://forms.gle/b18bbnKm8xbUKdxJ6

ההשתתפות ללא תשלום, אך יש להירשם מראש.

עדכונים על כנסים וארועים נוספים הרשמה לניוזלטר 

02 November, 2022 03:08 AM

אחד הדברים המבורכים בהפצות לינוקס – זו היכולת לקרוא את הדיונים לגבי שינויים שנעשים בהפצות לינוקס, דעות, בעד ונגד. במקרים רבים ישנם החלטות ודיונים פנימיים, אולם בד"כ התוצאות של הדיונים יוצאות בהודעה מסודרת ב-Mailing List הרלוונטי.

דיון מעניין שחל אתמול קשור להפצת Fedora ולהחלטה לבטל כל האצה של קידוד או פריסת וידאו בהפצת הלינוקס ברמת תשתית כברירת מחדל. במילים אחרות: אם מאן דהוא יפעיל מצלמת Webcam ברזולוציית 1080P והוא ינסה להקליט את הוידאו (לדוגמא עם תוכנה כמו OBS Studio) – סביר להניח שהוא ימצא את התוצאות בלתי מספקות. אם הוא ינסה לנגן וידאו שמקודד ב-H.264 או HEVC או VC1, סביר להניח שבקטעי האקשן, הוא יקבל דילוגים ו"נפילות" (Dropped) בפריימים כך שהתוצאה לא תיראה טוב.

סביר להניח שמי שישתמש בהפצת הלינוקס וידע לינוקס, ימצא בסופו של דבר כי יש צורך להוסיף REPO שנקרא rpmfusion וממנו יהיה צריך להתקין חבילות של Mesa בהתאם לכרטיס הגרפי שיש במחשב/בלאפטופ (החבילות כיום עדיין אינן קיימות, למיטב ידיעתי). משתמשים חדשים לעומת זאת, שהחליטו לנסות את פדורה, יצטרכו לחפש איזה "מדריך" או איזה פוסט בבלוג כלשהו שיסביר להם מדוע יש את הבעיה ואיך לתקן אותה – לכשהם יתקלו בבעיה.

מדוע בכלל הבעיה הזו קיימת? (כפי שניתן לראות בדיון הזה, העובדה שהחבילות יצאו עם Hardware Acceleration היא בכלל באג שעכשיו "תוקן" ושישבית כל האצה) – התשובה לכך פשוטה: פחדים עלומים של רד-האט מתביעות לגבי פטנטים ותמלוגים, דבר שלא קרה כבר יותר מ-30 שנה בהפצעות לינוקס.

מכיוון שכותבת שורות אלו ייעצה בעבר לחברות שונות בקשר לפתרונות מולטימדיה ועבדה מול עורכי דין וארגוני Patent pools שונים, אז אני מכירה את הנושא די טוב וחשבתי בפוסט זה לפשט ולהסביר את הדברים בכל הקשור לפטנטים ותשלומים.

כפי שתוכלו לראות בכל מיני אתרים – ארגון ה-MPEG LA (שהוא בעצם "ארגון" שדואג למכירת רשיונות למקודדי וידאו ואודיו שונים, גביית תמלוגים, תביעת מפירים וכו') לא ממש "רודף" אחרי נגנים מבוססי קוד פתוח. הארגון מעולם לא תבע את KODI (תבעו את KODI על דברים אחרים, לא על Codecs), או את VLC או את FFMPEG או OBS Studio או כל תוכנת ניגון ו/או עריכת אודיו וידאו מהסיבה הפשוטה שזה לא שווה להם – הן מבחינת יח"צ, הן מבחינת גביה ממשית והן מבחינת רווח סופי כלשהו. (חריגה אחת היתה, למיטב זכרוני, כאשר Dolby Labs ביקשו ממפתחי החבילה ac3dec להפסיק להשתמש במינוח "AC3" מכיוון שמדובר בסימן רשום. מאז פג תוקף למושג, כך שדולבי ירדו מהעניין).

הארגון כן "רודף" אחרי יצרנים של מוצרים סופיים (בין אם הם משתמשים בפתרונות מבוססי קוד פתוח או סגור). אם לדוגמא חברה מייצרת טלפונים או טאבלטים, והיצרן רוצה לכלול קידוד או פריסה (Encode/Decode) של אודיו או וידאו עם מקודדים מסויימים, אז אותה חברה תסגור רשיון עם MPEG-LA שבו יפורטו סוגי הרשיונות (יש כמה, לא רק סוגי codecs), האם זה יכלול רק פריסה, רק קידוד או גם וגם, וכמובן סוגי Codecs. דוגמא פשוטה: חברת Lenovo מייצרת טאבלטים וטלפונים זולים, רוב המכשירים מהסוגים הנ"ל כוללים תמיכה של פריסה וקידוד במקודד H.264 אך רובם אינם כוללים תמיכה בפריסה וקידוד במקודד HEVC (זה סגור ברמת חומרה), כך שלנובו משלמת רק על H.264, לא על השאר.

אם נתרגם את זה למציאות: אם מחר אבנה נגן מבוסס Raspberry Pi שיריץ KODI ואמכור זאת כמוצר סופי, סביר להניח ש-MPEG LA יצרו קשר ויבקשו תמלוגים (ואם לא אשלם – אתבע).

בתחום מערכות ההפעלה השונות, המצב שונה. מיקרוסופט מבקשת בחלק מהמקרים מהמשתמש לרכוש לדוגמא רשיון HEVC במחיר של $1. הסיבה? מיקרוסופט נותנת מספר כלים לתצוגה ועריכת וידאו עם תמיכה ל-HEVC ורשיון Windows אינו כולל רשיון ל-encode (קידוד) בכלים שמיקרוסופט נותנת, ולפיכך דרישת התשלום (לא תופיע דרישת תשלום אם מדובר רק בניגון וידאו, לדוגמא).

בכל הקשור לניגון וידאו – יש כבר מי שמשלם את רשיון ה-Codec והוא – יצרן ה-GPU במחשב, ובדרך כלל אותו יצרן גם כותב את התמיכה להאצת ה-codec ברמת הדרייבר גם בלינוקס, כך שאין כאן צורך תשלום כפול כלשהו לניגון הוידאו, ורד-האט יכולה להתנהג בדיוק כמו מיקרוסופט (שגם היא לא משלמת על מקודדים לצרכי ניגון מדיה), אולם לצערי רד-האט לוקחת צעד אחד רחוק-מדי, ועוצרת את תמיכת הקידוד/פריסה עוד ברמת התשתית (Mesa), אפילו לא ברמת הנגן, דבר שאף אחד לא עושה ואינו נדרש מצד שום גוף רשמי כלשהו, למיטב ידיעתי.

לסיכום: רד-האט היא חלק מחברת IBM, חברה בעלת מיליוני פטנטים (גם בתחום האודיו ו-וידאו, אגב), וחבל שברד-האט לא מנסים לבדוק את העניין לעומק ובמקום זאת מקשים על משתמשים חדשים בלי שום סיבה רצינית.

הטקסט המלא

28 September, 2022 05:03 PM

Duplicity backup utility is the old workhorse in all recent Ubuntu versions. I use the GUI called Deja-Dup for quite a while now. But until now I never bothered to check how to restore my files. I did decide to check how to restore file, because backup is only half the job! It turns out, that the GUI does a disservice for duplicity users. Restoring an encrypted backup turned out to not work. I didn't bother to research why, and turned to the CLI. This is a reminder on how to restore the files. continue reading...

01 June, 2022 01:49 PM

This already happend a while ago. I am on Github Sponsors and you can support my opensource work. continue reading...

01 June, 2022 01:49 PM

I just released the 2nd version of my CoreDNS plugin for getting DNS records from Netbox. This release adds IPv6. continue reading...

01 June, 2022 01:49 PM

I have just released WolkenBrot v0.3 with OpenStack support. WolkenBrot is my own little program to bake cloud images. The name means "Cloud Bread" in German. continue reading...

01 June, 2022 01:49 PM

A short guide for using IPython and Jupyter Notebook on remote Linux machine in the Enterprise Corp, where you don't have root rights. continue reading...

01 June, 2022 01:49 PM

After a long development hiatus I am releasing a new version of blogit continue reading...

01 June, 2022 01:49 PM

This is a short tutorial on how to build a data source for Grafana using Python Bottle micro-framework. Eventually, you can use this code to connect to any database (including SQLite). continue reading...

01 June, 2022 01:49 PM

Fooling around with JavaScript and OpenPGP, as the title says. I needed to create a page in which I can encrypt files with OpenPGP. Doing this with JavaScript turned out to be possible. These are the results of my experiment. continue reading...

01 June, 2022 01:49 PM

After two years at noris network AG, yesterday was my last day with this company. It has been a long time since it felt so hard leaving a company. In my two years I worked with really great people on some of the most cutting edge technologies. All these things were not possible without the help of so many great people with whom I worked with. Some of them might read this post, so here is a big thanks. I wanted to summerize my two years and gather all the lessons I learned in one place for my future self and others too. It's quite hard summerize such an eclectic post. It's been a wild ride in noris network with lots of new technologies and ideas. We have had a lot of success. I would like to think that a great part was because we opted to work in an open source matter, even thougah not all our projects where open source. This blog post is a summary of the good things we did, and the positive leasons we learned. I hope reading through these will inspire you to choose a similar path. continue reading...

01 June, 2022 01:49 PM

תוכנה חופשית היא דבר נפלא. אני מאוהב ברעיון כבר כ־28 שנה מאז גרקתי אותו לראשונה. ארגנתי קהילות ואירועים להפצת ידע על ואודות חופש התוכנה, ואי אפשר לזרוק היום אבן באף ענף כלכלי בלי להתקל בתוכנה חופשית רצה איפשהוא על שרת, עמדת חיוב כרטיסים בסופר וכמובן שכל האינטרנט וכל כיס מריצים תוכנות חופשיות למכביר. אין סטארטאפ שמתחיל היום בשוק וממציא לבד את כל הגלגלים, אם זה בתוכנה, ביולוגיה או כל תחום הנדסי, אתה תלוי בתוכנה, אם זה באסטרונומיה או מכונות CNC, תוכנה חופשית היא לפעמים החנות היחידה לשאוב ממנה את הכלים הדרושים למקצוע. מצד אחד אין להתעלם, ומהצד השני אין מנוס מלהשתמש. ההתנחלות הזו בלבבות וברשימות התלות של תוכנות היא חרב פיפיות, ובחודשים האחרונים אנחנו רואים כמה צרות שמאיימות על עתיד הקהילה.

אולי המכה הכי גדולה למוצר תוכנה היא נטישה שתוביל ל"רקבון ביטים". תוכנה שלא מתעדכנת לא מקבלת תכונות חדשות אבל גם לא נסתמות בה פרצות שמתגלות. אם יש לה עדיין משתמשים אז דברים ישברו, ובכל פעם שמשהו בעולם התוכנה החופשית נשבר ומשפיע על production של חברות מסחריות, התדמית נפגעת. לאחרונה אני רואה כמה ארועים שבאו ברצף:

• חזרתו של RMS להנהלת המוסד לתוכנה החופשית הבאישה את המוסד בעיני רבים, והחלה נטישה מדודה אבל מורגשת של תורמים (אני בינהם) ופרויקטים בולטים, חלקם עמודי תווך של פרויקט GNU.
• מוצרים כמו טראוויס ו־Docker שפתאום אינם בחינם יותר לפרויקטים רבים של תוכנה חופשית בשל שינוי מדיניול – מצב זה שובר הפצה של תוכנה חופשית קיימת, ועלול לגרום לאותם מוצרים לאבד משתמשים ותדמית. במקרה של טראוויס זה אומר שהרבה פרויקטים של תוכנה חופשית יאלצו לעשות בדיקות שכבר היתה להם אוטומציה בצורה ידנית או להתחיל לשכתב מחדש תהליכים כדי לעבוד מול כלי אחר, או להנטש ולהפוך לעוד גופה ללא עדכונים.
• מפתחים כמו מארק סקוויירז שהחליטו על "שברו את הכלים ולא משחקים" בצורה שיורה לעצמו ולכל הקהילה ברגל ומערערת מאוד את בטחון המשתמשים. היו עוד לפניו אבל הספריות שלו הן מרכזיות ובולטות.
• חורים אדירים שהתגלו בשנים האחרונות בכלים מרכזיים ונפוצים, כגון Log4Shell, Heartbleed, Shellshock ואחרים.
• יש פרויקטים שנטשו או השאירו בבלגן פרויקטים ישנים אצל גיטהאב כשמיקרוסופט קנתה אותה, אבל זה כנראה מיעוט.

תזוזה קטנה ועוד אחת, מתי נענועי הסירה יהפכו אותה? הפחד שלי היא לולאת משוב ענקית שבה פתאום חברות יפחדו להשתמש במוצרים חופשיים או לתרום להם, מה שיגרום לאיבוד רוח מהמפרשים של מפתחים מתנדבים. בנקודות כאלו כדאי לזכור שהמתנדבים לא ממש מקבלים הרבה גב, חלקם אפילו לא יודעים איך לשווק את הפרויקט או לקבל תרומות גם אם ירגישו שנכון להם לבקש. המקרים של מפתחים כמו מארק סקוויירס מדאיגים אותי מאוד: בוקר אחד קם אדם ואומר לעצמו שלא משלמים לו מספיק אז הוא יתקע לכולם מקל בגלגלים (אני אפילו לא יודע אם הייתה דרך למישהו לשלם לו לפני שהתחיל להשתולל). בתגובה לא בלתי מוצדקת נחסמו לו חשבונות אצל גיטהאב ו־pypi. יש לי כמה דברים לומר למפתחים שהחליטו לפרסם קוד ברישיון פתוח – ראשית ציינו בצורה ברורה מה תנאי הרשיון (אי ציון רישיון ברור מטילה עליכם את האחריות אם למשתמשים נדפק משהו, וברירת המחדל איננה "נחלת הכלל"), ושנית היו מוכנים שיהיו לכם הרבה משתמשים מסחריים. אם לא מקובל עליכם, אל תירו לעצמכם ברגל, פצלו את הפרויקט לגרסא פתוחה ואחת סגורה בתשלום או כל דרך אחרת. לדחוף קוד ששובר את הספריה שלכם מבטיח גם נטישה של משתמשים וגם איבוד האמון בכם לעתיד, וכמובן פותח פחת לתביעות משפטיות אם הרישיון שלכם לא מצוין נכון.

ורק כדי להיות ברור: יש המון חדשות טובות בקהילה הזו, הפחד שלי הוא מהתדמית בעיני משתמשים מסחריים, שהפכו לחשובים מאוד בתהליך הפיתוח של כלים קטנים לפעמים. הקרנל של לינוקס ופרוייקטים מסביבו עדיין חיים ותוססים ושיפורים קורים השכם והערב.

ומה הפתרון? אין לי תשובה. גם ככה הרשת שלנו הפכה בעשורים האחרונים לריכוזית מדי. כל הקוד העדכני בגיטהאב. כל הידע הטכני בסטאק אוברפלו. הרשת החופשית שהתאהבתי בה כמעט כבר לא קיימת, כשכל הידע והתקשורת קורים בין הכתלים של 10 חברות (אני נדיב) ולא בעשרות אלפי אתרים מבוזרים. אם מחר גיטהאב משנה תנאי רשיון, או סטאק אוברפלו פושטת רגל זו מכה רצינית מאוד לקהילת המשתמשים. אני למשל מחזיק בבית תלתפסת שכל הידע של קהילת המשתמשים שלה היה בגוגל פלוס, ויום אחד פשוט הוסר בלי יכולת לגבותו כראוי, ורק אחוז קטן ממנו שוחזר אח"כ לאתר עצמאי אחר.

מוזמנים לתת את דעתכם ופתרונותיכם פה בתגובות, רק אל תתחילו למכור לי בלוקצ'יין. דברים ישימים בלבד

15 January, 2022 04:44 PM

TL;DR; Before I get to ranting, here is the quick answer: Ventoy is a Free Software multi-platform tool that lets you boot ISO files from a USB drive. Key features that make it different from other tools like Etcher or Unetbootin are: You don’t need to “flash” the ISO to the drive – just copy […]

24 September, 2021 11:20 AM

I’m going to bring down my work volume around OSS to a minimum, specifically when it comes to orchestrator and gh-ost. This is to explain the whats and hows so that users are as informed as possible. TL;DR a period of time I will not respond to issues, will not review pull requests, will not produce releases, will not answer on mailing lists. That period of time is undefined. Could be as short as a few weeks, could be months, more, an unknown.

The “What”

Both orchestrator and gh-ost are popular tools in the MySQL ecosystem. They enjoy widespread adoption and are known to be used at prominent companies. Time and again I learn of more users of these projects. I used to keep a show-off list, I lost track since.

With wide adoption comes community engagement. This comes in the form of questions (“How do I…”, “Why does this not work…”, “Is it possible to…”), issues (crashing or data integrity bugs, locking issues, performance issues, etc.), suggestions (support this or that) and finally pull requests.

At this time, there’s multiple engagements per day. Between these two projects I estimate more than a full time job addressing those user interactions. That’s a full time job volume on top of an already existing full time job.

Much of this work went on employer’s time, but I have other responsibilities at work, too, and there is no room for a full-time-plus work on these projects. Responding to all community requests is unsustainable and futile. Some issues are left unanswered. Some pull requests are left open.

Even more demanding than time is context. To address a user’s bug report I’d need to re-familiarize myself with 5-year old code. That takes the toll of time but also memory and context switch. As community interaction goes, a simple discussion on an Issue can span multiple days. During those days I’d jump in and out of context. With multiple daily engagements this would mean re-familiarizing myself with different areas of the code, being able to justify a certain behavior; or have good arguments to why we should or should not change it; being able to simulate a scenario in my brain (I don’t have access to users’ environments); comprehend potential scenarios and understand what could break as result of what change — I don’t have and can’t practically have the tests to cover the myriad of scenarios, deployments, software, network and overall infrastructure in all users environments.

Even if I set designated time for community work, this still takes a toll on my daily tasks. The need to have a mental projection in your brain for all that’s open and all that’s to come makes it harder to free my mind and work on a new problem, to really immerse myself in thought, to create something new.

When? For how long?

Effective immediately. I made some promises, and there’s a bunch of open issues and pull requests I intend to pursue, but going forward I’m going to disengage from further questions/requests/suggestions. I’m gonna turn off repo notifications and not get anything in my mailbox.

My intention is to step back, truly disengage, and see what happens. There’s a good chance (this happened before) that after some time I feel the itch to come back to working on these projects. Absolutely no commitments made here.

What does this mean for orchestrator?

After 7 years of maintaining this project, first at Outbrain, then Booking.com, then GitHub and now at PlanetScale, I’m gonna step back and refrain from new developments, from responding to issues, from answering questions, from reviewing pull requests.

I should mention that in the past year or so, I’ve merged more community contributions than my own. That’s staggering! There are very capable contributors to this project.

In essence, the core of orchestrator hasn’t changed in a while. The main logic remains the same. I suspect orchestratorwill remain effective for time to come. I am sure some users will be alarmed at this post, and wonder whether they should keep using orchestrator or search for other solutions. I am in no position to make a suggestion. Users should carefully evaluate what’s in their best interests, what they deem to be stable and reliable software, what they deem to be supported or repairable, etc.

What does this mean for gh-ost?

I co-designed and co-authored gh-ost at GitHub (announcement) as part of the database infrastructure team. We wrote gh-ost to solve a pressing issue of schema changes at GitHub, and were happy to open source it. This led to, frankly, an overwhelming response from the community, with very fast adoption. Within the first few months we received invaluable feedback, bug reports, suggestions, all of which had direct and positive impact to gh-ost.

I’m not working at GitHub anymore, and I’m not an official maintainer of the upstream repo anymore. I do not have the authority to merge PRs or close issues. It is as it should be, the project is owned by GitHub.

I use gh-ost as part of my current job at PlanetScale working on OSS Vitess. Vitess utilizes gh-ost for online DDL. I therefore am an interested party in gh-ost, most specifically to ensure it is correct and sound. For this reason, I selectively engage with users on GitHub’s repo, especially when it comes to issues I consider important for Vitess.

I do maintain a fork, where I either interact with users, or push my own changes. I collaborate with the GitHub team, contribute upstream changes I make on my fork, and pull changes downstream. The GitHub team is kind enough to accept my contributions and invest time in testing and evaluating what might be risky changes. The upstream and downstream code is mostly in sync.

Going forward I will continue to work on things critical to my current job, but otherwise I’ll be stepping away and reduce interactions. This means I will not accept pull requests or answer questions. The upstream gh-ost repo remains under GitHub’s ownership and maintained by GitHub’s engineers. It is not in my authority to say how the upstream project will engage with the community and I do not presume to make suggestions.

On community interaction

I must say that I’m thoroughly humbled and grateful for the interactions on these projects. I hear of other OSS projects suffering abuse, but my work has seen respectful, thoughtful, empowering and inspiring user interactions. The majority of users invest time and thought in articulating an issue, or engage in respectful discussion while suggesting changes. I’ve actually “met” people through these interactions. I can only hope I payed back in same coin.

On community assistance

Community also provides assistance in several forms. The simplest and truly most helpful is by answering questions. Some community members will respond on issues, or on mailing lists, in chat rooms. Some users will identify similar issues to their own, opened by other users, will discuss and help each other, and share information.

Some companies and users are consistent contributors, working on issues that are both specific to their particular needs, as well as ultimately useful for the greater community.

At a previous time where I was overwhelmed with OSS/community work, two prominent companies, let’s call them S and P, stepped forward to offer actual development time; assign their own engineers part-time for a limited period to help pushing forward. I’m forever grateful for their kindness! I didn’t take those offers back then, because I didn’t have a good plan (I still don’t) for coordinating that kind of work; it felt like it would take even more efforts to set it up.

Can we jump in as contributors?

I don’t have a good plan for making this work, or for ensuring that this works well. I prefer that users fork orchestrator, and to not bring in contributors to this repo. If a contributor does have a solid plan, you probably know where to find me.

20 July, 2021 12:14 PM

23 April, 2021 05:43 PM

23 April, 2021 05:43 PM

I was browsing StackOverflow yesterday, and encountered an interesting question.Unfortunately, that question was closed almost immediately, with comments stating: “this is undefined behavior” as if there was no explanation to what was happening. But here is the twist: the author of the question knew already it was “undefined behavior”, but he was getting consistent results, […]

07 March, 2021 12:45 AM

השליט העליון שכב במיטת בית החולים. הוא התקשה לנשום והתקשה לחשוב. את מעט הריכוז שעוד הצליח לגייס הפרו הצפצופים הדחופים של מכונות הניטור והחמצן. המחלה הארורה השיגה אותו לבסוף. כמו שהזהירו המדענים, החיסון לא עבד. הוא שמח כשנזכר שהורה על הוצאתם להורג. "מה הטעם במדענים", חשב לעצמו בלעג, "אם אינם מועילים בריפוי המגיפה?"

לאט לאט, הנהן בראשו להסכמה. הרופאים ביקשו להרדים ולהנשים אותו. לא היתה ברירה, הם אמרו. בלי זה, הוא לא ישרוד את הלילה. הנהונו גרם לפרץ של פעילות. רופאים ואחיות החלו בשרשרת של סידורים. השליט לא סמך על רופאות ואסר על לימודי רפואה לנשים כבר לפני שנים רבות.

לבסוף שככה הפעילות ורופא זקן ניגש אליו. השליט העליון לא ראה את הרופא הזה קודם אך על פי יחס שאר אנשי הצוות אליו השליט העליון הבין שהוא רופא בכיר. השליט העליון היה טוב מאוד בלקרוא אנשים ומצבים. משהו הטריד אותו ברופא הזה. הרופא הזקן התכופף. השליט העליון הבחין בתואר "פרופסור" על תג השם שלו, אבל לא הצליח להתרכז מספיק כדי לקרוא את השם המלא. הוא לא אהב פרופסורים.

הרופא הזקן הביט בשליט העליון ואז, מבלי להסיר את עיניו ממנו, הנהן. רופא אחר, צעיר יותר, נחפז אל השליט העליון והוא חש דקירה בזרועו. הרופא הזקן נפנף והרופא הצעיר התרחק במהירות.

השליט העליון חש לפתע קור. "מה זה?" ,חשב, "מישהו פתח את החלון?". לא הייתה זאת מחשבה הגיונית, כך ידע, אבל הוא מצא שקשה לו עוד יותר להתרכז. הוא חש עייף. הרופא הזקן התקרב עוד יותר אליו, הביא את פיו לאוזנו, ואמר משהו. השליט העליון ניסה מאוד להתרכז להבין מה נאמר. זה היה קשה מאוד. לבסוף הבין. פיו נפער, אבל אף בת קול לא יצאה. עיניו נעצמו.

"Sic Semper Tyrannis"

02 October, 2020 08:11 AM

אני מודע לכך שלא כתבתי יותר משש שנים ואני מקווה שמישהו עוד עוקב אחרי הבלוג. אבל לאחרונה קניתי מחשב חדש וכמובן שהתקנתי עליו ארץ׳ וחשבתי שתיאור התהליך יוכל לעזור למישהו. לי לפחות יוכל לעזור בעתיד לדעת מה בדיוק עשיתי.

למרות הכותרת המפוצצת, לא מדובר על מדריך מלא עם הסברים ובטח לא על מדריך פשוט של העתק־הדבק. חשוב להבין מה אתם עושים ובמחשבים אחרים ייתכן שהפקודות יצטרכו להיות שונות.

בהתקנה התבססתי על שני מדריכים עיקריים:

• ויקי: https://wiki.archlinux.org/index.php/installation_guide (לפעמים מפורט מידי)
• מדריך itsfoss: ‏https://itsfoss.com/install-arch-linux (ברור מאוד אבל מתקין קצת דברים מיותרים)

בתור התחלה, הורדתי את תקליטור ההתקנה של ארץ׳, „צרבתי” אותו על החסן נייד והעליתי את המחשב ממנו.

התחברות לרשת האלחוטית

wifi-menu

או שמתחברים עם כבל לרשת קווית

בדיקה שמחובר:

ping -c3 google.com

עדכון שעון מערכת

timedatectl set-ntp true

חלוקת מחיצות עם fdisk

אצלי כבר היה מותקן אובונטו מהיצרן ולכן השארתי את שתי המחיצות הראשונות של uefi ומחיצת שחזור ומחקתי את המחיצה של אובונטו

fdisk /dev/nvme0n1

יצרתי מחיצה ל־swap של 24G, מחיצת שורש של 30G ומחיצת בית של 175G שנשארו (לפי הסדר הזה)

mkswap /dev/nvme0n1p3
swapon /dev/nvme0n1p3
mkfs.ext4 /dev/nvme0n1p4
mkfs.ext4 /dev/nvme0n1p5

הגדרת מקורות

pacman -Sy reflector
cp /etc/pacman.d/mirrorlist /etc/pacman.d/mirrorlist.bak
reflector -c "IL" -f 12 -l 10 -n 12 --save /etc/pacman.d/mirrorlist

עיגון

mount /dev/nvme0n1p4 /mnt
mount /dev/nvme0n1p5 /mnt/home

התקנה

pacstrap /mnt base linux linux-firmware nano intel-ucode

הגדרת fstab

genfstab -U /mnt >> /mnt/etc/fstab

ביצוע chroot

arch-chroot /mnt

הגדרת אזור זמן

ln -sf /usr/share/zoneinfo/Asia/Jerusalem /etc/localtime
hwclock --systohc

הגדרת locale

nano /etc/locale.gen

en_US.UTF-8 UTF-8
he_IL.UTF-8 UTF-8

locale-gen

הגדרת רשת

echo myname > /etc/hostname
nano /etc/hosts

127.0.0.1 localhost
::1 localhost
127.0.1.1 myname.localdomain myname

הגדרת סיסמה

passwd

התקנת grub

pacman -S grub efibootmgr
mkdir /boot/efi
mount /dev/nvme0n1p1 /boot/efi
grub-install --target=x86_64-efi --bootloader-id=GRUB --efi-directory=/boot/efi
grub-mkconfig -o /boot/grub/grub.cfg

יצירת משתמש

useradd -s /bin/bash -g users -G sys,adm,wheel -m user
passwd user

התקנת ממשק גרפי

pacman -S xorg-server xf86-video-intel
pacman -S eog evince file-roller gdm gedit gnome-calculator gnome-color-manager gnome-control-center gnome-disk-utility gnome-font-viewer gnome-keyring gnome-logs gnome-menus gnome-screenshot gnome-session gnome-settings-daemon gnome-shell gnome-shell-extensions gnome-system-monitor gnome-terminal gvfs gvfs-gphoto2 gvfs-mtp mutter nautilus networkmanager simple-scan totem xdg-user-dirs-gtk

לא כל גנום חובה, חלק אני רציתי

להפעיל את השירותים

systemctl enable gdm NetworkManager

הרשאות ניהול

pacman -S sudo
nano /etc/sudoers

%wheel ALL=(ALL) ALL

התקנת yay

pacman -S base-devel wget
wget https://aur.archlinux.org/cgit/aur.git/snapshot/yay-bin.tar.gz
tar -xzf yay-bin.tar.gz
cd yay-bin
makepkg -si

התקנת גופנים לעברית

קצת סיפור להוריד ולבנות את החבילה של הגופנים אז אפשר להוריד אותה מדרייב:

pacman -U ttf-ms-win10-10.0.18362.116-2-any.pkg.tar.xz
yay -S culmus culmus-fancy-ttf ttf-alef

התקנת דפדפנים

pacman -S firefox-i18n-he chromium

התקנת ליברה אופיס

pacman -S libreoffice-fresh-he

עוד כמה תוכנות חשובות בעיני (חלק צריך להגדיר)

libhdate-glib vlc mlocate reflector zsh zsh zsh-completions zoom parcellite

וזהו

reboot

אם התקנתם הכול נכון אז המערכת תעלה ותוכלו להינות ממנה. בהצלחה!

10 June, 2020 10:03 AM

ביחד עם משבר הקורונה, אנשים רבים גילו כי לצד העבודה מהבית הרישיון לתוכנות ה-GIS שלהם נשאר במשרד. סדנאות ה-QGIS שלנו מיועדות למי שרוצה להשתחרר ממגבלות עולם ה-GIS הקנייני ולעבוד עם תוכנה ללא מגבלות על שימוש והתקנות וזאת מבלי לוותר על יכולות של התוכנה.

לצד סדנה בהתאמה אישית לארגונית (דרך zoom בתקופת הקורונה) המאפשרת גמישות מקסימלית של התכנים, אנחנו מפעילים סדנאות חודשיות עם תוכן קבוע. סדנאות QGIS שלנו ביוני 2020:

1. מה זה QGIS ופלאגאין עבור מידע ישראלי פתוח (17 ביוני, דרך Zoom)
2. סדנת מבוא ל-QGIS (14 ביוני, דרך Zoom)
3. סדנת QGIS למתכנני ערים (15 ביוני, דרך Zoom)

סדנאות המבוא מיועדות לאנשים שרוצים לעבוד עם מפות ולבצע ניתוחים מרחביים במסגרת תחומי העיסוק שלהם: כלכלנים, מהנדסות, אדריכלים, מתכננות ערים, אקולוגים, ארכיאולוגיות, גיאולוגים ועוד. הן מיועדת גם למי שלא מכיר GIS או מכיר ברמה בסיסית.

ניתן להשאיר פרטים בטופס ההתעניינות ונחזור אליכם עם פרטים וכיצד להרשם או להצטרף לניוזלטר החודשי שלנו כדי לקבל עדכונים על סדנאות עתידיות.

26 May, 2020 10:15 AM

בכנס אייקון 2019 נתתי הרצאה על השורשים הבודהיסטים וטאואיסטים של מסדר הג'די מסדרת סרטי מלחמת הכוכבים. ההרצאה ההיא לא הוקלטה אבל בצוק העיתים וברוח הנדיבות עשיתי שחזור שלה בזום עם כמה א.נשים אמיצים והנה התוצאה לפניכם.

בהרצאה משולבים מספר קטעים קצרים (לצד הסברים שלי) מסדרת הסרטים והזכויות להם שייכים כמובן לחברת דיסני. השימוש בקטעים הוא לצרכי ביאור ונעשה בהבנה שהשימוש נופל תחת החרגת השימוש ההוגן של חוק זכויות היוצרים הישראלי.

מעבר לכך בסוף ההרצאה יש קטע בונוס מיוחד – גילוי של גלגולו הנוכחי של יודה, כאן ועכשיו!

תהנו!

12 April, 2020 03:08 PM

I had a use case where I wanted to colorizes an aggregated graph with a nice gradient color, so I looked to see how to add a new color template to Cacti, but the process is not usable when one need to add a lot of colors, in my case I was looking to add 110 different colors, and using the webUI was not a options. So I looked on the database schema and found that the color template is managed by 3 tables. One manage the template names plugin_aggregate_color_templates, and the other plugin_aggregate_color_template_items is a pivot table which manage the colors per template by referencing the colors table and the plugin_aggregate_color_template table.

Cacti Database Tables Related To Colors

Create a color Palette

First thing first we need to add our new colors to the colors table, so I looked a bit and found this nice website which allow you to set few colors and define the number of steps between the colors, and I used another site to find a nice palette for “fire” colors. The cool thing for was that the site will auto generate an PHP array snippet which you can copy and use.

The Code

Now we can write a small script which will take the array and generate a new color templates for us

15 March, 2020 11:17 PM

Mr. Magoo is an old cartoon character famous for his inflated sense of status and an extreme case of myopia, made worse by his refusal to wear corrective glasses. As a result of his poor vision and ego, Magoo would find himself in precarious — and hilarious — situations because he was unable to see the danger right in front of him. Typically, the oblivious Magoo would leave a trail of destruction behind him..

Enterprises today approach security a lot like Mr. Magoo, operating with the idea that they are more important than they really are and therefore are unable to see the real risks that beset them. The result? A lot of unnecessary damage.

Read the full article at Forbes here

Full text

06 December, 2019 09:24 PM

For some time now, I was looking for a way to Integrate Let’s Encrypt (LE) with My Cisco ASA, and use LE to issue the certificates for the VPN. And now Ansible is in a good place with its Network Modules to allow this without much of a problem.

I won’t go over the procedure of how I issue/renew the certificates, I will just mention that I use the DNS alias option, as I find it the most useful option, as it doesn’t require me to punch holes in my firewall to allow incoming connection to validate the requests.

My Playbook looks like this,

---
# see:
# - https://docs.ansible.com/ansible/latest/modules/asa_config_module.html
# - https://docs.ansible.com/ansible/latest/modules/asa_command_module.html

- name: Config CiscoASA
  hosts: CiscoASA
  connection: network_cli
  gather_facts: false
  become: true
  become_method: enable
  vars:
    ansible_user: ansible
    ansible_password: "in line or use vault!"
    cert_file: "vpn.pfx"
    cert_pass: "in line or use vault!"
    config_file: "asa.conf"

  tasks:

    - name: Get Certificate
      set_fact:
        cert: >
          {{ (lookup('file', cert_file) | b64encode | regex_replace('(.{1,64})', '\1|')).split('|') | list + [ 'quit' ] }}
      tags: [ cert ]

    - name: Create A TrustPoint
      asa_config:
        lines:
          - crypto ca trustpoint SSL-Trustpoint-Ansible
        after:
          - enrollment terminal

    - name: Import A New Certificate Into The TrustPoint
      asa_config:
        replace: block
        parents: "crypto ca import SSL-Trustpoint-Ansible pkcs12 {{ cert_pass }} nointeractive"
        lines: "{{ cert }}"
      notify:
        - Set SSL Trust-Point

  handlers:

    - name: Set SSL Trust-Point
      asa_config:
        save: true
        lines:
          - ssl trust-point SSL-Trustpoint-Ansible inside
          - ssl trust-point SSL-Trustpoint-Ansible outside

Extra

Generate PFX from Cert and Key

#!/bin/bash

CA=ca.cer
#fullchain.cer
CER=vpn.cer
KEY=vpn.key
OUT=vpn.pfx

openssl pkcs12 -export \
-inkey ${KEY} \
-in ${CER} \
-certfile ${CA} \
-out ${OUT}

19 November, 2019 09:52 AM

As I write these pieces for Forbes Tech Council, I’ve tried to chip away at the Hollywood reputation that hackers have been given over the years. That reputation often keeps people from making good decisions about how to protect their networks and data, keeps people focused on the wrong security priorities, and causes people to give up before the game is over.

It’s important to keep in mind, however, that while criminal hackers may be smart and devious, they are also, in a sense, entrepreneurs who are in the game to make a quick buck. As such, they realize that hacking costs money and so they will do what they can to keep their operating costs low. Why, then, would you expect a criminal hacker to expend time and money developing specialized tools when there are easier ways to get to what they want?

Read the full article at Forbes here

Full text

23 September, 2019 11:38 PM