תרגום להמון שפות, לעיתים קרובות שפות ממש לא צפויות, הוא קטע שמאפיין הרבה דתות, או זרמים בתוך דתות גדולות יותר. מורמונים, ג׳הווז ויטנסז, סיינטולוגיה, הארה קרישנה, אחמדיה – כל אלה עושים המון תרגום.
גם בברית המועצות, במיוחד בשנות ה־20, נעשתה עבודת תרגום ענקית של כתבי לנין ומרקס להמון שפות, שבחלק מהן מדברים פחות מעשרת אלפים אנשים. מרקסיזם־לניניזם הוא רעיון אתאיסטי כשלעצמו, אבל שמעתי סוציולוגים רבים שמתארים אותו בתור תנועה מעין־דתית, שהחליפה את הדבקות של ממשלת רוסיה המונרכית בנצרות אורתודוקסית.
וככל שאני חושב על זה יותר, תרגום להמון שפות הוא לא דבר הגיוני כל־כך, לפחות לא לפי הגדרות מסוימות של היגיון. תרגום לכמה שפות גדולות ושימושיות הוא דבר מתבקש במקרים רבים, אבל אפילו את זה מוסדות שמתנהלים לפי היגיון עסקי טהור עושים רק כשיש בזה צורך אמיתי.
נגיד, הניו יורק טיימס פרסמו פעם מהדורות שלמות בסינית ובספרדית, שהן שפות גדולות ומבוקשות לכאורה, והחליטו לוותר על זה. היום הם מפרסמים כתבות בשפות שאינן אנגלית רק כשיש קשר בין השפה לבין נושא הכתבה וגם זה במקרים מיוחדים ונדירים. אותי זה מצער, אבל ליעדים העסקיים שלהם זה כנראה טוב. ויש לי עוד הרבה דוגמאות לחברות שתמכו בתרגום מסיבי וצמצמו את זה או ויתרו לגמרי: טוויטר, מדיום, קווֹרה ואפילו דואולינגו.
אז כשם שאמונה דתית היא לא דבר הגיוני לגמרי, ככה גם תרגום מסיבי.
וזה מסביר למה ויקיפדיה יכולה להיות מה שהיא רק בתור מוסד ללא כוונת רווח. היא ממש לא ארגון דתי, אבל היא כן מבוססת על רעיון ללא כל מטרה עסקית: 100% ידע חופשי ו־0 הכנסות לבעלי מניות. כלומר, פשוט אין שם בעלי מניות. הרעיון הזה הומני לגמרי, ועצוב לי לומר שהומניזם הוא דבר „לא הגיוני”, כי זה אמור להיות הדבר הכי הגיוני שיש. בגלל זה כתבתי „לפי הגדרות מסוימות של היגיון”. אילו היה בה רעיון עסקי, לא היו בוויקיפדיה יותר מ־300 שפות, אלא 20 במקרה הטוב, או 1 במקרה הכי סביר.
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:
bluetooth
service:$ sudo systemctl edit bluetooth
This command will create the file /etc/systemd/system/bluetooth.service.d/override.conf
.
[Service]
ExecStart=
ExecStart=/usr/libexec/bluetooth/bluetoothd --experimental
Note that both ExecStart=
lines are required.
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
:
# deny access to all dotfiles
location ~ /\. {
deny all;
log_not_found off;
access_log off;
return 404;
}
# Allow access to the ".well-known" directory
location ^~ /.well-known {
allow all;
}
# deny access to files ending with ~ or .bak
location ~ ~$ {
deny all;
log_not_found off;
access_log off;
return 404;
}
location ~ \.bak$ {
deny all;
log_not_found off;
access_log off;
return 404;
}
location ~ /dump.sql$ {
deny all;
log_not_found off;
access_log off;
return 404;
}
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. בעולם הלינוקס המצב נותן מגוון רחב של סטנדרטים
אני יודע שימי מלחמת הפצות לינוקס כבר פחות מעניינים - כי כולם בסופו של דבר +/- אותו הדבר. אבל החלטתי להיזכר מה הייתה הדרך שלי.
התחלתי עם Fedora 3 - הנתנה לי הרגשה מה זה לינוקס מודרני (אז). אבל מהר מאוד התייאשתי - כי הרעיון לשדרג כל 6 חודשים להפצה חצי יציבה - כי זו מעבדתי ניסויים של Red Hat - לא קסם לי.
המשכתי ל־Debian - ה־stable אז היה ממש ישן עברתי ל־testing שאומנם עבד אבל... היה קשה וגם חיכיתי המון לגרסה "יציבה" שהייתה ישנה עם ההגעה.
כשרכשתי מחשב מחדש 64 ביט התקנתי עליו גרסת LTS הראשונה של Ubuntu 6.06 ומשם בבית אני עם גרסאות LTS - למה? כי לא בא לי להתעסק יותר מידי בלינוקס.
בעבודה עבדתי עם RHEL וגם עם CentOS וגם עם גרסאות שונות ומשונות של Ubuntu. שורה תחתונה. זה עובד וזהו. לא משנה מה.
העיקר שיהיה יציב שלא ישגע עם שדרוגים יותר מידי ויעבוד. ונחמד כשזה נתמך ע"י תוכנה מסחרית
שוחררה rusmux 0.6 עם תיקון באג, זוג שמות פקודה חדשים ותמיכה באפשרויות פר-חלון ב־tmux.
בוקר טוב.
מזה זמן רב שלא כתבתי כאן. אני מקווה לחזור ולכתוב מפעם לפעם.
כפי שידוע לכם, אני עוסק מזה למעלה מעשור בתרגום 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/.
תודה,
יוסף אור
בשם צוות תרגום GNOME לעברית
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.
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:
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:
Some things are demotivating when working on the project. Here they are and how I handle the ones that I know how (after “//”).
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.What motivates you? What demotivates you and how you handle that? Share in the comments.
Have a nice day!
לאחר מספר שנים, שחררתי את python-bidi 0.5, אשר מבוססת הפעם על Rust crate בשם unicode-bidi.
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:
¹ 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.
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
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.
This blog post describes how to mount an encrypted array of bcachefs disks at boot time. continue reading...
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 שנים עם השפה לכתוב מה אני פחות אוהב, ואני מפריד בין שפה, ספריות המגיעות עם השפה (יש המון כאלו) וכן גישה או אפילו בעיות תיעוד.
זו לא רשימה מלאה, אבל כן רשימה שלדעתי מפריעה להרבה אנשים במצבים שונים.
כאשר חושבים על coroutines (ב go השם או המונח הוא goroutines) יש יכולות לקבל יכולת לתקשר בצורה מאובטחת (מבחינת threads) עם משתנה מסוג channel שעליו מרכיבים טיפוס נתונים כלשהו.
זוהי מחסנית של מידע, אשר נהפת לזמינה רק כאשר יש מה לקבל, וכל עוד אין, הthread במצב של blocking (יש יכולת להתמודד גם עם זה).
ניתן "לסגור" את ה channel ואז ההקצאה שלו למעשה משוחררת וניסיון לעבוד איתו יגרום ל runtime error.
עד כאן הכל בסדר.
מה שמפריע לי זה שאין יכולת לבדוק האם channel סגור ללא לקחת את המידע ממנו.
כלומר אני רוצה להשתמש ב channel רק אם channel לא סגור, ואם ה channel סגור, אני למשל רוצה לצאת מפונקציה או ללכת למקום אחר בקוד או לא משנה מה… העיקר שאוכל לבדוק את המצב הזה ללא חילוץ מידע.
בשפת Go יש משהו הנקרא interface. למונח של interface מספר שימושים שונים, אלו הם העיקריים שבהם:
מי שמכיר שפות תכנות מונחה עצמים, מרביתן מכילות סוג "מחלקה" שהוא interface המתאר מה מבנה מחלקה אמור לממש בשביל להחשב שתומך באיקס. למעשה זה זהה לסעיף השני שציינתי.
הבעיה הראשונה היא שלא תמיד ידוע מראש איזה טיפוס נתונים מממש איזה interface. יותר מזה, בזמן כתיבה לא יודע אם טיפוס נתונים מימש בכלל את ה interface כמו שצריך – דבר שמגלים בזמן ריצה אם הקומפיילר לא תופס את זה בזמן קימפול.
אם בתיעוד אני לא אכתוב במפורש אודות המימוש, "אני" המתכנת לא יודע אם יש מימוש interface אלא אם פונקציה מסויימת מצפה ל interface כזה ובמקרה לטיפוס המידע שברשותי יש גם את כל פונקציות שיש בסוג ה interface שמצפים לו – דבר שאומר כי הוא מימש את אותו ה interface.
בעיה שנייה אני לוקח כערבון מוגבל, כי יכול להיות שאני מפספס משהו בהבנה שלי של המימוש של Generics (שהוא חדש מאוד בשפת Go) בשפה.
יש מצב שבו ניתן לקבל JSON שהוא מחרוזת בודדת, או רשימה של מחרוזות (אל תשאלו למה – משהו שנכפה עלי להתמודד איתו).
לא ניתן ליצור מערכת כזו עם Generics. כלומר ניתן ליצור הכרזה של תמיכה לזה, אבל הכרזה של Struct לא תדע להתמודד עם הנושא, ולכן צריך לממש struct אחד לכל סוג המקרים ולבצע המון "עיקומים" להתמודדות עם הנושא.
כלומר לא ניתן לדעת מראש מה ה JSON שיתקבל ואיך הוא יגיע אותו, ולמעשה ה generics לא פתר את הבעיה.
מה שניתן לעשות זה עדיין צריך להשתמש ב interface גנרי ולא ב Generics אשר תומך בשני המקרים, ואז צריך לעבוד המון עם reflection (התמיכה שיש ב Go היא מדהימה) בזמן ריצה ולבצע משחקים ולהחליט איך לתרגם את המצב הזה.
או במילים אחרות, למרות שיש תמיכה ב Generics הוא לא פתר את כל מצבי ה reflection שהיו עד אז בשפה, אלא רק חידד מצבים בהם לא צריך להשתמש ב reflection בזמן ריצה. ולדעתי התיעוד/לימוד של הנושא אינו נכון ומבלבל בין הסרת חוסר ב reflection לבין יצירת איזון מתי כל אחד צריך להגיע וכיצד לזהות את המצבים האלו.
אסיים את הפוסט בנושא הזה.
כאשר רוצים לדבר עם ספרייה חיצונית (דבר שמאוד לא מומלץ על פי יוצרי השפה – בעיה ראשונה), ניתן לבצע binding באמצעות "חבילה" ווירטואלית בשם C. ה"חבילה" הזו מתממשקת למשהו הנקרא cgo ואיכשהו במטה קסם יש סוג של binding.
יש עם זה כל כך הרבה בעיות שרק זה דורש סדרת פוסטים משל עצמו.
אבל הנה מספר רשימות קטנות:
הרשימה לא מסתיימת כאן, אלא כמו שאמרתי, ניתן ליצור סדרת פוסטים שלמה בנושא עם הדגמות.
עוד לא התחלתי לדבר על כל הדברים שמפריעים לי, וניתן לראות שהם קיימים.
הפוסט עצמו נהיה ארוך, ואולי אעשה חלק שני או יותר עבורו (עוד לא החלטתי נכון לכתיבת פוסט זה).
העניין הוא שבניגוד להמון פוסטים שתוקפים את Golang שעובד שונה מהשפה האהובה בשם כלשהו, או כי הוא מבצע דברים בצורה שונה, הפוסט הזה מנסה להציג דברים שבאמת מפריעים בעצמם מימוש השפה (ואם אבצע עוד פוסט אז יהיו דברים יותר על מימוש חבילות) עצמה ומקומות שדורשים לדעתי שיפורים משמעותיים.
תכנות נעים
Hey all,
In the past years I have had an ongoing project – I wanted an ultra-light modifiable electric violin. And finally I can share it with you.
This violin, weighs with all the parts on just 500 grams, which is the same as my acoustic violin. Moreover, the center of mass is close to the player making the violin feel lighter than an acoustic when playing.
This is made possible by an innovation I came up with, and have not seen anyone else do – The violin uses a truss like the one in a guitar neck, letting you balance the weight of the strings and tune the neck. This means that the violin can be printed with just a 15% infill making it ultra light (pegboard box at 20%).
I am not planning to start a violin-building business, so I see no reason to keep this to myself and I am releasing it. I ask you to give me some attribution, and consider releasing your design too. And perhaps a violin
This is the end result
I made the design with the help of several mechanical engineers that I want to thank – Tal Reindel, Michael Lev-Ari Layoush, Itai Meshorer, and Don Corson. Also want to take the opportunity to thank Yair Grinberg, Oleh Shevchuk. It’s also based on the ElVioin v2 which is under the Creative Commons – Attribution – Share Alike license. So you can use it, share it, modify it and even sell it. But our particular design must also be released under the same license.
You can download the design files here.
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.
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.
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.
Here is a link to the 3D parts on printables and (soon on thingiverse).
I would really appreciate any input to the design. Here is a list of things that I know could be done better
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.
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 הוא כרטיס "חכם" הנקרא גם java-card ומכיל מספר יכולות – כדוגמת מידע "צרוב" קבוע, ומידע צרוב שיכול להשתנות וכתוב בשפת Java עם ספריות יעודיות עבורה המיוצרות על ידי חברת אורקל והחומרה מיוצרת על ידי מספר קטן של חברות.
גם כרטיס אשראי הוא סוג של java-card ברעיון דומה, אך עם מידע שונה (אין לי ידע בנושא הזה ולכן לא יכול להרחיב).
כאמור, עבור כרטיס ה SIM ישנן מספר קטן של יצרניות בעולם (אשר נכנסו גם לעולם ה eSIM – אכנס לזה בסעיף של eSIM בפוסט).
כל ספק סלולרי מספק מפתחות הצפנה לשיחות הצרובות בכרטיס ועוד מספר דברים, כולל תוכנות והגדרות עבור מכשיר הטלפון.
כאשר מכשיר הטלפון עולה הוא "פותח" את המידע הזה מחלק נעול בכרטיס, קורא ומגדיר דברים בהתאם.
לאחר העליה המתאימה, ניתן לבצע פעולות כדוגמת Provisioning על ידי שימוש בהודעות SMS אשר המכשיר יודע לקרוא, ורובן לא מגיעות לבני האדם לקריאה. פעולה זו של שליחת המידע נקראת OTA – Over The Air.
ה OTA מעדכן גם את כרטיס הSIM כולל הגדרות ואפילו תוכנות שונות.
היות ו SMS מכיל מעט מאוד מידע יחסית, זה יהיה ב chunks שונים בהתאם לסוג ותוכן המידע, וכך גם מקבלים גרסה חדשה לדברים בהתאם לצורך.
השימוש ב OTA זו הסיבה מדוע הודעות SMS כל כך חשובות ברשת סלולרית, והסיבה לבקשת אתחול טלפון לאחר מכן, היא לפתוח מחדש את כל המידע – דבר אשר אינו מתבצע עם Flight-mode.
המונח eSIM הוא מונח לכרטיס פיזי היושב על מודם סלולרי (לרבות טלפונים). האות E בנושא היא עבור המילה Embedded.
למעט הצורה הזו, הוא נועד לבצע את אותה הפעולה כמו כרטיס ה SIM, אבל בצורה מעט שונה (ללא תוכנות נלוות עד כמה שאני יודע, אבל כן להגדרות).
ישנן שני "מסלולים" עבור מערכת ה eSIM:
היות וישנם שני מסלולים, ההתנהלות לכל מסלול מעט שונה.
כאשר ה OTA היא במערכת אינטראקטיבית, חייבים גישה כלשהי לרשת האינטרנט על מנת "להוריד" פרופיל ולהפעיל אותו.
זוכרים את יצרניות כרטיסי ה SIM? ובכן, הן מספקות מערכת OTA לשם כך, ולוקחים כסף על כל "הורדה" של פרופיל שכזה דרכם.
כאשר מדובר במערכת אשר אינה יכולה לקבל התערבות אנושית, הפרופיל נצרב בכרטיס ה eSIM ולא משתנה לאחר מכן.
בד"כ ה OTA מתבצע על ידי קריאה של מחרוזת המסופקת על ידי QR-Code.
המחרוזת היא URI של פרופיל הנקרא LPA – Local Profile Assistants.
הדבר הבא במידע יהיה כתובת מערכת ה provisioning עם איזשהו מפתח שהמערכת (SM-DP+) תזהה את הבקשה.
הצלחה של "הורדת" ההגדרות, מחוייבת לרוב בתשלום על ידי ספקיות חיצוניות לספק הסלולרי שלכם, ובמידה ויש בעיה, לרוב חוסמים את האפשרות להוריד בשנית (או לאחר כמות מוגדרת) את הבקשה, או מחייבים את הלקוח בהורדה נוספת.
לאחר ההורדה, המכשיר יאפשר להפעיל את הספק החדש.
עבור מערכת IoT קטנות במיוחד הדורשות System On a Chip, נוצר תת מעבד של eSIM בשם iSIM שהוא למעשה eSIM לכל דבר, אבל עבור סביבה מוגדרת. האות i מייצגת את המילה Integrated.
משום מה, iSIM מוגדר על ידי כל כך הרבה כ"מתחרה" של eSIM – אבל הוא למעשה עדיין מאותו "בית" (ארגון gsma) ואותו סטנדרט של eSIM, רק החומרה עצמה שונה לגמרי עבור צרכים אחרים מאשר הכרטיס הרגיל אשר עומד בפני עצמו, ואינו שייך ל SoC כלשהו.
זהו בקצרה ובפשטות על הנושא.
Hey all,
The past year I’ve been playing pretty active on federated social networks. This led me to try and write a federated social network group system. Although this group system is far from being complete since Fedigroup is currently in pre-alpha level. I think it is worth sharing what I have learned, and also explain a bit why, if you met me during the past three years. I’ve been going about federated social networks.
You are also welcome to join a server I maintain here, Hayu.sh is the second largest Hebrew-speaking instance.
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).
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.
I was asked this by other developers and power users. It makes people dismiss the Fediverse as a passing or niche thing.
Unlike Facebook, Twitter even if you’re been avoiding social networks, their marketing will reach you, your news channel, municipality and country are likely using them. Their existence depends on it that you use and browse on their site. However, in the Fediverse does not have a business model that demands it. Or a marketing team. Its just people. You are welcome to join, but no ones income depends on it.
The Fediverse is growing though, by word-of-mouth, or text-in-blog. Recently even celebrities and others. The latest are the BBC, PNAS, George Takei, Neil Gaiman, Stephen Fry and the European Commission.
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.
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.
I stopped developing it because it was far too much work only for me. It might pick up if someone joins me, but alone I will not manage to make it as good as others out there. It has potential as being a place to search for history on the Fediverse which is a little challenging today.
Also I think the recent migration of Reddit users show that the Fediverse is handling groups pretty well.
Still, Fedigroup was a good learning experience on how the technology works, and I think its worth sharing if you want to build a Federated instance that uses python, FastAPI and PostgreSQL.
If anyone wants to pick up where I left they are welcome. The source code is available on GitHub.
There is a running instance at: https://fedigroup.party
You welcome to try it out and as always – code contributions are welcome
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:
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)
תודה לכל מי שנרשם לקבלת כרטיסים, וברכות לזוכים המאושרים!
אם לא זכיתם בכרטיס חינם, מוזמנים לרכוש כרטיס ב-10% הנחה, כאן:
https://ti.to/hamakor/core-cpp-2023/discount/last-minute
השנה הכנס בהשתתפות ממציא שפת ++C, ביארנה סטרוסטרופ, בנוסף לשורה ארוכה של מרצים מעולים. לתוכניה המלאה: https://corecpp.org/schedule/
(הכנס מתקיים ביוני, 5-7 בסנימטק תל אביב, רחוב הארבעה 5)
מומלץ למהר ולרכוש, כי נותרו כרטיסים אחרונים בהחלט!
The post הסתיימה חלוקת כרטיסים חינם מעמותת "המקור" לכנס Core C++ 2023! first appeared on המקור.
שלום לחברי וחברות עמותת המקור, ידידים וידידות, ושותפים ושותפות לדרך,
בתאריך 28.5.23, ביום ראשון בשעה 18:00 (בתחילת מיטאפ "המקור") תכונס אסיפה כללית של עמותת המקור – עמותה ישראלית לתוכנה חופשית וקוד מקור פתוח (ע"ר).
שימו לב: האסיפה פתוחה לכלל חברי העמותה, ולא רק למשתתפי המיטאפ
האסיפה תתקיים:
לוח זמנים:
במידה ובמועד שנקבע לא יהיה קוורום (רבע מכלל חברי העמותה), האסיפה תדחה בשעה ותתקיים באותם אמצעים, בכל הרכב שהוא (במקרה כזה הלו"ז מעלה עשוי להשתנות).
פרטים טכניים:
טיוטות הדוחות יועברו לעיון החברים לפני האסיפה. אנו מקווים שדיון עליהם, או על כל נושא אחר בסדר היום, יתקיים בפורומים של העמותה, בכתב, לפני האסיפה. זאת, הן משיקולי אסינכרוניות והן משיקולי חיסכון בזמן באסיפה.
הצבעות יתקיימו באופן גלוי לחלוטין, משיקולי זיהוי. משתתפים פיזית – תתבצע הצבעה בהרמת יד.
משתתפי אונליין – לא תתאפשר הצבעה ללא הזדהות ויזואלית בוידאו, לכן, אנא בידקו את המצלמה טרם תחילת האסיפה.
חבר/ת עמותה שירצו להשתתף בהצבעות אך לא יוכלו להשתתף באסיפה, יוכלו לשלוח הודעת ייפוי כח לועד, המפרטת את ההצבעות, עם חתימתם (כן, הפיזית, מצולמת, על הדף שבו כתובות ההצבעות. לא חתימה דיגיטלית). למען הסר ספק, משתתפים באמצעות ייפוי כח לא יספרו לצורך קוורום, אלא רק יחשבו בהצבעות.
אנו מזכירים לכולם לשלם את דמי החבר לעמותה. הודעה על מצב התשלום תצא לחברי וחברות העמותה.
לנוחיותכם קישור להצטרפות כידידי/חברי העמותה ולשדרוג מעמד מידיד/ת לחבר/ת העמותה.
בברכה,
ועד עמותת המקור
The post הזמנה לאסיפה כללית של העמותה – 28.5.23 first appeared on המקור.
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:
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 DELETE
s on child_table
are never reflected and cannot be captured.
I’ve written about this at length in the past. But even that write up is incomplete!
MySQL is pushing towards INSTANT
DDL, which is a wonderful thing. With 8.0.29
, even more schema change operations are supported by ALGORITHM=INSTANT
. But, there’s still quite a lot of operations unsupported yet, and until such time that INSTANT
DDL supports all (or at least all common) schema changes, Online Schema Change tools like gh-ost
, pt-online-schema-change
, and Vitess
(disclaimer: I’m a Vitess
maintainer and actively developing Vitess'
s Online DDL), are essential when it comes to production changes.
Both Vitess
and gh-ost
tail the binary logs to capture changes to the table. In light of the previous section, it is impossible to run such an Online Schema Change operation on a foreign key child table that has either SET NULL
or CASCADE
rule. The changes to the table are never reflected in the binary log. pt-online-schema-change
is also unable to detect those changes as there’s nothing to invoke the triggers.
Then, please do go ahead and read The problem with MySQL foreign key constraints in Online Schema Changes, as it goes deep into what it otherwise means to deal with FK constraints in Online DDL, as it cannot fit in this post.
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!
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
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.
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.
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.NO ACTION/RESTRICT
rule, DELETE
data from a parent table even if children tables have matching rows.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)RENAME TABLE
statement (wishful feature, would really help Online DDL)This one becomes obvious as your data grows. If you use foreign keys and you rely on their behavior (e.g. your app relies on a DELETE
to fail if there’s dependent rows in children tables), and your data set grows such that a single server does not have the write capacity, you’re in trouble.
You may attempt to do functional sharding. You will hopefully find two subsets of your schema’s tables, that are not connected in the foreign key graph. If so, you win the day. But if it’s all connected, then you have to break some relationships. You’d have to audit your app. It previously assume the database would take care of data integrity, and now, for some relationships, it wouldn’t.
Or you may want to have horizontal sharding. If you mean to keep foreign key constraints, that means you need to find a way to co-locate data across the entire dependency graph. Unless this was pre-designed, you will probably find this to be impossible without a major refactor.
Vitess
is looking into FOREIGN KEY
implementation. It will attempt to address some of the above limitations. See https://github.com/vitessio/vitess/issues/11975 and https://github.com/vitessio/vitess/issues/12967 for some preliminary write ups and tracking.
לפני
root@cucomania:~# cat /etc/debian_version
10.13
אחרי:
root@cucomania:~# cat /etc/debian_version
11.6
השרת Next cloud אצלי גם שודרג מגרסה 23 אל 25 – וזה היה האתגר לשינוי. אני צריך את האפליקציה הזאת ב־next cloud והיא לא הייתה זמינה. גם לא קיבלתי עדכונים – כי גרסת php שלי הייתה נמוכה מדי..
השידרוג של דביאן היה פשוט. רק עדכנתי את /etc/apt/sources.list ואז עשיתי
apt dist-upgrade --auto-remove --purge
הבעייה היחידה שלי הייתה בהגדרות של nginx שבה הייתי צריך לשנות מיקום של php-fcm socket (היה טריויאלי).
לעומת זאת – שידרוג של next cloud כרגיל מאוד לא ישיר (קפצתי שתי גרסאות, וזה אומר לבצע שני שדרוגים..) ואחרי כל אחד מהם ללכת לשורת הפקודה ולייצר אידקסים של בסיס נתונים (occ עושה את זה…) ואז לאט לאט להשתיק את ההמצלות שלו… מעניין אם זה מעיק בכוונה תחילה.
לא יודע מתי תקראו את זה בעתיד, אבל פעם הייתה רשת חברתית סגורה אבל חביבה עלי בשם טוויטר. בא איש אחד בשם מאסק וקלקל אותה ופרחה לה בחזרה רשת מבוזרת כמו בימים הטובים של התחלת האינטרנט. מסטודון היה קילר אפפ שהופיע בדיוק בזמן לקלוט את חובבי המיקרובלוגינג שברחו מטוויטר וטאמבלר וצירף אותם לרשת סטטוסנט/אקטיביטי פאב שכבר כללה כמה תוכנות ניהול נוד רשתי (המקבילה של שרת דואר ברשת SMTP או שרת IRC וכולי). עכשיו אפשר לקרוא את הפרסומים שלי בתור הודעות ברשת הזו בזכות תוסף וורדפרס.
אז אם אתם מחפשים אותי כי לטוויטר אני נכנס פחות ופחות, אני @I
שרתי אקטיביטיפאב בעברית (מתוך אלפים שהוקמו) הם נכון להיום בעיקר על בסיס מסטודון אבל לא רק:
ועוקב אחרי כולם אתר פיד עברי.
בקיצור, בעוד רגע אלחץ פה על "פרסום" והפוסט יופיע פה. יאללה, תעקבו, נראה מה זה שווה?
Those days I am moving my website from Apache2.4 to Nginx.
So I googled for “convert apache rewrite to nginx”. I found the folllowing articles:
In addition to the aforementioned articles, I found the following SaaS services for converting Apache2.4 configuration files into Nginx configuration files.
I recommend that you run your conversion in both winginx.com and getpagespeed.com, review and edit the resulting Nginx configuration file.
את הבלוג הזה אני כותבת שנים רבות (כולל גירסת הארכיב) – עוד משנת 2006 (עוד מהימים שהנאיביות שלי היתה בשיאה…). כתיבה בבלוג הזה עזרה לי ולאחרים מבחינת שיתוף מידע, מבחינת עבודה ומבחינות נוספות, ואם מאן דהו ישאל אותי איך הוא יכול לקבל חשיפה יותר גדולה בשביל העסק שלו או בשביל עצמו – אני עדיין יאמר שבלוג הוא פתרון מעולה, אם כי כדאי לחשוב גם על אופציות כמו יוטיוב ואולי אפילו אינסטגרם או טיקטוק, תלוי בתחום..
הגעתי למצב שבו יש לי בכל זמן נתון כ-9 בלוגים שאני מתחזקת, חלקם פתוח לציבור וחלקם מיועד לסקטורים מסויימים והתוכן לא זמין, ולכן החלטתי להתחיל לאחד דברים כך שאוכל להקדיש את זמני הפנוי לתכנים בכמות קטנה של ערוצים, ולהלן הסדר החדש:
ערוצי יוטיוב
אני מודה כי בעבר עשיתי סלט שלם מבחינת קליפים ומיקומם בערוצים השונים, ולכן גם כאן דברים ישתנו:
לסיכום: ערוצים ירדו, ערוצים אחרים יעודכנו, ואתם תוכלו לפי הדברים שמעניינים אתכם – לקבל את המידע ממני בכמות קטנה של אתרים וערוצים.
ברצוני לנצל הזדמנות זו בכדי להודות לכל הקוראים והמגיבים והמשתתפים. בלעדיכם – זה לא היה קיים, ולכן – תודה לכם
# -avHAX: # -a = archive (equivalent to -rlptgoD) # -r = recurse into directories # -l = copy symlinks as symlinks # -p = preserve permissions # -t = preserve modification times # -g = preserve group # -o = preserve owner (requires sudo) # -D = --devices --specials # --devices = preserve device files (requires sudo) # --specials = preserve special files # -v = verbose # -H = preserve hard links # -A = preserve ACLs # -X = preserve xattrs # # Before actual work, you may want to use --dry-run. sudo rsync -avHAX --progress --exclude-from=- $SRCDIR $DESTDIR <<EOF - /temp/*** - /trash_script.sh EOF
בעבר רציתי שעון חכם וקניתי שעון חכם שתומך ב־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 שנעשו בזכות פתיחת מאגרי מידע לציבור. נראה גם יוזמות ממשלתיות בנושא מעקב והנגשת מידע אודות תחבורה ציבורית, כולל יכולת תחקור עבור כל הרשויות בארץ. כל אלה לצד היתרונות של קוד פתוח במעבר לענן הממשלתי (נימבוס).
מתי: רביעי, 9.11.22 9:00-13:00
מיקום: תל-אביב או בזום (לבחירתכם)
הרשמה בקישור: https://forms.gle/b18bbnKm8xbUKdxJ6
ההשתתפות ללא תשלום, אך יש להירשם מראש.
עדכונים על כנסים וארועים נוספים הרשמה לניוזלטר
אחד הדברים המבורכים בהפצות לינוקס – זו היכולת לקרוא את הדיונים לגבי שינויים שנעשים בהפצות לינוקס, דעות, בעד ונגד. במקרים רבים ישנם החלטות ודיונים פנימיים, אולם בד"כ התוצאות של הדיונים יוצאות בהודעה מסודרת ב-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...
This already happend a while ago. I am on Github Sponsors and you can support my opensource work. continue reading...
I just released the 2nd version of my CoreDNS plugin for getting DNS records from Netbox. This release adds IPv6. 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...
After a long development hiatus I am releasing a new version of blogit 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 של חברות מסחריות, התדמית נפגעת. לאחרונה אני רואה כמה ארועים שבאו ברצף:
תזוזה קטנה ועוד אחת, מתי נענועי הסירה יהפכו אותה? הפחד שלי היא לולאת משוב ענקית שבה פתאום חברות יפחדו להשתמש במוצרים חופשיים או לתרום להם, מה שיגרום לאיבוד רוח מהמפרשים של מפתחים מתנדבים. בנקודות כאלו כדאי לזכור שהמתנדבים לא ממש מקבלים הרבה גב, חלקם אפילו לא יודעים איך לשווק את הפרויקט או לקבל תרומות גם אם ירגישו שנכון להם לבקש. המקרים של מפתחים כמו מארק סקוויירס מדאיגים אותי מאוד: בוקר אחד קם אדם ואומר לעצמו שלא משלמים לו מספיק אז הוא יתקע לכולם מקל בגלגלים (אני אפילו לא יודע אם הייתה דרך למישהו לשלם לו לפני שהתחיל להשתולל). בתגובה לא בלתי מוצדקת נחסמו לו חשבונות אצל גיטהאב ו־pypi. יש לי כמה דברים לומר למפתחים שהחליטו לפרסם קוד ברישיון פתוח – ראשית ציינו בצורה ברורה מה תנאי הרשיון (אי ציון רישיון ברור מטילה עליכם את האחריות אם למשתמשים נדפק משהו, וברירת המחדל איננה "נחלת הכלל"), ושנית היו מוכנים שיהיו לכם הרבה משתמשים מסחריים. אם לא מקובל עליכם, אל תירו לעצמכם ברגל, פצלו את הפרויקט לגרסא פתוחה ואחת סגורה בתשלום או כל דרך אחרת. לדחוף קוד ששובר את הספריה שלכם מבטיח גם נטישה של משתמשים וגם איבוד האמון בכם לעתיד, וכמובן פותח פחת לתביעות משפטיות אם הרישיון שלכם לא מצוין נכון.
ורק כדי להיות ברור: יש המון חדשות טובות בקהילה הזו, הפחד שלי הוא מהתדמית בעיני משתמשים מסחריים, שהפכו לחשובים מאוד בתהליך הפיתוח של כלים קטנים לפעמים. הקרנל של לינוקס ופרוייקטים מסביבו עדיין חיים ותוססים ושיפורים קורים השכם והערב.
ומה הפתרון? אין לי תשובה. גם ככה הרשת שלנו הפכה בעשורים האחרונים לריכוזית מדי. כל הקוד העדכני בגיטהאב. כל הידע הטכני בסטאק אוברפלו. הרשת החופשית שהתאהבתי בה כמעט כבר לא קיימת, כשכל הידע והתקשורת קורים בין הכתלים של 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.
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.
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.
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 orchestrator
will 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.
I co-designed and co-authored gh-ost
at GitHub (announcement) as part of the database infrastructure team. We wrote gh-ost
to solve a pressing issue of schema changes at GitHub, and were happy to open source it. This led to, frankly, an overwhelming response from the community, with very fast adoption. Within the first few months we received invaluable feedback, bug reports, suggestions, all of which had direct and positive impact to gh-ost
.
I’m not working at GitHub anymore, and I’m not an official maintainer of the upstream repo anymore. I do not have the authority to merge PRs or close issues. It is as it should be, the project is owned by GitHub.
I use gh-ost
as part of my current job at PlanetScale working on OSS Vitess. Vitess utilizes gh-ost
for online DDL. I therefore am an interested party in gh-ost
, most specifically to ensure it is correct and sound. For this reason, I selectively engage with users on GitHub’s repo, especially when it comes to issues I consider important for Vitess.
I do maintain a fork, where I either interact with users, or push my own changes. I collaborate with the GitHub team, contribute upstream changes I make on my fork, and pull changes downstream. The GitHub team is kind enough to accept my contributions and invest time in testing and evaluating what might be risky changes. The upstream and downstream code is mostly in sync.
Going forward I will continue to work on things critical to my current job, but otherwise I’ll be stepping away and reduce interactions. This means I will not accept pull requests or answer questions. The upstream gh-ost
repo remains under GitHub’s ownership and maintained by GitHub’s engineers. It is not in my authority to say how the upstream project will engage with the community and I do not presume to make suggestions.
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.
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.
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.
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, […]
השליט העליון שכב במיטת בית החולים. הוא התקשה לנשום והתקשה לחשוב. את מעט הריכוז שעוד הצליח לגייס הפרו הצפצופים הדחופים של מכונות הניטור והחמצן. המחלה הארורה השיגה אותו לבסוף. כמו שהזהירו המדענים, החיסון לא עבד. הוא שמח כשנזכר שהורה על הוצאתם להורג. "מה הטעם במדענים", חשב לעצמו בלעג, "אם אינם מועילים בריפוי המגיפה?"
לאט לאט, הנהן בראשו להסכמה. הרופאים ביקשו להרדים ולהנשים אותו. לא היתה ברירה, הם אמרו. בלי זה, הוא לא ישרוד את הלילה. הנהונו גרם לפרץ של פעילות. רופאים ואחיות החלו בשרשרת של סידורים. השליט לא סמך על רופאות ואסר על לימודי רפואה לנשים כבר לפני שנים רבות.
לבסוף שככה הפעילות ורופא זקן ניגש אליו. השליט העליון לא ראה את הרופא הזה קודם אך על פי יחס שאר אנשי הצוות אליו השליט העליון הבין שהוא רופא בכיר. השליט העליון היה טוב מאוד בלקרוא אנשים ומצבים. משהו הטריד אותו ברופא הזה. הרופא הזקן התכופף. השליט העליון הבחין בתואר "פרופסור" על תג השם שלו, אבל לא הצליח להתרכז מספיק כדי לקרוא את השם המלא. הוא לא אהב פרופסורים.
הרופא הזקן הביט בשליט העליון ואז, מבלי להסיר את עיניו ממנו, הנהן. רופא אחר, צעיר יותר, נחפז אל השליט העליון והוא חש דקירה בזרועו. הרופא הזקן נפנף והרופא הצעיר התרחק במהירות.
השליט העליון חש לפתע קור. "מה זה?" ,חשב, "מישהו פתח את החלון?". לא הייתה זאת מחשבה הגיונית, כך ידע, אבל הוא מצא שקשה לו עוד יותר להתרכז. הוא חש עייף. הרופא הזקן התקרב עוד יותר אליו, הביא את פיו לאוזנו, ואמר משהו. השליט העליון ניסה מאוד להתרכז להבין מה נאמר. זה היה קשה מאוד. לבסוף הבין. פיו נפער, אבל אף בת קול לא יצאה. עיניו נעצמו.
"Sic Semper Tyrannis"
אני מודע לכך שלא כתבתי יותר משש שנים ואני מקווה שמישהו עוד עוקב אחרי הבלוג. אבל לאחרונה קניתי מחשב חדש וכמובן שהתקנתי עליו ארץ׳ וחשבתי שתיאור התהליך יוכל לעזור למישהו. לי לפחות יוכל לעזור בעתיד לדעת מה בדיוק עשיתי.
למרות הכותרת המפוצצת, לא מדובר על מדריך מלא עם הסברים ובטח לא על מדריך פשוט של העתק־הדבק. חשוב להבין מה אתם עושים ובמחשבים אחרים ייתכן שהפקודות יצטרכו להיות שונות.
בהתקנה התבססתי על שני מדריכים עיקריים:
בתור התחלה, הורדתי את תקליטור ההתקנה של ארץ׳, „צרבתי” אותו על החסן נייד והעליתי את המחשב ממנו.
wifi-menu
או שמתחברים עם כבל לרשת קווית
בדיקה שמחובר:
ping -c3 google.com
timedatectl set-ntp true
אצלי כבר היה מותקן אובונטו מהיצרן ולכן השארתי את שתי המחיצות הראשונות של uefi ומחיצת שחזור ומחקתי את המחיצה של אובונטו
fdisk /dev/nvme0n1
יצרתי מחיצה ל־swap של 24G, מחיצת שורש של 30G ומחיצת בית של 175G שנשארו (לפי הסדר הזה)
mkswap /dev/nvme0n1p3 swapon /dev/nvme0n1p3 mkfs.ext4 /dev/nvme0n1p4 mkfs.ext4 /dev/nvme0n1p5
pacman -Sy reflector
cp /etc/pacman.d/mirrorlist /etc/pacman.d/mirrorlist.bak
reflector -c "IL" -f 12 -l 10 -n 12 --save /etc/pacman.d/mirrorlist
mount /dev/nvme0n1p4 /mnt
mount /dev/nvme0n1p5 /mnt/home
pacstrap /mnt base linux linux-firmware nano intel-ucode
genfstab -U /mnt >> /mnt/etc/fstab
arch-chroot /mnt
ln -sf /usr/share/zoneinfo/Asia/Jerusalem /etc/localtime
hwclock --systohc
nano /etc/locale.gen
en_US.UTF-8 UTF-8
he_IL.UTF-8 UTF-8
locale-gen
echo myname > /etc/hostname
nano /etc/hosts
127.0.0.1 localhost
::1 localhost
127.0.1.1 myname.localdomain myname
passwd
pacman -S grub efibootmgr
mkdir /boot/efi
mount /dev/nvme0n1p1 /boot/efi
grub-install --target=x86_64-efi --bootloader-id=GRUB --efi-directory=/boot/efi
grub-mkconfig -o /boot/grub/grub.cfg
useradd -s /bin/bash -g users -G sys,adm,wheel -m user
passwd user
pacman -S xorg-server xf86-video-intel
pacman -S eog evince file-roller gdm gedit gnome-calculator gnome-color-manager gnome-control-center gnome-disk-utility gnome-font-viewer gnome-keyring gnome-logs gnome-menus gnome-screenshot gnome-session gnome-settings-daemon gnome-shell gnome-shell-extensions gnome-system-monitor gnome-terminal gvfs gvfs-gphoto2 gvfs-mtp mutter nautilus networkmanager simple-scan totem xdg-user-dirs-gtk
לא כל גנום חובה, חלק אני רציתי
להפעיל את השירותים
systemctl enable gdm NetworkManager
pacman -S sudo
nano /etc/sudoers
%wheel ALL=(ALL) ALL
pacman -S base-devel wget
wget https://aur.archlinux.org/cgit/aur.git/snapshot/yay-bin.tar.gz
tar -xzf yay-bin.tar.gz
cd yay-bin
makepkg -si
קצת סיפור להוריד ולבנות את החבילה של הגופנים אז אפשר להוריד אותה מדרייב:
pacman -U ttf-ms-win10-10.0.18362.116-2-any.pkg.tar.xz
yay -S culmus culmus-fancy-ttf ttf-alef
pacman -S firefox-i18n-he chromium
pacman -S libreoffice-fresh-he
libhdate-glib vlc mlocate reflector zsh zsh zsh-completions zoom parcellite
reboot
אם התקנתם הכול נכון אז המערכת תעלה ותוכלו להינות ממנה. בהצלחה!
ביחד עם משבר הקורונה, אנשים רבים גילו כי לצד העבודה מהבית הרישיון לתוכנות ה-GIS שלהם נשאר במשרד. סדנאות ה-QGIS שלנו מיועדות למי שרוצה להשתחרר ממגבלות עולם ה-GIS הקנייני ולעבוד עם תוכנה ללא מגבלות על שימוש והתקנות וזאת מבלי לוותר על יכולות של התוכנה.
לצד סדנה בהתאמה אישית לארגונית (דרך zoom בתקופת הקורונה) המאפשרת גמישות מקסימלית של התכנים, אנחנו מפעילים סדנאות חודשיות עם תוכן קבוע. סדנאות QGIS שלנו ביוני 2020:
סדנאות המבוא מיועדות לאנשים שרוצים לעבוד עם מפות ולבצע ניתוחים מרחביים במסגרת תחומי העיסוק שלהם: כלכלנים, מהנדסות, אדריכלים, מתכננות ערים, אקולוגים, ארכיאולוגיות, גיאולוגים ועוד. הן מיועדת גם למי שלא מכיר 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.
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.
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.
Read the full article at Forbes here
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
#!/bin/bash CA=ca.cer #fullchain.cer CER=vpn.cer KEY=vpn.key OUT=vpn.pfx openssl pkcs12 -export \ -inkey ${KEY} \ -in ${CER} \ -certfile ${CA} \ -out ${OUT}
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
As I write these pieces for Forbes Tech Council, I’ve tried to chip away at the Hollywood reputation that hackers have been given over the years. That reputation often keeps people from making good decisions about how to protect their networks and data, keeps people focused on the wrong security priorities, and causes people to give up before the game is over.
It’s important to keep in mind, however, that while criminal hackers may be smart and devious, they are also, in a sense, entrepreneurs who are in the game to make a quick buck. As such, they realize that hacking costs money and so they will do what they can to keep their operating costs low. Why, then, would you expect a criminal hacker to expend time and money developing specialized tools when there are easier ways to get to what they want?
Read the full article at Forbes here
את היום הראשון של הכנס פתחתי כרגיל בדוכן הרשמה (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 בבוקר בישראל).