Golan Levin: Our next pre­sen­ter is Luca Damasco, who makes things that help peo­ple make things. He devel­ops dig­i­tal tools for artists, stu­dents, and teach­ers while work­ing as an edu­ca­tor and cre­ative tech­nol­o­gist. In his cre­ative tech­nol­o­gy roles, he’s worked for Riot Games as a tech­ni­cal artist, con­tributed to the Processing Foundation’s Python mode project, he cre­at­ed Py5.js, a new project which allows p5.js-style pro­gram­ming in Python in the brows­er, and he runs wicked​i​tor​.com, a free open source ani­ma­tion and game cre­ation tool. Luca cur­rent­ly teach­es cre­ative cod­ing at New York University’s Integrated Digital Media pro­gram, and pre­vi­ous­ly taught inter­ac­tiv­i­ty at Carnegie Mellon School of Art. I’m also real­ly real­ly proud to say he’s an alum of our Bachelor of Computer Science and Art pro­gram at Carnegie Mellon. Luca Damasco.

Luca Damasco: Thanks so much Golan. Hi every­body. Let me get my screen share going. 

Okay. Hi every­one. I’m Luca. I’m a soft­ware engi­neer, edu­ca­tor, dig­i­tal tool­mak­er. As Golan men­tioned, I love mak­ing things that help peo­ple make things. And I’m an alum of Carnegie Mellon University. I was in the Computer Science and Art pro­gram. I also grad­u­at­ed from the HCI—Human-Computer Interaction—program. And through­out my time at CMU—and I actu­al­ly threw these slides in after hear­ing Cassie talk about the con­trib­u­tor’s con­fer­ence and things. I kind of think of myself as hav­ing grown up in the open source cre­ative tools and the OSSTA space. 

This is in 2015. This is when I was a sopho­more at CMU. We had the p5.js Contributor’s Conference. There’s a much less beard­ed ver­sion of me up there in the cor­ner giv­ing the p5.js hand gang sign, I think? It was a real­ly fun con­fer­ence and was kind of my first full intro­duc­tion to the world of open source soft­ware tools for the arts. 

And this is actu­al­ly from the 2019 con­trib­u­tor’s con­fer­ence. Cassie, on the left-hand side there, and I were work­ing on some P5 edi­tor work. So that was kind of a cool thing and great to see Cassie kind of recap a bunch of stuff from the project. 

And so right now I help run a project called Wick Editor. It’s a free and open source tool for cre­at­ing ani­ma­tions, games, and every­thing in between. And we’ll get to what those kind of things are in a second. 

But today, I real­ly want to talk about how we built Wick Editor to grow with the users that were using the tool, and some things that I wish I knew when we start­ed. And I think it’s super use­ful and super valu­able to hear from oth­er cre­ative tool­mak­ers about their process­es and about the dif­fer­ent kind of prob­lems and strug­gles and take­aways that they had from cre­at­ing their tools. So hope­ful­ly, to any young cre­ators over at CMU or through­out the world that are mak­ing their tools, hope­ful­ly this can give you a cou­ple of help­ful tips. 

So, I’m gonna be talk­ing about what the Wick Editor actu­al­ly is. You know, what peo­ple have made with it, how does it work, and some key fac­tors that we thought about as we were build­ing. And then some of the major take­aways from devel­op­ing the edi­tor, from how the edi­tor evolved over time, and dif­fer­ent kind of big things that I wish I had known from day one. 

And so let’s start with just look­ing at what some peo­ple have made with the Wick Editor, so we get a good idea of what it can actu­al­ly do. 

This first project is an ani­ma­tion by Kate Chaudoin, anoth­er stu­dent at CMU, and it’s called Good Eggs. It’s about some good eggs that just wan­na have a good time. Sentient eggs that get up, they dance, they have a grand old time. It’s a pret­ty short ani­ma­tion. You can watch the whole thing over on wicked​i​tor​.com

Now, aside from ani­ma­tions, it can also cre­ate games. So here’s a game called Bunny Tunnels. This was cre­at­ed by a stu­dent in one of our ses­sions that we ran. It was over a cou­ple of days at the STUDIO for Creative Inquiry. Lucia was 9 when they cre­at­ed this. And it’s an inter­ac­tive RPG game where you con­trol a bun­ny that goes around tun­nels and col­lects car­rots. You avoid the dif­fer­ent tun­nel mon­sters. And pri­or to hav­ing made this game, I don’t believe Lucia actu­al­ly ever cod­ed before. And so Wick Editor, we did some ani­ma­tion work­shops and inter­ac­tive stuff. There’s even an under­wa­ter lev­el for this game. We were real­ly impressed with what they were able to do, and this is kind of an exam­ple of the intro/beginner user that might use this tool. 

And in terms of the in-between, we got all sorts of dif­fer­ent types of in-between projects. This is one of the more kind of incred­i­ble ones from recent times. This one’s called Pixel Lide, by a user known as Hamzah Al Ani on our forum. This is a pixel-based ani­ma­tion soft­ware that was cre­at­ed inside the ani­ma­tion soft­ware Wick Editor, with its own ani­ma­tion engine. They’re doing all sorts of incred­i­ble stuff under the hood that I did­n’t even think of and that we don’t even have imple­ment­ed in the engine that they built along­side ours. And it actu­al­ly recent­ly won a small award over at Mozilla Festival this past March. So, you can make all sorts of dif­fer­ent inter­ac­tive projects in the tool itself. 

And so how does it actu­al­ly work? This is the Wick Editor. This is just a screen­shot of the inter­face. It’s got some basic draw­ing tools up on the top left. You’ve got a draw­ing can­vas. And this is super famil­iar for any­body that’s used Paint before, or Illustrator, or any of the oth­er tools. But on the bot­tom there is a time­line. And this is super rem­i­nis­cent of tools like Flash and oth­er video edit­ing pro­grams and things like that. The time­line on the bot­tom is just what con­trols the time-based ele­ment of your works, whether that be your games or your ani­ma­tions. And because there’s that time­line there, you get a real­ly real­ly easy tran­si­tion between this ani­ma­tion and game cre­ation environment. 

It works in the brows­er. So you can kind of see this is in a lit­tle Google Chrome brows­er. And peo­ple start by just draw­ing. So you just draw and use your brush tools. Super famil­iar. You get up and running. 

You then can start adding more and more frames to your ani­ma­tions. So here, just draw­ing out a lit­tle bounc­ing ball. You click the play but­ton, and you can cre­ate your lit­tle animation. 

Now, this is super awe­some. If you’re begin­ner, like Lucia, a 9‑year-old and you maybe haven’t worked with a full-featured ani­ma­tion soft­ware before, being able to just kin­da get start­ed and up and run­ning is a lot of fun, and it’s excit­ing. It makes the room kind of real­ly excit­ed to just be there. 

Then, after you’ve made your ani­ma­tions, you can start adding some inter­ac­tiv­i­ty. Here I’m just draw­ing a but­ton. And you can type in a lit­tle bit of code in a lit­tle cus­tom script­ing edi­tor that we have. And you can turn this lit­tle drawn ​“play” but­ton, with a lit­tle bit more code, into an inter­ac­tive but­ton. So with ten char­ac­ters and a few sec­onds, we can go from hav­ing nev­er made some­thing to hav­ing made an ani­ma­tion, to hav­ing made an inter­ac­tive project. 

So this hope­ful­ly gives a good idea of just kind of the breadth of what you’re able to do in the tool. But while we were devel­op­ing, we kind of mas­saged these core ideals of the soft­ware over time. And the first one—and this was from day one—that we knew was we want­ed the soft­ware to be free.

And the rea­son— I mean, it’s so sim­ple; we’re all talk­ing about open source soft­ware tools for the arts, so every­thing we’re talk­ing about is free to the user. But the con­cept of an open source ani­ma­tion tool real­ly came from the idea that all these oth­er tools that we loved like Adobe Animate, or Flash, and these oth­er, big­ger game cre­ation tools like Unity or Unreal Engine or what­ev­er, these big tools usu­al­ly have restric­tive licens­es. When the com­pa­ny deems them not prof­itable any­more they just die. Or when brows­er stan­dards change they go away for­ev­er. And so try­ing to build this in a way that if we weren’t able to com­plete­ly main­tain the project, or if we weren’t able to con­tin­ue it, maybe some­one could pick up our inter­face or work with us to actu­al­ly main­tain it and sup­port the project over time was real­ly impor­tant. Because if you’re using a tool and it just kind of dies out of nowhere, that’s ter­ri­ble for you as a cre­ator, no mat­ter what stage of your career you’re at. 

We also want­ed to make it as easy as pos­si­ble to access. And so it’s web-based; that helps a lot. Cassie men­tioned ear­li­er if you’re try­ing to use this in like a school envi­ron­ment, or a place where down­load­ing is pro­hib­i­tive, hav­ing a web-based tool just lets some­one go to the web site, click a but­ton, and they’re there. So, that’s super use­ful, super easy. You don’t have to get IT involved to get some­thing on your com­put­er. It makes it so much more accessible. 

It needs to work on expen­sive devices. So you know, just because some­thing is free or open source does­n’t mean that it’s designed for all sorts of stuff. So, an ani­ma­tion tool or game cre­ation tool can be super super intense on your com­put­er. And so we had to make this work for Chromebooks, like hundred-dollar lap­tops that are in schools that might not have great fund­ing. So that was a huge core ide­al of the project from the beginning. 

And then as we kept work­ing, we had this real incli­na­tion and desire to make sure that the tool con­tin­ued to grow with users as they used it. Basically we want­ed them to come for the ease of use as begin­ners, and then stay for the fea­tures. And that presents all sorts of kind of dif­fi­cult chal­lenges when you’re work­ing on such a lim­it­ed team. Building Wick Editor, I built it with myself and Zach Rispoli, a friend of mine. We start­ed it at CMU as a class project. And so we have very lim­it­ed resources in terms of what we’re able to actu­al­ly put into the project. We need to build all these fea­tures. We need to get them into the tool. And we need to make them easy enough that a begin­ner that’s nev­er used them before can use them. And we need­ed to then hide some more fea­tures. It gets kin­da com­pli­cat­ed. And so how could we make the tool ease some­one from a begin­ner to inter­me­di­ate stage as a creator. 

And so this leads to kind of an over­ar­ch­ing theme, which is like, design for begin­ners with­out sac­ri­fic­ing func­tion­al­i­ty. And that con­cept leads into these next big take­aways from the devel­op­ment process. 

And so where did we start? Where is the project…where is it now? And what would I have loved to learn while I was build­ing my soft­ware tool, you know, back in 2016 when we started? 

Now, the edi­tor has gone through five major redesigns over time. I’m so grate­ful to the Frank-Ratchye Fund for Art at the Frontier, which helped sup­port sev­er­al of the changes we made when we were under­grads at the STUDIO, as well as the Mozilla Open Source Support Program which helped us get our most recent release up and away. But through­out that time we had to keep those core ideals and these oth­er kind of major pieces of func­tion­al­i­ty in mind and con­tin­u­al­ly redesign. 

And so here are some big take­aways that I hope you can use as an open source offer tool devel­op­er, or a cre­ative, or an artist. Maybe this goes into your new media prac­tice in some way. Yeah, let’s see. 

First thing: go for the absolute min­i­mum. Just build the thing. Early on in that first week when we made our first ver­sion of this tool, we start­ed it as just like a basic HTML page. This was ver­sion 1 of Wick Editor. 

And you know, it had the basic fea­tures. Things like a basic time­line; you could con­trol the time­line by just click­ing these right and left arrow but­tons. You could drag in images, so we did­n’t even have draw­ing tools yet. In this first ver­sion, we were real­ly focused on the inter­ac­tion so we had like a pro­to­type of the inter­ac­tive sequence here. So, this was super impor­tant to just kind of have this in front of us. And often­times through­out the devel­op­ment process, we did­n’t stick to this ​“build the absolute min­i­mum” men­tal­i­ty, and that led us down so many rab­bit holes and made us waste so much time. Whereas if we had just stuck to this kind of fun­da­men­tal aspect of what was so great about our first ver­sion, we would’ve saved so much time and been able to use our resources as effec­tive­ly as pos­si­ble. So yeah, go for the min­i­mum in both your fea­tures and your tools, and don’t wor­ry if it’s not perfect. 

Next thing: build com­mu­ni­ty and get feed­back as you go. So, a lit­tle under a year into the first ver­sion, we put out a forum. This forum start­ed just out of kind of a need to get feed­back from our com­mu­ni­ty. It even­tu­al­ly grew into a place where peo­ple could vol­un­teer to actu­al­ly give us sup­port, where peo­ple could vol­un­teer new cri­tiques and crit­i­cisms and fan­tas­tic ele­ments of feedback. 

But build­ing the com­mu­ni­ty does­n’t just hap­pen. You don’t just get a com­mu­ni­ty that is pos­i­tive and engag­ing. And so we tried to fig­ure out how do we make sure this does­n’t become a neg­a­tive space from the get-go. And we looked towards oth­er projects that we loved and cher­ished. And so we got a lot of inspi­ra­tion from the Processing and p5.js com­mu­ni­ty. We looked at the com­mu­ni­ty state­ment. We mod­eled how we would respond to ques­tions based on how peo­ple in GitHub issues on the Processing repos would respond. And so real­ly focus­ing on that idea of like ​“no code snobs,” right. Making sure that if some­one maybe respond­ed in not-so-nice of a way on our forum, we did­n’t nec­es­sar­i­ly berate them or get angry at them, we just kind of explained like hey, that’s not how we do things here. And built that com­mu­ni­ty so that we could get as good feed­back as possible.

And this came back to us ten­fold. We would get respons­es from pow­er users that would send us real­ly detailed feed­back. This user, kryptot7, was fun­da­men­tal in some of the ear­li­er releas­es, where they’d come in and spit out twen­ty pages of feed­back after a new release, help fix bugs and things like that, and there are so many folks like this on the forum. I don’t just wan­na sin­gle them out and kind of miss every­body else. But there’s just so much great feed­back you get when you have a place your com­mu­ni­ty can live. It does­n’t have to be on a forum, it could be on a Discord. it could be on an email chain. It could be on a text chain for all you know, depend­ing on who you’re build­ing for. But just make sure that you’ve got some­where to con­nect with them. 

Now, you get­ting all this feed­back. You’ve got to fig­ure out a way to refine that feed­back in some way. And so you’ve got to know who you’re build­ing for. And this is some­thing that evolves with projects, and it evolved with Wick Editor over time as well. 

In our case we had this idea that we’d have like the com­plete begin­ner. And I’ve got a kid on the screen here, but we were think­ing some­one that’s nev­er made an ani­ma­tion before, or bare­ly used cre­ative tools before. Like could we build our thing for them, right? 

And the inter­me­di­ate user, right. So we had the inter­me­di­ate user from a cou­ple of per­spec­tives. The idea that the begin­ner gets good at some point. They get con­fi­dent in their own skills and they become an inter­me­di­ate user. And also some­one might come in with pre­vi­ous skills, and we want them to be accept­ed into our com­mu­ni­ty and be able to engage with our users and help each oth­er grow togeth­er. So we want to make sure we have them in mind when we’re look­ing at this feedback. 

And we also had stu­dents and edu­ca­tors. So we had a lot of real­ly real­ly good out­comes when we would go to schools and maybe run a ses­sion. Or we’d get emails from teach­ers say­ing ​“Hey, I found your tool. This worked per­fect in my class.” And you know, with no small thanks in part to the fact that we were build­ing this for a web-based sys­tem. You know, these three kind of core groups helped us under­stand which pieces of feed­back to real­ly con­sid­er the result that was most important. 

So, by focus­ing on these tar­get groups, we knew how to gauge our feed­back. We could refine feed­back that looked like this. And any­body who’s made an open source project before that’s got­ten any trac­tion has got­ten like, angry things. This is one of the nicer? kind of angry com­ments in terms of like, ​“This tool needs ani­ma­tion curves or it’s use­less.” And while you might look at this and as a more expe­ri­enced user you might say yeah, you know, with­out ani­ma­tion curves and dif­fer­ent tween­ing lev­els this isn’t real­ly that help­ful. But then you think back and say well, that inter­face might be too com­plex for a com­plete begin­ner and it might actu­al­ly make them not know how to use the tool. 

And so it lets you real­ly refine these ideas that come back to you and put things on the back burn­er that are valu­able, and maybe at some point we’ll be able to get to them for our more advanced folks, but it lets you know what’s most use­ful right now.

You’ve also got to be able to like, get respons­es from your com­mu­ni­ty, right, and know­ing who those major tar­get groups are lets you do things like ask real­ly tar­get­ed ques­tions. Something like what was the worst part about mak­ing your ani­ma­tion or mak­ing your game? And being able to ask that on your forum and know who’s going to be respond­ing and what kind of feed­back you might get. That’s a real­ly real­ly good way to get responses.

And then you’ve also got­ta know how to inter­pret your feed­back. So refin­ing the feed­back, get­ting the feed­back, inter­pret­ing it. And this isn’t too hard in terms of online dis­cus­sion. But when you’re in a class­room and you’ve got like a young kid, and they say some­thing like ​“Do you have any pur­ple?” You’ve got to know okay, this is a 5‑year-old, I’m mak­ing an ani­ma­tion with them, and they’re ask­ing me if I have any pur­ple. What’s the metaphor here? Oh, they can’t find the col­or pick­er. This means that there’s prob­a­bly a fun­da­men­tal issue with the way I’ve put the col­or pick­er on the screen, or maybe it’s too com­plex. Maybe instead of get­ting like a col­or wheel, maybe I should make this into some­thing sim­pler. So fig­ur­ing out how to inter­pret your feed­back, know­ing your tar­get groups, lets you inter­pret that a lit­tle simpler. 

And then last­ly hav­ing these dif­fer­ent com­mu­ni­ty groups and things lets you find arti­facts from your com­mu­ni­ty and use those as mea­sures of the com­mu­ni­ty’s suc­cess. And so in our case we would do things like search on YouTube for the term ​“wick edi­tor.” And if peo­ple were inter­est­ed enough in the tool itself to put ​“wick edi­tor” in their descrip­tion or in the title of their project, that was like a huge suc­cess for us. So we’ve got you know, kids that might be in mid­dle school, high school, using this tool. And they’re like ​“I made this in Wick Editor” and they’re hap­py and proud to dis­play that. That’s a great arti­fact to find, and a great kind of sto­ry to tell to let you know hey, are we doing the right thing for our com­mu­ni­ty and for the peo­ple that are using this tool. 

And this next kin­da big take­away is a lit­tle hard­er in times of COVID, obvi­ous­ly, but get on-site if you can. If you’re build­ing for oth­er peo­ple, work with those peo­ple direct­ly. And this one might seem like it’s kind of…you know, it goes with­out say­ing, but you start to find prob­lems that you nev­er would have expe­ri­enced when you’re build­ing stuff on your fan­cy dev machine like a Macbook. 

You start to do things like this. So this is our I think fourth release…fourth major release is what’s on the screen here. And this was our first release where we changed the col­ors of the edi­tor. And you might look at this and be like okay dark mode, it was a trend, right. All of my soft­ware that I’m using changed to be dark mode in the last cou­ple years. 

We changed this not because we thought it was a cool thing. We changed because it was an acces­si­bil­i­ty issue. We would go into class­rooms and they would have these real­ly inex­pen­sive com­put­ers that would cost a hun­dred bucks. And because our inter­face was so light, peo­ple could­n’t see. Students that might’ve had an indi­vid­u­al­ized edu­ca­tion plan, or some kind of impair­ment or some­thing like that, it was real­ly hard for them to actu­al­ly uti­lize our tool in the cur­rent con­trast state that it was in. And so that informed how we would improve it. If we had­n’t gone on-site and seen them in their sit­u­a­tions and tried to work with them direct­ly, we would nev­er have found many of these prob­lems as fast as we did. 

We also would­n’t have thought of some of our kind of like…expert fog, right? Like because we’re more advanced users, we would add in things like drop-down menus and think these were fine. We would do things like right-click menus that were pret­ty dense. And if we had­n’t gone into class­rooms and just seen that stu­dents com­plete­ly ignored these and begin­ners com­plete­ly ignored these, we would nev­er have come to solu­tions like this one:

And so in the most recent ver­sion of Wick there’s a real­ly real­ly big green play but­ton. Every major func­tion that a begin­ner or an ear­ly inter­me­di­ate or might need is just a one-click but­ton away. You don’t even have to go into a menu to use it. So in this case you’ve got a play but­ton, and then the but­ton right next to the play but­ton is the recen­ter but­ton. So if some­one drags their can­vas too far away or they zoom in too far, they can click ​“recen­ter” and come back home and we put their can­vas right in the mid­dle of their screen. 

These kinds of things, you won’t real­ize that they’re like fea­tures you real­ly need or inter­face changes you might need unless you’re on-site. And this goes for so many dif­fer­ent types of inter­ac­tive expe­ri­ences. If you’re not in the sit­u­a­tion you don’t real­ly know what kind of prob­lems will come up. 

And anoth­er big thing that we con­tin­ued to kind of use as we kept redesign­ing and redesigning…you know, five major redesigns in five years is quite a few, is we start­ed doing this con­cept of design­ing for redes­ignabil­i­ty. And this is like mak­ing sure the pro­duc­t’s approach­able with­out sac­ri­fic­ing this ​“redes­ignable” con­cept. And what that means is we’re just two peo­ple that are mak­ing this tool, and with maybe a design­er here and there that would jump in, our team would nev­er grow beyond five peo­ple at any time; the core developers. 

And so we would need to deal with prob­lems like this one, where we’d have our time­line, which was a core ele­ment of the ani­ma­tion and inter­ac­tion of the project, would start to get real­ly clut­tered. And so we’d have a few but­tons, and then we have to add some more fea­tures. And then a few more but­tons would show up. And even­tu­al­ly, because this part of the tool was­n’t real­ly redes­ignable, we did­n’t know how to add in new fea­tures or what we could remove. We kin­da got lost. 

And so this would even­tu­al­ly evolve into inter­faces that look like this, where we would have a cou­ple of but­tons, a cou­ple of real­ly core fea­tures. We’d real­ly nar­row down what was super use­ful. And we’d leave gaps and pieces of emp­ty space in the inter­face where we said maybe there’s a future we’re going to add here in the future.

We’d also add in some arti­fi­cial restric­tions. So here we could prob­a­bly only have five but­tons if you’re look­ing from that dia­mond but­ton next to the red play­head, and then there’s a lit­tle frame but­ton next to that, and a trash can next to that. We said we would­n’t want to have more than five things here. So we only left enough space for about five things. And we were think­ing how can we redesign this with­out kind of going over­board in the future. So yeah, redes­ignabil­i­ty, real­ly real­ly valu­able when you’re on just like a small core open source team. 

And then last, biggest take­away here is the con­cept of embrac­ing exter­nal resources, and learn­ing to ask ques­tions and not do it all your­self if you can help it. You know, before you build a fea­ture, try to ask has some­one else done this? There were so many times we were just writ­ing a bunch of code for our tool, and it was a pain. And we then real­ized three months lat­er that some­one had made a library and they had made their library open source. And it was what we were look­ing for orig­i­nal­ly. And hav­ing an open source tool, uti­liz­ing oth­er open source resources just saves you time. It let your projects col­lab­o­rate in some way. You as a user can then con­tribute back to them with feed­back, or mon­e­tary fund­ing if you’re able to do it. These things are super super helpful.

Next thing is before overex­tend­ing your­self, ask who you can reach out to. If you’ve got that com­mu­ni­ty build­ing up, or if you’ve got folks around you that are devel­op­ers, or if you’ve got oth­er folks that you can ask ques­tions to, see who you can reach out to at the very least for advice or sug­ges­tions. And don’t feel like you have to do it in a bub­ble. Many times through­out the devel­op­ment of Wick, we would kind of silo our­selves a lit­tle bit too much and not ask for help in cer­tain places. And so that was a big prob­lem through­out that process, and I’m sure a big prob­lem for so many oth­er open source tool developers. 

And the last kind of main thing here is before you can’t afford your serv­er, ask how can we fund this. And you know, there’s unfor­tu­nate­ly like this hard­core men­tal­i­ty for a lot of open source devel­op­ers where they try to com­plete­ly sep­a­rate any type of mon­e­tary fund­ing from the work that they’re doing? And if you can afford that, and if you’re in a posi­tion where that’s okay for you, that’s fine? But fund­ing in the form of com­mu­ni­ty con­tri­bu­tions to some­thing like a Patreon, or an OpenCollective page, or some way you can kind of crowd­fund those resources, or fund­ing from a grantor like if you’re at a stu­dent at a uni­ver­si­ty that might give you a grant that’s great. If you’re an open source devel­op­er and you can maybe find anoth­er orga­ni­za­tion that might be able to give you a grant. 

Or on the flip side of this, if you’re an orga­ni­za­tion that can fund an open source project, you should be doing that. Especially if you’re using it in your own pipelines. That fund­ing ques­tion should­n’t be a taboo thing to ask. Because you know, fund­ing means time, it means the abil­i­ty to pay your staff and design­ers and con­trib­u­tors. And that’s super, super valu­able. For the project, for the com­mu­ni­ties that they’re a part of. Ask the question. 

And then you know, I added this slide in after hear­ing Cassie say it, just to empha­size, con­tribute and sup­port your open source tools that you’re using. If you are from an orga­ni­za­tion using an open source soft­ware tool, or an indi­vid­ual that has the abil­i­ty to send a dona­tion or sup­port to those orga­ni­za­tions, that sup­port gets used a mil­lion­fold over, as Golan was say­ing. So make sure that that you’re con­tribut­ing to and sup­port­ing these tools in any way you can. 

And yeah, that’s it for my talk. I’m Luca. If you want to check out Wick Editor, it’s on wicked​i​tor​.com. Hopefully these take­aways are help­ful for you in your cre­ative tool and new media journeys. 

---

Golan Levin: Luca, thank you so much. We’ve got time for just maybe one quick ques­tion, so I want­ed to pull it from the YouTube chat. How do you get the first mem­bers of your com­mu­ni­ty? You know, what’s a good way to share your project in the very begin­ning, project in this case mean­ing your open source tool, to get that sort of vibrant com­mu­ni­ty. I can think of some ways that I observed you doing it. Let’s hear you talk about it.

Luca Damasco: Yeah, that’s a fan­tas­tic ques­tion. And it’s not an imme­di­ate­ly easy one, right? So the first thing I would say is like, ask your­self who you think would find it valu­able, and real­ly define for you what kind of a project are you try­ing to build. Is this a tool for you? Is this a tool for a spe­cif­ic group of peo­ple? Like I said, in our case we had stu­dents, we had begin­ners, things like that. Once you iden­ti­fy those groups, try to expand. We were like okay: begin­ners; we could go to a school. We could go to an after­school program. 

So we worked with a non­prof­it after­school, Assemble in Pittsburgh. And we just said hey, can we come by and run an ani­ma­tion work­shop for an hour? And they were total­ly fine with that and they loved that. So there’s so many orga­ni­za­tions where you can start build­ing out these ini­tial kind of like, testers? And from there, your com­mu­ni­ty starts to build.

Levin: In a cou­ple of the pre­vi­ous OSSTA lec­tures, I think it was on Tuesday night, we saw that peo­ple had made a mini-residency with­in their mini-residency. A.M. had made a res­i­den­cy with­in their project, and then Valencia made a res­i­den­cy with­in hers. And I remem­ber that one of the things you’ve done is you had lit­tle mini com­pe­ti­tions where you sort of elicit­ed peo­ple to make demos, for example.

Damasco: Yeah, yeah. We were for­tu­nate enough through the Frank-Ratchye Fund for Art at the Frontier at the STUDIO, we got a micro— I think was a…not a micro grant but it was a cou­ple thou­sand dol­lars, which was super valu­able for us at the time. We took that mon­ey, we broke it up into small­er amounts of mon­ey to do things like a small com­pe­ti­tion where folks could make an ani­ma­tion. That gave us feed­back and ini­tial users. We also had fan­tas­tic stu­dent artists and design­ers, and we had them—like, Good Eggs, the ani­ma­tion I showed at the begin­ning of the talk, that was fund­ed by a FRFAF grant. So like, these are fan­tas­tic ways of get­ting peo­ple in.