פלאנט תוכנה חופשית בישראל (Planet FOSS-IL)

25 March, 2017

Ilya Sher

NGS unique features – improving NodeJS require()

Background: what is NGS?

NGS, the Next Generation Shell is a (work in progress) shell and a programming language built ground up for systems engineering tasks. You can think of it as bash that’s designed today: sane syntax, data structures, functional programming, extensibility, cloud in mind, declarative primitives.

What’s good in NodeJS’ require()

I like most of how require() works in JavaScript. I’m not talking in this post about npm, just NodeJS require() function. require() does not pollute your namespace, you just get a reference, it’s simple to use and easy to reason about.

const a = require('cool-aws-wrapper');
// Can not be done easily with AWS SDK:

What’s there to improve in require() ?

NodeJS modules are usually fall into one of the categories:

  1. Class definition / big library that manages it’s own namespace. These usually end with module.exports = MyClass. No problem here.
  2. Group of functions or classes. These usually end with module.exports = { func1, func2, func3, ...} lists (ES6 syntax, otherwise written as module.exports =  { func1: func1, ... } ) which I think are cumbersome.

How require() and modules look in NGS?

Note that require() in NGS is work in progress and it doesn’t have much of the functionality that NodeJS provides. I just started with things that bothered me the most.

Consistent with other places in NGS, require() returns the last evaluated expression. NodeJS for example returns module.exports which you must explicitly set as the result of require().

I think of modules primary as a namespaces. Creating a namespace in NGS has a syntax: ns { ... } .

Combining require() behaviour of returning last evaluated expression and namespace syntax, typical NGS module consists of single top level expression which evaluates to a namespace. The whole module file can look like this:

ns {

  global init

  type Vpc
  type Subnet

  F init(v:Vpc) {

  F _helper_func(s:Str) { ... }

  MY_CONST = 42

  F ok() {


Let’s ignore the global for now, it’s about how methods and types’ instances creation are implemented in NGS. Anything defined inside the ns { ... } is exposed as namespace member so usage of the above module could look like this:

  m = require('mymodule.ngs')
  vpc = m::Vpc()

As you probably guessed, the :: operator is the namespace member access operator.

There is no need to explicitly state what module/namespace exports. That’s the improvement over NodeJS’ require().

How ns works and more options for the curios

ns { … } returns a Hash

As stolen from NodeJS, the namespace syntax (ns { ... }) returns a Hash. In NodeJS, require() typically returns JavaScript Object which is close enough for the purpose of this post.

About :: operator

The namespace member access operator :: is actually a Hash key access operator. It is helpful because the regular syntax for accessing members is not always a good fit for namespaces. The regular member access syntax is dot (.) but the dot syntax is also a function call: myobj.field – is a field/key/attribute access but myobj.func() is equivalent to func(myobj). For example, m::ok() will call the ok function defined in the module, m.ok() will call the function ok in current lexical environment with m as parameter.

As a bonus, since :: is an operator, it is implemented as function call. This means you can define how :: works with types that you define and modify how :: works with existing types.

ns { … } syntax implementation

For simplicity of implementation and absence of obvious reasons against, ns { ... } syntax is just a syntactic sugar for defining anonymous function without parameters and calling it immediately. The though behind this decision was simple: “I need to implement namespaces. Let’s see where I have them already. Oh, namespaces are already implemented in functions. This is so convenient, I can use this mechanism with minimal effort”.

How ns knows what to return?

ns is mostly a syntactic hack:

  1. Inside the ns body, the first statement, before any use-supplied statements is _exports = {} which sets the local variable _exports to an empty Hash.
  2. Any assignment and function definition also set _exports["something"]. MY_CONST = 42 becomes MY_CONST = 42;  _exports["MY_CONST"] = MY_CONST;
  3. Exception to the rule above are variables and functions with names starting with underscore (_). They are not automatically added to _exports. This for example is why _exports itself is not exported.
  4. Last statement, after all user-supplied statements is _exports.

The behavior I just described looks like sane defaults to me. As we all know, the life is usually more complex than hello world examples and customizations are need. Here are two ways to customize the resulting namespace.

  1. return your_expr – since ns is just a function, you can use return at any point to return your own custom namespace.
  2. manipulate _exports however you want towards the end of ns body. For example after _exports .= filterv(Type) only types will be exported. _exports.filterk(/^pub_/) will only export symbols (keys) that have names that start with pub_ .

Improvement suggestions are welcome! Have a nice day!

25 March, 2017 01:57 PM

Gabor Szabo

Perl related crowdfunding on Kickstarter and Tilt

Fundraising or crowdfunding is not easy. Here I collect all the Perl-realted crowdfunding campaigns I can find. (Still work in process)

For the full article visit Perl related crowdfunding on Kickstarter and Tilt

25 March, 2017 08:02 AM

24 March, 2017

Gabor Szabo

Hiking after Craft Conference in Budapest

If you like nature, nice views, and would like to get away from the city after you've enjoyed the Craft Conference, then you are invited to this short hike in the hills on the outskirts of Budapest. Date: April 29, 2017. from 10:00 till about 12:00. Assuming the weather permits.

For the full article visit Hiking after Craft Conference in Budapest

24 March, 2017 06:35 AM

21 March, 2017

Boris Shtrasman

כל הכבוד לספק הטלפוניה שלי

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

שנים האמנתי שלא שניתן לשבור Cell Broadcast וגם ערוץ נתונים בזמן חירום, אבל אני חייב להגיד לספק הטלפוניה תודה שלימדתם אותי שזה אפשרי - מתברר שיש אנשים שיכולים להרוס Public Warning System שעובדת שנים.

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

בהתחלה האשמתי את systemd שהוא לא הפעיל נכון, או לא הפעיל כלל את ה timer והservice.

לכן בדקתי שהקבצים במקומות הנכונים ושהכל תקין מבחינתו:

find /etc/systemd/system/  -name *pws* -print

$cat /etc/systemd/system/pws.timer 
Description=Public Warning System Timer



$cat /etc/systemd/system/pws.service
Description=Public Warning System Alert

ExecStart=/bin/bash /usr/local/bin/parse_alerts.sh http://pws/WarningMessages/Alert/alerts.json

$systenctl status pws.timer
● pws.timer - Timed alert check
Loaded: loaded (/etc/systemd/system/pws.timer; enabled; vendor preset: enabled)
Active: active (waiting) since Tue 2017-03-21 11:06:50 IST; 1s ago

Mar 21 11:06:01 pc systemd[1]: Started Public Warning System Timer

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

הקו שאני מדבר עליו מתחבר ב UMTS תחת דור ה "3.5G".
התחברות מבוצעת ע"י wvdial.

ביצעתי מספר בדיקות להבין מהיכן מגיעה הבעיה בערוץ הנתונים :

PING ( 56(84) bytes of data.
From icmp_seq=17 Packet filtered
--- ping statistics ---
157 packets transmitted, 0 received, +1 errors, 100% packet loss, time 159696ms

חשוב לזכור שהכתובות אצל ספק הטלפוניה שלי הן תחת המשכתי לראות מאיפה זה מגיעה וקיבלתי :
mtr --report-wide --show-ips
Start: Tue Mar 21 11:46:45 2017
HOST: pc Loss% Snt Last Avg Best Wrst StDev
1.|-- ??? 100.0 10 0.0 0.0 0.0 0.0 0.0
2.|-- 0.0% 10 49.7 59.7 46.8 92.0 16.7
3.|-- 0.0% 10 48.5 64.9 47.0 92.7 18.7
4.|-- ??? 100.0 10 0.0 0.0 0.0 0.0 0.0

PING ( 56(84) bytes of data.
64 bytes from icmp_seq=1 ttl=253 time=285 ms
64 bytes from icmp_seq=2 ttl=253 time=303 ms
64 bytes from icmp_seq=3 ttl=253 time=272 ms

Kernel IP routing table
Destination Gateway Genmask Flags Metric Ref Use Iface UG 0 0 0 ppp0 UH 0 0 0 ppp0

mtr --report-wide --show-ips
Start: Tue Mar 21 11:40:55 2017
HOST: pc Loss% Snt Last Avg Best Wrst StDev
1.|-- ??? 100.0 10 0.0 0.0 0.0 0.0 0.0
2.|-- 0.0% 10 51.1 52.2 48.7 55.9 2.4
3.|-- 0.0% 10 57.2 63.5 50.1 93.7 16.0

sudo nmap -sV

Starting Nmap 7.40 ( https://nmap.org ) at 2017-03-21 11:37 IST
Nmap scan report for
Host is up (0.064s latency).
Not shown: 999 closed ports
5222/tcp filtered xmpp-client

Service detection performed. Please report any incorrect results at https://nmap.org/submit/ .
Nmap done: 1 IP address (1 host up) scanned in 294.32 seconds

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

לאחר חצי יום שלא הייתה גלישה פניתי לשירות לקוחות במייל ובטלפון.

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

לא משנה ששלחתי קובץ pcap  ויש לי כתובת IP (שמגיבה כמו גדולה בתוך הרשת שלהם)

צילום מסך :

לאחר שלא הסתדרתי עם ספק הטלפוניה התחלתי לגגל לגבי CB.

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

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

21 March, 2017 09:41 PM

Shlomi Noach

MySQL Community Awards 2017: Call for Nominations!

The 2017 MySQL Community Awards event will take place, as usual, in Santa Clara, during the Percona Live Data Performance Conference, April 2017.

The MySQL Community Awards is a community based initiative. The idea is to publicly recognize contributors to the MySQL ecosystem. The entire process of discussing, voting and awarding is controlled by an independent group of community members, typically based of past winners or their representatives, as well as known contributors.

It is a self-appointed, self-declared, self-making-up-the-rules-as-it-goes committee. It is also very aware of the importance of the community; a no-nonsense, non-political, adhering to tradition, self criticizing committee.

The Call for Nominations is open. We are seeking the community’s assistance in nominating candidates in the following categories:

MySQL Community Awards: Community Contributor of the year 2017

This is a personal award; a winner would a person who has made contribution to the MySQL ecosystem. This could be via development, advocating, blogging, speaking, supporting, etc. All things go.

MySQL Community Awards: Application of the year 2017

An application, project, product etc. which supports the MySQL ecosystem by either contributing code, complementing its behavior, supporting its use, etc. This could range from a one man open source project to a large scale social service.

MySQL Community Awards: Corporate Contributor of the year 2017

A company who made contribution to the MySQL ecosystem. This might be a corporate which released major open source code; one that advocates for MySQL; one that help out community members by... anything.

For a list of previous winners, please see MySQL Hall of Fame.

Process of nomination and voting

Anyone can nominate anyone. When nominating, please make sure to provide a brief explanation on why the candidate is eligible to get the award. Make a good case!

The committee will review all nominations and vote; it typically takes two rounds of votes to pick the winners, and a lot of discussion.

There will be up to three winners in each category.

Methods of nomination:

Please submit your nominations no later than Friday, March 31 2017.

The committee

Members of the committee are:

Emily Slocombe and Shlomi Noach are acting as co-secretaries; we will be non-voting (except for breaking ties).

Update: there have been multiple nominations that I'm related to. In previous years I disqualified such nominations but this year I do not wish to disqualify the ones that have been made. I stepped down from the committee and will have no access to the ongoing discussion/voting. Emily is the chairwoman and the committee is likely to get more members.

There is no conspiracy 🙂


The committee communicates throughout the nomination and voting process to exchange views and opinions.

The awards

Awards are traditionally donated by some party whose identity remains secret. A sponsor has already stepped up. Dear anonymous, thank you very much for your contribution!


This is a community effort; we ask for your support in spreading the word and of course in nominating candidates. Thanks!

21 March, 2017 02:22 PM

20 March, 2017

Lior Kaplan

הקמת פרוייקטים וארגונים מבוססי קוד פתוח

Cloudify ו-Red Hat נתנו חסות/אירוח להרצאה של Marc Cohn, סגן נשיא לאסטרטגיה רשתות של Linux Foundation. הרצאה שסוקרת את ההתפחות בתחומי הרשתות וענני המחשוב שמתבססים עליהן.

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

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

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

תויק תחת:Free Software in Business

20 March, 2017 01:22 PM

19 March, 2017


הרשמה למפגש פיתוח ב־5 באפריל

מפגש הפיתוח הקרוב יערך ב־hackerspace של TAMI שככתובתו: קיבוץ גלויות 45, ת״א בשעה 18:30.

TAMI – או בשמה המלא Tel Aviv Makers Ineffable הנה קבוצת מתנדבים ששמה לה לדגש לפתח ולשפר מגוון כלים וטכנולוגיות בדגש על רוח האקינג וחדשנות תוך פיתוח קהילה תומכת ושיתוף ידע ופעולה בין הפעילים בתחומים השונים.

להלן הקישור למפגש (מומלץ להירשם לטובת העירכות מתאימה של המארחים):

19 March, 2017 11:05 AM

מפגש פיתוח, ה־14 במרץ 2017

את יום הפאי שחל עלינו לטובה חגגנו במפגש קוד פתוח.

ירון שהרבני ושי גובר: תכנון לקראת מפגש פיתוח באזור חיפה.
ירון שהרבני: אירוח (איפה הבירות?)​​,​ תרגום לעברית של מערכ​ת AskBot (חלופה פתוחה ל־StackExchange) ותרגום והרחבה של יישומון לאנדרויד לתקשורת עם שעוני כושר (בצורה הרבה יותר פתוחה מהיישומון של שיאומי)​ בקוד פתוח.​
שי גובר:​ ​הצעה ראשונית לארגון מפגש פיתוח בבאר שבע. מחפשים מתנדבים נוספים.
עומר זק ושי גובר: נגישות האתר (מבוסס WP).
עומר זק, שי ברגר ותומר בריסקר: לוגיסטיקה של הוועד.
 משה נחמיאס: פיתוח PyBee.
שי ברגר: פיתוח PyBee.
יהודית​ ​​דוברובסקי שרעבי: פיתוח PyBee.
אלון​ ​​לוי: הציע לארח את המפגש הבא (5.4) ב־TAMI​,​ מערכת Servo של מוזילה​.
​בני דאון: סיוע ליהודית עם פייתון.​
יהודה דויטש: טיפול בשרתי העמותה.
​חיים: סיוע ליהודה וחניכת Ansible.
​ויקטור צבטוב: מדיניות ארגונית בקוד פתוח.


19 March, 2017 10:56 AM

18 March, 2017

Hetz Ben Hemo

המעבר מ-Digital Ocean לאמזון Lightsail

בלוג זה התארח עד היום בבוקר אצל Digital Ocean וכלקוח שלהם, אני יכול לאמר שהם אחד הספקים שמעולם לא אכזבו אותי. שרתים יציבים, אפס תקלות חומרה, והמערכת עובדת כמו שעון שוויצרי, ובקיצור איך אומרים אנשי לינוקס רבים: ה-Uptime חוגג 🙂

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

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

אמזון לאחרונה הכריזה על שרות LightSail שמתחרה בדיוק ב-Digital Ocean, Linode וספקי VPS רבים אחרים. היתרון בחבילה זו: המחיר קבוע, גודל המכונה קבועה (מבחינת ליבות, זכרון וגודל דיסק SSD מקומי) ויש לך כמה טרהבייט תעבורה החוצה כלולים במחיר. מכיוון שקיבלתי לאחרונה כמה דולרים בקרדיטים, החלטתי היום להעביר את הכל מהמכונה ב-Digital Ocean למכונה חדשה באמזון LightSail. המכונה הישנה רצה על אובונטו 15, החדשה על 16 וחשבתי שזה לא יהיה מורכב: rsync להעברת קובץ tar (של האתרים עצמם), קובץ dump של ה-SQL, סקריפטים והגדרות שונות – ונגמור עניין. לא אמור להיות מסובך.

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

  1. האזור היחיד שאפשר להקים בו כרגע מכונה ב-Lightsail – זה אזור צפון וירג'יניה, שום מקום אחר. תרגום: תתכוננו לעוד 150 מילישניות Latency (אלא אתם משתמשים ב-CDN והקבצים הראשונים הם HTML/CSS).
  2. החלטתי לעשות dump ל-mysql כולו, כלומר all-databases ולהרים אותו על MariaDB החדש במכונה באמזון. הפקודה עברה בשלום, אבל restart ל-mysql הוציא הודעה על unix_socket plugin – לא נטען. מי שמקבל את התקלה הזו – יש פתרון כאן. מה שהפתרון לא מזכיר, זה שיש להקים לאחר עצירת ה-mysql תיקיה בשם /var/run/mysql/ כאשר לתיקיית mysql ההרשאות הן mysql:root אחרת לא תצליחו להפעיל את ה-MySQL כי הוא לא יכול לכתוב קובץ PID וההפעלה תיכשל.
  3. אם אתם משתמשים ב-Wordpress, תשמחו לדעת שהוא עובד מעולה עם PHP-7, ומאוד מומלץ לעבוד עם ה-FPM של PHP-7. ההבדל בין גירסה 5.6 של PHP לבין גירסה 7 – מהירות כפולה בלי לשנות אפילו שורת PHP אחת.
  4. המכונה שתקימו ב-LightSail לא תראו אותה ב-Instances או ב-VPC שלכם. אם אתם רוצים להשתמש בשרותים האחרים של אמזון דרך כתובות פנימיות, תצטרכו להפעיל שרות VPC Peering וכאן זה תלוי מתי נרשמתם לאמזון. במקרה שלי, מכיוון שאני רשום ל-AWS בערך מ-2009 אז כל נסיון VPC Peering נכשל, ויש לפתוח קריאה לתמיכה שיסדרו מהצד שלהם את הבעיה מהצד שלהם.
  5. מבחינת בניית חוקים ל-Security Groups/חומת אש – יש באג ב-LightSail: יש לך רשימת שרותים מאוד מצומצמת ש-Lightsail מכיר. רוצה להוסיף דברים כמו ICMP, SMTPS ודברים אחרים? אתה יכול לבחור Custom ולציין את מספר הפורט ואז … החוקים שיכתבו זה פתיחה של כל הפורטים. כרגע, מכיוון שאינך יכול לראות את מכונות ה-Lightsail בתוך VPC כלשהו, אינך יכול להגדיר Security Groups לאותו VPC ומכיוון שאינך רואה את ה-Instance בשום מקום (זולת האתר של LightSail) אינך יכול להגדיר גם שם את ה-Security Group למכונה שיצרת ב-LightSail. בקיצור – רוצה פורטים פתוחים/סגורים? תעשה זאת מתוך ה-VM.
  6. מבחינת השוואת מעבדים בין מה ש-Digital Ocean נתנו לי (המכונה שלי הראשית ששירתה את הבלוגים הוקמה שם לפני 4 שנים) המעבד היה XEON E5 דגם L (כלומר מהירות שעון נמוכה יותר – 1.8 ג'יגהרץ, וכמות ה-Cache היתה כמחצית ממה שיש ב-E5 ממוצע). באמזון דגם ה-E5 היה יותר חדש עם Cache מלא.
  7. מבחינת הפצות לינוקס – אינך יכול להקים מכונות מה-Market או מ-AMI שאתה בנית בעבר. יש לך רק מה שאמזון בנו שזה אמזון לינוקס (תואם CentOS בערך…), ואובונטו 16. לבחירתך ההפצות הללו כ"ערומות" או כהפצות + תוכנות קוד פתוח מוכנות, אבל שום דבר מעבר לזה. תשכחו מרשתות מורכבות וכו'.

לסיכום, המחיר עבורי הוא פחות או יותר אותו מחיר (רק שהפעם יש לי קרדיטים אז אני מאמין שה-3-4 חודשים הקרובים העלות היא על אמזון) – שזה במקרה שלי 40$ על אותה מכונה לחודש (2 ליבות, 4 ג'יגה זכרון, 60 ג'יגה דיסק, 5 טרה תעבורה בחודש החוצה). יש ל-LightSail פה ושם עדיין "מחלות ילדות" (בכל הקשור ל-VPC Peering) אבל אם שיחקת בעבר עם AWS, אתה תצליח להסתדר.

האם אני ממליץ להעביר מכונות שלכם לזה? אני לא ממש עושה SEO לבלוגים שלי כך שעוד 100 מילישניות לא משנים לי ממש (כי בין כה תקבלו את האתר בתצורתו הסטטית מאוד מהר דרך ה-CDN שאני משתמש – CloudFlare). יחד עם זאת, אני ממליץ להמתין שאמזון ירחיבו את השרות לאזורים אחרים גיאוגרפית ויטפלו במחלות הילדות.

הטקסט המלא

18 March, 2017 07:54 PM

28 February, 2017

Oz Nahum

coverage reporting and logging without a webservice

For quite a while now I wanted to have a cheap replacement for collecting and tracking coverage of codes I work on. Finally, I found a nice way to record and track coverage reporting inside git itself in a semi-automatic or completely automatic way. continue reading...

28 February, 2017 10:30 PM

25 February, 2017

Lev Meirovitch

Security risks or panic mongering?

When you read about IT related security threats and breaches in mainstream media, it usually looks like this: Tech sites and dedicated forums usually do a better job. Last week, a new article by experts from Kaspersky Lab was doing the rounds on tech sites and forums. In their blog, the researchers detail how they […]

25 February, 2017 03:09 PM

22 February, 2017

Boris Shtrasman


היום בעידן הHTM5 אחד הדברים שאני נהנה לראות זה התחברות מרחוק למערכת ע"י דפדפן בלבד, יש את זה אצל vmware ויש את זה בxen אבל פה מדובר על vnc.

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

המערכת עובדת ע"י הפעלת x11vnc בשביל להתחבר לsession קיים (בשונה משרתי vnc אחרים שמאפשרים חיבור ל session נוסף פה מדובר על הססן הנוכחי), בחרתי ב x11vnc ולא ב krfb כי x11vnc היה הרבה יותר מהיר.

apt-get install x11vnc
git clone git://github.com/kanaka/noVNC

יש להגדיר לx11vnc סיסמה  x11vnc -storepasswd

הפעלה ע"י תחת המשתמש שצריך לשתף את הססן שלו:

screen -d -m bash -c "x11vnc -shared  -rfbauth ~/.vnc/passwd"

screen -d -m bash -c "~/noVNC/utils/launch.sh --vnc localhost:5900"

אפשר להפעיל את זה תחת systemd כסרביס מה שיאפשר ביצוע login אבל לאחר משחק הבנתי שצירך שזה ידרוש התערבות גדולה יותר של המשתמש.

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

22 February, 2017 01:05 PM

19 February, 2017

Ilya Sher

NGS unique features – Hash methods I wish I had in other languages

NGS is a language and a shell that I am building for systems administration tasks. Enough of the language is implemented to enable writing some useful scripts. The shell is not there yet.

Some of the Hash methods in NGS

The methods for working with Hash I have not seen all at once in other languages are:

  1. filterk – filter Hash by key (produces Hash)
  2. filterv – filter Hash by value (produces Hash)
  3. mapk – map Hash keys (produces Hash)
  4. mapv – map Hash values (produces Hash)
  5. mapkv – map Hash keys and values (produces Hash as opposed to map which produces an array)
  6. without – filters out specific key

How these are actually used? Following is an excerpt from the pollute method (function), which is a part of the AWS module. It uses several of the Hash methods I mentioned, making the method a good example. pollute method (as in “pollute global namespace”) enables using Vpc variable for example instead of AWS::Vpc and so on. I would like to have this behaviour for small quick-and-dirty scripts but not as default so it’s in a method that one can optionally call.

F pollute(do_warn=true) {

    vars =
        _exports.filterk(/^AMI_OWNER/) +
        _exports.filterv(Type).without('Res').without('ResDef') +

    if do_warn {
        warn("Polluting ...: ${vars.keys().join(', ')}")


Let’s go over the code above step by step:

F pollute(do_warn=true) { ... } defines the pollute method with optional parameter do_warn that has default value of true.

_exports is a Hash containing all of the AWS’ module variables and functions, similar to NodeJS module.exports but members are added automatically rather than explicitly. Only the methods and variables that do not start with _ (underscore) are added. One can modify _exports in any way before the end of the module. I will write more in detail about require() and modules in NGS in another post.

filterk(/^AMI_OWNER/) filters all the variables that match the given RegExp

filterv(Type) filters all the variables that are of type Type. These are AWS types’ definitions, such as Vpc, Subnet or Instance.

without('...') filters out the types I don’t like to override.

+ between and after _exports.filterk(...) and _exports.filterv(...) joins the hashes.

mapk translates variables’ names into their index (using resolve_global_variable)

each runs set_global_variable with variable index and the value to set

Hash methods in other languages

I am aware that some of the methods above are present in other languages or libraries. Some examples:

  1. Ruby has mapv (transform_values) method.
  2. Rails has mapk (transform_keys) and mapv.
  3. Perl 6 can modify values in a convenient manner:for %answers.values -> $v is rw { $v += 10 };.

What I have not seen is a language which has all the methods above out of the box. I have a feeling that arrays get all the fame methods while hashes (dictionaries) often get less attention in other languages.

Why NGS has all these methods?

NGS is aiming to be convenient for systems administration tasks. More often than not these tasks include data manipulation. NGS has many functions (methods) for data manipulation, including the ones listed in this post.

Update: reddit discussion

Have a nice day!

19 February, 2017 09:30 PM

16 February, 2017

Itzik Kotler

The Key To Cybersecurity: Shared Intelligence And Industry Cooperation

Chicago in the 1930s was a hive of organized crime where the bad guys always had the upper hand. As dramatized by the film "The Untouchables," lawman Eliot Ness confides to Officer Jim Malone that he is prepared to do “everything within the law” to take down Al Capone. But streetwise Malone tells Ness that, to win, he must be prepared to do more. “He pulls a knife, you pull a gun. He sends one of yours to the hospital, you send one of his to the morgue. That’s the Chicago way.”

Like ‘30s Chicago, the dark web is crawling with global crime syndicates, and everyone I've talked to says fighting the Chicago way sounds appealing. The problem is that the same laws that make hacking a crime also make it a crime to retaliate.

Read full article at Forbes here

Full text

16 February, 2017 12:12 AM

06 February, 2017

Hetz Ben Hemo

הסיוט המתקרב עם חשבון הפייסבוק

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

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

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

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

אחת הטכנולוגיות שיכנסו בעתיד לשוק היא ה-AI (כלומר Artificial Intelligence), כלומר בעתיד (הקרוב) תהיה תוכנה או שרות שהלקוח יכניס את פרטי המשתמש (כן, תצטרך לתת שם משתמש וסיסמא כך שגם הפוסטים שהגדרת "פרטי" יהיו חשופים לבודק/ת), וה-AI יעבור על הפוסטים ויחפש מילות מפתח, למי עשית לייק (מבחינת קטגוריה – נניח אם עשית לייק ליצרן משקאות אלכוהוליים, קבוצות פוליטיות שונות, תחביבים מסויימים וכו' וכו'), מה היו תגובותיך לדברים שונים ולבסוף המערכת תבנה מעין "עץ" של מילות מפתח/נושאים שונים וכמות הפעמים שציינת את אותם נושאים ולסיום יהיה מעין "סיכום" אוטומטי שיוצג לבודק/ת ומשם יוחלט האם להיענות לבקשתו של הפונה או לדחות אותה.

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

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

מה אפשר לעשות בנידון? תלוי בסיטואציה:

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

הטקסט המלא

06 February, 2017 10:42 PM

01 February, 2017

Shlomi Noach

orchestrator Puppet module now available

We have just open sourced and published an orchestrator puppet module. This module is authored by Tom Krouper of GitHub's database infrastructure team, and is what we use internally at GitHub for deploying orchestrator.

The module manages the orchestrator service, the config file (inherit to override values), etc (pun intended). Check it out!



01 February, 2017 11:20 AM

23 January, 2017

Guy Rutenberg

`rsync` and FAT File-Systems

I’m using rsync to sync files from my computer to a FAT formatted SD card. Using the --update flag to rsync makes it “skip files that are newer on the receiver”. It seems that it should work as follows: After the first sync, any subsequent syncs will only transfer those files which changed in the meantime. However, I noticed that transfer times are usually longer than expected, which led me to think that things are not working as they should.

As --update relies only on modification date, obviously something is wrong with it. After ruling out several other possibilities, I’ve guessed that the modification date of some files get mangled. A quick check about FAT revealed that FAT can only save modification times in 2 second granularity. I’ve also used rsync’s --archive flag, which among other things attempts to preserve modifications times of the files it copies. But what about FAT’s lower granularity for modification time? That was apparently the culprit. Some files when copied got a modification time which was up to 1 second before the original modification time! Hence, every time I’ve synced, from rsync’s perspective, the target was older than the source, and hence needs to be overwritten.

This can be demonstrated by the following session:

$ dd if=/dev/urandom of=test-even bs=1M count=100
100+0 records in
100+0 records out
104857600 bytes (105 MB) copied, 6.20716 s, 16.9 MB/s
$ cp test-even test-odd

$ touch -t 201701180000.00 test-even 
$ touch -t 201701180000.01 test-odd

$ stat -c %Y test-*

We’ve created two files test-even and test-odd with random content. We’ve set the modification time of test-even to be on an even second, and for test-odd to be on an odd second (one second apart). Simply syncing the files to a FAT partitioned device works as expected:

$ rsync -av --update test-{even,odd} /media/guyru/4E09-6457
sending incremental file list

sent 209,766,550 bytes  received 54 bytes  7,627,876.51 bytes/sec
total size is 209,715,200  speedup is 1.00

Resyncing immediately also works:

$ rsync -avv --update test-{even,odd} /media/guyru/4E09-6457
sending incremental file list
delta-transmission disabled for local transfer or --whole-file
test-even is uptodate
test-odd is uptodate
total: matches=0  hash_hits=0  false_alarms=0 data=0

sent 78 bytes  received 136 bytes  428.00 bytes/sec
total size is 209,715,200  speedup is 979,977.57

Both files are reported as being up-to-date. But what happens if we unmount and remount the device and then sync?

$ umount /media/guyru/4E09-6457 
$ udisksctl mount --block-device /dev/disk/by-uuid/4E09-6457 
Mounted /dev/sdd1 at /media/guyru/4E09-6457.

$ time rsync -avv --update test-{even,odd} /media/guyru/4E09-6457
sending incremental file list
delta-transmission disabled for local transfer or --whole-file
test-even is uptodate
total: matches=0  hash_hits=0  false_alarms=0 data=104857600

sent 104,883,314 bytes  received 131 bytes  7,769,144.07 bytes/sec
total size is 209,715,200  speedup is 2.00

This time test-odd was reported as needing to be updated. So what changed? My guess is that while the device was mounted, modifcation dates were cached using normal granularity. Once I’ve remounted the file-system, the cache was purged, the the low-granularity modification date was used. That meant test-odd now had a modificaiton time which was one second before the original.

So how can it be avoided? Probably the trivial solution is to tell rsync not to copy over the modification date. This means that the copied files would probably anyway get a new modification time which is more than 1 second later than the original, hence even when rounding the modification time as FAT does it will still work. But a much better solution is built right into rsync: --modify-window

When comparing two timestamps, rsync treats the timestamps as
being equal if they differ by no more than the modify-window
value. This is normally 0 (for an exact match), but you may
find it useful to set this to a larger value in some situations.
In particular, when transferring to or from an MS Windows FAT
filesystem (which represents times with a 2-second resolution),
–modify-window=1 is useful (allowing times to differ by up to 1

By using --modify-window=1 we can overcome the problem, as the files will be deemed as modified at the same time. Indeed it solves the problem:

$ rsync -avv --update --modify-window=1 test-{even,odd} /media/guyru/4E09-6457
sending incremental file list
delta-transmission disabled for local transfer or --whole-file
test-even is uptodate
test-odd is uptodate
total: matches=0  hash_hits=0  false_alarms=0 data=0

sent 82 bytes  received 140 bytes  444.00 bytes/sec
total size is 209,715,200  speedup is 944,663.06

23 January, 2017 06:45 PM

13 January, 2017

Ram on Agmon

סיכום שנה שנת 2016 + מצבה של התוכנה החופשית

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

הטקסט המלא

13 January, 2017 12:10 PM

01 January, 2017

Guy Rutenberg

Let’s Encrypt: Reload Nginx after Renewing Certificates

Today I had an incident which caused my webserver to serve expired certificates. My blog relies on Let’s Encrypt for SSL/TLS certificates, which have to be renewed every 3 months. Usually, the cronjob which runs certbot --renew takes care of it automatically. However, there is one step missing, the server must reload the renewed certificates. Most of the time, the server gets reloaded often enough so everything is okay, but today, its been a quite a while since the last time since the nginx server was restarted, so expired certificates were served and the blog became unavailable.

To workaround it, we can make sure nginx reloads it configuration after each successful certificate renewal. The automatic renewal is defined in /etc/cron.d/certbot. The default contents under Debian Jessie are as follows:

# /etc/cron.d/certbot: crontab entries for the certbot package
# Upstream recommends attempting renewal twice a day
# Eventually, this will be an opportunity to validate certificates
# haven't been revoked, etc.  Renewal will only occur if expiration
# is within 30 days.

0 */12 * * * root test -x /usr/bin/certbot && perl -e 'sleep int(rand(3600))' && certbot -q renew

The last line makes sure certificate renewal runs twice a day. Append --renew-hook "/etc/init.d/nginx reload" to it, so it looks like this:

0 */12 * * * root test -x /usr/bin/certbot && perl -e 'sleep int(rand(3600))' && certbot -q renew --renew-hook "/etc/init.d/nginx reload"

The --renew-hook runs the next argument after each successful certificate renewal. In our case we use it to reload the nginx configuration, which also reloads the newly renewed certificates.

01 January, 2017 08:44 PM

26 December, 2016

Amir Aharoni

Amir Aharoni’s Quasi-Pro Tips for Translating the Software That Powers Wikipedia

As you probably already know, Wikipedia is a website. A website has content—the articles; and it has user interface—the menus around the articles and the various screens that let editors edit the articles and communicate to each other.

Another thing that you probably already know is that Wikipedia is massively multilingual, so both the content and the user interface must be translated.

Translation of articles is a topic for another post. This post is about getting all of the user interface translated to your language, as quickly and efficiently as possible.

The most important piece of software that powers Wikipedia and its sister projects is called MediaWiki. As of today, there are 3,335 messages to translate in MediaWiki. “Messages” in the MediaWiki jargon are strings that are shown in the user interface, and that can be translated. In addition to core MediaWiki, Wikipedia also has dozens of MediaWiki extensions installed, some of them very important—extensions for displaying citations and mathematical formulas, uploading files, receiving notifications, mobile browsing, different editing environments, etc. There are around 3,500 messages to translate in the main extensions, and over 10,000 messages to translate if you want to have all the extensions translated. There are also the Wikipedia mobile apps and additional tools for making automated edits (bots) and monitoring vandalism, with several hundreds of messages each.

Translating all of it probably sounds like an enormous job, and yes, it takes time, but it’s doable.

In February 2011 or so—sorry, I don’t remember the exact date—I completed the translation into Hebrew of all of the messages that are needed for Wikipedia and projects related to it. All. The total, complete, no-excuses, premium Wikipedia experience, in Hebrew. Every single part of the MediaWiki software, extensions and additional tools was translated to Hebrew, and if you were a Hebrew speaker, you didn’t need to know a single English word to use it.

I wasn’t the only one who did this of course. There were plenty of other people who did this before I joined the effort, and plenty of others who helped along the way: Rotem Dan, Ofra Hod, Yaron Shahrabani, Rotem Liss, Or Shapiro, Shani Evenshtein, Inkbug (whose real name I don’t know), and many others. But back then in 2011 it was I who made a conscious effort to get to 100%. It took me quite a few weeks, but I made it.

Of course, the software that powers Wikipedia changes every single day. So the day after the translations statistics got to 100%, they went down to 99%, because new messages to translate were added. But there were just a few of them, and it took me a few minutes to translate them and get back to 100%.

I’ve been doing this almost every day since then, keeping Hebrew at 100%. Sometimes it slips because I am traveling or I am ill. It slipped for quite a few months because in late 2014 I became a father, and a lot of new messages happened to be added at the same time, but Hebrew is back at 100% now. And I keep doing this.

With the sincere hope that this will be useful for translating the software behind Wikipedia to your language, let me tell you how.


First, let’s do some work to set you up.

Priorities, part 1

The translatewiki.net website hosts many projects to translate beyond stuff related to Wikipedia. It hosts such respectable Free Software projects as OpenStreetMap, Etherpad, MathJax, Blockly, and others. Also, not all the MediaWiki extensions are used on Wikimedia projects; there are plenty of extensions, with many thousands of translatable messages, that are not used by Wikimedia, but only on other sites, but they use translatewiki.net as the platform for translation of their user interface.

It would be nice to translate all of them, but because I don’t have time for that, I have to prioritize.

On my translatewiki.net user page I have a list of direct links to the translation interface of the projects that are the most important:

I usually don’t work on translating other projects unless all of the above projects are 100% translated to Hebrew. I occasionally make an exception for OpenStreetMap or Etherpad, but only if there’s little to translate there and the untranslated MediaWiki-related projects are not very important.

Priorities, part 2

So how can you know what is important among more than 15,000 messages from the Wikimedia universe?

Start from MediaWiki most important messages. If your language is not at 100% in this list, it absolutely must be. This list is automatically created periodically by counting which 600 or so messages are actually shown most frequently to Wikipedia users. This list includes messages from MediaWiki core and a bunch of extensions, so when you’re done with it, you’ll see that the statistics for several groups improved by themselves.

Now, if the translation of MediaWiki core to your language is not yet at 18%, get it there. Why 18%? Because that’s the threshold for exporting your language to the source code. This is essential for making it possible to use your language in your Wikipedia (or Incubator). It will be quite easy to find short and simple messages to translate (of course, you still have to do it carefully and correctly).

Getting Things Done, One by One

Once you have the most important MediaWiki messages 100% and at least 18% of MediaWiki core is translated to your language, where do you go next?

I have surprising advice.

You need to get everything to 100% eventually. There are several ways to get there. Your mileage may vary, but I’m going to suggest the way that worked for me: Complete the easiest piece that will get your language closer to 100%! For me this is an easy way to strike an item off my list and feel that I accomplished something.

But still, there are so many items at which you could start looking! So here’s my selection of components that are more user-visible and less technical, sorted not by importance, but by the number of messages to translate:

I put MediaWiki core last intentionally. It’s a very large message group, with over 3000 messages. It’s hard to get it completed quickly, and to be honest, some of its features are not seen very frequently by users who aren’t site administrators or very advanced editors. By all means, do complete it, try to do it as early as possible, and get your friends to help you, but it’s also OK if it takes some time.

Getting All Things Done

OK, so if you translate all the items above, you’ll make Wikipedia in your language mostly usable for most readers and editors.

But let’s go further.

Let’s go further not just for the sake of seeing pure 100% in the statistics everywhere. There’s more.

As I wrote above, the software changes every single day. So do the translatable messages. You need to get your language to 100% not just once; you need to keep doing it continuously.

Once you make the effort of getting to 100%, it will be much easier to keep it there. This means translating some things that are used rarely (but used nevertheless; otherwise they’d be removed). This means investing a few more days or weeks into translating-translating-translating.

But you’ll be able to congratulate yourself on the accomplishments along the way, and on the big accomplishment of getting everything to 100%.

One strategy to accomplish this is translating extension by extension. This means, going to your translatewiki.net language statistics: here’s an example with Albanian, but choose your own. Click “expand” on MediaWiki, then again “expand” on “MediaWiki Extensions”, then on “Extensions used by Wikimedia” and finally, on “Extensions used by Wikimedia – Main”. Similarly to what I described above, find the smaller extensions first and translate them. Once you’re done with all the Main extensions, do all the extensions used by Wikimedia. (Going to all extensions, beyond Extensions used by Wikimedia, helps users of these extensions, but doesn’t help Wikipedia very much.) This strategy can work well if you have several people translating to your language, because it’s easy to divide work by topic.

Another strategy is quiet and friendly competition with other languages. Open the statistics for Extensions Used by Wikimedia – Main. Find your language. Now translate as many messages as needed to pass the language above you in the list. Then translate as many messages as needed to pass the next language above you in the list. Repeat until you get to 100%.

For example, here’s an excerpt from the statistics for today:

MediaWiki translation stats exampleLet’s say that you are translating to Malay. You only need to translate eight messages to go up a notch (901 – 894 + 1). Then six messages more to go up another notch (894 – 888). And so on.

Once you’re done, you will have translated over 3,400 messages, but it’s much easier to do it in small steps.

Once you get to 100% in the main extensions, do the same with all the Extensions Used by Wikimedia. It’s over 10,000 messages, but the same strategies work.

Good Stuff to Do Along the Way

Never assume that the English message is perfect. Never. Do what you can to improve the English messages.

Developers are people just like you are. They may know their code very well, but they may not be the most brilliant writers. And though some messages are written by professional user experience designers, many are written by the developers themselves. Developers are developers; they are not necessarily very good writers or designers, and the messages that they write in English may not be perfect. Keep in mind that many, many MediaWiki developers are not native English speakers; a lot of them are from Russia, Netherlands, India, Spain, Germany, Norway, China, France and many other countries, and English is foreign to them, and they may make mistakes.

So report problems with the English messages to the translatewiki Support page. (Use the opportunity to help other translators who are asking questions there, if you can.)

Another good thing is to do your best to try running the software that you are translating. If there are thousands of messages that are not translated to your language, then chances are that it’s already deployed in Wikipedia and you can try it. Actually trying to use it will help you translate it better.

Whenever relevant, fix the documentation displayed near the translation area. Strange as it may sound, it is possible that you understand the message better than the developer who wrote it!

Before translating a component, review the messages that were already translated. To do this, click the “All” tab at the top of the translation area. It’s useful for learning the current terminology, and you can also improve them and make them more consistent.

After you gain some experience, create a localization guide in your language. There are very few of them, and there should be more. Here’s the localization guide for French, for example. Create your own with the title “Localisation guidelines/xyz” where “xyz” is your language code.

As in Wikipedia, Be Bold.

OK, So I Got to 100%, What Now?

Well done and congratulations.

Now check the statistics for your language every day. I can’t emphasize how important it is to do this every day.

The way I do this is having a list of links on my translatewiki.net user page. I click them every day, and if there’s anything new to translate, I immediately translate it. Usually there is just a small number of new messages to translate; I didn’t measure precisely, but usually it’s less than 20. Quite often you won’t have to translate from scratch, but to update the translation of a message that changed in English, which is usually even faster.

But what if you suddenly see 200 new messages to translate? It happens occasionally. Maybe several times a year, when a major new feature is added or an existing feature is changed.

Basically, handle it the same way you got to 100% before: step by step, part by part, day by day, week by week, notch by notch, and get back to 100%.

But you can also try to anticipate it. Follow the discussions about new features, check out new extensions that appear before they are added to the Extensions Used by Wikimedia group, consider translating them when you have a few spare minutes. At the worst case, they will never be used by Wikimedia, but they may be used by somebody else who speaks your language, and your translations will definitely feed the translation memory database that helps you and other people translate more efficiently and easily.

Consider also translating other useful projects: OpenStreetMap, Etherpad, Blockly, Encyclopedia of Life, etc. Up to you. The same techniques apply everywhere.

What Do I Get for Doing All This Work?

The knowledge that thanks to you people who read in your language can use Wikipedia without having to learn English. Awesome, isn’t it? Some people call it “Good karma”.

Oh, and enormous experience with software localization, which is a rather useful job skill these days.

Is There Any Other Way in Which I Can Help?


If you find this post useful, please translate it to other languages and publish it in your blog. No copyright restrictions, public domain (but it would be nice if you credit me and send me a link to your translation). Make any adaptations you need for your language. It took me years of experience to learn all of this, and it took me about four hours to write it. Translating it will take you much less than four hours, and it will help people be more efficient translators.

Filed under: Free Software, localization, Wikipedia

26 December, 2016 09:26 PM

17 December, 2016


ניתוח מחרוזות חלק א' התאוריה (על רגל אחת)

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

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

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

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

כיצד מחשב יבין זאת, כשפה אנושית?

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

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

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

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

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

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

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

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

עכשיו שאלה – כאשר מדובר בדף HTML, האם מדובר בשפה דטרמיניסטית או לא?

תויק תחת:regex, טכנולוגיה, פיתוח, קוד פתוח, תוכנה, תכנות

17 December, 2016 07:16 PM

08 December, 2016


מתכנת IT

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

תנו לי רגע להסביר מה זה בעצם IT, שכולם אוהבים להתייחס אליו.
IT הם ראשי תיבות של Information Technology. כלומר מי שמוגדר כאיש IT, מתעסק בטכנולוגיות העוסקות במידע.

עכשיו אשאל אתכם שאלה: האם איש DBA שייך לקבוצה הזו? התשובה היא כן. האם הוא איש DevOps? התשובה היא לא.

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

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

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

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

האם איש רשתות (כזה המקים רשתות, משחיל כבלים, ומגדיר ציוד), יודע כיצד TCP/IP Stack עובד? אולי. האם הוא יודע עכשיו לכתוב מערכת אשר יודעת לפתוח socket ולהעביר מידע? רוב הסיכויים שלא, אבל אם כן, זה לא המומחיות שלו, והוא יעשה את זה פחות טוב מאשר מתכנת שהמומחיות שלו זה socket. לא בגלל שמסובך לעשות זאת, אלא משום שיש עוד ניואנסים על גבי זה אשר צריך לקחת בחשבון. למשל האם צריך TCP Keep-Alive? האם צריך לשנות פרגמנטציה ברמה של תוכנה ולא של TCP? כל אלו הם התפקיד של המתכנת, אבל לא של איש רשתות.

עולם ה IT הוא ענק, ומכיל בתוכו מגוון עצום של תתי מקצועות.

אז מה הכוונה שלי, כאשר אני אומר שאני מתכנת IT?

אני יודע להשתמש ולהעביר מידע ממקום למקום, בצורה המתאימה ביותר לצורך ושימוש מסוים. עבורי מסד נתונים, sockets, ממשק web, שיחת טלפון וכיוב', הם כולם by product של הצורך להעביר מידע. אני מבין המון איך טלפוניה עובדת, כי זו תת ההתמחות שלי במשך 10 שנים, אבל טלפוניה דורשת ממני עוד המון דברים בנוסף:

והרשימה עוד גדולה מאוד יחסית.
אבל כל הרשימה הזו היא רשימה של by-product לדבר אחד – להעביר מידע ממקור x למקור y ולפעמים למספר מקורות, ולדעת להשתמש במידע הזה, או פשוט להנגיש אותו לשימוש.
זו אסופה של תכונות שמאפשרות לי לספק צרכים, אבל הם לא העיקר, אלא האמצעי. העיקר הוא הבנה של סוגי מידע והיכולת להתמודד איתו היא שהופכת אותי להיות מתכנת IT.
כלומר אני משתמש בהרבה תכונות של עולם ה IT בשביל להשיג מטרה של עבודה עם מידע.

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

אז אני מתכנת IT, מה המקצוע שלכם?

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

08 December, 2016 10:54 AM

18 October, 2016

PyCon Israel

Pycon Israel 2016 wrap up

A little less than six months ago, we held the first PyCon in Israel. To our dismay, it took us this long to post all the videos from the event, but now they’re finally up, and you can finally catch up on The Track Not Taken.

We’d like to take this opportunity to clear the 2016 table and summarize the conference, to give it some closure.

The conference was a lot of work and fun to organize, and truly wonderful to witness. We’ve had:

Over and beyond the hard data, there was a great feeling of a community coming together.

There’s a few points we want to discuss in more details:


We made a conscious effort to make the conference more welcoming to diverse populations. This included a well-defined Code of Conduct, as well as reaching out to specific communities, which are usually underrepresented in technical conferences. This included, of course, the cooperation with Django Girls Tel Aviv, who were invited to the conference; we did not collect the statistics of visitor gender, but we have reason to believe it was significantly more balanced than usual. We also reached out to some other groups who were less clearly visible. By all the feedback we got, everybody felt very welcome.

To our regret, we could not show the same level of diversity among the speakers. Only 3 of the 32 accepted talks were presented by women, and none of these were Israeli. Further, we did not have a travel-support plan for speakers, and partly as a result of that, we did not have any speaker from the less-privileged parts of the world. We still have some way to go there.

We intend to keep pursuing diversity in future editions of PyCon Israel.


In the spirit of Open Source and transparency, we’re happy to share a summary of our budget (all numbers are thousands of Shekels).


Sponsorship: 246

Ticket sales: 54

Total: 300


Venue (incl. food): 134

Conf. party (food+movie): 41

Keynote speakers travel: 30

Speaker’s dinner: 13

Video recording & editing: 20

T-shirts & other swag: 28

Wireless internet: 5

Various other: 3

Total: 274

As you can see, we ended with a positive balance of close to 26K ILS. This is more than we intended, a miss we attribute to over-cautiousness and inexperience. A small part of this surplus will go to support Hamakor, the Israeli F/OSS association which helped make the conference happen, and the rest will go into the budget of the next PyCon Israel.

Community organizations

We’d like to call out three special groups which could use your help — participation as well as sponsorship; groups whose ongoing work enabled this conference and will hopefully enable others like it in the future:


Since so long has passed, we can also add a look to the future: Preparations for PyCon Israel 2017 have already started! You can join the organizing team, or just keep track of our progress via our different channels -

Blog: https://medium.com/@pyconil

Twitter: @pyconil, #pyconil

YouTube channel: https://www.youtube.com/channel/UC8ApA9ibgkf0XK7lgTVZgEQ

Facebook: https://www.facebook.com/pyconisrael/

Google group: https://groups.google.com/forum/#!forum/pycon-israel (requires registration)

Website: http://il.pycon.org/

Final words

Watching the months of preparations come to full fruition made our hearts burst with joy. We’d like to thank everyone involved — all CFP submission authors, the invited and accepted speakers, the sponsors (and in particular the Diamond sponsors, Red Hat & Cymmetria), the vendors (and in particular the helpful staff of our wonderful venue at Yes Planet), the Israeli Python community in general for making such an event possible, and you, the attendees, for making it a reality.

See you in 2017,

The PyCon Israel organizing team

18 October, 2016 07:45 PM

12 October, 2016

Lev Meirovitch

Beware Java’s half baked generics

Usually I don’t badmouth Java. I think its a very good programming language. In fact, I tend to defend it in arguments on various forums. Sure, it lacks features compared to some other languages, but then again throwing everything including a kitchen sink in to a language is not necessarily a good idea. Just look […]

12 October, 2016 10:32 PM

23 September, 2016

Yosef Or Boczko

GNOME 3.22 שוחרר !

צהריים טובים.

לאחר מחזור פיתוח בן שישה חודשים, שוחררה גרסה 3.22 של שולחן העבודה GNOME !

GNOME 3.22 Hebrew

גרסה זו מכילה 22980 שינויים שנרשמו ב־Git על ידי 775 תורמים, בהשוואה ל־28933 שינויים על ידי 837 תורמים ב־3.20.

אחוז התרגום עומד על 80% (36912 מחרוזות מתורגמות, 3682 מעורפלות ו־49874 שאינן מתורגמות), בהשוואה ל־80% (36069 מחרוזות מתורגמות, 3702 מעורפלות ו־4937 שאינן מתורגמות) ב־3.20 ו־82% (37120 מחרוזות מתורגמות, 3326 מעורפלות ו־4675 שאינן מתורגמות) ב־3.18.

על התרגום בעיקר אני אחראי, ולאחרונה הצטרף ניב באר ותרגם את חלק מהתיעוד למשתמש „צעדים חדשים ב־GNOME” (נקרא ‏gnome-getting-started-docs) ואפילו החל לתרגם ליישומים (טרם מצאתי זמן להכניס את התרגומים האחרונים שלו).

להלן מוטמע סרטון המציג את GNOME 3.22. קריינות על ידי קארן סנדלר, לשעבר מנכ״ל קרן GNOME, ומייק טרנטינו. עריכה על ידי Bastian Ilsø, שעורך סרטונים אלו כבר למספר שחרורים.

כרגיל, אוסיף כאן שיר. שיר יפה, שפשוט נהניתי לנגן על הפסנתר.


יוסף אור

23 September, 2016 02:47 PM

07 September, 2016

Oz Nahum

Dockerfile quicky - templating with M4

Creating abstracted Dockerfile is something I really wish existed. Every time, I write a `Dockerfile` for a specific base image I must specify the correct package manager command. You either use `apt-get` or `apk` or `yum` or any other call for the package manager. This is unfortunately, not very reusable. But, here is a simple schema how to use M4 macros to achieve this abstraction. continue reading...

07 September, 2016 09:12 PM

14 August, 2016

Yosef Or Boczko

מצב תרגום GNOME – לקראת 3.22

ערב טוב.

בשבוע האחרון תרגמתי ובכך צמצמתי פערים של חצי שנה ללא תרגום, והבאתי את GNOME לתרגום מלא (להוציא את gitg ואת gnome-builder, שלא תורגמו גם בגרסה הקודמת).

אחוז התרגום עומד על 80% (36915 מחרוזות מתורגמות, 3727 מעורפלות ו־4987 שאינן מתורגמות), בהשוואה ל־80% (36069 מחרוזות מתורגמות, 3702 מעורפלות ו־4937 שאינן מתורגמות) ב־3.20 ו־82% (37120 מחרוזות מתורגמות, 3326 מעורפלות ו־4675 שאינן מתורגמות) ב־3.18.

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

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

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

ערב טוב,

יוסף אור


14 August, 2016 04:05 PM

12 August, 2016


החלצות מעידכון כושל

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

הטקסט המלא

12 August, 2016 04:42 PM

08 August, 2016

Lior Kaplan

איש קוד פתוח מחפש עבודה

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

מאז הפרסום הקודם עשיתי אינטגרציה של ZendServer להפצות הלינוקס השונות (Debian, Ubuntu, RHEL/Centos), עסקתי בקמפול של PHP לכל מיני ארכיטקטורות (חוץ מאינטל) וגם הפכתי לחבר בקהילת ה-PHP עם תרומות קוד בסיסיות ועבודה עם צוות האבטחה של הפרוייקט ושאר ההפצות. בנוסף, עבדתי בלינווייט כדי לשלב את הידע שלי מפרוייקטי קוד פתוח עם תהליכי הפיתוח של החברה (ברמת הניהול וברמה הטכנית). הרקע שלי הוא של sysadmin וארכיטקט מערכת, ואז המשכתי בעיקר לעולם תהליכי הפיתוח Continuous Integration. במסגרת פרוייקטי הקוד הפתוח צברתי ניסיון עם GIT וכמובן בעבודה מול קהילה. כיום אני חבר בשלושה פרוייקטים: Debian, LibreOffice ו-PHP (רמת התרומות משתנה לפי העניין והזמן הפנוי).

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

פרטים נוספים אפשר למצוא בפרופיל הלינקדאין שלי: https://www.linkedin.com/in/liorkaplan

תויק תחת:Israeli Community

08 August, 2016 12:10 PM

31 July, 2016

Ram on Agmon

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

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

הטקסט המלא

31 July, 2016 08:25 PM

13 July, 2016

Itzik Kotler

Fuzzing The Kill Chain

Fuzzing is a technique in software testing where you generate a number of random inputs, and see how a program handles it. So what does a testing technique have to do with a process such as the Cyber Kill Chain as developed by Lockheed Martin? Easy! Just as fuzzing a software produces resilient software, fuzzing a process will produce a validated process. The Kill Chain takes about seven steps that adversaries must complete in order to achieve their goals, but will it always be the case? Can an attacker pull off a successful attack with just one step? Or three? That’s what we’re going to fuzz out ...

(Again, in order to avoid cross-posting between the different blogs, that was just a brief paragraph and a link to the original post is below).

Continue reading: https://www.safebreach.com/blog/fuzzing-the-kill-chain

Full text

13 July, 2016 08:14 PM

08 July, 2016

Lior Kaplan

First uses of the PHP 5.4 security backports

I recently checked the Debian PHP 5.4 changelog and found out this message (5.4.45-0+deb7u3 and 5.4.45-0+deb7u4):

* most patches taken from https://github.com/kaplanlior/php-src
Thanks a lot to Lior Kaplan for providing them.

I was very pleased to see my work being used, and I hope this would save other time while providing PHP long term support.

Also, while others do similar work (e.g. Remi from RedHat), it seems I’m the only when that make this over GIT and with full references (e.g. commit info, CVE info and bug number).

Comments and suggestions are always welcome… either mail or even better – a pull request.

Filed under: Debian GNU/Linux, PHP

Full text

08 July, 2016 12:07 AM

07 July, 2016

Lior Kaplan

Anonymous CVE requests

A year ago I’ve blogged about people requesting CVE without letting upstream know. On the other hand, per requests from Debian, I’m working on improving PHP upstream CVE request process. For the last few release this means I ask the security list members which issues they think should have CVE and ask for them in parallel to the release being made (usually in the space between the release being tagged publicly and is actually announced).

In the last week, I’ve encountered a case where a few CVE were assigned to old PHP issues without any public notice. The fixes for these issues have been published a year ago (August 2015). And I find out about these assignment through warning published by the distributions (mostly Debian, which I’m close to).

Sometimes things fall between the chairs, and it’s perfectly OK to ask for CVE to make sure security issues do get attention even if time has passed. But after the issues (and fixes) are public, I don’t see a reason to do so without making the request itself public as well. And even if the request wasn’t public, at least notify upstream so this info can be added to the right places. Most of these bug were found out when I started to add sequential number into the CVE search after getting an a notice from Debian for two of the issues.

And while working on processing these issues for PHP, I also notice they weren’t updated for libGD where appropriate (including recent issues).

Beyond keeping the eco-system up to date, another aspect of publicity is getting opinions from other parties. For example, in the case of CVE-2015-8879, RedHat doesn’t agree with the classification of the bug as security. To give an example of a way things should happen is the request of CVE for PHP 5.5.34 in April, in which the Gentoo security team asked for assignment without upstream knowledge, Debian representative CCs upstream (Thanks!) and also asks CVE for issues covered by Ubuntu, to which the Ubuntu guy then adds some details.

I hope this blog post will reach the anonymous people behind these CVE requests, and also the people assigning them. Without transparency and keeping things in synchronization, the idea of having a centralized location for security warning is not going to accomplish its goals.

Filed under: Debian GNU/Linux, PHP

Full text

07 July, 2016 11:51 PM

24 June, 2016


טיפ: התקנת NX על OpenSUSE Leap 42.1

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

הטקסט המלא

24 June, 2016 09:35 AM

27 May, 2016

Shlomi Fish

Tech Tip: Checking the Latest Build in Travis CI

If you are using Travis CI, you can check the latest build after a failed build by going to the “Build History” tab in your project’s main page (= https://travis-ci.org/shlomif/fc-solve or equivalent), and selecting the new commit.


Copyright by Shlomi Fish, 2016.

You can reuse this entry under the Creative Commons Attribution 3.0 Unported licence, or at your option any later version of it. See the instructions on how to comply with it.

27 May, 2016 12:43 PM

21 May, 2016

Amir Aharoni

I Deleted My Facebook Account

I used Facebook quite a lot. I posted lots of things, I got to know a lot of people, I learned about things that I wouldn’t learn anywhere else, I shared experiences.

But the feeling that I am the product and Facebook is the user got stronger and stronger as time passed. It happens with many other companies and products, but with Facebook it’s especially strong.

In February 2015 I stopped posting, sharing and liking, and I deleted Facebook apps from all my other devices. I continued occasionally reading and exchanging private messages in a private browser window.

Then I noticed that a few times things were shared in my name, and people liked them and commented on them. I am sure that I didn’t share them, and I am also quite sure that it wasn’t a virus (are there viruses that do such things on GNU/Linux?). Also, a few people told me that they received messages from me, and I’m sure that I didn’t send them; It’s possible that they saw something else under my name and thought that it’s a message even though it was something else, but in any case, nobody is supposed to think such a thing. That’s not how people are supposed to interact.

I am not a bug, not an A/B test, not a robot, not an integer in a database. I am Amir Aharoni and from today Facebook doesn’t use me. There are other and better ways to communicate with people.

Stop saying that “everybody is on Facebook”. I am not. I don’t feel exceptionally proud or special. I am not the only one who does this; a few of my friends did the same and didn’t write any blog posts or make any fuss about it.

You should delete your Facebook account, too.

Filed under: Facebook, Free Software, Internet

21 May, 2016 09:30 PM

Shachar Shemesh

על פטרת צפרניים ופרטיות

פוסט זה הוא תגובה לטור של ג׳קי לוי בישראל היום. מר לוי היקר, אני יהודי חרד. לא חרדי. אינני נוהג ללבוש שחורים, אפילו לא כאסטרטגיית דיאטה. את השקפתי הדתית ניתן לסכם במילה „אתאיסט”, אף כי אני מקיים באדיקות את הוראות מורינו הדגול רוג׳ר רביט (הוראות שמהכרותי עם הצדדים היותר פומביים של אישיותך, גם אתה לא […]

The post על פטרת צפרניים ופרטיות appeared first on לינוקס ותוכנה חופשית.

21 May, 2016 05:59 AM

29 April, 2016

PyCon Israel

Meet our silver sponsors — Cloudify

Cloudify is an open-source Python Shop developing an orchestration framework for any cloud infrastructure provider allowing to use the tools of your choice to manage your applications. Cloudify’s mission statement is to allow organizations to realize the benefits of cloud computing by simplifying the management of cloud applications at scale.

Our complex challenges vary from scaling and healing to abstracting common tools like Docker, Puppet, Chef, Telegraf and the likes via Cloudify plugins. We adhere to PEP8 and do not compromise on code quality! OpenStack contributors are welcome.

We’re looking for brilliant developers to join us on a journey to take the concept of orchestration to the next level. http://github.com/cloudify-cosmo is our home. You’re invited.

29 April, 2016 08:55 AM

14 April, 2016

Arie Skliarouk


In our company developers deal with massive datasets that needs to be easy to copy, modify a fraction of it and scrape. Snapshotting is an ideal solution here. Each developer has a personal vserver (LXC container). The missing piece here is to provide them with a way to manipulate partitions and snapshots from inside of their vservers.

To enable users manipulate partitions from inside of the virtual server, I wrote LLS (LXC+LVM+Snapshots) scripts.

LXC+LVM+Snapshots = LLS

LLS system is set of scripts that enable LVM partitions and snapshots to be managed from inside of LXC vservers. It is safer to allow developers to use the scripts, instead of giving them superuser access to the physical machine.


The LLS scripts consist from two parts. The daemon script on the host and client scripts on the vservers. The clients communicate with the server over a named pipe in a shared (bind mount) directory /lls (lls - LXC+LVM+Snapshots). The /lls directory is actually a small partition that contains configuration file, the shell scripts and the named pipe used for communcation.
The daemon script does all the necessary low-level manipulations, both on the physical machine and on the LXC vservers.

Each LLS vserver has /lls partition mounted. To preserve mounts across reboots, the /etc/rc.local file runs /lls/tools/lls_mount_on_boot.sh script.
There are several client scripts the /lls/tools partition that do various operations:
script nameOperation
lls_create_partition.shCreate a partition
lls_create_snapshot.shCreate an LVM snapshot from an existing LVM partition
lls_delete_partition.shDelete an LVM partition or snapshot
lls_list_partitions.shList available LLS partitions and refresh /dev/mf directory
lls_mount_on_boot.shMount LLS partitions using configuration in the /etc/fstab file

The scripts show informative Usage information when ran without arguments.
Developers are expected to operate the scripts by themselves. They are also expected to maintain the /etc/fstab file for mounts they want to survive reboot of their vserver. Unmounted snapshot is assumed to be not necessary anymore and might be deleted at any time.

Further work

As the LLS system is used, more features are asked by developers and system administrators. Here are some of them:
  • Track unused (unmounted) LVM snapshots and delete them automatically
  • Track disk space used/required by LVM snapshot and grow it automatically. Send email to sysadmin each time this happen.
  • Have a way to enable/disable visibility of a LLS partition. This is useful while the LLS partition is under construction.
  • Have a way to mark an LLS partition as non-mountable or mountable in read-only mode.
Version 20111124.

14 April, 2016 12:15 PM

08 April, 2016

Meir Kriheli

מצגת ההרצאה אודות asyncio

AsyncIO נמצאת בספריה הסטנדרטית של פייתון החל מגרסה 3.4, ומספקת תשתית לכתיבת קוד מקבילי הרץ ב-Thread בודד.

ההרצאה אודות AsyncIO שהועברה במסגרת PyWeb-IL 52 זמינה בעמוד הרצאות ומצגות.

08 April, 2016 06:49 AM

25 March, 2016

Shlomi Fish

Freecell Solver 4.2.0 was Released

Freecell Solver version 4.2.0, has been released. It is available in the form of a source archive, from the download page. Freecell Solver is an open source library and some command line applications, for automatically solving several variants of card Solitaire / Patience games, including Freecell.

This release sports the new configuration theme “-l conspiracy-theory” (or “-l ct”) which is somewhat faster than the best contender up to it, “-l amateur-star”, some relatively minor bug fixes, new compile-time options, and many small and somewhat larger code cleanups, refactorings, and optimisations.

“conspiracy-theory” is a reference to the Jewish holiday of Purim, which took place around the time of its release and an old post of mine about it.


25 March, 2016 04:14 PM

13 March, 2016

Artyom Beilis

לבנות RPM להרבה הפצות

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

בזכות debootstrap היה לי יחסית קל לבנות חבילות deb ל־Debian ו־Ubuntu, אבל המצב הרבה יותר מורכב כשמדובר ב־rpm כי אין דרך קלה לשים את הפצת rpm בספריה ולעשות לתוכה chroot.

בהמלצת שגיא בן־עקיבא התחלתי להשתמש ב־Open Build Service של OpenSuse.

האמת, אני מאוד מרוצה! כל מה שצריך זה להעלות Source RPM או קובץ spec, כל השאר ייעשה בצורה אוטומטית: בניה למספר הפצות ופלטפורמות, הכנת מקורות מסודרים ואפילו אתה מקבל repository מסודר.

בצורה כזו הכנתי rpmים ל־3 הפצות (Fedora, Suse, CentOS) כולל מספר גרסאות וגם הכל עבור שתי ארכיטקטורות: x86 ו־x86_64.


מה שנותר... להבין כיצד משתמשים בשירות עבור debים

הטקסט המלא

13 March, 2016 02:11 PM

כיצד לא לעשות יוניקוד

הסיפורו של הניסיון להדפיס "שלום" במספר שפות במסוף של חלונות.


הטקסט המלא

13 March, 2016 02:11 PM

09 February, 2016

Dan Fruehauf

Spanning files over multiple smaller devices

Imagine you are in Tasmania and need to move 35TB (1 million files) to S3 in the Sydney region. The link between Tasmania and continental Australia will undergo maintenance in the next month, which means either one or both:

In short, I’m going to be presented with a bunch of HDs and I need to copy the data on them, fly to Sydney and upload the data to S3. If the HD given would be 35TB I could just copy the data and be done with it – no dramas. Likely though, the HDs will be smaller than 35TB, so I need to look at a few options of doing that.

Things to consider are:

LVM/ZFS over a few HDs

Building a larger volume over a few HDs require me to connect all HDs at the same time to a machine and if any of them fail I will lose all the data. I decide to not do that – too risky. It’ll also be difficult to debug if anything goes wrong.

tar | split

Not a bad option on its own. An archive can be built and split into parts, then the parts could be copied onto the detination HDs. But the lose of a single HD will prevent me from copying the files on the next HD.

tar also supports -L (tape length) and can potentially split the backup on its own without the use of split. Still, it’ll take a very long time to spool it to multiple HDs as it wouldn’t be able to do it in parallel. In addition, I’ll have to improvise something for untarring and uploading to S3 as I will have no staging area to untar those 35TB. I’ll need something along the lines of tar -O -xf ... | s3cmd.

tar also has an interesting of -L (tape length), which will split a volume to a few tapes. Can’t say I am super keen using it. It has to work the first time.

Span Files

I decided to write a utility that’ll do what I need since there’s only one chance of getting it right – it’s called span-files.sh. It operates in three phases:

The utility is available here:

I’ll let you know how it all went after I do the actual copy. I still wonder whether I forgot some things…

09 February, 2016 12:28 PM

31 January, 2016

Kobi Zamir

Diff , Patch ו Pull Requests

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

הטקסט המלא

31 January, 2016 05:35 PM

24 January, 2016

Kobi Zamir

מכתב לא שגרתי

לפני שבוע קבלתי מכתב לא שגרתי לגבי libhdate. ראשית הכותב אינו שגרתי, מדובר באדם בגיל 80 בערך. שנית מדובר בפלטפורמה לא שגרתית Raspberry Pi. ושלישית מדובר בשימוש לא שגרתי בספריה.

הטקסט המלא

24 January, 2016 04:00 PM

13 December, 2015

Arie Skliarouk

GRUB-based multiple iso booting flash drive

With huge USB flash drives of today it is sad that one can't easily put several bootable ISO images on it and have nice on-boot selection menu.

GRUB to the rescue!

Historically GRUB is being used for hard disks and syslinux for floppies and flash drives. But nothing prevents using GRUB for flash drives as well. Here are instructions for creating bootable GRUB-based USB flash drive (disk on key):

  1. Create vfat partition. For big drives you must use fat32 format.
  2. Unpack the http://t11.meshanet.com/skliarie_blog/boot.tar.gz onto it. It will create single directory boot on the drive.
  3. Customize boot/grub/grub.cfg file, put iso images accordingly
  4. On linux box, put bootable MBR onto the DOK (for example on /dev/sdf):
    1. mount /dev/sdf /mnt/dok
    2. grub-install --force --no-floppy --root-directory=/mnt/dok /dev/sdf
    3. umount /mnt/dok 


    The ISO image must support GRUB-based booting. Specifically it must be smart enough to locate ISO image on the DOK using parameters specified in grub.cfg file.

    Latest Ubuntu and Debian based ISO images are known to work.

    Thanks to Jonathan Vollebregt there is a way to boot knoppix as well. You will need custom initrd, with your flash drive specific tuning. I built one for mine: knoppix_minirt.gz, you are free to take and modify it according to your DOK and filesystem parameters. Important commands here are:
    1. Unpack the initrd
      gzip -dc /mnt/dok/boot/knoppix/minirt_ska.gz | cpio -i
    2. Modify the init file (put sector numbers that are correct for your DOK)
    3. Compress back the initrd
      find ./ | cpio -H newc -o | gzip -9 -c > /mnt/dok/boot/knoppix/minirt_ska.gz
    Please send me GRUB stanzas for other ISO images and I will put them into the grub.cfg file.

    13 December, 2015 01:33 PM

    07 December, 2015

    Ira Abramov

    תלתפסת לכל פועל

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

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

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

    https://ira.abramov.org/3DPadventures/ אנא גלשו למצג המקורית אם משום מה זה לא מציג לכם פה.

    07 December, 2015 03:42 PM

    01 December, 2015

    Meir Kriheli

    מצב התרגום לעברית של Django 1.9

    התחלתי לתרגם מאוחר לאחר הקפאת המחרוזות של Django 1.9, התרגום עמד על 95%.

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

    נשארו בחוץ, שוב, עקב חוסר זמן והיקף המשימה:

    01 December, 2015 07:58 AM

    24 November, 2015

    Yoav Farhi

    וורדפרס.קום, הדור הבא

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

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

    ברמה הטכנית, מדובר על אפליקציית עמוד אחד (Single Page Application), שעושה שימוש בין השאר ב-React, Flux ו Node, ועובדת מול Rest API פתוח. אולי זה נראה כמו תהליך אופייני של כתיבה מחדש של מערכת, אבל בעיניי מדובר בהרבה יותר מזה. מבחינת המתכנתים באוטומטיק המעבר לעבודה על המערכת החדשה דרש אימוץ של כלים וטכנולוגיות חדשות במהירות שיא, ולמידה תוך כדי תנועה. אנדי פיטלינג, מרכז הפרוייקט, כותב על התהליך מאחורי הקלעים ומסביר על הבחירות שלנו, ועל השינויים שעברנו כחברה כדי ליישם אותן.

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

    כן, אנחנו מגייסים עובדים – בואו לעבוד איתנו.

    24 November, 2015 08:51 AM

    16 November, 2015

    Liran Tal

    VeriGreen – lightweight, server side solution for verification of git commits

    Verigreen – https://github.com – is a lightweight, server side solution for verification of git commits. Now open-sourced  by HPE’s VeriGreen team.


    The post VeriGreen – lightweight, server side solution for verification of git commits appeared first on Liran Tal's Enginx.

    16 November, 2015 11:13 AM

    08 November, 2015

    Rabin Yasharzadeh

    Run Command Before Starting SSH Connection

    This a quick hack I found while I was looking to run a knock script before connecting to servers which I have the SSH service protected with a knock sequence. In my setup I used the ProxyCommand option in the ssh_config file to loop over my loop-back interface.

    Host server1
        User root
        Hostname server1.com
        ProxyCommand bash -c 'knock-script %h; sleep 1; ssh -W %h:%p'
    # in the above
    # %h is a place holder for the hostname i.e server1.com
    # and i added 1 sec delay before running the ssh tunnel
    # to give the script on the server side time to validate my knock.


    08 November, 2015 04:58 PM

    05 November, 2015

    David Kaplan

    Lunchbox Glitching for Fun & No Profit

    As part of my work on the IBM X-Force Application Security Team, a few months ago I wanted to see if I could reproduce a Rowhammer-exploit-type memory corruption via an externally-generated electromagnetic pulse (EMP). The idea here was to target primary memory (usually [S]DRAM) to perform a bit-flip via an electromagnetic pulse-induced glitch.

    I have (thus far) failed miserably to build an actual exploit; more on why in a subsequent blog post.

    In this post, I'd like to detail my IBM-sponsored single-pulse glitcher (EMP generator) build (yes, it involves Tupperware) and touch on some basics of the theory of operation of its various components.



    Disclaimer 3: My build's EMP range is in the order of millimeters to centimeters and the interference it causes is relatively weak. It's not a weapon and was built at my employer for security-research purposes only and used only within a private lab. Do not use this build for nefarious reasons!

    OK, warnings aside, let's begin.

    I'll start by detailing the most basic build which simply consists of a single capacitor, a switch and a coil of wire like so:

    If the capacitor was charged, closing the circuit (by flipping the switch) would induce an extremely high current over the coil load (as there is very little resistance in the circuit). This is because capacitors store energy. The amount of energy stored by a capacitor is denoted by Farads, or the symbol F.
    As the electrons flow from the negative pole to the positive pole of the capacitor, a magnetic field is formed as per Maxwell's correction to Ampère's Law. In our circuit above, these electrons flow through the coil - a solenoid - concentrating the magnetic field inside the coil. The strength of this field is proportional to the current flowing through the solenoid which, in turn, is proportional to the energy dissipated by the capacitor discharge.

    It is this magnetic field that causes electronics to go crazy. This is due to the fact that the field can excite electrons (and hence current flow) within the target device (the exact reverse of what's happening on the EMP side). If one manages to excite the target enough, Bad Things May Happen.

    It follows therefore that the more energy stored within the capacitor, the stronger the magnetic field will be.

    The decision that we have to make at this point is which capacitor to chose. We need a capacitor capable of quickly discharging its stored energy and one with large enough capacity to induce a sufficiently-strong magnetic field within the solenoid. We don't wish for the field to be too strong as our range of operation for this project (glitching memory) is in the order of millimeters and the target devices operate at around 3.3 volt so the glitch amplitude shouldn't need to be that high to induce some undefined behaviour.

    The easiest capacitor to go for, imho, is a 330V 80uF flash capacitor. You'll see this advised by a number of glitcher-building guides on the net. The reason is that it's easily available and comes with a charging circuit to match! Just find a disposable camera with a flash and gut it (actually getting more difficult to find these days; I think I found the last 3 in the country).

    A word of caution when opening these cameras. Make sure the capacitor is discharged before touching any part of the circuitry inside. You can do this by firstly winding up the camera and charging the flash. Then activate the shutter to discharge the capacitor. Additionally it's a good idea to make sure it has fully discharged by shorting both ends of the capacitor with a rubber-handled screwdriver (it might make a spark - the energy dissipates as light and heat - but it's likely safe to do with a capacitance of this value).

    In our first circuit above, we assumed that the capacitor was already charged. In our working circuit we will need to charge the capacitor.

    In order to charge capacitors, one must apply a potential difference (voltage) over it's poles which is greater than its rated voltage for a set amount of time. The time that a capacitor takes to charge is specified by the RC time constant, tau T, of the circuit such that the capacitor will be charged to 63% after 1T. At 4T the capacitor will be charged to 98%. The charging time between 0T and 4T is called the transient period. After 4T the capacitor enters the steady-state period. At 5T the capacitor is considered to be fully charged.

    In our circuit, we have selected a value of R = 10k. Our capacitance is C = 80uF.

    T = RC
      = 10k x 80u
      = 800 milliseconds
    5T = 4 seconds

    So in order to charge our capacitor to capacity, we need to apply 330V over its poles for 4 seconds.

    The challenge now is to provide a 330V source with which to charge the capacitor. One can use a DC-DC step-up transformer, however luckily the disposable camera which we pillaged above has a nice little charging circuit which we can re-purpose for our needs.

    The circuit in most disposable cameras has a feedback mechanism whereby closing the switch causes the charging process to commence and it automatically stops charging when the target voltage is reached (this is so that one doesn't need to hold down the flash button on the camera for the whole duration of the transient period). We'll consider it a black-box for our purposes and using this charger, we can update our circuit diagram as follows:

    The push button switch in the diagram above commences the charging procedure. After the capacitor has reached capacity, closing the switch between the capacitor and the solenoid will create the EMP.

    Even though we now have a full EMP circuit, I added a number of features to my design.

    Firstly, I doubled the capacitance of the circuit in order to create a stronger pulse. I pillaged another 80uF capacitor from a disposable camera and added it in parallel to the first capacitor. This gives a total capacitance of 160uF.

    I then added a high impedance voltage-divider circuit which allows me to digitally measure the voltage of the circuit. This is connected in parallel over the capacitor. The reason for the high impedance is that I don't want the capacitor to discharge ('bleed') its energy though this path otherwise there won't be any energy to discharge through the coil!

    The total impedance of the voltage divider is just over 2.2M. To understand the affect that this has on the circuit, we need to take a look at how the capacitor discharges.

    As with the charging circuit above, the capacitor will discharge 63% of its energy in 1T and be fully discharged at 5T. The impedance of the voltage divider is approximated 2.2M, therefore:

    T = RC
      = 2.2M * 160uF
      = 58.6 minutes

    As one can see, the bleeding through the voltage divider is quite slow and doesn't have a major affect on the energy of the EMP if the EMP is triggered shortly after the capacitor is charged.

    Interestingly this also provides a built-in safety feature. Forgetting to discharge the circuit could prove hazardous as capacitors will hold their charge for a long time. The voltage divider will cause the circuit to bleed the capacitors over time as even though the impedance is high, there is some current flowing through this path. The capacitors I'm using will generally be considered safe at around 42V. They will be discharged to this value at roughly 2.2T, so after about 2 hours and 10 minutes.

    The aforementioned voltage divider is connected to a microcontroller (MCU). The one I'm using is the MicroPython board which is a pretty awesome bit of kit (highly recommended). I use this board connected over USB to a PC to control the glitcher (mostly). The voltmeter gives me an indication of the current level of charge of the capacitor. The MCU is also connected to two relays. The first relay is used to complete the charger circuit (in place of the disposable camera push button). The second relay connects a 3.3k resistor over the poles of the capacitor. I can use this to very quickly discharge (bleed) the circuit and even use it to select a particular voltage for the pulse (I can bleed the circuit for a very short time causing a controlled drop in capacitor charge; to half the voltage for example). This is a 35W rated part as it needs to be able to handle the amount of energy dissipated through it (high current). The interface is shown in the video of the capacitor charging below:

    The final part of the build is the solenoid itself. I have experimented with a number of different coils; diameter, number of windings etc. The ideal coil depends on the application and isn't an exact science at all. For my needs I wanted a small, focused EMP with which I could target a RAM IC without glitching the surrounding electronics. My first attempt at a large coil tended to reset my computer! I then made a few smaller coils out of insulated copper wire wound around ferrite iron cores. Here are some pictures of my various coils:

    So does the glitcher work? Well yes! I verified this experimentally. As mentioned, the large coil can reset my computer. I used the smaller coils to target RAM IC chips in a PC. I was able to cause some havoc with RAM contents but I'll leave that for another blog post.

    As for how the glitch actually looks on the target; according to Wikipedia, what we should see is a damped sinewave pulse. This is due to coupling on the ground plane between the glitcher and the target. I won't go into this in detail but it's all on Wikipedia if you're interested. Throwing an EM pulse out at a scope probe shows exactly this affect so all seems to be working well:

    That's all for now folks! Leaving you with a picture of the glitcher in all it's tupperwear-enclosed glory!

    05 November, 2015 06:12 PM

    02 November, 2015

    David Kaplan

    CUPC/8 Goodbye ROM, Hello ROM

    So it has been a while since my last CUPC/8 (formerly known as CUPCake) update.

    Over the past few months I have spent a significant amount of time working fleshing out the instruction set, implementing support in the assembler and simulator and coding the Kernel (the status of which will be discussed in another blog post).

    I have also spent some time back with the hardware itself; integrating and testing the physical RAM and MMU FPGA modules, bus interfaces etc.

    Additionally, I finally got around to starting the documentation (see here). Some of it is already slightly out of date but hopefully I'll revise it soon.

    As development has progressed, I have continually challenged my original design decisions and this has resulted in a few design revisions.

    The main change is that the memory board is no longer responsible for loading the ROM into primary memory on boot. It just didn't make sense for me to use a powerful (relative to CUPC/8) XMEGA MCU within the context of the project as a whole.
    As such, I have removed the XMEGA from the design. The ROM chip is now connected directly the the SoC over I2C. The SoC also now includes a small ROM buffer on-chip (termed ROM0) which will hold code that will be responsible for bootstrapping the ROM code. ROM0 is memory-mapped into the 64k memory region by the MMU. The hard reset vector points to the start of the ROM0 and will therefore execute it on boot.
    The ROM0 code will be minimal; consiting of a stripped-down I2C driver responsible for the loading of the off-chip ROM chip (ROM1) into primary memory and jumping to the ROM1 start vector.
    This is somewhat similar to how modern CPUs bootstrap today.

    My next milestone is to get the hardware SPI and I2C modules working properly and interfacing ROM1 with the FPGA development board.

    02 November, 2015 01:44 PM

    20 October, 2015

    Guy Sheffer

    FullPageOS – Out-Of-The-Box Kiosk mode for the RaspberryPi



    Hey all,

    Today I am announcing a RaspberryPi operating system that addresses a small need we have – Get the RaspberryPi to display a webpage on full screen with no hassle.
    The OS is called FullPageOS. And you can download it here.

    Why I built it

    A friend of mine, Tailor Vijay wanted something to stream video and add titles to it. Also I was looking for a way to start the RaspberryPi with a browser on full screen for a stats screen at work, and apparently the only thing available is complex guides that only partly work on today’s RaspberryPi.

    So what I did last weekend is build a distro based off the code of OctoPi, the 3D printer operating system I built. All this distro does is start Chromium at boot on full screen, with a URL of your choice. The url can be changed conveniently from a text file on the /boot FAT folder. So all you have to do is set the wifi and url via text files, boot, and voilà!
    Among the minor tweaking is the elusive setting of disabling the screen from blanking.

    How to set it up

    What’s nice about FullPageOS is that its simple, no need to install packages, just flash it like any distro, set your wifi and URL settings and boot.

    1. Open the FAT filesystem that is mounted as /boot
      on the pi
    2. Set the URL you want in the file fullpageos.txt
    3. If you need to set up wifi, set your wifi settings with the file fullpageos-network.txt or any way you want are used to on the RaspberryPI
    4. Plug to HDMI display, internet and boot

    Known issue with black boarders

    On some screens I tried FullPageOS I got a black boarder, to fix this, you need to edit config.txt and uncomment the line:


    This fixes the issue.

    Contribution is appreciated!

    FullPageOS works, but its missing the shiny slickness that OctoPi has today. For example if someone wants help me write a nice default boot page that would be great! The current default url is just the github page. So as usual, pull requests are welcome.
    The source works just like an OctoPi build, and as a by product I wanted to show how easy it is to create custom distros for the RaspberryPi using this build method. We could, really, build a universal custom distro system based off these things. There is already a variant system that was ported from OctoPi code.

    FullPageOS image can be downloaded here


    Share and enjoy,

    Full text

    20 October, 2015 04:04 PM

    20 September, 2015

    Guy Sheffer

    How I Founded a Startup

    ShapeDo logo

    ShapeDo logo

    Hey all,

    It’s my 29th birthday this week, and that sorta made me realise no one really knows what I have been doing the past 18 months, so I thought it’s time to tell you how I founded a company. Unlike the tutorials and guides I wrote here, I am not sure this would work for everyone, but it did work for me.

    The Idea

    I have started one of my biggest and ambitious projects yet, after collaborating with people around the world bringing OctoPi to the world, I realised that something was missing from the scene of 3D design – a decent version control and collaboration tools.

    This was the initial idea, as you will see things played out differently, but what was important with this idea was contagious, I got the feeling everyone I told about it wanted to join me, it was wonderful.

    Assembling the team

    My talent is mostly in the core backed stuff, so I found myself going to one of the more talented web developers I know for help, my co-worker at Zend, Amit. It started by asking him javascript questions. When he realized what I was doing, he started helping me out, and he was fast, suddenly in days my core stuff was accessible to the world with a simple and elegant interface. At that time we thought this is going to be a nice open source project, not something commercial, but as the server load grew on Amit’s little server we understood we needed some way to pay its bills, so I started to look for someone that would help me figure out how to sustain this financially. Since our idea was “github for 3D printing”, it seemed like there should be a way to support it, perhaps charge for closed-source projects.

    I’ve been going around the Makerspaces in Tel-Aviv, mostly XLN and T.A.M.I, in some random workshop I came across someone who said “You should write an executive summary, I don’t mind helping you out”. I didn’t even know what an executive summary was at the time, and today it makes me realise how much I learned about fundraising during this year. I later found his name was Ari and he was between companies. We set to meet at Google Campus and write it since we both went to some ecology hackathon that was going on there.

    We ended up drunk from exhaustion and pizza, scooting on chairs at the space and we also had a draft. As we wrote it, the idea spread to Ari, and he realized he that he wanted to join. I introduced him to Amit. It took a while to put our trust in Ari, less time than we expected, and today I know ShapeDo would not have reached anything without Ari’s help. Eventually we wrote a few basic agreements on paper and Ari made sure we register a company, ShapeDo was born.

    The Pivot

    We worked on a new site for 3D printing and launched, we got coverage on 3D printing industry, and the user base grew, but people were not really using the collaboration features. It turns out most people 3D printing share are simple one person designs in one afternoon projects. However, what is special about the 3D printing industry is that there is no 3D CAD tool that was built for it. So you end up meeting designers from mechanical engineering, gamers, architects, programmers and any discipline that has a 3D design program that can export the printable files. We (everything eventually becomes “we”) found that everyone wanted this kind of tool in their workplace, while in 3D printing was not as urgently needed.

    Ari and I had a talk where he thought we should pivot either to construction planning, or mechanical engineering. In the end construction seemed more favourable because AutoDesk, who rule that realm, had neglected collaboration (also known as, product lifecycle management or PLM) for the past decade, and so there was a lot of low-hanging fruit. At first I didn’t want to pivot, after all 3D printing was my idea, but eventually, I let it go. A lot of what a startup is about is letting go of your ownership, a company has to grow beyond you. We slowly found ourselves with a technology for an industry we know nothing about, so we learned, we banged on doors and met with architects, contractors, constructors, anyone that is in the process of construction, we can’t cover everything, but we were getting an idea of what is going on.

    Investors and our Investment

    The pivot did more than point us to users we could talk to and find out what they actually need, it also made the business proposition make more sense. The goal was not to just build a big collection of files for people to share, it was to build a system we could charge for. We started getting investors interested, we first started talking to angel investors, but it seemed to be much harder than anticipated. Angels seem to be mostly interested in apps. Something your 6 year old could download, something they can understand, there are a small number of them that would understand what it means to sell something to a construction enterprise. So it made the process much harder, we found that the first meeting was just for grasping what we actually do, before talking about the investment itself.

    Ari and I went around looking for an investment, I had an 80% time job so I had an extra day to do this. I had a few chats about it with Gina, who also had that extra day for OctoPrint. I think that 80% is good when you want something steady while looking for funds, stability in your life in one part lets you explore radical stuff in another.

    Eventually we set a meeting with Incentive, we got a warm recommendation for them for the accelerator Ari was going to at the time called Siftech (an accelerator is a place you got to for a few months that helps your startup out with a physical location and various services, usually paid). Indeed when we met with them they seemed much better than the angel investors we were talking to. The catch was that we had to base our offices in Ariel University (though today it seems not so bad, there is never traffic to work). The program they offer was enough to keep us and an extra worker for a 1.5-2 years. Working on something as volatile as ShapeDo means you don’t want to have to think about personal finance, it means you don’t have time to consider the company’s. So we went through a due diligence, it took a while, but it was a good process for us and the company. Today our offices are located in the investors offices.

    Today, Happy 29th Birthday

    Today we found a go to market, something we can sell, and we are just in the process of hiring someone from the industry to help us out. Our system is flooded with real customer data. Things are going great. But as I saw every step of the way, everything can explode the next day, nothing is certain, and I think that kind of attitude is what got us this far.

    I hope this helps the people around me to know what is going on, I feel like I had to let this be known. It might even help others that are on a similar path. I’ve been playing with 3D printers for fun in the meantime, and I might post a few findings.

    As always, would love to hear your comments.

    Celebrating first day at the office

    Celebrating first day at the office

    Example of what we do today

    What we are selling today is a a construction planning collaboration platform and a comparison tool for constructors. At the bottom you can see how complex an architectural plan is, and how easy it is to spot the changes marked in purple detected by our software, normally this would have been done on hard paper by the constructor.

    Architectural plan with the changes marked between two versions

    Architectural plan with the changes marked in purple between two versions

    Full text

    20 September, 2015 09:23 AM

    10 September, 2015

    Yoav Farhi

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

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

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

    10 September, 2015 07:58 AM

    15 August, 2015

    Rabin Yasharzadeh

    [NetworkManager] Using dispatcher.d to run scripts based on network connectivity

    This post is based on my personal need to mount/umount some network shares automatically when I’m switching between networks (e.g Homer/Office). Later on I was looking to make it more modular and came out with this solution, which can be further extended.

    NetworkManager have a nice option to execute scripts after ones connect/disconnect to a network, you can find more in the Arch wiki page including some examples.

    The problem I had with the way dispatcher.d works is that it execute all the files in the dispatcher.d folder in a linear order, and you have to code each script to handle the interface, connection state and the network you’re connecting to, so at first all my scripts looked something like this,

    interface=$1 status=$2
    if [ "$CONNECTION_UUID" = "uuid" ]; then
      case $status in
          export SSH_AUTH_SOCK=$(find /tmp -maxdepth 1 -type s -user "$USER" -name 'ssh')
          su "$USER" -c "sshfs $REMOTE $LOCAL"
          fusermount -u "$LOCAL"

    I hated that I had to replicate the if/case template for each script I was adding, so I came with a different approach. And in my current setup I added the following file to the dispatcher.d folder

    CWD=$(dirname "$0")
    # DEBUG
    echo "$(date +"%F %T") Called with ($*) and connection uuid is: ${CONNECTION_UUID}" >> ${LOG}
    # Needed only if you need to display notification popups
    #export DISPLAY=:0.0
    #export $(grep -z DBUS_SESSION_BUS_ADDRESS /proc/$(pgrep session)/environ)
    for FILE in ${CWD}/${CONNECTION_UUID}/${STATE}/*
            echo "$(date +"%F %T") Running ${FILE}" >> ${LOG}
            . "${FILE}"

    NetworkManager pass 2 parameters to each script it runs under the dispatcher directory,

    And so if we have connected to the home network with, The “master” script will list all the files under 

      and will execute them one-by-one.

    And so my dispatcher folder structure look like this,

    # tree /etc/NetworkManager/dispatcher.d 
    ├── 4237f1af-15bf-46f7-a3a1-9a37c0d075de/
    │   ├── down/
    │   │   └── 00-umount-freenas-media*
    │   └── up/
    │       ├── 00-mount-freenas-media*
    │       ├── 70-wifi-wired-exclusive.sh*
    │       └── 99-set-display*
    ├── fdd94fcd-c801-401c-9caa-ebb21e10bc9e/
    │   ├── down/
    │   └── up/
    │       └── 99-set-display*
    ├── Home -> 4237f1af-15bf-46f7-a3a1-9a37c0d075de/
    ├── Office -> fdd94fcd-c801-401c-9caa-ebb21e10bc9e/



    15 August, 2015 08:28 PM

    09 August, 2015

    Ira Abramov

    איך לא לעצבן לנו את הנגן

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

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

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

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

    1. רספברי פאי 2, עם קופסת ABS קשיחה וספק כוח – סביבות $42. אם אתם רוצים ספק שגם יודע לדחוף זרמים כראוי, אני יכול להמליץ על המפלץ הזה.
    2. להתקין דביאן וקודי על כרטיס 16GB, נגיד עוד כ$5.
    3. כבל HDMI.
    4. זהו. סטרימינג מהרשת, מכוננים של USB או משרת הטורנטים שבחדר העבודה. מי צריך יותר מזה, תכלעס? אה, וזה אפילו מריץ מיינקראפט לילדה, אז בכלל…


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

    אני מקווה שלא שכחתי כלום. בהצלחה!

    09 August, 2015 05:11 PM

    13 April, 2015

    Liran Tal

    The Drupal Rap song – Everyday I’m Drupalin’

    This YouTube video doesn’t need any further explanation beside it’s title: The Drupal Rap song – Everyday I’m Drupalin’





    Everyday I’m drupalin

    Where them forms you gettin fapi with I’m the fapi boss/ hookin into edit form and webforms is my specialty sauce/ I’ll hook form alter by form id’s or entities/ put a list on Ajax/ just to keep it callin back/

    I got them distrobutions, I’m like acqia/
    Check my public repos, I didn’t copy nuttin/ I know dries n webchick, I kno Ryan szrama/ all the commerce guys we hipchat when they got some drama/
    Might not be pretty code but it gets me paid/ I’m using rules like php loopin through arrays/ I put it all in features, so the code is stable/ it might take longer, but next time I just click enable/ These dudes clearin caches, on every hook init/ queries by thousands, page loads by the minutes

    No matter the language we compress it hard/ drugs cc all, we just drugs cc all/
    Where’s all of the changes, you never saw/ so drush cc all, we just drugs cc all/ I lean heavy on smacss, compass compilin my sass/ you just installed flexslider now you teachin a class/
    I seen your content types, I don’t need to kno you/ to know that we ain’t even in the same nodequeue/
    I’m on drupal answers, check my reputation/ I’m on my tablet earnin karma while I’m on vacation/ ya girl like a module, she stay hookin n/ you couldn’t code an info file, without lookin in/
    Mo scrums, equals better sprints, break the huddle, n the work begins

    Thanks to New Valley Media for helping with the video http://www.newvalleymedia.com/
    Thanks to Broadstreet Consullting http://www.broadstreetconsulting.net

    The post The Drupal Rap song – Everyday I’m Drupalin’ appeared first on Liran Tal's Enginx.

    13 April, 2015 05:26 PM