What did you experience the last time you watched a movie in a theater?
Were you captivated by the fast-paced action and special effects?
Deeply moved by the characters that came to life during those two hours when the outside world just melted away?
Yeah, movies are still magical.
What was likely not top of mind was all the work that went into that movie,
from the editing of the audio and video, to the special effects, the rendering, the coordination,
and maybe hundreds of creative professionals.
It turns out that Python plays a key role in coordinating all of that production work,
and that's what this episode is all about.
Join me as I talk with Rob Blau from Autodesk about Python in the movies and entertainment business.
This is Talk Python to Me, episode number 46, recorded January 28, 2016.
I'm a developer in many senses of the word,
because I make these applications, but I also use these verbs to make this music.
I construct it line by line, just like when I'm coding another software design.
In both cases, it's about design patterns.
Anyone can get the job done, it's the execution that matters.
I have many interests, sometimes...
Welcome to Talk Python to Me, a weekly podcast on Python,
the language, the libraries, the ecosystem, and the personalities.
This is your host, Michael Kennedy.
Follow me on Twitter, where I'm @mkennedy.
Keep up with the show and listen to past episodes at talkpython.fm,
and follow the show on Twitter via at talkpython.
This episode is brought to you by SnapCI and OpBeat.
Thank them for supporting the show on Twitter via snap underscore CI and OpBeat.
Hey, everyone.
Two weeks ago, I told you I had a huge announcement that I was really excited to share with you,
but couldn't.
Now that everything is in place, it's time to share my big plan with you.
When I started this podcast almost a year ago, I had modest expectations and more than a little
uncertainty about how it would be received by the community.
And honestly, every day I'm blown away by how many people's lives I touch and help educate
in some part of Python that was less well known to them.
I get a huge amount of satisfaction spending time making Python more relevant to you through
this podcast.
I've been thinking about how I do more of that.
I believe the natural counterpart to this podcast, which exposes people to new ideas and inspires
them to learn more about Python, is a comprehensive set of online courses to help you go from inspired
to empowered, from new developer to highly effective developer, from specialized developer to a
well-rounded one.
So today, I'm announcing the first course and taking the first step on a journey to build
this resource for you and the whole Python community.
Over the next two years, I plan to release 20 high-quality online courses that will be between
three to ten hours each.
These no-fluff courses will strive to make you effective with some corner of the Python ecosystem,
including the Python language, web apps, databases, GUIs, parallelism, and more.
The first course will be about the Python programming language, and will take a fun and playful approach
to teaching you the language details such as classes, loops, variables, and more.
It's called Python Jumpstart by Building 10 Applications.
It'll be about six hours long, and it will be a comprehensive introduction to the Python
language.
If this project resonates with you, I need your help.
As of today, I'm launching a Kickstarter to make the first course, this first step on
my journey, a reality.
Take a moment to visit the Kickstarter to see what it's all about.
Just go to talkpython.fm/course, and you'll be redirected to the Kickstarter page.
There are many reward levels, but the main one is the $29 student reward, which gives you
lifetime access to the course at a significant discount.
If you believe in this project and want to help, please tweet about the Kickstarter, share
it with your coworkers, or even back it yourself.
I'm really excited to start down this path to build something amazing for the community,
and I can't do it without you.
So any support or word-of-mouth endorsements you can give me will be deeply appreciated.
Please let me know what you think.
Send me a message over email, contact at talkpython.fm, or on Twitter via at Talk Python.
I'm also doubling my efforts on this podcast as well, so keep listening and sending in suggestions
and feedback, and I'll do my best to bring you interesting and relevant episodes.
Now, let's hear from Rob Blau about making movies and video games with Python.
Rob, welcome to the show.
It's great to be here.
Thanks for having me.
Oh, you're welcome.
Thanks for coming.
I'm super excited to talk about Autodesk.
You guys kind of make a little bit of everything.
There's so many different pieces of software that you write.
And it sounds like Python plays some pretty cool part in that.
Yeah, definitely.
So Autodesk is a great company.
The company mission is to help people build cool things.
So pretty much software that helps people realize their creative vision.
The largest piece is kind of on the AutoCAD, like production architecture side.
And the piece of Autodesk that I work in is the media and entertainment division.
So we get to work with animation houses, visual effects houses, and help build the software
that they use to do the cool things they do to put pixels and games together.
That's really cool.
So if I jump on a train and I go over to the airport and I get on a plane, fly somewhere,
and find my way to a movie theater, how many of those different experiences are modeled or
somehow created with Autodesk things?
Chances are every single step of the way from the car that you jumped into, somewhere along
the way from the factory that it was created in and the robots that made it, they were designed
using some of the Autodesk software, the actual car itself, the models, all of the pre-visualization
that people do in order to figure out what it's going to be.
And then the actual instructions for building it.
Autodesk makes products that do that.
I mean, the city streets and the planning, it's incredible, the places that the software
is used, and then the airplane, the exact same thing.
And then you're going to the movie theater.
The movie theater itself was probably done by an architect who was using AutoCAD in some
way, shape, or form, or Revit, which is used to build bigger projects and make sure that
all of the various components in the building, like the HVAC and the design and the wiring,
all talk to each other and will work once you actually build it.
And then you finally get the movie showing and you start seeing, nowadays, almost every
single shot has some kind of visual effect on it, whether it's just a little bit of 2D
cleanup that happens up to the full 3D.
The actual environment is completely created from scratch inside of some software.
Autodesk makes some of the most widely used pieces of software for that, like Maya 3 Studio
Max.
All of those are used to model and render what you're seeing up on screen.
That actually kind of blows my mind.
That's even more intense than my original thought.
That's awesome, though.
It's really cool.
Fun mission to have to just make it easier for people to realize their creative vision.
It's a nice one.
Yeah, I bet it is.
So let's totally dig into that.
But before we do, maybe sort of give me your background story.
Like, how do you get into this place where you're working on basically building everything
that makes up the synthetic world?
I had kind of a roundabout way there.
I went to school for computer science.
So from Boston, went to MIT and graduated around the first tech boom, did a couple of dot coms
at that point and built up kind of just a varied background.
I did a lot of scripting, a lot of database work, a lot of just systems admin kind of stuff.
Just there was a startup culture and you did whatever you had to do to get going.
And from that, I went to actually a Linux conference and saw a presentation from DreamWorks,
DreamWorks Animation, where they were presenting how they're using Linux because they were one
of the first companies to switch over to kind of big open source software as the foundation
of the technology that they're using.
Interesting.
What were they switching from?
Do you know?
Silicon Graphics?
Yeah.
Back in the day, it was kind of Silicon Graphics.
Yeah.
So they kind of had deals with Red Hat going and figuring out kind of the enterprise Linux
distro.
They were early in adopting all of that stuff.
So you intersected there when they were talking about how they were using Linux.
Okay.
Exactly.
And I got to talking with them and it turns out that they had an interesting job that was
doing, it's called pipeline work in the visual effects industry, which is the software that
helps tie together what all of the different departments do.
So you've got an artist sitting there, they've got a very specific job to do.
It's almost like in an assembly line in a factory, you've got your station where you're doing your
very specific thing, except with an artist, it's a very creative process, but they still have to
take work done by somebody else, get it working for them, do what they're supposed to do to it,
package it up for somebody else and then hand it to somebody else.
And all of those pieces other than that creative work is kind of overhead that it's
nice to artists to not have to do.
And that's where this idea of pipeline comes in.
So I was kind of fascinated by that right from this original conversation.
Plus I had about 10 Boston winters and the idea of California sounded pretty good.
So I went to work for DreamWorks where I was for five years and was a member of their pipeline
department, ended up being a supervisor in that department.
And that actually is where I first started using Python extensively.
The pipeline at DreamWorks was Pro-based because back originally when you were doing text processing
and having to glue together different software, Pro made a lot of sense.
Right.
What year was that?
That was about 2003, 2004.
Yeah.
I'm talking about right now.
Yeah.
Pearl was still in a pretty strong position back then.
Exactly.
And the pipeline that I'm talking about had been in place for like a good probably five, six,
seven years before that even.
So when it was written, like that was the choice.
But there was something that was kind of interesting that was happening with software in the 3D space.
There was already a couple of pieces of software that had Python embedded in them.
And Maya actually, as one of the biggest, again, taking it back to an Autodesk product, was introducing a version that had an embedded Python.
And at that point, if one of the biggest applications that you're using in your pipeline speaks Python natively,
there was a pretty serious indication to DreamWorks as a whole that maybe committing to Python rather than Perl would be a great idea
because all of a sudden, all of this integration work that we're doing doesn't have to end outside of the applications that we're trying to tie together.
We get the chance to run inside the application with code that you're using to tie everything together,
which is amazing because all of a sudden you can speak the same language throughout the entire pipeline
and do a much more seamless handoff for the artists, kind of, which is, again, the purpose of all of this is to make it so that they can spend their time
just doing as much creative work as possible.
Right.
Yeah, that's really cool.
rather than trying to integrate Perl and Python and have some sort of handshake or handoff, just make it Python all the way through, right?
Yep, which actually was, at the time, controversial.
It was a pretty big jump to do, and it wasn't clear that Python was going to take hold in the entertainment industry the way that it has.
But since then, nowadays, it's a no-brainer.
Almost every new piece of software that comes out has an embedded Python interpreter,
and Python studios around the world is the de facto language that's used in order to do this kind of work,
in order to tie stuff together, or even just the tools that you write for artists.
Unless it has to be compiled, you tend to gravitate towards Python to do it.
That totally makes sense to me.
What I think is interesting, and I see it happening in data science, I see it happening in education,
you're telling me it happens here as well, which makes a lot of sense,
is it seems like Python is becoming more and more popular, and that popularity is almost accelerating.
The rate of popularity growth seems to actually be growing, which is really cool to be part of it as that's happening.
Why do you think that is the case in the entertainment industry?
I think I was thinking about this in advance of sitting down.
A lot of it, I think it got its start by being so easy to embed and having kind of this kitchen sink approach.
Those two things combined together made it so that with just a little bit of C code,
all of a sudden, the scripting environment that you could offer people became incredibly rich.
And because of the ease of exposing your C, C++ libraries through to Python,
even if you just go natively to the Python C API,
it meant that all of these programs that didn't necessarily have a great scripting language
could have one without too much investment.
Now, Maya actually did have an incredibly embedded scripting language, still does, called Mel,
but it was only for Maya.
And people were Mel experts.
There was a ton of work done in Mel,
but your world ended at the boundaries that Maya provided.
And it didn't give you too much of a chance to extend outside of that.
Whereas with Python, you get the exact same kind of scriptability,
but now you get to talk to the rest of the world and the rest of the universe
that's also speaking Python, which is huge.
So I think the application developers saw that,
and it wasn't that huge an investment to say,
like, hey, let's just slap Python in there.
And then it paid dividends.
And then once that started happening, it almost was a no-brainer.
If you're going to be doing this work,
you do it in a language that all of the big applications that you're running speak natively.
And everything just kind of came together around that.
Yeah, it just kind of snowballs from there.
Exactly.
And then once it's kind of established as the de facto,
then everything else that comes in just has to speak it.
In the industry, there's been a ton of new open source projects
that are going on,
like a standard way to pass 3D geometry between applications,
a standard way of describing what's going on inside of a 3D scene.
And every single one of those comes with Python bindings out of the box
because everybody knows that you're going to have to interact with it via Python.
Right.
So if you don't have the Python bindings,
it's almost like you don't have a mature scripting story or something like that.
Yes.
And it almost like that can be the bulk of your scripting story.
And if you don't write it, then someone will write it really shortly
because people need it.
If you're going to be used, you need to speak Python.
That's interesting.
You were talking about sort of, you know,
you had the scripting language Mel and it was doing fine, presumably,
but it kind of, it could only do its thing.
And I think that's also why Python's becoming one of the major reasons
why it's becoming so popular in like data science
is there are languages like R and so on.
But if you want to build like a full stack sort of thing,
like I want to do my, you know, the data science part,
I want to do my science and my visualization and my web app
and my database access all in Python.
You know, you can't do that in these other more specialized languages.
So it's interesting to see the parallels over there.
Yeah, it is.
I'd actually say the thing that I'm seeing where Python isn't in play as much
comes from applications that were kind of originally developed
for either like a very specific workflow or from outside the industry
and they're coming in.
a lot of those actually start with nowadays JavaScript engines built in
because I think the same story has kind of repeated itself a little bit on the JavaScript side
where it's so easy to embed at this point that for very little investment,
you can go ahead and have a JavaScript interpreter running inside your app,
just like you can have a Python interpreter inside your application.
like within the entertainment industry,
those are actually some of the big areas where we're kind of have a miss
in terms of getting everything to talk to each other.
Photoshop is a good example where there's various somewhat convoluted ways
to try to get the JavaScript that Photoshop speaks to talk to Python outside of Photoshop
and various places are doing that.
But again, it's that idea of just how easy it is to create a scripting environment
inside of these applications where there's a lot of value to being able to talk to it
without writing compiled code.
You know, I think the whole V8, the thing happening with Node,
but really the V8 engine itself being a separate thing that you can host
has done some pretty amazing stuff for JavaScript.
Exactly.
And I think some of the full stack, like it's Python all the way through,
like the whole Node story and V8 is like it's JavaScript all the way through.
Yeah.
And it has a lot of the similar kind of parallels where it has a little bit more
of the kitchen sink, not as much as Python does,
but there's more and more JavaScript libraries popping up all the time,
just like there are Python libraries too.
So it's interesting just seeing that pattern replicate itself.
It's kind of detrimental from where I'm sitting,
because I would love it if all of those things spoke Python.
It would make my job easier,
but it's just kind of interesting seeing that take hold again.
continuous delivery.
Continuous delivery isn't just a buzzword.
It's a shift in productivity that will help your whole team become more efficient.
With SnapCI's continuous delivery tool, you can test, debug, and deploy your code quickly and reliably.
Get your product in the hands of your users faster and deploy from just about anywhere at any time.
Did you know that ThoughtWorks literally wrote the book on continuous integration and continuous delivery?
Connect Snap to your GitHub repo and they'll build and run your first pipeline automagically.
Thanks SnapCI for sponsoring this episode by trying them for free at snap.ci slash talkpython.
That is super interesting.
It makes a lot of sense to say either Python or JavaScript as a proposition for somebody who's not a developer but needs to automate a thing.
To say your API is C++ and you've got to have this compiler with these headers and these libs you're statically linking.
That just doesn't fly, does it?
No.
The stuff that Python is used for tends to be a lot higher level workflow.
I think you're taking workflow and translating it to code.
So it tends to be pretty dynamic.
It needs to be updated constantly.
I mean, almost each project you'll be tweaking the stuff to work how the people working on that project need to work to get their job done most efficiently.
And it doesn't need to be performant, I guess.
Yeah, because it's just orchestrating the things that are probably written in C.
Exactly.
Interesting.
You were talking about JavaScript and having the JavaScript try to interact with Python somehow.
And obviously getting out of a JavaScript engine can be pretty tricky because they try to sandbox you a lot.
But have you looked at PyPyJS or one of these embedded JavaScript foundation Python implementations?
We haven't.
I guess I should qualify.
What I'm doing at Autodesk is actually a group that is putting together one of these production pipelines that is just part of a production management product that we make.
So I'm now not working at a studio doing all this pipeline work, but working at a software company that is, again, just trying to make it so that the various workflows that we see being done in VFX and animation, just content creation in general, we make it really easy for people to get some of the grunt work out of that.
Given that setup, we're not embedding the interpreters ourselves.
So I'm working on the scripting code that's going to be able to talk to that application.
So it's like Photoshop has JavaScript.
We're not going to be able to embed Python in it, although we could do a plugin, get an embedded Python running.
But then there's a lot of threading issues and other stuff that we've tried to be as seamless as possible.
But you can only do so much with an application.
It all depends on what kind of SDK and API they offer you.
So we don't have that level of control.
But we are looking at some standard RPC kind of libraries and trying to figure out what does make for a good bridge between those worlds.
Right.
I think probably the easiest way to bridge JavaScript to another thing is some kind of network layer, right?
Network layer or even if you're not going over the network.
Yeah, exactly.
Like RPC, even if it's just talking to another process on the same machine.
Yes, exactly.
But making that a really rich communication channel.
And there's some impressive projects out there that do that.
And we're actually kicking off an effort to evaluate them and try to pick one that's going to work well for us.
One of the things you'd sent over is you talked about sort of Python and games.
And what's the story there?
Sure.
Games is kind of an interesting take on all of this because VFX and pixel production has been around longer
and has a bunch of different constraints than games have.
So far, games have really been driven by the game engine and the developers as almost separate from the creation of the models and the shaders that show up in the game.
All of those need to play well together.
But it's almost been more of an agile developer kind of style than a cascade of content flowing between different departments,
which is what you see in animation and VFX, mostly because the complexity of all of the environments and models that VFX has been playing around with has been higher than what you've seen in games.
But that's actually switching a lot nowadays, where the complexity of production in a game is a lot of times higher than what you would see in a feature film.
The need for this kind of pipeline is showing up in games more and more.
But they've got this whole coding side to the game where the artists are just a piece of what's going on and they need the developers in order to tie everything that they're creating in.
And it all comes together in the game engine.
That is what's actually going to be running all this stuff at the end of the day.
What we've seen there is there's some game engines that speak JavaScript coming out now.
The tried and true has been .NET.
Just a lot of this has been pretty Microsoft-centric.
And the .NET code can speak Python, the iron Python that's out there, which has been kind of an interesting tie-in for us.
Or Lua, actually, is another scripting language that a lot of the game engines tend to speak.
But it's yet another kind of separate world.
Even the .NET side has limitations.
It lets us do kind of basic Python integration.
But you hit brick walls pretty quickly when you want to do cross-platform networking stuff or GUIs, especially.
You have to start writing things specifically for the .NET flavor as opposed to treating it just like another Python interpreter that's out there.
Right.
Yeah, you get very, very specific, like WPF-type stuff.
You can't do PySide, PyQt type of things.
That kind of, which is much more cross-platform.
Can you give me just your feedback on what you've done and what it's like to work with IronPython?
I haven't actually...
I've played with it and looked at it, but I don't really know much about it.
So it'd be interesting to hear.
I've actually found it to be pretty good.
The boundaries that you hit are kind of what you'd expect, where Python itself starts having dependencies on third-party libraries, like SSL implementation or the GUI kind of side of the world.
But, I mean, personally, I've had fun little side projects like getting IronPython up and running in a plugin for Microsoft Office projects.
So that, you know, there's an API that's available only via Python.
You can start interacting with it from within Excel in order to kind of get deep scripting ability within something like that without having to write visual basics.
So that you can, again, reuse that Python code base that you've got.
Yeah, that's quite interesting.
It's kind of a Frankenstein kind of approach, but a lot of the integration that we end up doing has some element of that because you're really trying to establish this rich Python programming environment in all of these different spots.
And some of them are more conducive to it.
Some of them, you kind of have to jam it in.
They resist a little more, huh?
Exactly.
IronPython was a Microsoft project.
I think it was created by people inside Microsoft or maybe they created it and promptly joined Microsoft.
I can't remember the exact chronology of it.
But they, a while ago, set it free and said, we're not really doing anything more with IronPython, but it's now this sort of open source project.
The world can have it.
And I just, like, a few hours ago, although it's been out for a couple of months, learned about this thing called Pyjion.
Pyjion?
P-Y-J-I-O-N.
Have you heard of this?
I've heard the name, but I don't actually know much more than that.
It's kind of a competitor to PyPy, which is a JET compiled runtime implementation for Python.
But this is one that runs on the new open source cross-platform version of .NET.
So maybe there's something interesting there coming in the future.
I don't know.
We'll see.
But it's interesting to see them taking kind of a second shot at something like that.
Cool.
I'll just check that out.
Because something like that could potentially open up, like, the game engines that speak .NET to the deep integration with kind of the rest of the creative process that would share the pipeline from feature animation and the kinds of complex asset builds, like the models and the various assets that you see on screen, that process for games.
Yeah, absolutely.
I mean, IronPython seemed really cool, but kind of like you were saying, its limitation is you're all in on Windows.
Like, it only runs on Windows.
You have to really program against the .NET, so at the time, Windows-specific APIs.
But with the cross-platform plus this, you know, maybe that sort of opens up again.
It's going to be really interesting.
I don't know where it is.
Is that the mono environment?
No.
No, it's the mono environment was Miguel de Caza's work on sort of re-implementing .NET, which is Herculean.
And they've gone on to do Xamarin, right, with the mobile stuff.
So this is a new effort called the Core CLR by Microsoft to do a shell or a core kernel of .NET that's totally cross-platform that you can do on OS X and Linux and sort of, but, you know, official, not like a sort of frenemy-type project in what they're doing.
So it'll be interesting to see if this can bring a really rich version of Python to that story, kind of like we have Jython for Java.
Exactly.
But, you know, that's not really updated really quickly.
So maybe, I don't know, I have high hopes, but they may get dashed.
We'll see.
I hope it comes out awesome.
We'll see.
Definitely dig into that.
Thanks.
Yeah, you bet.
This episode is brought to you by OpBeat.
OpBeat is application monitoring for developers.
It's performance monitoring, error logging, release tracking, and workflow in one simple product.
OpBeat is integrated with your code base and makes monitoring and debugging of your production apps much faster and your code better.
OpBeat is free for an unlimited number of users.
And starting today, December 1st, OpBeat is announcing that their Flask support is graduating from beta to a full commercial product.
Visit opbeat.com slash Flask to get started today.
There sounds like a lot of positive news from all the cool things you're doing and the way you're able to weave these pipelines together.
I want to kind of talk about what you see, the sticking points and so on a bit.
But before we do, maybe just to give me and everyone else a better idea, could you describe what the steps are and this pipeline that you talk about?
What are people doing?
What does the software have to do?
Just so we get a little more concrete idea there.
The kind of nature of this is that you can go down these giant rabbit holes.
Like you can go extremely deep into automating things.
And traditionally, only fairly large studios that could afford having an R&D department had the ability to go deep.
Lots of places had pipelines, but they tend to be pretty easy handoffs rather than tackling a lot of the deeper issues.
It can start as early as a script.
If you've got a script that you're thinking of making a movie of or that you need to do visual effects for, it tends to come in from some program that stores it as an XML file.
You can write a parser for that in Python and use that in order to get a listing of here's all of the different scenes in the movie and here's the characters and location, things like that.
Which, if you were doing this by hand, traditionally you would do a breakdown where you would just build up a spreadsheet of all of those things so that you can start getting your head around what you have to build.
You go ahead and you start storyboarding things so that you get an idea of what everything is going to look like.
And there's various software that's built around storyboarding.
I mean, Photoshop is kind of one of few players in that area.
Even then, you tend to just have these images that you're working on and then tracking those to say, OK, here's the current storyboards that relate to this scene.
We want to hand them off to editorial that's going to start cutting them together into a movie that we can watch to get a sense of how this plays together.
There's lots of iterations there that go back and forth.
So you have to keep track of those files and know which ones were approved, what the notes were, so that whoever's going to be doing the next iteration on that can take those into account.
And it's really trying to put some organization around a very creative, quick iteration workflow without getting in the way of that creative process.
So then you start getting this editorial content together where you're cutting together these images on a timeline and you get a sense of timing.
That tends to be a place where you need a lot of R&D to dig in because a lot of the editorial software out there, Avid being the biggest one, tends to be a little bit of a black box.
You've got Final Cut, which has an XML spec that you can start taking apart, but you don't get a chance to understand too much of what's going on inside of editorial software.
Sure.
So are you guys doing actual processing of MP4 files or raw assets in Python and looking at them, that kind of stuff?
So an example of how Python would tie in over there, not with Autodesk, but my previous job at a studio that's in Portland called Leica that does stop motion animation.
We actually, there's a C library around this file format called AAF that is what the Avid editorial software speaks.
And it's a pretty obscure format, very complicated.
The API is very complicated.
And we wrapped that with Python bindings so that we could take a export from Avid and really deconstruct it, which meant that we actually were able to know which storyboards an editor cut in where and what characters were in that storyboard.
So that when you're going ahead and putting together a shot, you would know generally the contents of that and all of the comments that came through, all of the notes that the director had for the storyboard artist, which is incredibly valuable because in the shot, you've got to go ahead and take your 3D models and bring them in.
So having the list of what's already been included from the storyboard artist gives your layout artist who's doing that work a leg up and you can get started and you can write a tool to automate the initial pass at that and then let him actually do the creative piece of that, which is where you should be spending his time rather than searching for the right models to put in.
And then when it gets to animation, it's really valuable for the animator to be able to see all of the notes that the director had for the storyboard artist because they're very applicable to the job that he has to do.
And none of that would be readily available without being able to connect the dots between all of those different handoffs.
So connecting those dots and managing those handoffs and making it so that you can deal with this explosion of data that happens throughout this process in a kind of tractable, meaningful way is what the pipeline is responsible for.
Okay.
That gives me a really good view into it.
I think it seems like there's all these different apps that the various people have to use, editors, artists, and so on, and they don't necessarily talk to each other.
Right?
So you're kind of writing.
Yeah.
So you're kind of writing this glue that can turn that into like one almost distributed data source or something.
Right?
Right.
It's kind of like if you're used to using Excel on one front and you've got this text editor that you use on another front, if you were able to kind of connect those together because it knew that you're doing accounting work and it was able to actually react to the files that you're saving from the text editor, parse them, and automatically bring them into your spreadsheet so that you didn't have to manually do that.
Each time you've changed one piece of information and get the rest of it in sync with that.
It's kind of that on an extremely grand scale.
I don't know if you have the answer off the top of your head or really no, but I'm thinking about all these different processes and all these different raw editions and then produced and sliced up editions.
So these files, you know, if I go and get like a movie, it's probably a couple of gigabytes.
But what's the data, the total data size for like a modern production movie or something?
Do you have an idea?
Oh, we're in many terabytes land nowadays.
Yeah, it is terabytes and terabytes in order to do the models and the effects work and all of the simulations that need to happen in order to get the quality that we're seeing on screen.
It's incredible the amount of data that goes into just those final pixels that you see.
So like the gig, couple gig download that you get, which is a really high quality video that you could watch.
Yeah.
Each of those, you know, frames as gigabytes and gigabytes and gigabytes, like hundreds of gigs behind it alone.
So we put it all together at 24 frames a second for feature length.
It definitely adds up.
Yeah.
Wow, that's crazy.
It is the scale and especially just the amount of data and the number of people involved and the amount of handoffs that happen in order to achieve that thing that is on the screen is pretty amazing.
Yeah, I bet it is.
Everything sounds really good, but you said that there was actually some issues that you were running into.
Like one of them was that using Python 3 in this world is not something you can just necessarily jump straight into.
A lot of the issues kind of around Python use almost come from how successful Python has been and how it's embedded in so many different places.
We just have this versionitis problem where currently the code that we're writing, we actually support back to Python 2.4 because there's some versions of software that are out there and they've been updated since.
But studios are pretty notoriously slow to update if everything is still working.
It had Python 2.4 embedded in it.
There's definitely a lot of Python 2.5, 2.6 that's still out there.
The majority of modern stuff is on Python 2.7.
There's like one notable source project that's made the jump to Python 3.
But because the nature of this pipeline work is to glue stuff together, when you have a jump that's not backwards compatible, it kind of makes it hard because you have to have two different code bases.
There's one that will run for all of the environments that are Python 2.5 based and one that will run for everything that's Python 3.5 based.
And you can kind of work to minimize this.
But there's definitely this hard jump that happens because not all of these pieces of software are going to update their Python interpreters at the same time.
And there's nothing that says that you'll be able to, as a studio, be able to update to that version of that software at the same time.
It gets into a whole lot of issues from just cost, support, licensing, getting the bugs out of it, down to having the resources to update your code to run in Python 3.
Wow, that's crazy.
That's going to be an interesting cliff for the visual effects feature animation world to get to the other side of.
There's various attempts within the industry to try to control this versionitis issue because it's not just Python.
There's all sorts of common libraries that are used throughout production.
And whenever they don't match, it causes issues.
So there's a VFX reference platform that tries to standardize some things.
Python 3 isn't even on the radar of that.
I think Python 2.7.whatever is the target for the foreseeable future.
I think it's probably going to be dropping support with a combination of security issues that just force updates.
That'll be the thing that finally gets us as an industry to the other side of that.
But it is kind of unfortunate just because of the wide range of versions that you have to support and the dependent libraries and all of the complications that come up trying to develop software in that kind of an environment.
Yeah, that really, that's quite challenging, it sounds like.
I mean, when I think of people that are using Python 2 and they say we can't switch to Python 3, in my mind, I often think of a couple things.
Like one is we have a quarter million or more lines of code that was tested and is working on Python 2.
And we're just not going to change that because it's too risky and it's just, you know, it's not broken.
We don't really want to mess with it.
That kind of thing.
And then the other is we've got some key library that we depend on, some package that itself is only Python 2.
So until that gets upgraded, you can't only flip your app, right?
But this is a whole nother level, like those two things still apply.
They definitely still apply.
They're just one part, right?
Because you've got multiple compiled, distributed, shipped, non-updating, potentially pieces of software that have a host of versions packed into them.
And you've got to fit into that.
That's pretty crazy.
And then you guys are building software that works with multiple versions of those, right?
Because you're not building the pipeline to make a movie.
You're building software to give to the people that are making the movie.
So it's just, you know, a few more dimensions there.
It actually is one of the things that really excites me about the project that I'm working on where almost for the first time, rather than building one of these just for a particular studio or as kind of just an open source project, we're trying to do it with the resources of a company like Autodesk behind it.
Autodesk, which all of a sudden, like the jump to Python 3, which for the industry as a whole feels like it's a huge issue.
It gives us a place where if all of these vendors for the major applications got together and said, okay, here's the version where we need to switch to Python 3.
We could do a lot of the legwork for the industry as a whole and get stuff going and create that bridge over to Python 3, which doesn't exist if every studio had to do that themselves and manage it themselves.
Yeah, that's really interesting.
You're one of the few groups that lives, you basically are one of the few groups that live between all these pieces of software where everyone else is just consuming it, right?
Exactly.
And everyone, you know, almost every company figures out a way to get that in-between stuff written in order to automate stuff that they do.
It's just too tedious otherwise.
But we're kind of a central place where we can do that, which gives these software developers someone to work with in order to figure out some of the issues.
And we definitely wouldn't encounter all of the issues that studios out there could see with the setup.
But we at least can take it a big step further and prove that this kind of integration does work on the other side of that giant chasm.
And here's how we did it.
And here's the issues we found and help other people cross it.
So another thing that you said that was kind of challenging, kind of like this version story, is PySide and PyQt.
Can you maybe first of all tell people what that is so that everyone knows?
And then what's the story there?
Sure. Qt is a cross-platform C++ GUI toolkit.
So you can build complicated applications using Qt as the components that you're using to build all of the GUI widgets and do it in a way that's cross-platform.
So it runs on Linux and on OSX and on Windows.
Yeah. And one thing I'd like to add about that is that's one of the few cross-platform UI frameworks that I think looks modern and really good on all the different environments.
Like a lot of times you're like, whoa, that is definitely not native.
That looks like a weird app or whatever, you know.
But I think Qt or Qt, it's nice.
Yeah. I mean, it has a rich set of widgets.
They're very configurable.
It ties in nicely with the native OSs.
It's been around a while.
It's been used in a ton of places.
Some huge applications use Qt.
And it's funny that you say it looks modern.
There's actually been this divide in the Qt world between Qt4 and Qt5, similar to the kind of the jump to Python 3, where Qt5 is this big leap forward.
And that's one of the other things that the entertainment industry is trying to navigate the jump from Qt4 to Qt5.
And to go back to what is Qt and what is PySide, PySide and PyQt are two Python bindings to that Qt library so that you can build these cross-platform, good-looking, complicated UIs in complete Python.
It's pretty prevalent.
It's out there.
It's great.
But PyQt is not open source.
There's licensing restrictions around it.
It makes it hard to build a commercial product around that, even though kind of supporting it as a runtime is completely doable.
But in order to actually run a PyQt app, you need to be licensed if it's a commercial software.
PySide, it was the branch, was another implementation of that Python binding in order to kind of get around those licensing restrictions to make it so that within Python,
you could build these rich GUIs without having all those licensing constraints that come with PyQt.
The problem with PySide is that it's one of those open source projects that's kind of stalled out.
And there has not been a version that supports Qt5.
So ironically, one of the big reasons that the industry can't cleanly jump over to Qt5 is because Python is everywhere.
And people have used Python to build these really awesome production tools that are Qt4.
And there needs to be an upgrade path for all of that code.
So figuring out how to kind of breathe some life into the PySide project and get it going has been a topic of consideration.
And it's something that, with the help of that VFX reference platform that I talked about earlier, because they are trying to drive this jump to Qt5 because there's a lot of improvements there.
Qt4 is starting to show some age.
They're trying to drive some life into the PySide project in order to get this update to be possible.
It's an interesting thing where, again, this dependency and having all of these different apps coordinate this kind of an upgrade affects how we use Python and what's possible.
I tend to really think about, I guess, how that kind of paints you into a corner.
I did play around with PySide and PyQt and ran into the issue of, well, the licensing on PyQt, it seems overly restrictive.
I'm not really against commercial software, but it seems like, I don't know, it just seems harder or more restrictive than it should be.
But then again, I tried to use PySide and it was like almost working.
It was frustrating.
But I knew if I could get him to work, I'd have something really cool.
But I kind of gave up and went and did something else altogether.
Yeah.
We do a ton with PySide.
It would be amazing to have it be under more active development.
Like I said, it's almost there.
You can do a lot with it.
There's definitely kind of low-level issues with memory management and things like that at the interface between the Qt world and the Python world.
that if it was under active development, we would be seeing some upgrades happen that would clean that up and make it easier to develop rich Python GUIs that are embedded in these giant applications,
which is where we actually realize a lot of just saving artist time so that they don't have to hunt around for files or manually export things knowing the settings that they do.
And then they can just get back to doing the creative part of their job.
And all of that currently for a lot of places, unless they bought the license for PyQt, is done in PySide.
Have you considered using some of the fully native options like Py, OBJ, C, OS X, and Iron Python and WPF on Windows and just having a separate UI layer?
Definitely thought about it.
It's a lot of overhead when something like PySide is there and you can write it once and have it work everywhere.
Yeah, it makes perfect sense.
It's something I've been thinking about some native apps in Python and I'm like, well, you know, how much, I guess it depends on how much of your code and complexity is in the UI itself and how much you can push down to packages that those two distinct UIs that you'd have to write would consume, you know?
I mean, at that point, you start wondering, like, would it make sense to have the GUI level written in actually Objective-C for OS X directly and embed a Python interpreter and tie it in like that?
Like, at that point, it being in Python, you start wondering if having that layer be Python makes sense because you're having to code it specifically for the operating system itself.
And for the GUI work, you get to use Xcode in a really deep way.
Right, right.
Maybe just use Xcode and like Swift now.
So that's pretty close to Python, actually.
Something like that, right?
Exactly.
Yeah.
Yeah, but you'd lose all the packages.
Anyway.
Exactly.
And it needs to talk to the rest of the pipeline.
Again, your general knowledge of what's going on in the production and how to translate between these different applications is usually Python logic.
So you've got to figure out a way to talk to that.
Yeah, yeah.
It's a super interesting set of trade-offs to consider.
I personally would love to see PySide really come on strong.
But...
It'd be amazing.
Yeah.
All right.
I have just enough time for a few more questions for you before you go.
All right.
So if you're going to write some Python code, what editor do you open up?
That's funny.
I have switched over to Sublime.
I was kind of diehard VI Vim for a long, long time.
And Sublime was the first thing that I saw that I was like, okay.
It's fast enough to launch and fast enough to get going that it competes.
There's still definitely some stuff that I miss from them.
But I've grown addicted to multiple cursors.
Yeah.
Okay.
Very cool.
Yeah.
I like Sublime as well.
That's nice.
There's, you know, many thousands of packages out on PyPI that people can go grab.
What are some of your favorites that maybe not everyone knows about that they should check out?
Oh, man.
I mean, it's not on PyPI.
But I do think PySide and kind of being able to build a GUI in complete Python and then even package it up with like Py2XE, Py2App or that kind of flavor of that is a pretty amazing thing for people to do.
It's just kind of cool to be able to take something and actually hand it off as a self-contained thing to somebody else to run.
Yeah.
That is really cool.
And I don't think I or any of the guests have spoken about Py2App or Py2XE or CXFreeze or any of those categories of things.
Maybe you could just tell everyone out there, like those you can go pip install at least one or two of them, I think.
Yeah.
Some of them just come with the Python distributions.
So it's a way of basically compiling down and freezing the Python interpreter and your code together as a native executable.
So on OSX, the Py2App will actually create a bundle that has all of the Python embedded in it.
And the same thing with Py2XE.
You get a standalone EXE that you can run on Windows and it'll run your code.
So if you combine it with PySide, then you get this EXE that you double click on and you don't even necessarily know that you're running Python under the hood.
You got to take the code that you wrote and the speed with which you got to develop it because it's all scripted and you're able to put it together with something like PySide.
And at the end of the day, you end up with this self-contained thing that you can just email to somebody without them having to set up any infrastructure under it and they'll be able to run it.
Yeah, that's really cool.
And you can, it takes your packages and everything, right?
Yep.
It embeds it all.
Yeah, I haven't had a real good use case for that because I mostly do web stuff.
But yeah, it's really cool to think, you know, instead of zipping up a bunch of scripts and sending them, I go, oh yeah, and you need to, you know, pseudo-pip install this while you're at it.
Just go, you know, here's your .app, double click it.
Or here's your .exe, double click it.
It's great.
Nice.
Final call to action or anything people should check out?
Let's say there's calls to action.
Then people who are interested in open source development and the PySide, I would recommend that.
It would be amazing to get people interested in that again.
All right.
Awesome.
And how do they find this project that you're working on?
Is it something that's out or something you're working on still that's going to come out?
It is out in a beta form.
There's a production management software that Autodesk sells called Shotgun.
You can go to shotgunsoftware.com.
And everything that I've been talking about is the pipeline developer section of that.
So the project is Toolkit.
We're the pipeline toolkit for Shotgun software.
All right.
It sounds like a really interesting project.
And definitely got a fresh look at all the barbs that live in the different versions of all these things.
Yeah.
I would say if people are kind of interested in the stuff that I was talking about, the project that we work on is source shared.
We've got public repos on Git.
The license is you kind of have to be using Shotgun as a product in order to use the project.
But all of the Python code is there for people to look at, improve upon.
We try to do it as a very open project so that everybody that does this kind of work can join together as a community.
That's great.
It's been really fun talking to you, Rob.
Thanks for being on the show.
Thank you.
It's been a pleasure.
Yeah.
Bye-bye.
This has been another episode of Talk Python to Me.
Today's guest was Rob Blau, and this episode has been sponsored by SnapCI and OpBeat.
Thank you guys for supporting the show.
SnapCI is modern continuous integration and delivery.
Build, test, and deploy your code directly from GitHub, all in your browser with debugging, talker, and parallelism included.
Try them for free at snap.ci slash talkpython.
OpBeat is mission control for your Python web applications.
Keep an eye on errors, performance, profiling, and more in your Django and Flask web apps.
Please take a moment to check out the online course Kickstarter at talkpython.fm/course.
You get a discount for the course by signing up early and the satisfaction of helping create something amazing.
You can find the links from this show at talkpython.fm/episodes slash show slash 46.
Be sure to subscribe to the show.
Open your favorite podcatcher and search for Python.
It should be right at the top.
You can also find the iTunes and direct RSS feeds in the footer of the website.
Our theme music is Developers, Developers, Developers by Corey Smith, who goes by Smix.
You can hear the entire song on talkpython.fm.
This is your host, Michael Kennedy.
Thank you so much for listening.
Smix, take us out of here.
First, developers, developers, developers, developers, developers, developers, developers, developers, developers.
you