Javascript on Lorenzo Bolla

Wired elements

Tue, 04 Jun 2024 00:00:00 +0000

Recently, a cool project appeared on the front page of HN reported: Wired Elements.

I love the font Gloria Hallelujah, so, although I am not using the UI elements in this site, I wanted to give the font a try. It fits very well the spirit of these personal "notes".

Nice threads in Python

Sat, 01 Feb 2020 00:00:00 +0000

Python has two ways to execute code in parallel: processes and threads. Both have their strengths and weaknesses. In particular, threads are cheaper in terms of resources and are able to share memory, but besides the obvious pitfalls of multi-threaded programming, they suffer from some Python specific problems, notably:

Because of the GIL, only one Python's thread is actually running at any one time. So, very little parallelism is possible if the task is CPU bound. In fact, more often than not, it's more efficient to execute multiple tasks sequentially on a single thread (pinned to a single CPU), rather than spawning multiple threads and having the Python interpreter context switching too much and not being able to schedule the threads on all available CPUs.

Elixir pipe operator in Python

Wed, 25 May 2016 00:00:00 +0000

Elixir implements lots of nice ideas, one of which is its pipe operator. It allows you to write things like:

iex> [1, [2], 3] |> List.flatten()
[1, 2, 3]

Or:

iex> inc = fn x -> x + 1 end
iex> dec = fn x -> x - 1 end
iex> square = fn x -> x * x end
iex> 5 |> inc.() |> dec.() |> square.()
25

Today, just for fun, I tried to implement something similar in Python. Here is the result:

So, you can write something like:

>>> 5 |P| inc |P| dec |P| square
25

Obviously, this is just a toy: it does not implement all the features available in the Elixir's one, but it was fun!

Comparison of blocking and non-blocking Python multiprocessing Queue

Mon, 25 Apr 2016 00:00:00 +0000

Python's multiprocessing module offers a Queue implementation. Surprisingly enough (for me at least), its performance varies greatly if used in a blocking or non-blocking fashion. In particular, the non-blocking way is about ten times slower than the blocking one!

Consider this code, which feeds a Queue and then drains it in a blocking and non-blocking way:

Running it on my machine, with Python 2.7, gives me these results (Python 3.4 results are similar, but less dramatic):

Long running processes manager

Fri, 17 Jan 2014 00:00:00 +0000

If you want to run multiple processes in Python, the nicest way, in my opinion, is to use concurrent.futures (there is a backport for Python 2.x, too).

A problem that came up recently was to manage multiple long running processes, intended to run forever, from the same Python process. Using something like supervisord wouldn't be ideal, because each individual application would have its own config file and deployment procedure.

Instead, having just one "master" Python process to drive several other processes doing the job seemed the easiest solution to manage. The only caveat is that, being the processes managed long running, you want to restart them as soon as they die.

Overcoming Python GIL with Cython

Mon, 23 Dec 2013 00:00:00 +0000

Everybody is aware of the infamous Python's GIL. In a nutshell, the GIL is a global variable that prevents multiple threads to be run concurrently by the interpreter. Under some occasions, for certain operations, the interpreter releases the GIL therefore in certain cases this is not a problem. For example, the GIL is released before doing I/O, so I/O bound threads tend to run concurrently. Another example is when doing system calls. Unfortunately, for CPU bound tasks that don't make any I/O or system calls, the GIL prevents different threads from running concurrently, even on multicore CPUs. The astonishing thing is that, in fact, not only different threads do not run concurrently, but they also run slower on multicore CPUs than on single core ones!

Connect to MSSQL from Python with ODBC and FreeTDS

Thu, 29 Aug 2013 00:00:00 +0000

This is another of those posts that I wrote because I always forget how to do things…

This time, I don't want to forget how to connect from Python to MSSQL server anymore. In order to do it, you need the following system packages installed:

$> sudo apt-get install unixodbc-dev tdsodbc sqsh

sqsh installs all the required freetds-related libraries; tdsodbc is the FreeTDS driver for ODBC and unixodbc-dev is needed to install pyodbc.

Python and C with ctypes

Wed, 28 Aug 2013 00:00:00 +0000

Calling C code from Python is very simple using ctypes. Here is a very simple example to get you started and to serve as a reminder for me!

Let's say you have this C file, defining 3 functions:

foo which prints something to stdout;
bar which returns and int;
baz which takes a parameter and returns a value.

First, you want to compile this C file into a shared object. Here is a Makefile to do just this: simple type make all and you're done.

Useful scripts - csvfmt, xmlfmt, jsonfmt

Fri, 16 Nov 2012 00:00:00 +0000

This is the third post of a series describing simple scripts that I wrote to ease my life as a programmer.

In this post, I'll describe 3 scripts to "pretty print" some common file types, to improve readability: csvfmt, xmlfmt and jsonfmt.

csvfmt takes a CSV ("Comma Separated Values") file from stdin, parses it and pretty print each record as a Python dictionary.

#!/usr/bin/env python

import csv
import sys
import pprint

for row in csv.DictReader(sys.stdin):
 pprint.pprint(row)

Output looks like this:

Tornado vs. Warp vs. Yesod

Sun, 02 Sep 2012 00:00:00 +0000

Today I tried to benchmark 3 web servers that I've used recently:

In fact, these are only *2* web servers, because Yesod runs on top of Warp and it's a fully fledged web framework, rather than a web server: but this was also the intent of the benchmark, i.e. to measure how slower all its goodies made Yesod with respect to Warp.

Tornado and Warp are obviously very different web servers (async vs. threaded, interpreted vs. compiled, etc.) but, who cares?

Pipelines in Python

Fri, 20 Apr 2012 00:00:00 +0000

Generators (PEP 255 "Simple Generators") and Coroutines (PEP 342 "Coroutines via Enhanced Generators") are the cleanest way I've come across so far to implement the concept of a "pipeline" in Python.

First approximation

A pipeline is made of:

a Producer, that generates data;
many /Stage/s, that receive data from the previous stage and send it to the next;
a Consumer, that receives data from the last stage.

The producer is a coroutine that only /send/s data, generated internally from some initial state. /Stage/s are coroutines that both receive and send messages. The consumer only receives data. Chaining is done in function pipeline: each argument but the last is instantiated with an instance of the next stage. The full pipeline is started by issuing a next (or send(None)) to the Producer.

Sudoku solver in Haskell

Mon, 27 Feb 2012 00:00:00 +0000

Recently, I've been challenged to write a Sudoku solver. Not knowing the rules and with only 30 minutes, I needed some help…

So, in case someone asks me again, I've implemented the same algorithm in Haskell.

I know that there are already a lot of other solutions, but, hey, it was fun!

ulint, Universal Lint

Thu, 05 Jan 2012 00:00:00 +0000

I've been using so many code static checkers lately, that I decided to write a wrapper around the ones I use the most. I called it: Universal Lint, ulint for short.

At the moment, Python, Javascript and Haskell files are supported, but adding new linters/extension is trivial.

Download it and use it!

git pre-commit hook for Python and Javascript

Thu, 17 Nov 2011 00:00:00 +0000

Following a recent discussion on HN, I decided to share my own git pre-commit hook.

#!/usr/bin/python

import os
import sys
import re
import subprocess


devnull = open(os.devnull, 'w')


def call(cmd):
 p = subprocess.Popen(cmd.split(),
 stdout=subprocess.PIPE,
 stderr=subprocess.PIPE)
 out, err = p.communicate()
 return out.decode('utf-8'), err.decode('utf-8'), p.returncode


def execute(cmd, silent=False):
 if silent:
 params = {
 'stdout': devnull,
 'stderr': devnull,
 }
 else:
 params = {}

 retcode = subprocess.call(cmd.split(), **params)
 return retcode


def exists(cmd):
 return execute('which %s' % cmd, silent=True) == 0


def get_modified(ext):
 modified = re.compile('^(?:M|A).(?P<name>.*\.%s)' % ext)
 out, _, _ = call('git status --porcelain')
 modifieds = []
 for line in out.splitlines():
 match = modified.match(line.strip())
 if (match):
 modifieds.append(match.group('name'))
 return modifieds

It's a work-in-progress, so you can find the most updated version here. To use it, just drop it in your .git/hooks directory. At every git commit, it will run [pep8][4] and [pyflakes][5] on .py files, and [gjslint][6] on .js files.

They broke delicious

Fri, 30 Sep 2011 00:00:00 +0000

The new redesign of delicious.com broke so many things, that I thought I had to take notes:

bookmarklet in Chrome can't be drag-n-dropped to the toolbar. Its Javascript code is also hard to copy and paste to create the bookmarklet "manually".
install links for the chrome and Firefox extensions redirect to empty pages.
documentation for developer is coming soon (!)
the top-right menu with the logged-in username and stuff is the most horrible I've ever seen: it changes its width on hover, the corners look interrupted (in Chrome, at least – I'm not bothered trying with other browsers)
what the hell are stacks? Grouping can be done with tags, already, and I don't want that much space in the page taken by a "social" feature! Who needs it?
the list of links in the main personal page only shows 8 links on my screen… 8 links?! There's way too much padding, too whitespaces, too much to scroll… It's a bookmarking services, it should show you bookmarks in the most friendly way!
image: why should I use an image for myself? And if I don't use one, I got assigned one by default… Please…

I'll add more to the list in the future.

Javascript templating benchmark

Mon, 23 May 2011 00:00:00 +0000

There are many popular libraries to do templating in Javascript.

The most popular are:

I decided to benchmark them, so I created a simple "hello world" test.

As usual, the results are interesting. Here are, on my box:

	Firefox 3.6	Chrome 11.0	Safari 5.0
jQuery Template	297ms	138ms	113ms
Pure	309ms	43ms	36ms
Resig	309ms	41ms	41ms
Trimpath	15ms	5ms	6ms
JQote2	7ms	1ms	6ms

A part from the obvious result that Firefox is the slowest browser of all, I'm astonished by the excellent performance of JQote2!

Migrating away from wordpress.com

Mon, 11 Apr 2011 00:00:00 +0000

Today I decided to migrate my blog from wordpress.com to my own domain.

I did it for many reasons:

To be able to add plugins
To be able to add javascript to individual pages
To run a customized theme
And all the other reasons listed here

I did not want to loose the popularity and the ranking of my original address, accumulated over the years.

Here are the steps I had to follow (if the following steps make no sense to you, this guide might help you):

Get registered domain in Python and Javascript

Tue, 05 Apr 2011 00:00:00 +0000

reg-dom-libs are a set of libraries for C, PHP and Perl to convert an arbitrary domain name to the registered domain name.

For simple domains, like www.amazon.com or news.ycombinator.com, the task is trivial.
For more complicated ones, like www.ebay.co.uk or www.japantimes.co.jp, handling the second level subdomain is a little painful.
For exoteric ones, like nic.com.ai or www.nic.net.ge or 公司.cn, the problem becomes virtually impossible.
After seeing stupid ones, like www.comune.caserta.it (believe it or not, the registered domain is comune.caserta.it!), I gave up finding an elegant algorithm for the problem.
A full list of valid registered domain is necessary. Luckily, it is available (and nightly updated) here.

Inspired by reg-dom-libs, I've ported the algorithm to Python and Javascript. See the tests at the end of each file for an example of the usage. A demo is available here.

Handling an iframe from the inside

Wed, 30 Mar 2011 00:00:00 +0000

If you've ever worked with iframes you've certainly run into the same origin policy.

From here:

The same origin policy basically limits how scripts and frames on different domains can talk to each other.

This is particularly bad if you want to resize an iframe to accomodate its content, as this is not doable with simple CSS (to the best of my knowledge!). It can be done using window.postMessage, though.

See a demo here.

Papers about Python and scientific computing

Wed, 25 Apr 2007 00:00:00 +0000

Here is a list of articles about Python and scientific computing appeared in Computing in Science and Engineering, available online:

Python for Scientific Computing by Travis E. Oliphant (pdf);
Python: Batteries included by Paul F. Dubois;
A Python module for modeling and control design of flexible robots by Ryan W. Krauss;
Analysis of Functional Magnetic Resonance Imaging in Python by K. Jarrod Millman and Matthew Brett, Computing in Science and Engineering, vol. 9, no. 3, pp. 52-55, May/June, 2007;
IPython: A System for Interactive Scientific Computing by Fernando Perez;
Matplotlib: a 2D Graphics Environment by John D. Hunter.

Happy reading!