By default, the Power tab in GNOME’s Settings does not show the battery percentage for Bluetooth headphones like the Sony WH-1000XM3. However, you can enable this feature by activating the DBUS interface of Bluez, the Linux Bluetooth protocol stack. The DBUS interface is hidden behind the --experimental flag for the Bluez service. To enable it, follow these steps:
Create an override file for the bluetooth service:
$ sudo systemctl edit bluetooth
This command will create the file /etc/systemd/system/bluetooth.service.d/override.conf.
As more websites and applications are being hosted on the web, the necessity for securing these resources is skyrocketing. Among various web servers, Nginx has gained substantial popularity due to its performance, flexibility, and stability. Despite its many merits, securing your applications can always be a tricky business. But fret not, securing sensitive files in Nginx is achievable by configuring the Nginx server to block attempts directed at accessing specific files or file types.
This blog post will guide you through a way to enhance the Nginx server’s security by blocking access to sensitive files. As seen in the code snippet in the block_bad.conf file, we will deny access to all dotfiles, files ending with ~ or .bak, and the dump.sql file which often contains database dumps.
Start by saving the following code snippet in the /etc/nginx/snippets/block_bad.conf:
By using the deny all; directive within the location blocks, Nginx will disallow access to the specified locations. The access_log off; and log_not_found off; directives prevent logging access to these blocked file types, and the return 404; directive makes Nginx return a 404 error when an attempt is made to access these files.
Specifically, the location ~ /\. clause will block access to all dotfiles. These files usually store configuration for individual programs, revealing them might cause security vulnerabilities. The next location block with the pattern ~ ^/.well-known overrides the previous one by specifically allowing access to URIs startings with .well-known (which is used by certbot).
The next set of directives beginning with location ~ ~$ and location ~ \.bak$ blocks access to files ending with ~ or .bak. These files are often temporary files or backup copies which may accidentally leak sensitive information if accessed by malicious actors.
Lastly, the location ~ /dump.sql$ rule denies access to dump.sql files. These files may contain database dumps, which can expose sensitive database information.
After saving this file, you need to include it in your server block configuration using the include directive. Open the Nginx server block configuration. Then, to load the block_bad.conf, add include snippets/block_bad.conf; in each server block that you want to apply these security rules. Restart the Nginx service after including this rule to apply the changes.
By taking the steps outlined in this guide, you can enhance the security of your Nginx server by preventing unauthorized access to sensitive files and thus reducing potentials for information breach. Remember, securing your servers is a continual process, and consistently updating your configurations to counter evolving threats is a good practice.
אחרי תקופה ארוכה של פיתוח תוכנה/אפליקציית OpenLiveStacker המיועדת לצילום אסטרונימי בזמן אמת, הגעתי לנקודה שמעבר לתמיכה במצלמה נדרשת תמיכה בחצובה ובמצלמה גנרית. אז איך מתחברים במשהו גנרי? משתמשים בממשק סטנדרטי! בעולם "חלונות" יש ASCOM. בעולם הלינוקס המצב נותן מגוון רחב של סטנדרטים
מי ששם לב, בשנה האחרונה יש המון התקפות על אנשים מבוגרים, לאחרונה יצא לי לסייע למספר כאלה בחזרה מההתקפה,
בהתקפה מתקשרים לאנשים ממספרי VoIP מקומיים, מדברים בשפה הרוסית או העברית, מציגים את עצמם כעובדי בזק /בנק /משטרה ומציינים שיש בעיית תשתית או בעייה בחשבון, ושעל מנת לבדוק שהכל בסדר צריך להתקין אפליקציה מסויימת או לפתוח שליטה מרחוק במכשיר הסלולארי ואז לבצע לשים את המכשיר ליד הנתב בצורה הפוכה.
שוחחתי עם קולגה שמתעסק בנושא אבטחת מובייל, והוא אמר שככל הנראה מפיק לבצע factory reset, על מנת להיות בתוך שה maleware (אם הותקן ) יוסר מהמערכת , ואין צורך לבצע עידכון קושחא כי מניסונו ,בהתקפות הללו לא משתמשים במערכות כאלה.
יש לי קרובי משפחה שקיבלו שיחה בשפה העברית ללא מבטא כלל, שהיה להם את כל הפרטים האישיים (כנראה הסיפור של מפלגת הליכוד לפני מספר שנים) , הם יידעו להגיד באיזה בנק מנוהל החשבון, האמת זה לא סיפור לגלות , רוב האנשים יש להם חשבון בסניף הקרוב לביתם.
לפי הקורבן, בבדיקה שנעשתה מול הבנק, הבנק (פועלים) חסם את ניסיון ההעברת הכספים , המלצנו לקורבן להסיר את כלל אפליצקיות הניהול של הכספים והנכסים שלהם מהמכשיר, ולהגיע פיזית כל פעם, כי אם נפלתם בנושא פעם אחת, תיפלו בו בפעם נוספת. כאשר הקורבן הגיע לנקודת תמיכה (לא ברור אם הבנק או מקום בו מתקנים טלפונים) , נאמר לו שמספיק לאפס את הסיסמה בפועלים באינטרנט, מדובר בהמלצה בלתי מקצועית, ברגע שהייתה התקנה של משהוא על המכשיר , כל מה שיש על המכשיר הוא compromised, אפשר להחליף סיסמאות עד מחר, זה לא יעזור כי לתוקפף הייתה גישה שייכל להתקין keyloagger ווכל זבל אחר, במקרים כאלה הכול אמור להיות מוסר, לכל הפחות factory reset וחזרה מגיבויי לפני ההתקפה, אין גיבויי ? שומרים מספרי טלפון, הודעות והקלטות למדיה חיצונית, בודקים אותם ע"י הכלים החביבים אליכם, חוזרים להגדרות יצרן ומחזירים את התמונות וההודעות.
אילו היו בונים אתרים כמו שצריך, ושהם היו משתמשים ברכיבי אימות חומרה, כן אני יודע שקיים passkey באנדרויד, ושבתאוריה ניתן להשתמש ברכיבי חומרה לאימות (למשל yubico) בכדי לאחסן אותם, יש בעייה כי אנשים ייבחרו להשתמש בטלפון שלהם כממפתח החומרתי שלהם, וכשזה נפגע (כמו בהתקפה הזאת) הכל נפגע שוב פעם. זה אומנם מונע גניבת מכשיר האימות בצורה דיגיטלית, אבל זה לא מפריע כשיש התקפה נגד המכשיר עצמו.
עכשיו, אילו למשל האפליקציות כמו whatsapp ואפליצקיות ניוהל החשבון הבנקאי והניהול הרפואי של האנים היו דורשות רכיב חומרתי בשביל לאמת כל פעם ? אז הבעייה היתה פתורה מלתחילה, והאמת לא באמת חייבים אפליקציות , מספיק שתבנו אתר מספיק טוב, ושם המערכת הזאת כבר קיימת המון זמן, למעשה ניתן להתחבר להרבה מאוד שירותים באמצעות באמצעות רכיבי אימות חומרתי , החל מגוגל דרך Github ואפילו בתוך ebay ! משיטוט באתרי הבנקים הגדולים לא מצאתי אפשרות שהם יוכלו להתשתמש בכרטיס חכם חומרתי לאימות (ולא הודעת SMS או תוכנות OTP למיניהם).
עכשיו האמת , אילו האנשים המבוגרים היו משתמשים בטלפונים המריצים לינוקס, הבעייה ככל הנראה הייתה נמנעת, למה ? כי מכייון שמרבית השירותים הדיגטליים מיועדים רק לאנדרויד וiOS לא היו מותקנות האפליקציות של הבנק, והעובדה שאפליקציות השטלתות מרחוק גם לא עובדות בצורה פשוטה, כל זה היה נמנע מראש.
השתמשו בטלפון אורן ! וחלק גדול מההתקפות על הטלפונים הסלולארים פשוט לא עובדים עליהם!
צחוק צחוק , אבל יש מצב שאם יש שימוש ב wayland ושימוש טוב יותר ב sandboxing ברמת מערכת ההפעלה גם יפתרו חלק מהבעייה בהפצות מיועדות לטלפונים סלולארים, בצורה כזאת הסיכויי יהי נמוך יותר לגניבת מידע. מדוע ? כי אם אננו גם ככה מונעים משתמש root וגישת sudo כברירת מחדל בטלפון , אז לא כל התקפה תמיד תהיה ברמת המשתמש הנוכחי ולא כלל המערכת, ואז הוצאת מידע תהיה קשה יותר, וגם שימוש באפליקציות "מסוכנות" כמו הבנק והתיק הרפואי יהיו מוגבלות למשתמש אחר ולסביבה אחרת לחלוטין.
אז איזה שהיא נשמה טובה מהמתכנתים של פיירפוקס החליטו לשים אזהרה בגרסאות ה ESR כנגד חבילות שמותקנות מדביאן.
some of Firefox’s security features may offer less protection on your current operating system
המלל הוא "some of Firefox’s security features may offer less protection on your current operating system"
על מנת להיות בטוח שזה לא משהוא באמת באתרים מסויימים , בחרתי לפתוח בכוונה אתר שהוא 100% בטוח ולא מכין חורים או רושעות , והלכתי "למה קורה ?" , וכן , אתם רואים את האזהרה עליו ,הטריגר שראיתי שמפעיל את האזהרה הזאת זה אם לוחצים על קישור מתוכנה כלשהיא ושועל האש מוגדר כדפדפן ברירת המחדל במערכת ההפעלה.
האזהרה קופצת רק אם אין תהליך אחר של שועל אש שכבר רץ ורק עם לוחצים על קישור מתוכנה אחרת, אני עשיתי זאת מתוך hexchat.
הקישור מוביל לפה , בהתחלה חשבתי שהם מצפים מהמשתמש להתקין מהגרסה של מוזילה, שזה כמו שאתם יודעים לא רעיון חכם אף פעם (לא מתקינים כלום ממאגר שהוא לא המאגר הרשמי של ההפצה, בשום מקרה אלא אם אתם מדבגים משהוא), אבל אם מעבר על המלל מספר פעמים יכול להיות שהם רוצים בפועל לאשר user namespaces בתור פרופיל תוכנות-שיריון (apparmor), עכשיו כברירת מחדל בדביאן ישנן חבילות מיוחדות שמספקות את הפרופילים הללו, מוזילה יחלו לספר פרופיל כחבילה בתוך דביאן אבל בחרו לזרוק רפש על ההפצה.
אני אישית משתמש בפרופיל הישן והטוב, שש בו המון הרשאות ייתר, כי אני כן רוצה שאני אוכל לקרוא קבצים מתיקיות מסויימות ולבצע פעולות שהן חסומות בצורה אחרת אצלי (כן מדובר בפרופיל בן 4 שנים !) :
# This profile allows everything and only exists to give the
# application a name instead of having the label "unconfined"
abi <abi/4.0>,
include <tunables/global>
profile firefox-local
/home/USER>/bin/firefox/{firefox,firefox-bin,updater}
flags=(unconfined) {
userns,
# Site-specific additions and overrides. See local/README for details.
include if exists <local/firefox>
}
הם גם לא מציעים להפעיל את האזהרות או להפעיל במניעה של תוכנת-השיריון (שהדפדפן יוכשל אם יש חוק שאוסר את זה).
עכשיו במקום שנראה הרשאות מדוייקות והראשות לכל מני תיקיות יש פה שימוש של הוספה userns , זה גם לא מכסה את firefox-esr כלל!.
מצאתי שבתוך אובנטו בחרו לחסום את userns כברירת מחדל מכיוון שההצעה הזאת היא פתח לפרצןת אבטחה. במקום נוסף קראתי 44% מההתקפות ניצלו את userns במהלך ההתקפות שלהם, אני האמת לא יודע למי להאמין, מצד אחד אני מאמין שיכול להיות זבל שיגיע מאיזה אתר ויינצל חולשות בפיירפוקס, מצד שני ההסבר באובנטו (לא מצאתי הסבר כזה טוב אצל דביאן ) די משכנע אותי, מצד שלישי דביאן אישרו כברירת מחדל את userns בשנים האחרונות.
אמנם יש לי היום דפדפן בתוך מכונה וירטואלית בשביל שירותים כמו משרדי ממשלה, כי אני לא סומך על הקוד שלהם להיות מספיק בטוח, אולי באמת צריך לאמץ ריצת דפדפן מתוך podman לכל אתר, ואת זה להפעיל מתוך משתמש מוגבל. זה די מצחיק שהגענו למצב הזה.
הכי זה טוב זה שכולם ישתמשו ב elinks ו w3m (למרות ש ב elinks יש לי תמיד בעיות ).
עריכה:
מתברר שאם משנים את פרופיל השיריון-תוכנה מ enforce ל complain זה לא מציג את ההודעה הזאת כלל, כל הכבוד שועל האש , פשוט כל הכבוד.
אני יודע שימי מלחמת הפצות לינוקס כבר פחות מעניינים - כי כולם בסופו של דבר +/- אותו הדבר. אבל החלטתי להיזכר מה הייתה הדרך שלי.
התחלתי עם Fedora 3 - הנתנה לי הרגשה מה זה לינוקס מודרני (אז). אבל מהר מאוד התייאשתי - כי הרעיון לשדרג כל 6 חודשים להפצה חצי יציבה - כי זו מעבדתי ניסויים של Red Hat - לא קסם לי.
המשכתי ל־Debian - ה־stable אז היה ממש ישן עברתי ל־testing שאומנם עבד אבל... היה קשה וגם חיכיתי המון לגרסה "יציבה" שהייתה ישנה עם ההגעה.
כשרכשתי מחשב מחדש 64 ביט התקנתי עליו גרסת LTS הראשונה של Ubuntu 6.06 ומשם בבית אני עם גרסאות LTS - למה? כי לא בא לי להתעסק יותר מידי בלינוקס.
בעבודה עבדתי עם RHEL וגם עם CentOS וגם עם גרסאות שונות ומשונות של Ubuntu. שורה תחתונה. זה עובד וזהו. לא משנה מה.
העיקר שיהיה יציב שלא ישגע עם שדרוגים יותר מידי ויעבוד. ונחמד כשזה נתמך ע"י תוכנה מסחרית
מזה זמן רב שלא כתבתי כאן. אני מקווה לחזור ולכתוב מפעם לפעם.
כפי שידוע לכם, אני עוסק מזה למעלה מעשור בתרגום GNOME לעברית, יחד עם ירון שהרבני, בהתנדבות מלאה.
התרגום כיום במצב מצוין: 98% ל־GNOME 46, ו־95% ליישומי „מעטפת GNOME”.
אנו רוצים להמשיך לתרגם יישומים נוספים ולהמשיך ולתרגם את אלה הקיימים – בזמן קצר יותר.
לשם כך אנחנו רוצים לטייב מודל (בינה מלאכותית, למידת מכונה) קיים שמתרגם מאנגלית לעברית, באמצעות כ־100,000 מחרוזות תרגום איכותיות שיש לנו, כך שהמודל יתרגם על פי כללי התרגום של GNOME.
השאיפה – מודל קטן שניתן להרצה על מחשב (או על שרת), אליו ניתן לשלוח קובץ he.po לא מתורגם, ולקבל אותו בחזרה מתורגם, עם סימון על המחרוזות שתורגמו אוטומטית (כדי שנדע לעבור עליהם).
לפני כחודש כתבתי קוד Python קצר שעושה את התהליך הפשוט הזה על בסיס מודל של OPUS. אבל OPUS לא מתרגם לפי כללי התרגום שלנו ל־GNOME (למרות שהוא אומן גם על תרגומים מ־GNOME).
אין לי העדפה להתבסס דווקא על המודל של OPUS. אני רוצה לאמן מודל פתוח כלשהו, שהוא מספיק טוב, על בסיס הנתונים שיש לנו מ־GNOME, כדי לקבל תרגום על פי כללי התרגום של GNOME.
אני קורא כאן למי שבקיא בתחום, למי שיש יכולת לגייס משאבים על מנת לטייב מודל כזה – לסייע לנו.
אנחנו, צוות התרגום של GNOME, נדע להביא 100,000 מחרוזות מתורגמות לאימון, מכם נצטרך את השאר.
ניתן ליצור קשר בכתובת yoseforb אצל gmail.com או yoseforb אצל gnome.org. אפשרות נוספת – לשלוח הודעה כאן באתר או להיכנס לדף צוות התרגום: https://l10n.gnome.org/teams/he/.
I have a friend that likes the feeling of progress in the professional area. He considers working on a project as part of his professional development. Following our discussion with regards to staying motivated on such a project, I would like to describe the factors that keep me going. Your factors are likely to be different but I would like to share mine as a starting point.
I hope that this article will help you, the reader, to pick and/or stay motivated on your own project. Note that you should first think hard about what you are trying to achieve and whether a project is the right solution to that.
My Project
The project I’m basing my self-observations on is Next Generation Shell, an open source shell which doesn’t ignore advances that happened outside of the terminal for last decades (do you feel the pain in these words?). I started working on the project in 2013. As of time of writing, which is 2024, I’m still on it.
The project has two main parts:
Programming language – it’s in a good shape and we use it at work
User Interface – early stage, too early to impress anyone
Motivation
I can not separate motivation from picking the project. In my case, all the original motivation behind starting the project is still relevant. It’s worth noting that my feeling is that this project chose me, not the other way around.
Roughly from more significant motivators to less significant ones:
Pain. My project solves my own pain. I was programming in bash and Python. They both suck for DevOps scripting. Looked around for other languages and projects that would be aligned with my vision of the solution. Found none. Decided to do it myself. It was very clear from the beginning though that the amount of effort to solve my own pain doesn’t justify working on the project… if not for the next point:
I like helping others to be more productive. Software is a very scalable way to do exactly that. While you can maybe generalize this as “the project is aligned with my values”, I tend to think about this as “the project is aligned with my intrinsic motivation”. While the programming language should make the user more productive, the UI should really take the productivity to the next level (some would categorize the UI as “groundbreaking”).
The project became usable long time ago. Around 2016 I think. Seeing that it actually works for yourself is a great motivator. From GitHub issues that are opened from time to time, I assume that others are using NGS too. That means that NGS works for others too, at least to some extent.
The project is mentally challenging but not too hard (ignoring speed optimizations here, which could be). When I started, I knew roughly how to do it. It touches two topics that I enjoy: programming language design and semantics.
While I’m writing an NGS script I’m always thinking “how this can be more ergonomic?” and constantly improving the language. When I do the appropriate changes, it’s “NGS just became a bit more useful”. That contributes to the feeling of progress.
While looking at any piece of code in any other language, it’s always a challenge: should NGS do it better? If yes, how? It’s very motivational to see that in many cases NGS does it better that the piece of code in front of me.
Speaking of comparison, it does make me feel good that the niche is still not covered (amazing how bad the things still are) and therefore has huge potential for improvement of productivity. Looking at other projects that showcase anything but working with the cloud I’m thinking “Yep, we still need a shell to work with the cloud”.
It’s something to show to a potential future employer.
Not a near future plan but there is a potential for a startup here which would provide cloud-based enterprise features (I had a list of such features written down somewhere). If you can do that around a terminal, I guess you can do it around a shell.
Demotivation
Some things are demotivating when working on the project. Here they are and how I handle the ones that I know how (after “//”).
“You don’t understand, bash is perfect, we don’t need another shell” comments. // There are people that just can’t be moved easily.
I’m sure some assembler programmers didn’t want to move to Fortran or COBOL or C. Some didn’t want to move from these to let’s say Java or Python. There is no more “right” motivation behind creating a programming language than dissatisfaction with existing ones.
With regards to UI, some people think that Command Line Interface which mostly limits the interaction to a single line is the pinnacle of UX today. Well, I disagree and I’m about to prove that we can do better. It’s actually partially proven since 1976, when Bill Joy released vi which used the whole screen for text editing. Now I just need to prove the same for the shell instead of text editing.
UI is not ready yet and I can’t show it. I assume it’s way easier to sell productive UI than a programming language. // It shouldn’t be to far away from bare minimum demo though.
Attracting users and developers is hard. I suspect few reasons:
It’s harder market now. When you have C and you release awk the amount of convincing is way less than when you have Python and Ruby and many other languages which are popular and kind-of do the job.
My personal skills in attracting people to a project are not great I assume // Need to team up with someone but again – need to find that person first
I’m prioritizing technical work above finding users. I guess that “solving my own pain” dominates here.
The changes needed to be done to the language to make scripts at work more ergonomic (which I just like doing) come at the expense of working on the UI. It’s just really a hard tradeoff.
What motivates you? What demotivates you and how you handle that? Share in the comments.
It sometimes happens in people’s lives that someone tells them something that sounds true and obvious at the time. It turns out that it actually is objectively true, and it is also obvious, or at least sensible, to the person who hears it, but it’s not obvious to other people. But it was obvious to them, so they think that it is obvious to everyone else, even though it isn’t.
It happens to everyone, and we are probably all bad at consistently noticing it, remembering it, and reflecting on it.
This post is an attempt to reflect on one such occurrence in my life; there were many others.
(Comment: This whole post is just my opinion. It doesn’t represent anyone else. In particular, it doesn’t represent other translatewiki.net administrators, MediaWiki developers or localizers, Wikipedia editors, or the Wikimedia Foundation.)
There’s the translatewiki.net website, where the user interface of MediaWiki, the software that powers Wikipedia, as well as of some other Free Software projects, is translated to many languages. This kind of translation is also called “localization”. I mentioned it several times on this blog, most importantly at Amir Aharoni’s Quasi-Pro Tips for Translating the Software That Powers Wikipedia, 2020 Edition.
Siebrand Mazeland used to be the community manager for that website. Now he’s less active there, and, although it’s a bit weird to say it, and it’s not really official, these days I kind of act like one of its community managers.
In 2010 or so, Siebrand heard something about a bug in the support of Wikipedia for a certain language. I don’t remember which language it was or what the bug was. Maybe I myself reported something in the display of Hebrew user interface strings, or maybe it was somebody else complaining about something in another language. But I do remember what happened next. Siebrand examined the bug and, with his typical candor, said: “The fix is to complete the localization”.
What he meant is that one of the causes of that bug, and perhaps the only cause, was that the volunteers who were translating the user interface into that language didn’t translate all the strings for that feature (strings are also known as “messages” in MediaWiki developers’ and localizers’ jargon). So instead of rushing to complain about a bug, they should have completed the localization first.
To generalize it, the functionality of all software depends, among many other things, on the completeness of user interface strings. They are essentially a part of the algorithm. They are more presentation than logic, but the end user doesn’t care about those minor distinctions—the end user wants to get their job done.
Those strings are usually written in one language—often English, but occasionally Japanese, Russian, French, or another one. In some software products, they may be translated into other languages. If the translation is incomplete, then the product may work incorrectly in some ways. On the simplest level, users who want to use that product in one language will see the user interface strings in another language that they possibly can’t read. However, it may go beyond that: writing systems for some languages require special fonts, applying which to letters from another writing system may cause weird appearance; strings that are supposed to be shown from left to right will be shown from right to left or vice versa; text size that is good for one language can be wrong for another; and so forth.
In many cases, simply completing the translation may quietly fix all those bugs. Now, there are reasons why the translation is incomplete: it may be hard to find people who know both English and this language well; the potential translator is a volunteer who is busy with other stuff; the language lacks necessary technical terminology to make the translations, and while this is not a blocker —new terms can be coined along the way—, this may slow things down; a potential translator has good will and wants to volunteer their time, but hasn’t had a chance to use the product and doesn’t understand the messages’ context well enough to make a translation; etc. But in theory, if there is a volunteer who has relevant knowledge and time, then completing the translation, by itself, fixes a lot of bugs.
Of course, it may also happen that the software actually has other bugs that completing the localization won’t fix, but that’s not the kind of bugs I’m talking about in this post. Or, going even further, software developers can go the extra mile and try to make their product work well even if the localization is incomplete. While this is usually commendable, it’s still better for the localizers to complete the localization. After all, it should be done anyway.
That’s one of the main things that motivate me to maintain the localization of MediaWiki and its extensions into Hebrew at 100%. From the perspective of the end users who speak Hebrew, they get a complete user experience in their language. And from my perspective, if there’s a bug in how something works in Wikipedia in Hebrew, then at least I can be sure that the reason for it is not the translation is incomplete.
As one of the administrators of translatewiki, I try my best to make complete localization in all languages not just possible, but easy.¹ It directly flows out of Wikimedia’s famous vision statement:
Imagine a world in which every single human being can freely share in the sum of all knowledge. That’s our commitment.
I love this vision, and I take the words “Every single human being” and “all knowledge” seriously; they implicitly mean “all languages”, not just for the content, but also for the user interface of the software that people use to read and write this content.
If you speak Hindi, for example, and you need to search for something in the Hindi Wikipedia, but the search form works only in English, and you don’t know English, finding what you need will be somewhere between hard and impossible, even if the content is actually written in Hindi somewhere. (Comment #1: If you think that everyone who knows Hindi and uses computers also knows English, you are wrong. Comment #2: Hindi is just one example; the same applies to all languages.)
Granted, it’s not always actually easy to complete the localization. A few paragraphs above, I gave several general examples of why it can be hard in practice. In the particular case of translatewiki.net, there are several additional, specific reasons. For example, translatewiki.net was never properly adapted to mobile screens, and it’s increasingly a big problem. There are other examples, and all of them are, in essence, bugs. I can’t promise to fix them tomorrow, but I acknowledge them, and I hope that some day we’ll find the resources to fix them.
Many years have passed since I heard Siebrand Mazeland saying that the fix is to complete the localization. Soon after I heard it, I started dedicating at least a few minutes every day to living by that principle, but only today I bothered to reflect on it and write this post. The reason I did it today is surprising: I tried to do something about my American health insurance (just a check-up, I’m well, thanks). I logged in to my dental insurance company’s website, and… OMFG:
What you can see here is that some things are in Hebrew, and some aren’t. If you don’t understand the Hebrew parts, that’s OK, because you aren’t supposed to: they are for Hebrew speakers. But you should note that some parts are in English, and they are all supposed to be in Hebrew.
For example, you can see that the exclamation point is at the wrong end of “Welcome, Amir!“. The comma is placed unusually, too. That’s because they oriented the direction of the page from right to left for Hebrew, but didn’t translate the word “Welcome” in the user interface.² If they did translate it, the bug wouldn’t be there: it would correctly appear as “ברוך בואך, Amir!“, and no fixes in the code would be necessary.
You can also see a wrong exclamation point in the end of “Thanks for being a Guardian member!“.
There are also less obvious bugs here. You can also see that in the word “WIKIMEDIA” under the “Group ID” dropdown, the letter “W” is only partly seen. That’s also a typical RTL bug: the menu may be too narrow for a long string, so the string can be visually truncated, but it should happen at the end of the string and not in the beginning. Because the software here thinks that the end is on the left, the beginning gets truncated instead. This is not exactly an issue that can be fixed just by completing the localization, but if the localization were complete, it would be easier to notice it.
There are other issues that you don’t notice if you don’t know Hebrew. For example, there’s a button with a weird label at the top right. Most Hebrew speakers will understand that label as “a famous website”, which is probably not what it is supposed to say. It’s more likely that it’s supposed to say “published web page”, and the translator made a mistake. Completing the translation correctly would fix this mistake: a thorough translator would review their work, check all the usages of the relevant words, and likely come up with a correct translation. (And maybe the translation is not even made by a human but by machine translation software, in which case it’s the product manager’s mistake. Software should never, ever be released with user interface strings that were machine-translated and not checked by a human.)
Judging by the logo at the top, the dental insurance company used an off-the-shelf IBM product for managing clients’ info. If I ask IBM or the insurance company nicely, will they let me complete the localization of this product, fixing the existing translation mistakes, and filing the rest of the bugs in their bug tracking software, all without asking for anything in return? Maybe I’ll actually try to do it, but I strongly suspect that they will reject this proposal and think that I’m very weird. In case you wonder, I actually tried doing it with some companies, and that’s what happened most of the time.
And this attitude is a bug. It’s not a bug in code, but it is very much a problem in product management and attitude toward business.
If you want to tell me “Amir, why don’t you just switch to English and save yourself the hassle”, then I have two answers for you.
The first answer is described in detail in a blog post I wrote many years ago: The Software Localization Paradox. Briefly: Sure, I can save myself the hassle, but if I don’t notice it and speak about it, then who will?
The second answer is basically the same, but with more pathos. It’s a quote from Avot 1:14, one of the most famous and cited pieces of Jewish literature outside the Bible: If I am not for myself, who is for me? But if I am for my own self, what am I? And if not now, when? I’m sure that many cultures have proverbs that express similar ideas, but this particular proverb is ours.
And if you want to tell me, “Amir, what is wrong with you? Why does it even cross your mind to want to help not one, but two ultramegarich companies for free?”, then you are quite right, idealistically. But pragmatically, it’s more complicated.
Wikimedia understands the importance of localization and lets volunteers translate everything. So do many other Free Software projects. But experience and observation taught me that for-profit corporations don’t prioritize good support for languages unless regulation forces them to do it or they have exceptionally strong reasons to think that it will be good for their income or marketing.
It did happen a few times that corporations that develop non-Free software let volunteers localize it: Facebook, WhatsApp, and Waze are somewhat famous examples; Twitter used to do it (but stopped long ago); and Microsoft occasionally lets people do such things. Also, Quora reached out to me to review the localization before they launched in Hebrew and even incorporated some of my suggestions.³
Usually, however, corporations don’t want to do this at all, and when they do it, they often don’t do it very well. But people who don’t know English want—and often need!—to use their products. And I never get tired of reminding everyone that most people don’t know English.
So for the sake of most humanity, someone has to make all software, including the non-Free products, better localized, and localizable. Of course, it’s not feasible or sustainable that I alone will do it as a volunteer, even for one language. I barely have time to do it for one language in one product (MediaWiki). But that’s why I am thinking of it: I would be not so much helping a rich corporation here as I would be helping people who don’t know English.
Something has to change in the software development world. It would, of course, be nice if all software became Freely-licensed, but if that doesn’t happen, it would be nice if non-Free software would be more open to accepting localization from volunteers. I don’t know how will this change happen, but it is necessary.
If you bothered to read until here, thank you. I wanted to finish with two things:
To thank Siebrand Mazeland again for doing so much to lay the foundations of the MediaWiki localization and the translatewiki community, and for saying that the fix is to complete the localization. It may have been an off-hand remark at the time, but it turned out that there was much to elaborate on.
To ask you, the reader: If you know any language other than English, please use all apps, websites, and devices in this language as much as you can, bother to report bugs in its localization to that language, and invest some time and effort into volunteering to complete the localization of this software to your language. Localizing the software that runs Wikipedia would be great. Localizing OpenStreetMap is a good idea, too, and it’s done on the same website. Other projects that are good for humanity and that accept volunteer localization are Mozilla, Signal, WordPress, and BeMyEyes. There are many others.⁴ It’s one of the best things that you can do for the people who speak your language and for humanity in general.
¹ And here’s another acknowledgement and reflection: This sentence is based on the first chapter of one of the most classic books about software development in general and about Free Software in particular: Programming Perl by Larry Wall (with Randal L. Schwartz, Tom Christiansen, and Jon Orwant): “Computer languages differ not so much in what they make possible, but in what they make easy”. The same is true for software localization platforms. The sentence about the end user wanting to get their job done is inspired by that book, too.
² I don’t expect them to have my name translated. While it’s quite desirable, it’s understandably difficult, and there are almost no software products that can store people’s names in multiple languages. Facebook kind of tries, but does not totally succeed. Maybe it will work well some day.
³ Unfortunately, as far as I can tell, Quora abandoned the development of the version in Hebrew and in all other non-English languages in 2022, and in 2023, they abandoned the English version, too.
⁴ But please think twice before volunteering to localize blockchain or AI projects. I heard several times about volunteers who invested their time into such things, and I was sad that they wasted their volunteering time on this pointlessness. Almost all blockchain projects are pointless. With AI projects, it’s much more complicated: some of them are actually useful, but many are not. So I’m not saying “don’t do it”, but I am saying “think twice”.
For search engine indexing and for understanding: Protobuf is frequently used with GRPC. Protobuf is how the requests and responses are serialized.
The Problem
Look at the output below. Printing protobuf messages using debug(‘%j’) produces unreadable output (the first one below).
$ DEBUG=myapp npx ts-node tojson.ts
myapp My object without toJSON {"wrappers_":null,"arrayIndexOffset_":-1,"array":[null,null,null,null,null,"Session name 01"],"pivot_":1.7976931348623157e+308,"convertedPrimitiveFields_":{}} +0ms
myapp My object with toJSON {"id":"","CENSORED4":"","CENSORED3":"","version":"","name":"Session name 01","CENSORED1":"","status":0,"CENSORED2":""} +1ms
Solution
Here is all you need to make it work. SessionResponse below is a sample message (export class SessionResponse extends jspb.Message in another file, after import * as jspb from "google-protobuf";)
// --- Setup ---
import {Message} from "google-protobuf";
import {
SessionResponse
} from "./PATH/TO/YOUR_GENERATED_PROTOBUF_FILE_pb";
import debug0 from 'debug';
const debug = debug0('myapp');
const req = new SessionResponse().setName("Session name 01");
// --- Test before ---
debug('My object without toJSON %j', req)
// --- Add this to your code --- start ---
declare module "google-protobuf" {
interface Message {
toJSON(): any;
}
}
Message.prototype.toJSON = function () {
return this.toObject();
}
// --- Add this to your code --- end ---
// --- Test after ---
debug('My object with toJSON %j', req)
Hope this helps. Let me know if you have questions.
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...
בשנים האחרונות אני רואה המון "תלונות" על שפת 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 מספר שימושים שונים, אלו הם העיקריים שבהם:
יצוג טיפוס נתונים משתנה- לפעמים מוכר בשם variant בעולם התכנות.
ליצור מבנה המייצג פונקציות למבנה נתונים או במילים אחרות ABI.
מי שמכיר שפות תכנות מונחה עצמים, מרביתן מכילות סוג "מחלקה" שהוא interface המתאר מה מבנה מחלקה אמור לממש בשביל להחשב שתומך באיקס. למעשה זה זהה לסעיף השני שציינתי.
הבעיה הראשונה היא שלא תמיד ידוע מראש איזה טיפוס נתונים מממש איזה interface. יותר מזה, בזמן כתיבה לא יודע אם טיפוס נתונים מימש בכלל את ה interface כמו שצריך – דבר שמגלים בזמן ריצה אם הקומפיילר לא תופס את זה בזמן קימפול.
אם בתיעוד אני לא אכתוב במפורש אודות המימוש, "אני" המתכנת לא יודע אם יש מימוש interface אלא אם פונקציה מסויימת מצפה ל interface כזה ובמקרה לטיפוס המידע שברשותי יש גם את כל פונקציות שיש בסוג ה interface שמצפים לו – דבר שאומר כי הוא מימש את אותו ה interface.
בעיה שנייה אני לוקח כערבון מוגבל, כי יכול להיות שאני מפספס משהו בהבנה שלי של המימוש של Generics (שהוא חדש מאוד בשפת Go) בשפה.
יש מצב שבו ניתן לקבל JSON שהוא מחרוזת בודדת, או רשימה של מחרוזות (אל תשאלו למה – משהו שנכפה עלי להתמודד איתו). לא ניתן ליצור מערכת כזו עם Generics. כלומר ניתן ליצור הכרזה של תמיכה לזה, אבל הכרזה של Struct לא תדע להתמודד עם הנושא, ולכן צריך לממש struct אחד לכל סוג המקרים ולבצע המון "עיקומים" להתמודדות עם הנושא. כלומר לא ניתן לדעת מראש מה ה JSON שיתקבל ואיך הוא יגיע אותו, ולמעשה ה generics לא פתר את הבעיה.
או במילים אחרות, למרות שיש תמיכה ב Generics הוא לא פתר את כל מצבי ה reflection שהיו עד אז בשפה, אלא רק חידד מצבים בהם לא צריך להשתמש ב reflection בזמן ריצה. ולדעתי התיעוד/לימוד של הנושא אינו נכון ומבלבל בין הסרת חוסר ב reflection לבין יצירת איזון מתי כל אחד צריך להגיע וכיצד לזהות את המצבים האלו.
יש עם זה כל כך הרבה בעיות שרק זה דורש סדרת פוסטים משל עצמו.
אבל הנה מספר רשימות קטנות:
ניהול זיכרון זה דבר נורא, ולא כזה ברור מה ואיך קורה במצבים מסוימים.
"מחרוזות" זו עוד בעיה קשה ולא ברורה תמיד איך להמיר נכון בין תווי 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 שעובד שונה מהשפה האהובה בשם כלשהו, או כי הוא מבצע דברים בצורה שונה, הפוסט הזה מנסה להציג דברים שבאמת מפריעים בעצמם מימוש השפה (ואם אבצע עוד פוסט אז יהיו דברים יותר על מימוש חבילות) עצמה ומקומות שדורשים לדעתי שיפורים משמעותיים.
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
Violin fully assembled
The design
Design cross-section in Soldworks showing the truss (in blue) that goes along the violin.
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 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.
Oleg’s pickup mounted on the violin
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.
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%.
A ukulele truss 330mm in length – the link is to the exact one I used.
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.
Metal-core violin strings (cheap ones seemed to do fine, but you could use D’Addario Hellicore too).
The Build
Sand any parts you want smooth, or use smooth-on XTC-3D.
Thread the truss along the body
Thread the electrical wire along the body and make sure to have slack on both sides
Electrical wire going along the neck, and grounding the strings at the head
Side view of the neck, the grounding wire of the strings is serviceable
Glue the parts together using the glue. Do this outside.
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.
Add the tuning keys and screw them in to place. You might need to drill the hole for the screws to go in smoothly.
Add in the chin rest and shoulder rest attachment.
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
This is the cool part about this violin – you can now adjust the truss to compensate for the strings warping the neck.
View of the pegbox, with an allen key in the truss adjusting the neck
Electronics – electric shield the box, install the pickup and solder the components using this diagram:
Diagram how to wire the pickup
Electronic box with copper shielding
Audio jack from the outside
Switch for parallel or serial pickup configuration
Electronics box closed
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.
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.
אני נתקל בכל כך הרבה מידע מוזר על הנושא של 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 כלשהו.
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.
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.
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
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.
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:
The shortest messages are found, unsurprisingly, in Chinese, Japanese, and Korean.
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.
Three more languages surprised me by being at the shoter 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.
English is at #22 out of 151, with an average length of 38.
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.
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.
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.)
Other language groups that tend to be longer are Slavic (Belarusian, Russian, Bulgarian, Polish, Ukrainian) and Austronesian (Sakizaya, Ilokano, Tagalog, Bikol, Indonesian).
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.
Turkish is only slightly above average with 44.1, at #88.
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.
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!
#
Language code
Average translation length
1
zh-hans
17.67324825
2
zh-hant
18.52284388
3
skr-arab
21.81899964
4
ja
24.67007612
5
ko
25.8110372
6
sd
27.71960396
7
mhr
28.95451413
8
ps
32.73647059
9
pnb
33.03592163
10
bgn
34.39934667
11
se
34.69274476
12
hy
35.02317597
13
su
35.37706967
14
th
35.52957892
15
ce
35.6969602
16
mai
36.02093909
17
lv
36.14100906
18
gu
36.59380971
19
bcc
36.64866033
20
fy
37.60139287
21
nqo
37.94138834
22
he
37.95259865
23
en
38.04300371
24
ar
38.18569036
25
ckb
38.66867672
26
min
38.71156958
27
ses
38.87941712
28
jv
38.94753377
29
is
39.0652467
30
alt
39.39977435
31
az
39.4337931
32
kab
39.50967506
33
tk
39.54990758
34
mr
39.72049689
35
as
39.72080166
36
sw
39.73986071
37
km
39.77591036
38
azb
39.92411642
39
nn
39.96771069
40
yo
40.00503291
41
io
40.0528125
42
af
40.1640678
43
blk
40.2813059
44
sco
40.33289474
45
diq
40.33887373
46
yi
40.34033476
47
ur
40.39857651
48
ug-arab
40.53965184
49
da
40.55894826
50
my
40.67551519
51
kk-cyrl
40.87443182
52
guw
41.07080182
53
mg
41.08369028
54
sq
41.23219241
55
fa
41.27007299
56
or
41.27020202
57
ne
41.33971151
58
rue
41.40219378
59
lfn
41.54527278
60
lrc
41.61281337
61
sah
41.63293173
62
vi
41.74578313
63
awa
41.84093291
64
hi
41.9257885
65
si
41.93065693
66
te
41.99780915
67
mn
42.18728223
68
lki
42.21091396
69
bjn
42.57961538
70
sr-ec
42.67730151
71
cy
42.75020408
72
frr
42.92761394
73
vec
43.00573682
74
sr-el
43.13764389
75
nb
43.34987835
76
krc
43.54919554
77
ms
43.5553814
78
hr
43.55564807
79
eo
43.57477789
80
nds-nl
43.59060895
81
ka
43.60108696
82
ban
43.64178033
83
bs
43.681094
84
tt-cyrl
43.78230132
85
xmf
43.80860161
86
et
43.96494239
87
ba
43.99432099
88
tr
44.17996604
89
bn
44.28768449
90
bew
44.44706174
91
sv
44.49027333
92
sa
44.58670931
93
cs
44.59026764
94
ta
44.62803055
95
mt
44.70207417
96
lt
44.7615
97
roa-tara
44.79812466
98
fit
44.79824561
99
dsb
44.9151957
100
hsb
44.96197228
101
br
44.98873461
102
sh-latn
45.00976709
103
fi
45.1222031
104
hu
45.17139303
105
sk
45.35804702
106
lb
45.39073034
107
li
45.5539548
108
id
45.56471159
109
gsw
45.63605209
110
sl
45.75350606
111
be
45.80325
112
oc
45.85709988
113
mk
45.90943939
114
bcl
45.97070064
115
scn
46.11905532
116
an
46.14892665
117
uk
46.22955524
118
qu
46.30301842
119
eu
46.33589404
120
lij
46.660536
121
pl
46.76863316
122
hrx
46.79802761
123
ast
46.87204161
124
nap
46.93783147
125
ru
47.02326139
126
bg
47.03590259
127
be-tarask
47.28525242
128
hif-latn
47.41652614
129
tl
47.51263001
130
rm
47.60741067
131
pms
47.69805527
132
pt-br
47.84063647
133
ca
47.92468307
134
ro
48.22437186
135
nl
48.4175636
136
ia
48.48612816
137
it
48.52347014
138
frp
48.54542755
139
gl
48.57820482
140
ml
49.12108224
141
es
49.21062944
142
pt
49.63085602
143
de
49.77225067
144
szy
49.84650877
145
shn
49.92356241
146
fr
50.15585031
147
lmo
50.85627837
148
ilo
50.9798995
149
el
51.14834894
150
gd
51.72994269
151
ksh
53.36332609
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)
השנה הכנס בהשתתפות ממציא שפת ++C, ביארנה סטרוסטרופ, בנוסף לשורה ארוכה של מרצים מעולים. לתוכניה המלאה: https://corecpp.org/schedule/ (הכנס מתקיים ביוני, 5-7 בסנימטק תל אביב, רחוב הארבעה 5)
מומלץ למהר ולרכוש, כי נותרו כרטיסים אחרונים בהחלט!
19:00 – 18:40 – הצגת הדוחות הכספיים לשנת 2022 ואישורם
19:20 – 19:00 – דיון פתוח בנושא יוזמות לפעילות העמותה
19:20 – סיום ופתיחת המיטאפ
במידה ובמועד שנקבע לא יהיה קוורום (רבע מכלל חברי העמותה), האסיפה תדחה בשעה ותתקיים באותם אמצעים, בכל הרכב שהוא (במקרה כזה הלו"ז מעלה עשוי להשתנות).
פרטים טכניים:
טיוטות הדוחות יועברו לעיון החברים לפני האסיפה. אנו מקווים שדיון עליהם, או על כל נושא אחר בסדר היום, יתקיים בפורומים של העמותה, בכתב, לפני האסיפה. זאת, הן משיקולי אסינכרוניות והן משיקולי חיסכון בזמן באסיפה.
משתתפי אונליין – לא תתאפשר הצבעה ללא הזדהות ויזואלית בוידאו, לכן, אנא בידקו את המצלמה טרם תחילת האסיפה.
חבר/ת עמותה שירצו להשתתף בהצבעות אך לא יוכלו להשתתף באסיפה, יוכלו לשלוח הודעת ייפוי כח לועד, המפרטת את ההצבעות, עם חתימתם (כן, הפיזית, מצולמת, על הדף שבו כתובות ההצבעות. לא חתימה דיגיטלית). למען הסר ספק, משתתפים באמצעות ייפוי כח לא יספרו לצורך קוורום, אלא רק יחשבו בהצבעות.
אנו מזכירים לכולם לשלם את דמי החבר לעמותה. הודעה על מצב התשלום תצא לחברי וחברות העמותה.
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.
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.
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.
השרת Next cloud אצלי גם שודרג מגרסה 23 אל 25 – וזה היה האתגר לשינוי. אני צריך את האפליקציה הזאת ב־next cloud והיא לא הייתה זמינה. גם לא קיבלתי עדכונים – כי גרסת php שלי הייתה נמוכה מדי..
השידרוג של דביאן היה פשוט. רק עדכנתי את /etc/apt/sources.list ואז עשיתי
apt dist-upgrade --auto-remove --purge
הבעייה היחידה שלי הייתה בהגדרות של nginx שבה הייתי צריך לשנות מיקום של php-fcm socket (היה טריויאלי).
לעומת זאת – שידרוג של next cloud כרגיל מאוד לא ישיר (קפצתי שתי גרסאות, וזה אומר לבצע שני שדרוגים..) ואחרי כל אחד מהם ללכת לשורת הפקודה ולייצר אידקסים של בסיס נתונים (occ עושה את זה…) ואז לאט לאט להשתיק את ההמצלות שלו… מעניין אם זה מעיק בכוונה תחילה.
לא יודע מתי תקראו את זה בעתיד, אבל פעם הייתה רשת חברתית סגורה אבל חביבה עלי בשם טוויטר. בא איש אחד בשם מאסק וקלקל אותה ופרחה לה בחזרה רשת מבוזרת כמו בימים הטובים של התחלת האינטרנט. מסטודון היה קילר אפפ שהופיע בדיוק בזמן לקלוט את חובבי המיקרובלוגינג שברחו מטוויטר וטאמבלר וצירף אותם לרשת סטטוסנט/אקטיביטי פאב שכבר כללה כמה תוכנות ניהול נוד רשתי (המקבילה של שרת דואר ברשת SMTP או שרת IRC וכולי). עכשיו אפשר לקרוא את הפרסומים שלי בתור הודעות ברשת הזו בזכות תוסף וורדפרס.
אז אם אתם מחפשים אותי כי לטוויטר אני נכנס פחות ופחות, אני @I
שרתי אקטיביטיפאב בעברית (מתוך אלפים שהוקמו) הם נכון להיום בעיקר על בסיס מסטודון אבל לא רק:
In addition to the aforementioned articles, I found the following SaaS services for converting Apache2.4 configuration files into Nginx configuration files.
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.
את הבלוג הזה אני כותבת שנים רבות (כולל גירסת הארכיב) – עוד משנת 2006 (עוד מהימים שהנאיביות שלי היתה בשיאה…). כתיבה בבלוג הזה עזרה לי ולאחרים מבחינת שיתוף מידע, מבחינת עבודה ומבחינות נוספות, ואם מאן דהו ישאל אותי איך הוא יכול לקבל חשיפה יותר גדולה בשביל העסק שלו או בשביל עצמו – אני עדיין יאמר שבלוג הוא פתרון מעולה, אם כי כדאי לחשוב גם על אופציות כמו יוטיוב ואולי אפילו אינסטגרם או טיקטוק, תלוי בתחום..
הגעתי למצב שבו יש לי בכל זמן נתון כ-9 בלוגים שאני מתחזקת, חלקם פתוח לציבור וחלקם מיועד לסקטורים מסויימים והתוכן לא זמין, ולכן החלטתי להתחיל לאחד דברים כך שאוכל להקדיש את זמני הפנוי לתכנים בכמות קטנה של ערוצים, ולהלן הסדר החדש:
בלוג זה – זה יהיה הפוסט האחרון. רשמית, "חץ בן חמו" כבר לא קיים יותר, אני בתהליך ולכן יש לי בלוג חדש שמתייחס לנושאים שכתבתי עליהם פה + דברים שקשורים למגדר ונושאים נוספים. אתם מוזמנים להוסיף אותו ל-RSS שלכם: הבלוג של דורין.
ערוץ "חץ ביז" – בניגוד למה שלא מעט חושבים, הערוץ לא בא לקדם את העסק שלי אלא בא לשתף מידע ותוכן על טכנולוגיות, פלטפורמות וכו' (ברוב המקרים העסק שלי אף אינו מוכר שרותים לחלק מהדברים המוצגים) – ערוץ זה ישאר
ערוץ Server Techs – ערוץ היוטיוב הטכני שלי בשפה האנגלית, גם כאן – מדובר על קליפים בנושאים טכנולוגיים בלבד ומיועד לצופים מכל העולם
ערוץ הפינה של דורין – זה הערוץ שיחליף את הערוץ "כמה מילים ברשותכם".
לסיכום: ערוצים ירדו, ערוצים אחרים יעודכנו, ואתם תוכלו לפי הדברים שמעניינים אתכם – לקבל את המידע ממני בכמות קטנה של אתרים וערוצים.
ברצוני לנצל הזדמנות זו בכדי להודות לכל הקוראים והמגיבים והמשתתפים. בלעדיכם – זה לא היה קיים, ולכן – תודה לכם
בעבר רציתי שעון חכם וקניתי שעון חכם שתומך ב־AsteroidOS. זה התברר בתור דבר פשוט מיותר… והחלטתי למכור את השעון. אני לא ממליץ על המערכת הפעלה הזאת, היא פשוט לא טובה.
אז יש בחור שהתחיל לעשות מכשיר חכם מאפס מאפס. קוראים לו פאול.
המיזם זמין בכתובת https://open-smartwatch.github.io . יש תרשימים סכימטים, קוד למערכת ההפעלה, קבצים למדפסות תלת מימד ועוד. יש גם חנות שבה אפשר לקנות את החומרה מוכנה – https://www.makerfabs.com/open-smartwatch.html . אני לא ממליץ – זאת הגרסה הראשונה שנראית מגעילה. הגרסה השקופה, בצבע שחור נראית לי הכי יפה, אבל גם הגרסה הלבנה (הדקיקה עם המסך ה”רגיל”) נראית משהו בהחלט שמיש.
רב התיעוד שמצאתי נמצא בווידאו הזה: https://www.youtube.com/watch?v=a6kkrQ26h_4 . נראה שפשוט צריך לבנות את הדבר הזה בעצמך נכון לעכשיו, זה מצריך גישה למדפסת תלת מימד בשביל המארז עצמו, להזמין כמה חלקים מדוד עלי, כלי הלחמה וסבלנות. חומרי הגלם עולים בערך 300₪. אם מישהו קונה ורוצה לבנות לי אחד – צרו קשר!
כנס GIS בקוד פתוח חושף את המגזר הציבורי לפתרונות הקיימים וליוזמות של גופים מקבילים. הדוברים/ות בכנס יציגו מגוון רחב של פרויקטים העושים שימוש בכלים השונים.
בשנים האחרונות אנחנו רואים מגמה של אימוץ GIS בקוד פתוח על ידי גופי ממשלה וגופים מוניצפאלים רבים, זאת בין היתר בעקבות האתגרים שהציבה מגיפת הקורונה לצד יתרונות טכנולוגיים ועסקיים בנושאי הסרת מגבלות רישוי תוכנה.
בכנס נדבר על מהו GIS בקוד פתוח והרלוונטיות לתפקידים שונים ברשויות המקומיות, וכיצד איך הוא בא לידי ביטוי בגופי הממשלה. מה ההבדל בין קוד פתוח למידע פתוח ואיך פותחים את המידע לציבור בצורה הנכונה. נציג פרוייקטי GIS שנעשו בזכות פתיחת מאגרי מידע לציבור. נראה גם יוזמות ממשלתיות בנושא מעקב והנגשת מידע אודות תחבורה ציבורית, כולל יכולת תחקור עבור כל הרשויות בארץ. כל אלה לצד היתרונות של קוד פתוח במעבר לענן הממשלתי (נימבוס).
אחד הדברים המבורכים בהפצות לינוקס – זו היכולת לקרוא את הדיונים לגבי שינויים שנעשים בהפצות לינוקס, דעות, בעד ונגד. במקרים רבים ישנם החלטות ודיונים פנימיים, אולם בד"כ התוצאות של הדיונים יוצאות בהודעה מסודרת ב-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, חברה בעלת מיליוני פטנטים (גם בתחום האודיו ו-וידאו, אגב), וחבל שברד-האט לא מנסים לבדוק את העניין לעומק ובמקום זאת מקשים על משתמשים חדשים בלי שום סיבה רצינית.
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...
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...
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...
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...
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...
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...
תוכנה חופשית היא דבר נפלא. אני מאוהב ברעיון כבר כ־28 שנה מאז גרקתי אותו לראשונה. ארגנתי קהילות ואירועים להפצת ידע על ואודות חופש התוכנה, ואי אפשר לזרוק היום אבן באף ענף כלכלי בלי להתקל בתוכנה חופשית רצה איפשהוא על שרת, עמדת חיוב כרטיסים בסופר וכמובן שכל האינטרנט וכל כיס מריצים תוכנות חופשיות למכביר. אין סטארטאפ שמתחיל היום בשוק וממציא לבד את כל הגלגלים, אם זה בתוכנה, ביולוגיה או כל תחום הנדסי, אתה תלוי בתוכנה, אם זה באסטרונומיה או מכונות CNC, תוכנה חופשית היא לפעמים החנות היחידה לשאוב ממנה את הכלים הדרושים למקצוע. מצד אחד אין להתעלם, ומהצד השני אין מנוס מלהשתמש. ההתנחלות הזו בלבבות וברשימות התלות של תוכנות היא חרב פיפיות, ובחודשים האחרונים אנחנו רואים כמה צרות שמאיימות על עתיד הקהילה.
אולי המכה הכי גדולה למוצר תוכנה היא נטישה שתוביל ל"רקבון ביטים". תוכנה שלא מתעדכנת לא מקבלת תכונות חדשות אבל גם לא נסתמות בה פרצות שמתגלות. אם יש לה עדיין משתמשים אז דברים ישברו, ובכל פעם שמשהו בעולם התוכנה החופשית נשבר ומשפיע על production של חברות מסחריות, התדמית נפגעת. לאחרונה אני רואה כמה ארועים שבאו ברצף:
חזרתו של RMS להנהלת המוסד לתוכנה החופשית הבאישה את המוסד בעיני רבים, והחלה נטישה מדודה אבל מורגשת של תורמים (אני בינהם) ופרויקטים בולטים, חלקם עמודי תווך של פרויקט GNU.
מוצרים כמו טראוויס ו־Docker שפתאום אינם בחינם יותר לפרויקטים רבים של תוכנה חופשית בשל שינוי מדיניול – מצב זה שובר הפצה של תוכנה חופשית קיימת, ועלול לגרום לאותם מוצרים לאבד משתמשים ותדמית. במקרה של טראוויס זה אומר שהרבה פרויקטים של תוכנה חופשית יאלצו לעשות בדיקות שכבר היתה להם אוטומציה בצורה ידנית או להתחיל לשכתב מחדש תהליכים כדי לעבוד מול כלי אחר, או להנטש ולהפוך לעוד גופה ללא עדכונים.
יש פרויקטים שנטשו או השאירו בבלגן פרויקטים ישנים אצל גיטהאב כשמיקרוסופט קנתה אותה, אבל זה כנראה מיעוט.
תזוזה קטנה ועוד אחת, מתי נענועי הסירה יהפכו אותה? הפחד שלי היא לולאת משוב ענקית שבה פתאום חברות יפחדו להשתמש במוצרים חופשיים או לתרום להם, מה שיגרום לאיבוד רוח מהמפרשים של מפתחים מתנדבים. בנקודות כאלו כדאי לזכור שהמתנדבים לא ממש מקבלים הרבה גב, חלקם אפילו לא יודעים איך לשווק את הפרויקט או לקבל תרומות גם אם ירגישו שנכון להם לבקש. המקרים של מפתחים כמו מארק סקוויירס מדאיגים אותי מאוד: בוקר אחד קם אדם ואומר לעצמו שלא משלמים לו מספיק אז הוא יתקע לכולם מקל בגלגלים (אני אפילו לא יודע אם הייתה דרך למישהו לשלם לו לפני שהתחיל להשתולל). בתגובה לא בלתי מוצדקת נחסמו לו חשבונות אצל גיטהאב ו־pypi. יש לי כמה דברים לומר למפתחים שהחליטו לפרסם קוד ברישיון פתוח – ראשית ציינו בצורה ברורה מה תנאי הרשיון (אי ציון רישיון ברור מטילה עליכם את האחריות אם למשתמשים נדפק משהו, וברירת המחדל איננה "נחלת הכלל"), ושנית היו מוכנים שיהיו לכם הרבה משתמשים מסחריים. אם לא מקובל עליכם, אל תירו לעצמכם ברגל, פצלו את הפרויקט לגרסא פתוחה ואחת סגורה בתשלום או כל דרך אחרת. לדחוף קוד ששובר את הספריה שלכם מבטיח גם נטישה של משתמשים וגם איבוד האמון בכם לעתיד, וכמובן פותח פחת לתביעות משפטיות אם הרישיון שלכם לא מצוין נכון.
ורק כדי להיות ברור: יש המון חדשות טובות בקהילה הזו, הפחד שלי הוא מהתדמית בעיני משתמשים מסחריים, שהפכו לחשובים מאוד בתהליך הפיתוח של כלים קטנים לפעמים. הקרנל של לינוקס ופרוייקטים מסביבו עדיין חיים ותוססים ושיפורים קורים השכם והערב.
— Filippo Valsorda @filippo.abyssdomain.expert (@FiloSottile) December 30, 2021
ומה הפתרון? אין לי תשובה. גם ככה הרשת שלנו הפכה בעשורים האחרונים לריכוזית מדי. כל הקוד העדכני בגיטהאב. כל הידע הטכני בסטאק אוברפלו. הרשת החופשית שהתאהבתי בה כמעט כבר לא קיימת, כשכל הידע והתקשורת קורים בין הכתלים של 10 חברות (אני נדיב) ולא בעשרות אלפי אתרים מבוזרים. אם מחר גיטהאב משנה תנאי רשיון, או סטאק אוברפלו פושטת רגל זו מכה רצינית מאוד לקהילת המשתמשים. אני למשל מחזיק בבית תלתפסת שכל הידע של קהילת המשתמשים שלה היה בגוגל פלוס, ויום אחד פשוט הוסר בלי יכולת לגבותו כראוי, ורק אחוז קטן ממנו שוחזר אח"כ לאתר עצמאי אחר.
מוזמנים לתת את דעתכם ופתרונותיכם פה בתגובות, רק אל תתחילו למכור לי בלוקצ'יין. דברים ישימים בלבד
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 […]
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 utilizesgh-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.
לוח האם מחבר בין כל חלקי המחשב, אליו מתחברים הרכיבים ודרכו הם "מדברים".
באיור 1 פירטתי את המחברים השונים שקיימים בלוח אם טיפוסי: ניתן לראות את שקע המעבד, את שקעי הזיכרון (RAM), שקע לכרטיס מסך, שקעי SATA (אליהם מחברים דיסק הקשיח / צורב).
אם אמשיל את המחשב למכונית אז לוח האם מהווה את השלדה של הרכב. כשם שלשלדת רכב מחברים את כל רכיבי המכונית כך ללוח האם מחברים את כל רכיבי המחשב. כשם שבמכונית ספורט עם מנוע פרארי לא תשימו שילדה של פיאט 850 כך גם בלוח האם: אם השקעתם במעבד יקר מן הסתם שתשקיעו גם בלוח אם איכותי (למרות שניתן להרכיב גם לוח אם פשוט).
בוחרים לוח אם מיד לאחר שקונים מעבד. אם קניתם מעבד של Intel תצטרכו לבחור בלוח אם שתומך במעבדי Intel (מהדגם הספציפי שקניתם), כנ"ל אם תקנו מעבד AMD.
אם ברשותכם מעבד ישן רוב הסיכויים שתתקשו למצוא לו לוח אם מתאים (כך שאם ברשותכם לוח מקולקל תתקשו למצוא לו תחליף: תוכלו לרכוש באתרים כגון Ebay, עם כל הסיכון הכרוך בכך, פחות בחנויות מחשבים רגילות)
בלוח האם מיושמת אלקטרוניקה "כבדה" שמאפשרת את עבודת המחשב. האלקטרוניקה הזאת מיושמת באמצעות ערכות שבבים הנקראים Chipset. יש Chipset זולים, שמתאימים למחשבים פשוטים, ויש יקרים יותר.
כל המעבדים החדשים של אינטל (דורות 8 ו- 9) מחייבים שימוש בציפסט מסדרה 300. ניתן לדרג את איכות הציפסט כך:
H310 < B360, B365 < H370 < Z370 < Z390
למה אני מייחס איכות?
מספר חריצי הרחבת זכרון (2 או 4)
יכולות המהרה
איכות כרטיס הקול
כמות יציאות USB
אפשרות לחבר SSD מסוג M2 ישירות ללוח האם
איכות הרכיבים (קבלים בעיקר) ואיכות הבניה כללית
כללי האצבע לבחירת לוח אם:
לוח מבוסס ציפסט H310 הוא הלוח הפשוט והזול ביותר. תבחר בו אם בחרת במעבד Intel Pentium
תבחר בלוח מבוסס ציפסט B360 או B365 אם בחרת במעבד Intel Core i3
תבחר בלוח מבוסס ציפסט H370 אם בחרת במעבד Intel Core i5
תבחר בלוח מבוסס ציפסט Z370 אם בחרת במעבד Intel Core i7
תבחר בלוח מבוסס ציפסט Z390 אם בחרת במעבד Intel Core i9
ההיגיון בבחירה הוא זה: אם שילמת 1500 ש"ח על מעבד אז בבקשה אל תקנה לוח אם שעולה 200 ש"ח… זה יעבוד, אבל כדאי מאוד להשקיע יותר ולהתאים את איכות הלוח לאיכות המעבד…
ל- AMD יש כמובן סדרות אחרות של ציפסטים אבל הרעיון דומה…
בטח תשאלו: למה מחשב צריך בכלל זכרון? למה הוא משמש?
הזיכרון הוא אזור העבודה של המעבד. כשאתם טוענים תוכנה (אופיס, מחשבון או כל תוכנה אחרת) התוכנה נטענת מהדיסק הקשיח לתוך אזור מסוים בזיכרון ושם היא רצה. מאחר שהזיכרון מאוד מהיר אז מעבר מתוכנה לתוכנה מתבצע כהרף עין (המעבד רק מדלג בין אזורים שונים בזיכרון). כשאתם מדליקים את המחשב גם מערכת ההפעלה עצמה נטענת לזיכרון ורצה ממנו.
כפי שניתן להבין, לזיכרון תפקיד קריטי בעבודת המחשב. תקלה ברכיב לא תאפשר עבודה שוטפת במחשב (הוא יקרוס, תראו מסכים כחולים והדבר היחידי שניתן יהיה לעשות זה לכבות אותו בכוח)
דרישת המינימום של חלונות 10 היא 2 גיגה בייט (2GB) זכרון.
מה זה גיגה בייט? גיגה זה מיליארד. אז 2 גיגה בייט זה 2 מיליארד תאי זכרון. בדרך כלל רוכשים 4 גיגה בייט זכרון (כשיש מגבלה תקציבית מאוד גדולה), 8, 16 או 32 גיגה בייט (למשתמשים הכבדים ביותר).
באיור 1 ניתן לראות כיצד נראה התקן זכרון של מחשב נייד. זכרון של מחשב נייח נראה דומה (רק הוא קצת יותר ארוך – איור 2).
קניית זכרון הוא תהליך פשוט יחסית. תפעלו לפי הכללים הבא:
1. "כמה שיותר הרי זה משובח…"
2. “קנו תמיד את הדגם האחרון"
היסטוריה: פעם השתמשו בהתקן זכרון שנקרא SDRAM. עם הזמן הוא שודרג ונקרא DDR. השנים חלפו, המהירויות גדלו וככה נוספו ספרות שונות לרכיב: DDR3, DDR2 ועכשיו מוכרים DDR4. אם תקראו את המאמר בעוד מספר שנים בטח יהיה DDR5 או DDR6. אתם תקנו תמיד את הדגם האחרון (DDR4 בזמן כתיבת המאמר).
בסעיף קודם כתבתי לקנות כמה שיותר זכרון אבל בכל זאת לא צריך להשתגע… מס' כללי אצבע לרכישת זכרון:
נפח 4GB: כשהתקציב מאוד לוחץ. מתאים לאדם שכל רצונו לגלוש מעת לעת במחשב (בלי הרבה לשוניות פתוחות), לערוך מסמכים ולשחק במשחקים פשוטים
נפח 8GB: נפח שמתאים לרוב האוכלוסיה ולרוב השימושים
נפח 16GB: מתאים לגיימרים, עורכי וידאו ופוטושופ
נפח 32GB: מתאים לגיימרים כבדים ועורכי וידאו מיקצועיים.
הערה:
הזיכרון עליו כתבתי הוא זכרון נדיף. זה אומר שהמידע שעליו נמחק ברגע שאתחלתם או כיביתם את המחשב (מידע קבוע נשמר רק בדיסק הקשיח)
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, […]
השליט העליון שכב במיטת בית החולים. הוא התקשה לנשום והתקשה לחשוב. את מעט הריכוז שעוד הצליח לגייס הפרו הצפצופים הדחופים של מכונות הניטור והחמצן. המחלה הארורה השיגה אותו לבסוף. כמו שהזהירו המדענים, החיסון לא עבד. הוא שמח כשנזכר שהורה על הוצאתם להורג. "מה הטעם במדענים", חשב לעצמו בלעג, "אם אינם מועילים בריפוי המגיפה?"
לאט לאט, הנהן בראשו להסכמה. הרופאים ביקשו להרדים ולהנשים אותו. לא היתה ברירה, הם אמרו. בלי זה, הוא לא ישרוד את הלילה. הנהונו גרם לפרץ של פעילות. רופאים ואחיות החלו בשרשרת של סידורים. השליט לא סמך על רופאות ואסר על לימודי רפואה לנשים כבר לפני שנים רבות.
לבסוף שככה הפעילות ורופא זקן ניגש אליו. השליט העליון לא ראה את הרופא הזה קודם אך על פי יחס שאר אנשי הצוות אליו השליט העליון הבין שהוא רופא בכיר. השליט העליון היה טוב מאוד בלקרוא אנשים ומצבים. משהו הטריד אותו ברופא הזה. הרופא הזקן התכופף. השליט העליון הבחין בתואר "פרופסור" על תג השם שלו, אבל לא הצליח להתרכז מספיק כדי לקרוא את השם המלא. הוא לא אהב פרופסורים.
הרופא הזקן הביט בשליט העליון ואז, מבלי להסיר את עיניו ממנו, הנהן. רופא אחר, צעיר יותר, נחפז אל השליט העליון והוא חש דקירה בזרועו. הרופא הזקן נפנף והרופא הצעיר התרחק במהירות.
השליט העליון חש לפתע קור. "מה זה?" ,חשב, "מישהו פתח את החלון?". לא הייתה זאת מחשבה הגיונית, כך ידע, אבל הוא מצא שקשה לו עוד יותר להתרכז. הוא חש עייף. הרופא הזקן התקרב עוד יותר אליו, הביא את פיו לאוזנו, ואמר משהו. השליט העליון ניסה מאוד להתרכז להבין מה נאמר. זה היה קשה מאוד. לבסוף הבין. פיו נפער, אבל אף בת קול לא יצאה. עיניו נעצמו.
אני מודע לכך שלא כתבתי יותר משש שנים ואני מקווה שמישהו עוד עוקב אחרי הבלוג. אבל לאחרונה קניתי מחשב חדש וכמובן שהתקנתי עליו ארץ׳ וחשבתי שתיאור התהליך יוכל לעזור למישהו. לי לפחות יוכל לעזור בעתיד לדעת מה בדיוק עשיתי.
למרות הכותרת המפוצצת, לא מדובר על מדריך מלא עם הסברים ובטח לא על מדריך פשוט של העתק־הדבק. חשוב להבין מה אתם עושים ובמחשבים אחרים ייתכן שהפקודות יצטרכו להיות שונות.
ביחד עם משבר הקורונה, אנשים רבים גילו כי לצד העבודה מהבית הרישיון לתוכנות ה-GIS שלהם נשאר במשרד. סדנאות ה-QGIS שלנו מיועדות למי שרוצה להשתחרר ממגבלות עולם ה-GIS הקנייני ולעבוד עם תוכנה ללא מגבלות על שימוש והתקנות וזאת מבלי לוותר על יכולות של התוכנה.
לצד סדנה בהתאמה אישית לארגונית (דרך zoom בתקופת הקורונה) המאפשרת גמישות מקסימלית של התכנים, אנחנו מפעילים סדנאות חודשיות עם תוכן קבוע. סדנאות QGIS שלנו ביוני 2020:
מה זה QGIS ופלאגאין עבור מידע ישראלי פתוח (17 ביוני, דרך Zoom)
סדנת מבוא ל-QGIS (14 ביוני, דרך Zoom)
סדנת QGIS למתכנני ערים (15 ביוני, דרך Zoom)
סדנאות המבוא מיועדות לאנשים שרוצים לעבוד עם מפות ולבצע ניתוחים מרחביים במסגרת תחומי העיסוק שלהם: כלכלנים, מהנדסות, אדריכלים, מתכננות ערים, אקולוגים, ארכיאולוגיות, גיאולוגים ועוד. הן מיועדת גם למי שלא מכיר GIS או מכיר ברמה בסיסית.
ניתן להשאיר פרטים בטופס ההתעניינות ונחזור אליכם עם פרטים וכיצד להרשם או להצטרף לניוזלטר החודשי שלנו כדי לקבל עדכונים על סדנאות עתידיות.
בכנס אייקון 2019 נתתי הרצאה על השורשים הבודהיסטים וטאואיסטים של מסדר הג'די מסדרת סרטי מלחמת הכוכבים. ההרצאה ההיא לא הוקלטה אבל בצוק העיתים וברוח הנדיבות עשיתי שחזור שלה בזום עם כמה א.נשים אמיצים והנה התוצאה לפניכם.
בהרצאה משולבים מספר קטעים קצרים (לצד הסברים שלי) מסדרת הסרטים והזכויות להם שייכים כמובן לחברת דיסני. השימוש בקטעים הוא לצרכי ביאור ונעשה בהבנה שהשימוש נופל תחת החרגת השימוש ההוגן של חוק זכויות היוצרים הישראלי.
מעבר לכך בסוף ההרצאה יש קטע בונוס מיוחד – גילוי של גלגולו הנוכחי של יודה, כאן ועכשיו!
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
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.
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
It is a very bad idea to run database (especially production one with lots of I/O) on BTRFS because the filesystem at any random time might become readonly:
Oct 24 12:30:22 db02 kernel: BTRFS: error (device nvme0n1) in btrfs_run_delayed_refs:2936: errno=-28 No space left Oct 24 12:30:22 db02 kernel: BTRFS info (device nvme0n1): forced readonly
And then you find that you need to do rebalance. You try and find out that rebalance can not be done because - you guessed it - there is no space left. They suggest to delete couple of snapshots though. You delete them, start rebalance and now the whole filesystem is stuck completely.
If you need HA mysql db with snapshots, then you should go with mysq/LVM/DRBD path, see this link for insight: https://rarforge.com/w/index.php/2_Node_Cluster:_Dual_Primary_DRBD_%2B_CLVM_%2B_KVM_%2B_Live_Migrations
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?
את היום הראשון של הכנס פתחתי כרגיל בדוכן הרשמה (front desk) והייתי שם עד הצהרים כדי שהצוות ירשום את הגל אנשים שהגיעו.
לצערי הכנסים של דביאן נפתחים מאוד בעצלתיים מבחינת תוכן – יש הרצאת/טקס פתיחת ואחרי אין ישר רצף גדול של הרצאות אלא טפטוף קטן של נושאים והרצאות. קצת מאכזב מבחינתי. ומצד שני, אפשר לי להתחיל לעבוד על החבילות של עברית בדביאן בלי לדאוג לפספס תוכן כלשהו. אבל לפני שאפשר לעבוד על החבילות, צריך לייצר סביבה מתאימה. לקח לי זמן להוריד חלודה לגבי מה צריך, ואיך לייצר משהו שיודע לבנות בתוך chroot (גם כדי שהבניה תהיה נקייה, וגם כי אני משתמש ב-testing בעוד שהבניה נעשית ב-unstable). בעזרת כמה תזכורות מ-Bálint הכל הסתדר, ויש סביבה עובדת עם sbuild.
השלב השני היה להתחיל להמיר את ההיסטוריה של הצוות מ-SVN ל-GIT ואז לדחוף את זה לשרת ה-GitLab החדש של דביאן. עשיתי את זה בנפרד עבור כל חבילה, כאשר הראשונה בתור היא Hspell כי צפריר הספיק להכין את הרוב מראש. ואחר כך עבדתי על המרת Culmus כי לא הייתי רוצה שהגרסה הבאה תצא בלי פונטים בעברית (על הדרך כבר הועלתה גרסה 0.132). כל המאגרים זמינים תחת Debian Hebrew Packagers בכתובת https://salsa.debian.org/hebrew-team . למי שצריך לעשות משהו דומה, הכלי להמרה היא git svn clone ואפשר להשתמש בהוראות שיש באתר git-scm.com בכתובת https://git-scm.com/book/en/v2/Git-and-Other-Systems-Migrating-to-Git . על בסיס הפקודות שלהם עוד עשיתי כמה שינויים קלים, אבל החלקים החשובים נמצאים שם.
בין לבין שמעתי את הדיווח השנתי של Chris Lamb במסגרת תפקידו כ-Debian Project Leader. בין השאר גיליתי שם כי דביאן תחגוג השנה יום הולדת 25 באמצע אוגוסט, וישר החלטתי לפתוח event כדי לחגוג עם עוד אנשים. נתראה שם בקרוב (: בנוסף, גיליתי כי המעבר של דביאן ל-GitLab נובע בין השאר גם מהשינוי שלהם בנושא ה-Content License Agreement ושינוי ל-Developer Certificate of Origin מה שמאפשר ליותר אנשים לתרום קוד בלי לוותר על הזכויות שלהם או לקרוא מסמך משפטי כבד. שאפו ל-GitLab, ואיזה כיף לעבור לעבוד במערכת מתקדמת.
הכנס השנתי של דביאן, Debconf, מתקיים השנה בפעם הראשונה באסיה (Hsinchu, Taiwan). הישג מכובד לאחר שנים של אירופה / ארה"ב ולפעמים דרום אמריקה. וגיוון מבורך בהמשך לכנס בדרום אפריקה לפני שנתיים. כלומר הפעם טסים לכנס מזרחה ולכן גם כולם סובלים מג'ט לג חמור יותר. לצערי זה גם גרם לי לתרום הרבה פחות בדוכן הרשמה (front desk) למרות שזה אחת ההתנדבויות הקבועות שלי.
היום הפתוח התנהל בחלקו בסינית, כך שאפילו לא ניסיתי ללכת להרצאות (גם לבודדות שהיו באנגלית), ובמקום זה התמקדתי בקצת שיחות עם אנשים (למרות העייפות). הספקתי לדבר עם Bálint Réczey שעובד עבור Canonical בצוות Ubuntu Foundation שאחראי על הסנכרון עם דביאן והתרומה של שינויים לקהילה. גם ניצלתי את ההזדמנות כדי לשמוע באיזה כלים הם משתמשים בפעילות, כדי לתזכר את עצמי. אחרי כמעט שנה שלא נגעתי בחבילות, אני בהחלט חלוד (וגם צריך לסדר את סביבת העבודה על המחשב). אגב, קנוניקל מחפשים אנשים עובדים, אם מישהו מתעניין, צרו קשר בפרטי (יש אפשרות לעבוד מרחוק, ואוכל לעזור בסידורים הנדרשים).
בהמשך הערב ישבתי על באג שדיווח לקוח על פיצ'ר של PHP שלא עובד לו מול OpenSSL. תפסתי את Kurt Roeckx שאחראי על החבילה בדביאן וגם עושה עבודת upstream בכמה שנים האחרונות כדי לבדוק את הנושא. אחרי קצת שאלות מולו ובדיקות שלי הסתבר שהבעיה היא לא ב-OpenSSL אלא ב-PHP, ואחרי מספיק חיטוטים בקוד נפתח באג #76676.
לאורך היום יצא לי להכיר את הלן (Helen Koike), בחורה נחמדה שסיפרה שהיא לא מעורבת מאוד בדביאן, ובאה ללמוד קצת כי היא הולכת לעזור לצוות המארגן של שנה הבאה. תייגתי אותה כעוד מישהי שעושה עבודה כללית ולא משהו טכני (הקהילה מורכבת גם מכאלה) והמשכתי הלאה. יותר מאוחר בערב, בשיחה רנדומלית גיליתי שהיא עשתה פעילות על הקרנל במסגרת Outreachy, תרמה דריברים, עובדת ב-Collabora בצוות שמתעסק עם הקרנל וכו'. היא פשוט צנועה לאללה. ניסיתי לדחוף אותה לתרומה בצוות קרנל של דביאן והיא אמרה שהיא לא יודעת לארוז חבילות. הסברתי לה שהיא יודעת לתקן באגים בקרנל, וזה תרומה משמעותית לצוות. בנתיים מישהו אחר יכול לארוז. ויותר חשוב לתקן באגים.
במקביל, למדתי כמה מהר אנחנו מתייגים אנשים לפי המקום שנוח לנו לתייג אותם. ומצד שני, שיש אנשים (ויתכן שבעיקר נשים) שהם סופר צנועים ולא מספרים על כל הפעילות והיכולות שלהם וכך דברים מתפספסים (ברושם הראשוני ומעבר).
לסיום הערב, עשיתי תיאום עם צפריר לגבי החבילות של עברית בדביאן שדורשות תשומת לב בעקבות מהעבר מ-Alioth ל-Salsa שעל הדרך סגר את רשימות התפוצה הצוותיות וגם מכריח את כולם לעבור ל-GIT. כאשר המטרה היא לעשות את המיגרציה, לתקן את הבאגים שדווחו מולן כתוצאה מכך, שגם מונעים מהן להכנס ל-testing (ולכן לגרסה הבאה של דביאן). והדבר משמעותי, כי תהליכי ה-freeze מתחילים בספטמבר. בסופו של דבר, אני הולך להקדיש את הזמן לחבילות, בעוד שצפריר יתעסק בדברים אחרים שלו. שזה סה"כ הוגן, כי במהלך השנה לא יצא לי לתרום כלום לתחזוקת החבילות האלה.
מי שרוצה לעקוב אחרי הכנס מרחוק, אז הלוח זמנים נמצא בכתובת https://debconf18.debconf.org/schedule, רק לא לשכוח שהכנס מתקיים באזור זמן +8, כלומר 5 שעות לפני ישראל (ריאלית, אפשר לצפות בהרצאות של אחרי ארוחת הצהריים כאן, שזה 9 בבוקר בישראל).
After serving in the board of a few technological Israeli associations, I decided to run as an individual candidate in the OSI board elections which starts today. Hoping to add representation outside of North America and Europe. While my main interest is the licensing work, another goal I wish to achieve is to make OSI more relevant for Open Source people on a daily basis, making it more central for communities.
This year there are 12 candidates from 2 individual seats and 5 candidate for 2 affiliate seats (full list at OSI elections wiki page). Wish me luck (:
