Have you ever needed to give awk multiple files to process, but wanted it to skip files that it can’t open? Use this snippet!
BEGINFILE {
# skip files that cannot be opened
if ( ERRNO != "" ) {
nextfile
}
}
This trick is mentioned in the documentation for the BEGINFILE pattern, but not spelled out as code. You’re welcome. 😀
A friend asked me if I could help him write a Python script for fetching and processing data from emails in his mailbox … Well, the thing with emails is that they’re a pain to work with (in any form). So, I tried to help him out with a little scaffolding (also available as a Gist).
Titus Winters talks about maintaining and refactoring large C++ code bases (i.e. code bodies that require multi-step refactoring). He describes how “higher-level” language features effectively make refactoring harder (e.g. functions, classes, templates, concepts).
In my work – every now and then – I found myself in need of a browser with reduced security checks (mainly to gloss over cross domain XMLHttpRequests and SSL certificate violations) for testing purposes. I didn’t want to take the risk and use my main browser session with these settings, so I made me a script (also available as a Gist). 🙂
Tip:
If you use oh my ZSH you can save this file in
~/.oh-my-zsh/custom/plugins/chrome-unsafe/chrome-unsafe.plugin.zsh
and add “chrome-unsafe” to your list of used plugins in
~/.zshrc
I came up with a IMHO nice piece of code while working with and getting to know Python.
incomplete_items = [
item.quantity_ordered > item.quantity_delivered for item in order.items
]
if any(incomplete_items):
do_something()
This feels clean and obvious. It might not be very efficient though. :/
has_incomplete_items = sum(
item.quantity_ordered > item.quantity_delivered for item in order.items
)
if has_incomplete_items:
do_something()
Doing it this way can be more efficient, since it can leverage generators and doesn’t need to go through the list again with
any
. But using
sum
over booleans feels hackish and non-obvious … 🙁
Thanks to @immoralist I’ve learned a new Python testing trick. I didn’t know about the “spec” argument for MagicMock. m(
Let’s see an example:
from mock import MagicMock
class SomeModel(object):
foo = "f**"
bar = "b**"
m = MagicMock(spec=SomeModel)
Here we create a mock object which mimics the interface of
SomeModel
as we would expect, returning mock values for things we access.
>>> m.foo <MagicMock name='mock.foo' id='4506756880'> >>> m.bar <MagicMock name='mock.bar' id='4506754192'>
Let’s see what happens if we call something else:
>>> m.baz
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File ".../env/lib/python2.7/site-packages/mock.py", line 658, in __getattr__
raise AttributeError("Mock object has no attribute %r" % name)
AttributeError: Mock object has no attribute 'baz'
It will fail loudly while a mock object without a spec would have returned a mock value as it did in the previous example.
But the magic doesn’t end there. You can still set additional attributes/methods “by hand” and have them not fail even if they aren’t part of the original spec.
>>> m.baz = "bazzzzz" >>> m.baz 'bazzzzz'
Learning new things makes me happy. 😀
In Python there is a simple way to make methods behave like properties using the @property decorator. But this only covers the getter side of things. What if you want to have a setter function for this “property”? Well there is a way. 🙂
Consider the following example:
import json
class SomeModel(object):
_foo = '{"foo":["bar", "baz"]}'
@property
def foo(self):
return json.loads(self._foo)
@foo.setter
def foo_setter(self, new_value):
self._foo = json.dumps(new_value)
m = SomeModel()
Now you can use the
foo()
method like a property.
>>> m.foo
{u'foo': [u'bar', u'baz']}
This is a simple way to have a property contain a JSON string but access it as a Python dict, doing (de-)serialization on the fly.
So what if you want to set the value using a dict?
>>> m.foo = ["foo", "bar"] Traceback (most recent call last): File "<stdin>", line 1, in <module> AttributeError: can't set attribute
This is can easily trip up even seasoned Python developers. I’ve read code that did exactly this and I (as a novice) had to find out why the code failed. m(
The solution is quite simple … but “non-obvious” (as in: I wouldn’t have thought of that without consulting the docs) 🙁
@foo.setter
def foo(self, new_value)
self._foo = json.dumps(new_value)
Notice the method name? The setter and the getter methods have to have the same name!
Fabien Sanglard has written an interesting drill down into the recently released source code for Doom3. He tries to reason why certain things are the way they are and also had a few of his questions answered by John Carmack himself.
There was news about the source code for the Prince of Persia game on Apple II computers restored from a set of ancient floppy disks. There is also a great quote on why going through the trouble of restoring/releasing the source code of those games is something worthwhile.
“Because if we didn’t, it might have disappeared forever.”
Video game source code is a bit like the sheet music to a piano sonata that’s already been performed and recorded. One might reasonably ask: If you have the recording, what do you need the sheet music for?
You don’t, if all you want is to listen and enjoy the music. But to a pianist performing the piece, or a composer who wants to study it or arrange it for different instruments, the original score is valuable.
It’s possible, up to a point, to reverse-engineer new source code from a published video game, much as a capable musician can transcribe a musical score from listening to a performance. But in both cases, there’s no substitute for the original document as a direct line to the creator’s intentions and work process. As such, it has both practical and historical value, to the small subset of the game-playing/music-listening community that cares.
It you want to know how demos are coded, farbrausch has released 10 years worth of code.
As a starting point: there is an ongoing series of blog posts showing you around the code.