Here are two separate ideas about programming, Internet security, Internet
architecture, and free software. Both of them are fundamental to
everything those of us who work on free software are doing.
-
Writing secure and reliable code is a highly complex and demanding
task. It's something that one has to learn, like any other skilled
profession. It's not something we're very good at teaching via any
mechanism other than apprenticeship and experimentation. The field is
changing quickly; if you took ten years off from writing
security-critical code, you would expect to have to learn multiple new
tools (static analysis, testing techniques, security features),
possibly new programming languages, and not infrequently new ways of
thinking about threat models and vulnerabilities.
-
Nearly every computer user trusts tens of thousands of other
programmers and millions of lines of code with their day-to-day
computer security and reliability, without auditing that code
themselves. Even if you have the skill required to audit the code
(and very, very few people have the skill to audit all of the code
that they use), you do not have the time. Therefore, our computer
security is built on trust. We're trusting other programmers not to
be malicious, which is obvious, but we're also trusting other
programmers to be highly skilled, careful, cautious (but still fast
and productive, since we quickly abandon software that isn't "actively
developed"), and constantly adopting new techniques and treat models.
I think both of those principles are very widely understood and widely
acknowledged. And, as we all know, both of those principles have failure
modes, and those failures mean that our computers are nowhere near as
secure as we would like them to be.
There has been quite a lot of
technical discussion about both of
these principles in recent days and months, ranging from better code
analysis and testing through the flaws in particular programming languages
to serious questions about the trust model we use for verifying the code
that we're running. I'm going to switch gears away from that discussion
for a moment to talk about a
social aspect.
When a piece of code that one is using has a security vulnerability, it is
not unusual to treat that as a trust failure. In other words, technical
flaws are very quickly escalated to
social flaws. This is less
likely among practitioners, since we're all painfully aware of how many
bugs we have in our own code, but it's still not unheard of, particularly
if the authors of the code do not immediately and publicly show a
socially-acceptable level of humility and contrition (in the middle of
what is often a horrifically stressful experience).
I think this reaction comes largely from fear. Anyone who has given it a
moment's thought is painfully aware of just how much code they are running
on trust, and just how many ways it could be compromised, accidentally or
maliciously. And how frequently that code
is compromised. The
less control one has over a situation, the more terrifying it is, and the
cold reality is that we have very little control over our computer
security. There is a natural tendency, when afraid, to look for targets
for that fear.
Now, go back and think about the first principle.
Anyone who has ever worked on or near free software is painfully aware
that we have far more good ideas about how to improve computing and
security than we have skilled resources to execute on those ideas. My own
backlog of things that I've already thought about, know would be good
ideas, and simply have to implement is probably longer than my remaining
lifespan. I suspect that's the case for nearly all of us.
In other words, we have a severe shortage of programmers who care and who
have skill. We desperately need more skilled programmers who can write
secure and reliable code. We may (and I think do)
also need better
tools, techniques, languages, protocols, and all the other machinery that
we, as technical people, spend most of our time thinking about. But none
of that changes the fact that we need more skilled people. In fact, it
makes that need more acute: in addition to skilled people to write the
code we use, we need skilled people to write the tools.
Skilled people are not born. They're made. And in professions where
training techniques are still in their infancy and where we don't have a
good formal grasp on which techniques work, those skilled people are made
primarily through apprenticeship, experimentation, and learning from
failure.
Worse, people who
were skilled do not
remain skilled without
continually participating in that learning process. See the above point
about a fast-changing field with evolving best practices. It's not enough
to know how to write secure code to the best known practices today, or
even enough to retrofit all of your existing code to current knowledge
(which is often so large of an effort as to be practically impossible).
You have to constantly, continually learn more, for which there is no
reliable formal training.
We have to try, fail, try again, and fail better.
But failure that leads to a security vulnerability is treated as a loss of
trust. We trusted that person to write secure code that we could use.
They failed. Now we can't trust them. Based on the trust model of
security, we should revoke their ability to try again and instead rely on
people who have not failed, since that will make us more secure.
Except now we just broke the learning process. And there's no such thing
as a programmer who can stop learning. So what does that do to our
resource pool?
It's sadly ironic, but I believe the free software community writ large
has a very serious collaboration problem: we do not tolerate each other's
learning processes. This leads to a wide variety of social failures
around hostile communities and the failures of meritocracy that other
people have talked about at much greater length. But even if you set that
all aside, it
threatens our security. We need secure code, a lot
of it, a lot more than we have right now. To get that code, we need
people who can write it. We need to grow, encourage, and support those
people and enable their learning processes.
Code is written by people. If we rip people apart when they write bad,
insecure code, we don't get better, secure code. We get fewer people
writing security code. We get far fewer people writing security code in
public, since some of the people who haven't been ripped apart will look
at that experience and say, "No way am I going near that problem area.
It's too scary. I don't want to end up like those programmers."
Fewer people writing security code means fewer people learning how to
write better security code.
Fewer people capable of writing good, secure code is not a solution to any
of our problems.
If we do not tolerate, support, and encourage the learning process
required to become a skilled programmer, or maintain one's skill in
programming, we are destroying our future as a community.
When you find code that is broken and badly written, you have found a
problem that should be reported, analyzed, and corrected. You have also
found a programmer who is about to have one of two very different types of
experiences. Either they are about to learn how to become a better
programmer, or they are about to be publicly shamed, humiliated, and
treated as untrustworthy. Which branch they take is partly up to them,
but it's also heavily influenced by how all of us react socially to the
discovery of bad code.
One of those branches leads to more good, secure code being written in the
future. The other does not.
My alternative option to quitting my day job
so I could spend more time with Zoe was to take three months leave without
pay. That wasn't really a great option, because it would mean that Zoe would
only get one term of Kindergarten, and then I'd be back at work.
Well today is the day that I'd go back to work if I took 3 months leave without
pay.
So far, I have zero regrets from doing the stay year-long at home Dad thing. At
the end of the first week, I was absolutely exhausted, and a little worried
that I'd bitten off more than I could chew, but since that point, I've found my
stride and now I'm mostly just worried about what I'm going to do with myself
next year.
I'm really happy with the range of activities that I've been able to do with
Zoe in the past 90 days. For this term, I'm going to do a combination of
repeating some of the things we've done previously (Zoe's already asking to go
ice skating again), and introduce her to a few new things that we didn't get a
chance to do last term. As it starts to cool down a little bit more, we'll be
looking around for more indoor activities to do, as well.
Today though, I had a bit of a motivational slump. Zoe woke up, briefly, at
4:30am. I can't even remmeber why. I was smack bang in the middle of some
serious REM sleep, so I found getting up to attend to her particularly jarring.
I was a bit sluggish this morning as a result, and Zoe was also doing some
spectacular procrastination. That coupled with rain meant we were a bit late
getting to Kindergarten.
The drop off itself went pretty well, and I drove home and had a late shower.
There was a myriad of things I could have been doing, but I mostly just made a
bunch of phone calls to organise things, did some more planning for Zoe's
birthday party this Saturday, and waited for pick up time to roll around. I'll
need to do a better job of being self-disciplined tomorrow.
Kindergarten pick up was fine. I've been encouraging Zoe to reconsider napping
at rest time, and the last two times I've picked her up, she hasn't napped,
which has made for a much easier departure, and she hasn't been noticeably
worse for wear for it.
We went to take a look at the park we're having her birthday party in on
Saturday, just to get a lie of the land in terms of tables and BBQs, and then
we went to the Valley to clear my PO box. After that we went to the dance store
in the Valley to get a leotard, socks and stockings for her ballet class.
By the time we got home from all of that, there was only about an hour
before Sarah was due to pick Zoe up, so she watched a bit of TV, and then we
played hide and seek for a bit, and watered the seeds we've planted.
I skipped yoga tonight because I'm still on lifting restrictions, and
decided to skip Meatless Monday as well and hang out with my friend Michael
and eat all the ribs I could
handle. Boy was that an eating binge.
I was tempted to ask if she also wanted my fingerprints and a DNA sample too. Not wanting to be too offensive though, I simply told her that there was no way she would be making a copy of our documents. I tried to explain it to her in terms that she would understand: that AirBNB had already verified my identity and that 
Distributing software efficiently accross your platform can be
difficult. Every distribution comes with a package manager which is
usually suited for this task. 
Current Glamor Performance
I finally managed to get a
I'm moving. Well, not right here, right now. Rather less than two years. But I already know what my flat will look like and was able to influence that decision. And there will be more to influence, like what to do with common rooms in the builing, or what to put in the garden (voting for climbing facilities for my son of course!). It's this kind of co-housing project where you already know your neighbours beforehand and can find common grounds for decisions like that.
The co-housing project I'm moving to is called 
On the last UDS we talked about 
Update: As the comments pointed out, this bricked 
Ok, so the day has come: Today begins the much awaited 
Unless you've been living under a rock, or in a tent (which would make me slightly jealous) you'll have heard about the recent heartbleed attack many times by now.
The upshot of that attack is that lots of noise was made about hardening things, and there is now a new fork of openssl being developed. Many people have commented about "hardening Debian" in particular, as well as random musing on hardening software. One or two brave souls have even made noises about auditing code.
Once upon a time I tried to setup a project to audit Debian software. You can still see the 
Starting yesterday, I am a happy user of the 
Pain points - For now, sync is the core of the pains. You need either a Mac or a Windows PC. I have a Windows 7 VM with USB Passthru, but that doesn't work. There's also an option to sync over mobile (iOS and Android). That again does not work for my Chinese Mobile Handset running MIUI.
So I wasn t able to complete the earlier attempt to boot the VM. Something to do with the SATA backplane not having enough juice to keep both my 6-disk array and the w2k8 disk online at the same time. I had to dd the contents off of the w2k8 disk and send it to the SAN via nc. And it wouldn t write at more than 5.5MB/s, so it took all day.
[edit 20140422T172033 -0700]
[edit 20140422T204904 -0700]
Yup. That did er!
About a month ago, on 20th of March, 
After several weeks of review and discussion, the application and
selection period for the 2014 Google Summer of Code is over. 4,420
students proposed a total of 6,313 projects for this summer. From
those, 1,307 students have been accepted
(
This will be my one and only off-topic posting, but I just have to share all my joy and happiness with all of you!
On monday, April 14th 2014, our beautiful daughter Valerie was born. As we almost live next door to our midwife,
we just grabbed our stuff and walked over to the midwife's house, as my wife told me "things are starting".
My wife was very glad to be able to give birth in such a beautiful, cosy and comfortable place, with no hassle, no beeping machines and nervous hospital staff running around.
This helped her to "let go", and she gave birth to our beautiful daughter after about 2 hours.
I took a 4 week break from work to support my wife and daughter. This is quite involving :-) , so please forgive me if I don't reply quickly to your mails.
Screenshot:
