The internship, apprenticeship, sinking ship (just kidding) goes
very well. Tensions are high as we count down the days until the start
of production. Monday we will see how well our preparations have paid
off.
I was confined mostly to the office today, where I participated in
traditional production work- typing, faxing, copying, sorting,
delivering items, picking things up. I realized how privileged I have
been the past few days, when I accompanied the Director, A.D., D.P.,
and Location Coordinator to location scouts. I had the rare opportunity
to listen to them strategize their plans for the coming weeks, and to
see our locations before the art department had a change to work
their movie magic.
I have also been informed that I will most likely be taking over for
the product placement intern when she joins the set crew next week. If
this keeps up, I will have worked in nearly every department by the
time the project wraps. I definitely see the advantages of working in
the Hollywood system, where everyone has their well-defined jobs from
which they rarely deviate. However, as one just starting out, I believe
a small production may have been the best choice. Oh, the things I will
learn!
But now, dear readers, I must retire. Your humble storyboard artist
(and “Jill of all trades”) was up until 3am last night/this morning,
trying to complete as many stunt-related sketches before the tech scout
today.
Who knows what adventures await me tomorrow- but you shall know soon
after they occur!
Well, I’ve finally done it. I’ve finally managed to land a position
as a Production Assistant, for a feature film in NYC. Yes, you may
applaud. Thank you, thank you.
Granted, it is largely unpaid. And, it is a very small, low-budget
production. But in addition to the traditional servitude associated
with PA work, I have been asked to be the storyboard artist for the
film. In fact, I believe that will be my official credit in the
completed project.
The director, Jacob (Jake) Kornbluth is just a couple of years old
than I, and this is his second feature. The first was “Haiku Tunnel”, a somewhat
twisted comedy about temping at law firms in San Francisco. As many of
you know, I am more than able to relate.
This project ”
The Best Thief in the World”, is a drama that traces a family’s
struggle to hold together in the wake of the father’s incapacitating
stroke; at the center is 11-year-old Izzy, an introspective boy who
breaks into other apartments in his building as a way to create a
“safe” imaginative space for himself. The script was a good, fast
read, which is usually a very good start.
I have spent the past couple of days on location scouts, sketching
possible interior location floorplans and exterior landscapes. They
begin shooting next week, and so everything is increasing in pace and
intensity. I hope we all survive- especially yours truly!
There will be additional updates in the weeks to come…
It’s been a very long time since I’ve had to write Windows software
in C++. My last several projects have been C#, Java, and JavaScript
based web applications. Therefore, I was insulated from the pain of
having to deal with Microsoft’s bizarre shared library system (AKA
DLL-hell) which causes untold pain when trying to implement C++-based
plug in modules.
A friend in Seattle once postulated that most of Windows was
designed by drunken or stoned interns. Based on my recent experience, I
can believe it. The whole idea of having to explicitly export
functions, classes and templates from a DLL is ridiculous. My most
recent painful experience was with an inner class to a template. For
example:
template
class Iterator
{
public:
class IteratorRep
{
public:
virtual ~IteratorRep() {}
virtual bool hasNext() = 0;
virtual T next() = 0;
};
Iterator( IteratorRep* TheRep );
~IteratorRep();
bool hasNext() { return rep->hasNext(); }
T next() { return rep->next(); }
private:
IteratorRep* rep;
};
You would think this would be an easy scheme to implement. But once
you through Microsoft’s lame implementation of shared libraries into
the mix, you get the following:
template
class EXPORT Iterator
{
public:
class EXPORT IteratorRep
{
public:
virtual ~IteratorRep() {}
virtual bool hasNext() = 0;
virtual T next() = 0;
};
Iterator( IteratorRep* TheRep );
~IteratorRep();
bool hasNext() { return rep->hasNext(); }
T next() { return rep->next(); }
private:
IteratorRep* rep;
};
The EXPORT macro handles the nasty Microsoft specific
keywords necessary to export the class from the DLL. The red EXPORT is where I made my
mistake. Naturally, if I have to export the outer class, it is
reasonable for me to think I’d need to export the inner class. However,
this causes very weird problems when implementing an IteratorRep class.
Essentially, the linker is trying to import the implementation of the
new IteratorRep-derived class despite having just compiled the
implementation. It’s all very silly.
I accidentally removed the red EXPORT macro and everything
worked correctly.
Were Bill Gates here, I’d punch him in the nose.
