A bug I've recently seen in production code gave me the idea for this
blog post. Probably smarter people already wrote better things on this
topic, so this is mostly for myself, to better summarise my own
thoughts. Corrections are welcome, please leave a comment!
Let's say we have a somewhat standard API in Python or C++:
- a function (
init_t) to create/initialise our data type, which
returns an object of type t
- the object then has some properties or methods that we can call
Signalling failures to initialise the object can be done in two ways:
either by raising an exception, or by returning a null/None
result. There are advantages and disadvantages to both:
- if using exceptions, then you must be sure to catch and handle all
possible exceptions that the initialisation function can raise
(otherwise more of your code can be aborted than you want)
- if using None as return value, then you must check that the value
is correct before using it, otherwise you get an exception or null
pointer dereference
The None model can create latent bugs, for example in the following
code:
ok = True
for arg in input_list:
t = init_t(arg)
if t is None:
ok = False
continue
t.process()
return ok
The presence of the
continue statement there is critical. Removing
it, or moving it after some other statements which work with
t will
result in a bug. So using value-based returns forces us to introduce
(manually) control points, without having the possibility to validate
the model by the compiler (e.g. in C++).
So it would seem that this kind of latent bugs pushes us to use the
exception model, with its drawbacks.
Let's look at how this interface would be implemented in (IMHO)
idiomatic Haskell (where the
a and
b types represent the input and
output types):
initT :: a -> Maybe T
processT :: T -> b
my_fn =
case initT arg of
Nothing -> -- handle failure
Just v -> processT v
Yes, this can be written better, but it's beside the main point. The
main point is that by introducing a wrapper type around our main
type (
T), we are forced via the type system to handle the failure
case. We can't simply pass the result of
initT to a function which
accepts
T, because it won't type check. And, no matter what we do
with the result value, there are no exceptions involved here, so we
only have to think about types/values, and not control flow
changes. In effect, types become automatically-validated control-flow
instructions. Or so it looks to me .
So using types properly, we can avoid the exception-vs-return-value
debate, and have all advantages without the disadvantages of
either. If that is the case, why isn't this technique used more in
other languages? At least in statically typed languages, it would be
possible to implement it (I believe), via a C++ template, for
example. In Python, you can't actually apply it, as there's no static
way of enforcing the correct decapsulation. I was very saddened to see
that Google's Go language, which is quite recent, has many examples
where initialisation functions return a tuple
err, value = ,
separating the actual value from the error, making it not safer than
Python. It might be that polymorphic types are not as easy to work
with, or it might be the lack of pattern matching. In any case, I
don't think this was the last time I've seen a null pointer
dereference (or the equivalent
AttributeError: 'NoneType' object has
no attribute ). Sadly
You can even go further in Haskell and introduce more control flow
structure via wrapper types. Please bear another contrived example: an
HTML form that gets some input data from the user, validates it, saves
it to the database, and echoes it back to the user. Without types, you
would have to perform these steps manually, and ensure they are kept
in the correct order when doing future modifications. With types, you
only have to design the types correctly and export only smart
contructors (but not the plain ones):
module Foo ( ValidatedValue
, validateValue
, RecordId
, CommittedValue
, commitValue
, buildFeedbackForm
) where
data ValidatedValue a = ValidatedValue a
validateValue :: a -> Maybe (ValidatedValue a)
data RecordId =
data CommittedValue a = CommittedValue a RecordId
commitValue :: ValidatedValue a -> ComittedValue a
buildFeedbackForm :: CommittedValue a -> HTMLDoc
From these types, it follows more or less that the only correct
workflow is:
- get a value from the user
- validate it
- commit it, getting a transaction/record ID
- send the response to the user
In other words:
handleFeedbackForm = buildFeedbackForm . commitValue . validateValue
There are still issues here, e.g. the type
a is completely hidden
behind the wrapper types, and we can't recover some basic properties
(even if we use
newtype, unless we use
GeneralizedNewtypeDeriving). But it does offer a way to improve
control flow safety.
And that is my 0.02
currency unit for today.
Four years ago I started using Goodreads to maintain
the list of books I've read (which had lived in a flat text file for a
decade+ before that).
Now it's been aquired by Amazon. I doubt it will survive in its current
form for more than 2 years. Anyway, while Goodreads has been a quite good
way to find what my friends are reading, I've been increasingly annoyed by
the quality of its recommendations, and its paucity of other features I
need. It really doesn't seem to help me keep up with new and interesting
fiction at all, unless my friends happen to read it.
So I looked at LibraryThing. Actually, I seem to have looked at it several
times before, since it had accounts named "joey", "joeyh", and "joeyhess"
that were all mine. Which is what happens to me on sites that lack Openid
or Browserid.
Digging a little deeper this time, I am finding its recommendations much
better than Goodreads' -- although it seems to sometimes recommend
books I've already read. And it has some nice features like tracking
series, so you can easily tell when you've read all the books in a series
or not. The analytics overall seem quite impressive. The UI is cluttered
and it seems to take 5 clicks to add and rate a single book. It supports
half stars.
Overall I get the feeling this was designed for a set of needs that doesn't
quite match mine. For example, it seems it doesn't have a single database
entry per book; instead each time I add a book, it seems to pull in data
from primary sources (library of congress, Amazon cough) and treat this
as a separate (but related) entry somehow. Weird. Perhaps this makes sense
to say, librarians. I'm willing to adjust how I think about things if
there's an underlying reason that can be grasped.
There's a quite interesting thread on LibraryThing
where the founder says:
The goal of this article is to illustrate how to manage Python code which includes comments in UTF-8 characters inside a latin-1 source org-mode for LaTeX export.
Note that I ve pasted in wordpress the HTML generated by org-mode, so I hope it isn t broken too much.
My typical use case is a french lecture on Python where the text is written in french, as well as some of the code comments and examples
We ll use org-mode s babel module to include and manage the Python
I've made two new designs for 
Also this year the 
On the next two days at the booth we chatted and discussed with visitors and other exhibitors a wide variety of questions, including 'When will be (the next Debian version) released?' and 'Are there installation disks available?'. The answers was as always 'When we are ready and we will have reached the quality-level we defined', 'No we don't have installation medias, as they are always outdated. Do you have an USB-dongle with you?'.
Merchandising was requested by visitors as always, but we just had some leftovers of fosdem, brought by Axel.
Many thanks to Florian Baumann, Jan Dittberner, Andreas Tille, Christian Hoffmann, Axel Beckert, Markus Rekkenbeil, Daniel Schier, Jonas Genannt, Jan H rsch and kurio for taking care and running the booth, which worked out this year extreme smoothly from my point of view. Likewise as the last years a special thanks to 
This night you might have noticed that some services like 
Today, during Blackhat Europe, 
On Saturday I had the opportunity to teach another one-day master class on
Partially because of 
Mark Shuttleworth recently critized Jonathan Riddell for proposing Xubuntu and others join the Kubuntu community. I thought I could make a few amendments to Mark s writing:
Composite and Swap Getting it Right
Where the author tries to make sure DRI3000 is going to do what we
want now and in the future
DRI3000
The basic 
(Looking for those graphs online, I realized that I never properly published them, besides that 
A large majority of our packages are maintained in a VCS repository, with Git being the clear winner now.
Possible goal for Jessie: standardize on a Git workflow, since every team tends to design its own?
Packaging helpers
