It's surprising how many people do not know that their mysql dumps and restores can be faster if they disable autocommits.
mysqldump mydb --single-transaction >mydb.sql
(echo "SET autocommit=0; cat mydb.sql; echo "COMMIT;") | mysql mydb
It almost works. It will update signatures that you store in a Google Sheet at regular intervals. The only problem is… You have to be a Google Apps for Business administrator to run this thing, because the only way to update a Gmail signature programmatically is via the Google Apps for Business Admin SDK. Ha-ha. Another problem is tha the signature only gets updated when you refresh the page. But that's a minor thing ;-)
Check it out and make a copy to have access to the script.. And here's the code:
There's been very few laws that I followed closely, but all of them had a direct impact on my life, so I took this seriously. I didn't actually follow laws, but rather legislative processes because I either wanted a change or I was averse to it. In both cases, the object of interest was not a law itself, but its evolution.
You should already know that most laws are hand-crafted patches applied to previous laws. There are virtually no laws that are written from scratch, one notable exception is the constitution. Other laws refer to past laws.
For example, today's law that extends the powers of the Belgian intelligence service is a patch applied to the law that created the service in 1996, and it says literally this:
If you go and search for the original law, you won't find it that easily, because laws were digitized back to 1998, while the original law dates from 1996. If you are lucky, you'll have free online access to the so-called 'consolidated' version of the law. That is, a version with all the patches applied. However:
People used to write Greasemonkey scripts or exploit some long-forgotten Gmail Labs extensions… but there's an easier way: just generate images on the fly and refer them in signatures.
Here's my quick-and-dirty way of doing it:
Version-controlled laws
Here's a EurActiv article that gives a bird's eye view of the subject of version control systems applied to legislation.
End-to-end verifiable anonymous voting
This one is better explained by Wikipedia. Here's the description of the simplest of such voting systems.
Inline comments
Here's the best implementation of inline comments until now.
…but because he is ashamed of your ignorance.
…never trust what the user tells you.
…when none cares what operating system he is using.
Ok, ok… it's just one of the mandatory requirements.
Here is an excerpt of the Legal aspects of free and open source software workshop notes. Every phrase is a masterpiece.
"When the public agency has decided that open source requirements are particularly important for a specific software acquisition case, the process described in this section can be followed. This process would end in the agency downloading open source software itself, with no fee paid whatsoever. Separately, commercially provided services and support, if required, may be acquired by publishing calls for tender. Note that this process can be abandoned at any point - for instance, if the software cannot be found easily, or evaluated, or once downloaded is found unsuitable for any reason. At that point, the other approach described in the next section can be followed, namely, publishing a call for tender for open source software."
I had this stuck in my head for months, but only now managed to have some time to write it up
Below are two snippets of SQL code that do the same thing, namely extract the number of contact emails per year from a CRM. The result in both cases is something like the following:
+----------+------+ | count(*) | y | +----------+------+ | 1142 | 2012| | 1148 | 2013| +----------+------+
The first query is written against a heavily customized SugarCRM instance. The second is written against my own home-made CRM
SELECT count(*), year(email_addresses.date_created) y
FROM email_addresses LEFT JOIN email_addr_bean_rel
ON email_addr_bean_rel.email_address_id = email_addresses.id
WHERE email_addresses.email_address LIKE '%@%'
AND email_addr_bean_rel.bean_module = 'Contacts'
AND email_addr_bean_rel.deleted = 0
AND email_addresses.invalid_email = 0
AND email_addresses.opt_out = 0
AND email_addresses.deleted = 0 GROUP BY y;
SELECT COUNT(*), YEAR(created_at) AS y FROM clients WHERE email IS NOT NULL GROUP by YEAR(created_at);
It should be obvious even for a non-programmer which is easier to understand. What is not obvious for non programmers is the amount of effort one needs to make before SugarCRM starts doing things it was not designed for. I could now start talking about the importance of data structures and how the UI is irrelevant, but this will take more pages than Google can handle.