Waf is a Python based build system (or more generally a task execution system).  Directly from the site:

Waf is a Python-based framework for configuring, compiling and installing applications. It derives from the concepts of other build tools such as Scons, Autotools, CMake or Ant.

Just like make, waf is a quasi-declarative build system.  You define the tasks and results you require, and waf determines dependences and executes the tasks (in a valid order) necessary to produce the desired output.  However, waf differs from make in that waf actually uses a real programming language for declaring tasks and developing the build system (in case it wasn’t obvious, the language I’m referring to is Python).  This single fact alone is enough for me to want to move away from make completely.  However, waf also offers a whole slew of other extremely nice features that make it very powerful. See the project site for more details.

Until now I’ve been using make to build my LaTeX documents.  However, I’ve finally taken the time to discover how to do this with waf.  The following script (really just two functions), named wscript in the directory with the LaTeX source, is the result:

1
2
3
4
5
6
7
8
9
10

srcdir='.'
blddir='build'
 
def configure(conf):
   conf.check_tool('tex')
 
def build(bld):
   obj=bld.new_task_gen(features='tex')
   obj.source='source_tex_file.tex'
   bld.install_files('${PREFIX}','output_pdf_file.pdf')

The first two lines define the source directory (the current directory is denoted by the ‘.’) and the name of the build directory (where all the temporary files will be stored).  The configure function simply tells waf, using the check_tool call, to ensure that the tools necessary for building LaTeX documents are present on the system.  The build function defines that we want to create a PDF document from the file source_tex_file.tex using the tex waf tool.  And that’s it… seriously.

My workflow with this setup is basically edit LaTeX file, call ./waf build install, check the output PDF, repeat.  Easy as pie.

So, if you’re looking for a fabulous alternative to make, check out waf, I’m sure you’ll be impressed.

The day started with an almost exactly 1 hour drive down to Boulder after picking Kate up from her place.  Even at 7am, traffic wasn’t bad enough to slow us down too much.  We’ve averaged around 1 hour over the ~3 trips we’ve made down there.  I’m guessing it is now safe to say that it takes an hour to get from Fort Collins to Boulder (with our apartment or NCAR as the destination).

As we were early (we were supposed to be at NCAR at 9am), we stopped at our not-yet-paid-for apartment and found that the office was closed.  Resolving to call at lunch to get apartmenty things settled, we headed up the hill towards NCAR.

In contrast with the previous times we’d been to the NCAR campus, it was fairly windy and cold today when we arrived.  We headed in to the building and found our way to the cafeteria.  We were early (by around 30 mins) and met and talked with some of the other SiParCS interns who were also early.  Once 9am rolled around we headed to a conference room and started the day.

Most of the morning was filled with filling out forms, tours, and getting machines setup, configured, and working.  On the outside the building is really intersting, very cool architecture.  On the inside, you find that the cool architecture requires a complex layout that is initially difficult to find your way around.  Luckily I think I figured most of the useful routes out, but I’m guessing I’ll still have trouble at some point.  In terms of machine setup, I had to be the difficult one and use my personal laptop (along with one other inten).  To get access to various NCAR intranet resources, I needed to get VPN working.  However, the vpnc settings I was using weren’t working for some reason.  Later in the day we finally setup kvpnc and got VPN working with it.  (Later I figured out that I needed to specify my password each time using my recently acquired cryptocard, and got VPN working with vpnc in networkmanager, whooo!).

I ate lunch with Kate, Nick (the third intern working under John) and John in the NCAR cafeteria.  Kate and I learned that food is pretty expensive there ($20 for both of us total) and decided to shop later in the day for lunchy food and save ourselves some money.  The food is decent, just not worth $10 a meal.

After lunch I actually got started on my project, which I’ll describe in more detail at some point in a future post.  Basically right now I’m writing some Python scripts to process lookup table access traces from a run of CAM (the Community Atmospheric Model).  I’m hoping I can get some results to discuss with John by tomorrow.

Kate, Nick, and I decided to attend a welcoming reception and left around 3:30.  Nick headed straight there while Kate and I went and took care of apartmenty things first.  After paying rent and dropping off our stuff in our newly claimed apartment, we headed to the reception.  We were enticed by free food, expecting some sort of BBQ or something, but it turned out to be a more fancy-pants snacky event.  We grabbed some of the food (including coconut chicken on a stick!), listened to some speeches, chatted with Kuo, Nick, Even and Kate (all SiParcS interns) and decided we needed some real food.  We headed to our new favorite brewery, Southern Sun.

Southern Sun is a local Boulder brewery just across from our apartment.  We headed there for food, and ended up getting more than we could handle.  I ordered the Blackberry Wheat beer they had on tap (super tasty!) and Kate ordered a Belgium tripel (also super tasty!).  For food, we had an interesting soup that tasted exactly like a grilled cheese sandwich, very nice!  On top of that, we ordered the chicken nachos, and realized after it came out we had made a mistake:

Massive stack of nachos at Southern Sun Brewery

Needless to say, we didn’t manage to finish them, but what we did have was delicious.

After dropping Kuo off at home, Kate and I headed to our apartment and chilled for the evening and went to bed.  It was a long day and I’m pretty tired.  This is looking to be quite a fun summer.  I’m excited to get to work tomorrow on my project!

Reverse list, slicing: (0.58000000000000007, 0.64144396781921387)
Reverse list, method: (0.20000000000000018, 0.19551301002502441)
Reverse string, slicing: (0.45000000000000001, 0.49545693397521973)
Reverse string, list: (3.71, 3.7981550693511963)

I’m using a quick Timer class that I implemented to report the running time for a chunk of code using both of time.clock() (the first item) and time.time() (the second item). Here is the code used to produce these results:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

import time
from collections import namedtuple
from copy import deepcopy
 
class Timer(object):
   Times=namedtuple('times','clock time')
 
   def __init__(self):
      self.running=False
 
   def _set_times(self,field_name):
      times=Timer.Times(time.clock(),time.time())
      setattr(self,field_name,times)
 
   def start(self):
      if self.running: raise ValueError('Timer is already running!')
      self.running=True
      self._set_times('tstart')
   def stop(self):
      if not self.running: raise ValueError('Timer is not running!')
      self.running=False
      self._set_times('tstop')
 
   def time(self):
      return (self.tstop.clock-self.tstart.clock,self.tstop.time-self.tstart.time)
 
timer=Timer()
test_string='Time flies like an arrow.  Fruit flies like a banana.'
test_list=list(test_string)
iterations=1000000
 
timer.start()
for i in xrange(iterations):
   new_string=test_string[::-1]
timer.stop()
print 'Reverse string, slicing:',timer.time()
 
timer.start()
for i in xrange(iterations):
   l=list(test_string)
   l.reverse()
   new_string=''.join(l)
timer.stop()
print 'Reverse string, list:',timer.time()
 
timer.start()
for i in xrange(iterations):
   test_list=test_list[::-1]
timer.stop()
print 'Reverse list, slicing:',timer.time()
 
timer.start()
for i in xrange(iterations):
   test_list.reverse()
timer.stop()
print 'Reverse list, method:',timer.time()

Feel free to use any of this code yourself, consider it under a BSD license. Particularly the Timer class has been useful for me in multiple cases.

Based on the timing results, I’d say it looks best to use the slicing idiom on strings and the reverse method on lists.