
How the Scripto App Became a Fixture of Late-Night Comedy News - riordan
https://www.newyorker.com/tech/elements/how-scripto-the-app-that-stephen-colbert-helped-build-became-a-fixture-of-late-night-comedy-news
======
jccalhoun
This is the site that shows some of what the program looks like:
[http://scripto.computer/](http://scripto.computer/)

~~~
jdtang13
Wow, this looks really nice, actually. Hard to believe the creator is simply
an "amateur coder".

~~~
ilaksh
Much of the core functionality was created by the Etherpad and Etherpad Lite
team. The integration, rundown editor (originally), full-text search, and
other features were created largely by myself (in addition to Mindy). The use
of the term "amateur coder" here is slander. But I understand why Rob and them
started describing it that way -- the system fell down a few times in high-
profile situations of course they totally blame me rather than taking credit
for project management issues, so they used the fact that I don't have a
degree against me and found all of the bad code and system restarts and
pointed at that (I also wrote a lot of _very good_ code and solved some very
tough technical challenges).

Really the last time I was lead that we had an issue with the server going
down was a third-party component that had a bug, and it came down to me
deploying it in a hurry because we didn't have a good release process and I
was tired from my other job. So I believe there were project management issue
which I should have been more assertive over. But if I had money then I would
consider suing regarding the use of terms like "amateur coder". I started
learning software engineering when I was 8 years old (32 years ago), taught
myself object-oriented programming in middle school. I have studied software
engineering curriculum for many years online and also developed my own
philosophy and practices around software engineering focused on feedback loops
of different types and levels. I am a very good software engineer, not an
"amateur coder".

~~~
datalus
Ummm.. Rob Dubbin was mentioned as the amateur coder. Slow down there :)

~~~
spunker540
Are you sure that person is not Rob Dubbin??

~~~
notatoad
In another comment he says he isn't.

------
MattGrommes
Rob Dubbin was on the Track Changes podcast with Paul Ford a couple of months
ago and it was a pretty great episode:
[https://trackchanges.postlight.com/rob-dubbin-goes-off-
scrip...](https://trackchanges.postlight.com/rob-dubbin-goes-off-
script-a32f921961fa)

------
daveguy
Nice. Collaborative version control for Script writing/show running. Can the
"amateur coder" and Stephen Colbert make something like this for programming?
That would be very nice/useful. A layer on git? Is GitHub/GitLab/Bitbucket
already it? Real-time and ease of use don't seem to be there.

Are there editor plugins like this for paired / multi programming? Is it just
that the problem of "programming" is a lot more complex / open ended than show
script development / execution? It seems like they have a lot of similarities.

Getting multiple people to agree on the same tool may be a big part of the
battle, but surely there are some comparable programming tools out there.

~~~
ilaksh
My name is Jason Livesay
([https://github.com/runvnc](https://github.com/runvnc)). I was the original
lead developer of this software (with Mindy Tchieu also doing a lot of the
front end, and Sasha Stewart working hard on QA along with her other normal
Colbert Report job, don't know why they weren't mentioned in the article). Rob
Dubbin didn't code anything on the project by the way, although he does
deserve at least as much credit as me for keeping the project going. My
current income is below the federal poverty level, but at least this time I
have partial ownership of the product/company I am building (its automated
statistical arbitrage on cryptocurrencies).

To answer your question, yes, there are multiple good collaborative code
editors out there. The software was originally based on Etherpad, and after a
year or two I switched it over to Etherpad Lite. I don't know if they now are
based on something else at this point, I doubt it -- maybe their new
"Showrunner" has a different core. But for something just like that for code,
there is this
[https://www.npmjs.com/package/ep_codepad](https://www.npmjs.com/package/ep_codepad).
Probably the best option though would be something like Cloud 9
[https://github.com/c9](https://github.com/c9)

In case anyone is interested in my own take in general on this software, I
will write a few comments here also. We started working on it in 2011. I
consider this to be a cautionary tale for 'freelance' developers working for
startups everywhere (more on this towards the end).

I solved most of the key technical challenges that enabled the main Colbert
Report writing group to start using the system well before 2015 (I forget when
the main group started using it mostly full time, maybe 2014). We had a lot of
problems, but certainly nothing catastrophic every few weeks the way Rob
suggested. One note about this, the first request I made (and I repeated
multiple times) to Rob was to hire a professional quality assurance engineer
to help with the release process, and this was never done.

Some of the key technical challenges that I solved:

1) how to make a system for TV writers that works like Etherpad and has a few
other features. This is how the problem was originally described, and I took
the most direct approach -- I built a prototype based on Etherpad, which was a
Rhino (JS in Java) and Scala program. (The other sort of 'runner-up' for
developer selection had presented a prototype built from scratch with zero
actual collaborative functionality.)

2) reverse-engineering the partially text/partially binary-based document
database for ENPS and creating JavaScript code to read it.

3) full-text document search for the script document database (more than 1GB
of data) -- there were multiple approaches, one thing that mostly worked was
based if I recall on redis and
[https://www.npmjs.com/package/natural](https://www.npmjs.com/package/natural),
then later I rebuilt it on Elasticsearch.

4) a Google Spreadsheets-like collaborative realtime rundown editor

5) outputting script and rundown data as PDFs to match their old print-out
format

6) how to deploy the software. I built a single all-inclusive Docker container
starting back in January 2014 (they later took it apart, which at the time the
component infrastructure for Docker didn't make that a good trade off, now is
a different situation).

There are a few lessons I took from this project:

\-- if you find yourself working full-time as a 'freelance' developer for a
project for more than a year or two, you are probably going to get screwed.
For the last few years I have been careful to explain up-front that if I work
full-time on a project for a significant amount of time then I will need
equity.

\-- be assertive in terms of project management. Sometimes this is hard to do
because freelance developers may not always have stable income and that may
make it hard to put your foot down. There were some core problems with the
server administration, lack of resources, and release process that I would
have been able to correct if I had more leverage (in terms of savings?) or
balls. The server admin, back-end coding, tech support, and support for front-
end was all on me, even after I had taken on another project in order to make
ends meet. I should have insisted on more resources.

~~~
mikekchar
I've been around the block a few times, so maybe I can give you some counter
advice which I hope you're find useful.

\- Projects can be technical successes without them being
satisfying/fulfilling in one way or another for all parties. Developers are
usually skilled at development and not so skilled at navigating political
problems. Good managers are worth their weight in gold because they take care
of those problems (IMHO, managers who avoid dealing with those problems are
probably not worth working with). It took me a long time to realise this. As
I've gotten more experienced, I've learned how to deal with political issues
and I can do that role if I need to -- but I'd rather not. So basically I tend
to demand: give me a great manager or a _lot_ more money ;-)

\- Equity is fine, but it's often a big risk. Even more, asking for equity
means placing you back into the role of having to deal with political issues
-- because there are a _lot_ of ways to screw people over when it comes to
equity. Entrepreneurs often do that role because they _like_ competing for
money. Good entrepreneurs (the ones that will have successful companies) are
_good at making sure that they end up with the money_ \-- just like you are
good at writing code. You probably don't want to place yourself in competition
with them. My philosophy: cash on the barrel head. I don't work for promises
(though I have a bad habit of giving outrageous discounts to work on projects
that I want to work on ;-) ).

\- Project management is hard. A person who doesn't understand this is likely
to be a really bad project manager. Most projects have lamentable project
management. After decades in the industry I've learned innumerable ways to
screw up a project. I have learned precious few ways to succeed dramatically
-- and those ways can easily be pushed over by well meaning, but under
experienced management. (And come to think about it, they can be pushed over
by well meaning, but under experienced _me_ ). Any idiot can succeed when the
situation is set up perfectly. The real trick is succeeding when everything is
against you. Learn to play in hard mode -- it will help you in the long run.

\- It's hard, but important to control your ego. In addition to not over-
estimating your worth/ability I also mean not under-estimating it. All
projects have risk. If, in a headstrong fashion, you demand to control
everything that you think introduces risk, you assume that risk. Others then
depend on _you_. If you fail, then you may destroy their
dreams/livelihood/fortune. It is possible to put yourself into a situation
where you have assumed all the risk for the project, but almost none of the
consequences. People who will suffer the consequences, but control none of the
risk will naturally be put into conflict with you. It pays to be careful. On
the other hand, judiciously putting risk into the hands of those who are most
able to mitigate that risk is wise. That person may be you. Before getting too
deep into the project, make sure that you see eye to eye about this with your
partners. Failing to do so can cause the failure of the project all by itself.

You seem like a passionate, genuine developer so I wish you good luck in your
endeavours.

~~~
swsieber
Could you give more insight on "precious few ways to succeed dramatically".
I'd love to hear them.

~~~
mikekchar
My best projects have been full on XP projects. However, XP is a subtle beast.
It's tempting to look at the 12 practices of XP and say, "We're doing XP. We
will be awesome", but it doesn't really work that way (in my experience). The
12 practices in XP are "generative practices". What that means is that they
are meant to _lead_ you to a process that will be "hyper productive" (I think
Ron Jeffries coined that term). The 12 practices are not the process itself.
It's a bit like the difference between pointing at something and the thing
itself. The practices only point to the process -- _which will be different
for each team_.

And in case you are wondering what I mean by "hyper productive" (and I
apologise if this is not the original meaning, but I _think_ it is...): it
means being able to go faster as time progresses. On normal projects it is
easiest to work on the project when it is still greenfield -- you have no
constraints to work around. As you work on the project, the decisions you make
create constraints and make it more difficult to change what it does.

With a hyper productive team it works the other way around. Imagine working on
an embedded system where you may have a compiler, but you have no standard
libraries, or frameworks or third party code to help you. It's very slow
because you have to build all of the tools that you need to go forward. You
have to consider all of the abstractions and build designs that make it easy
to follow those abstractions. On modern systems we have lots of tools that
allow our "green field" projects to be boot strapped quickly. Now imagine that
you are constantly keeping your code in a state where every future change is
like that. As the code base gains capability, it actually makes it easier to
make the next thing. This, of course, is the holy grail of programming :-) You
can make a lot of money selling maps to the holy grail, so you shouldn't
believe me!

With that disclaimer, I will rashly state that I have been on "hyper
productive" projects before. But it's a pretty ridiculous tightrope. For
anything I could say, there will be someone who will reply, "Yes, that sounds
great in theory, but what if X happens? It will all come crashing down". Those
people are correct. That's why XP is not the 12 practices. They are just
something that will hopefully make you aware of what you need to do when X
happens.

I don't think XP is the only way to get to "hyper productive", but it is they
way I have used to get there. I don't know any other way, personally, but that
doesn't mean that it doesn't exist. Usually when people ask me the question
you have asked, I direct them to XP and suggest that they study it thoroughly
(including running projects in full-on XP mode). The problem is the "Agile"
attitude that people usually bring with them. Because they think, "Well, that
doesn't make sense", or "I can't do that because Y" and they use their
experience to insert something else. In the end they create a kind of "We
tried baseball and it didn't work" situation (to borrow from Ron Jeffries
again). It's a catch 22. Blindly applying the XP practices won't give you
success, but you probably can't get the experience to understand where the
practices are pointing without doing just that.

Even for me, where I've had success with those techniques, I often find myself
in situations where I can't actually get there from here. So I try things I
haven't tried before (usually without success :-) ). Or I wait until the
situation changes and I _can_ get there from here. It's really hard.

I'd love to talk more about politics and the difficulty of just getting people
to walk in the same direction. For example, I often tell the story about 5
people all walking in different directions. _One_ of the people is walking in
the right direction, but every one of them _thinks_ they are walking in the
right direction, so they can't agree. Let's take the position of the person
walking in the right direction. If that person just pushes on, then they will
arrive safely, but the 4 other team members will fail -- and hence the project
will fail. So it makes more sense for everyone to walk together _even if it is
in the wrong direction_ , because you have a chance that you can change course
and succeed. If everyone goes in different directions, then you will fail,
almost by definition -- even though one of them might be right.

The problem about talking about things like the above is that I don't fully
understand what to do. Kent Beck's famous C3 project was a technical success
(though, I'm not sure it was every fully implemented) because all of the team
members were fed up with the previous process and were willing to do pretty
much anything else. My most successful project was actually similar -- the
previous manager had been overbearing and couldn't work with the team members.
He was removed from the project and I was inserted "to make everyone happy".
So I did -- they wanted to try "this XP thing" and my job was to make them
happy. (Side note: you usually don't go far wrong if you make your workers
happy).

But there is far more to it than that. I always say that the most dangerous
actors in a project are senior management. Virtually every failed project I
have been on (and I've been on a _lot_ ) has failed because it was cancelled
by senior management. Now, I say that partially tongue in cheek because
projects don't fail until they stop and they don't stop until they are
cancelled :-). But it's actually true in a very real fashion. Most poor
choices actually stem from trying to appease stake holders or managers who are
worried about something. Again, I will say that XP can really help you there,
but I will forgive you if you look at the 12 practices and say, "I don't see
how".

I didn't really intend to write a long response to this question, but... you
can see what happened. It's really a difficult question to answer and I'm not
sure that my answer sheds any light. However, just keep pressing on. The holy
grail _is_ there. I've seen it. Your path will be different than mine, but you
can get there if you keep believing.

~~~
jholman
Overall, I appreciate and respect your thoughts about the relationship between
the aspirations of XP, your experiences with XP, and XP-as-a-written-document
(c.f. the pointing hand vs the things pointed at). Thank you for sharing them.
And so I apologize if the following distracts or detracts from that...

My understanding is that C3 was a failure in every respect (except in terms of
the results on the careers of certain evangelists). So I'm curious what you
mean when you say "a technical success".

~~~
mikekchar
First, I have to say that I think you are right to call me out on that one.
Especially since I was venturing into the territory of "projects getting
cancelled because senior management is getting worried". I've been lucky
enough to have passing conversations with some of the team members on mailing
lists and met one or two more at conferences. I'll be honest in that I don't
really know what went on there. My impression (and I'm happy to be corrected)
is that the team members felt that the way the work progressed was a success.
That's what I meant from the kind of caveat of "technical success". I don't
think the project was a success from the perspective of delivering a product
that the stakeholders were happy with (again, not trying to step on toes and
I'm happy to be corrected). My main point in bringing up that project was more
to highlight the conditions that might be necessary to get a group of people
working together in that way -- namely that people were unhappy with the
previous process.

It's hard to talk about this kind of stuff for reasons like you bring up. As
you say, XP and the mythos surrounding it brought many people to the public
eye that might not have been so noticeable. Although having lived through that
time, Kent Beck and Ward Cunningham were pretty big names in the OO community
even before XP. In fact, I doubt that anybody would have looked at XP (given
that it is so strange) if someone lesser known had been behind it.

I struggle with this quite a bit. I've been lucky enough to meet and even work
with some of the big names in the London tech scene. I mean, people are people
and they sometimes have some pretty stupid ideas. They sometimes do some
stupid things that don't work well. They sometimes don't realise which of
their ideas are stupid :-) But without exception, they've been really awesome
to talk to, work with and learn from.

I think C3 suffers a bit from the perspective of being "the example", even
though it's clear that it wasn't all positive. I tend to look at it as the
point at which the people involved realised, "Hey, this could work." When you
decide to write a book about this kind of stuff, on one side you are being a
good self-promoter, but on the other side you are really putting yourself out
there. Is there some defensiveness there? I wouldn't doubt it.

My view has been to try to ignore the people behind the ideas. A lot of time
you have to think to yourself, "How do I evaluate this idea? There are so many
ideas. Which ones should I consider and which ones should I let go?". Unlike
Pokemon, I think the secret is that you don't have to catch them all. Although
there are many paths out there, my personal feeling is that there are probably
not that many destinations. We'll all converge eventually. So follow the path
that looks interesting to you.

XP is the path that took me the farthest so far. It's hard to give people
advice because I can say, "I know XP can take you here, because I did it that
way". I don't know any other way so far, so I can't give good advice on other
good paths (although I can give a _lot_ of advice about bad paths -- as I'm
sure all experienced developers can relate to :-) ).

Hope that answers the question!

------
jkeat
I’m in the midst of writing a script with a few other people, and we’ve been
using Writer Duet: [https://writerduet.com](https://writerduet.com)

------
randall
A lot of people don’t know this but there’s a one person startup called
Rundown Creator that a lot of big companies use to plan shows.

~~~
sjwright
A lot of people don’t know this but [insert literally any non-trivial fact
here].

(Sorry for the sarcasm, but I couldn't help myself.)

~~~
dang
Please don't post unsubstantive comments here.

------
usermac
Wow. I use Etherpad every day. Really enjoy Colbert. Colbert is really
innovative in his use of tech. He uses Adobe to make the cartoon Trump and
gives regular updates to Adobe to improve the product(the name escapes me).

