The Changelog: Software Development, Open Source - Truffle framework and decentralized Ethereum apps (Interview)

Episode Date: March 13, 2018

Tim Coulter joined the show to talk about Truffle — a development environment, testing framework, and asset pipeline for Ethereum. We talked with Tim about how he got into Ethereum and dapp development, Solidity vs JavaScript, smart contract testing, EthPM which is like npm but for Ethereum, Why decentralization? Why dapps? Basically, why rebuild the internet? And last but not least - who's using Truffle and what have they built with it?

Bandwidth for ChangeLog is provided by Fastly. Learn more at Fastly.com. Error monitoring is by Rollbar. Check them out at Rollbar.com. And we're hosted on Linode servers. Head to Linode.com slash ChangeLog. This episode is brought to you by Rollbar. Rollbar is real-time error monitoring, alerting, and analytics that helps you resolve production errors in minutes.

And I talked with Paul Bigger, the founder of CircleCI, a trusted customer of Rollbar, and Paul says they don't deploy a service without installing Rollbar first. It's that crucial to them. We operate at serious scale. And literally the first thing we do when we create a new service is we install Rollbar in it. We need to have that visibility.

And without that visibility, it would be impossible to run at the scale we do. And certainly with the number of people that we have. We're a relatively small team operating a major service. And without the visibility that Rollbar gives us into our exceptions, it just wouldn't be possible. All right, if you want to follow in Paul's footsteps and start deploying with confidence today,

head to rollbar.com slash changelog., head to rollbar.com slash changelog. Once again, rollbar.com slash changelog. All right. Welcome back. This is the changelog, a podcast featuring the hackers, leaders, and innovators of open source. I'm Adam Stachowiak, editor-in-chief of ChangeLog. On today's show, Jared and I are talking to Tim Colter, the creative truffle, a development environment, testing framework, and asset pipeline for Ethereum. We talked with Tim about how he got into Ethereum, Solidity versus JavaScript, smart contract testing, ETHPM, which is like NPM but for Ethereum,

why decentralization, why dApps, basically why rebuild the internet, and last but not least, who is using Truffle and what have they built with it. So Truffle is called an Ethereum Swiss Army Knife. We're going to dive into all of the details of Truffle, Tim, and we're going to have you explain it soup to nuts to us. But let's get to know you a little bit and understand your relationship with the Ethereum ecosystem and how you got into this game in the first place and how you became the Truffle developer. Can you tell us that story? Yeah, sure. So the short version of it is when the Bitcoin boom hit in 2013, when it went from, I don't know, $5,000 to $1,000. I got into cryptocurrency after that and got really excited about what it is and what it could do. So early 2014, started mining.

Mined on a bunch of different altcoins at the time, now worth nothing. It was a fun experience for me and did it mostly on the side. I was working for startups and have worked for startups my whole career coming out of college. And the startup I was working at, I eventually got laid off. And by that time, I had been doing other work in cryptocurrency. I had built an application on my own,

time to track all of the price data for a bunch of different trading pairs, basically every trading pair on every exchange available at the time. And I was trying to aggregate all those and eventually sell that data. In any case, that whole thing got me interested in the blockchain world itself. And so when I got laid off from this company, I told myself, you know what, I'm going to go work in blockchain.

So I searched around, eventually found a post on angel.co. And that led me to ConsenSys. So that was around April of 2015. The post was actually for a web designer job. I can't do, excuse me, not web design, a graphic designer job. And I can't actually do graphic design, but I sent them a message anyway and said, hey, look, I could try this. I'm really excited to work in the blockchain world. I'd love to work with you. And they responded the next day. So the rest from there is kind of history. But as far as Truffle is concerned, my past history in software development is actually in the software testing world. So in college, I have a software engineering degree, but I worked a lot with a professor in software testing, and that was big in the software testing community. And so when I came out of college, I used that network to find jobs in the software testing role. And so what that meant is that for most of my career, effectively eight years leading up to coming into the Ethereum world, I was doing developer support. And this is everything from

performing manual testing to writing software testing frameworks around new technologies. And so when I came into Ethereum, it was very clear that there were no tools at all. You had a compiler and a JavaScript library for interacting with the Ethereum blockchain, and that was about it. So from there, it seemed very easy to fall back into this developer support role, and I ended up building tools for the ethereum ecosystem yeah it's it's very apparent um looking at truffle that there's a lot of tooling around ethereum that you know has been lacking and as i was actually commenting adam before the show as we were doing a little bit of reading how we found ethpm which is like npm for eth right and for the ethereum ecosystem and i was just telling him, it seems like everything is being recreated in this particular Web3 Ethereum world. And it kind of reminds me of when Node first came out, and I remember Ryan Dahl announced it,

and it was like a bunch of interest and a bunch of developers like, okay, this is cool, I want to dive into this. And there was just nothing. I mean, it was completely greenfield. If you wanted to be influential and helpful, really in node, it was very easy at the outset because there was so, I mean, pick a library, pick a domain, and there was just no tooling. And so it very much feels like the early days in that regard

with Ethereum. Yeah. So everything you just said is probably applicable to how it is now, even with Truffle and other tooling. But it was even more applicable in 2015. There was one other tool or framework available. And I looked at it. I didn't like the way it was built. And instead of going into that project and telling them to re-architect their whole thing,

I created Truffle and really it was formed out of a bunch of scripts that I had built for myself to do all the 17 steps that I need to do in order to build an Ethereum application. So it just started out that way. As far as being influential, this is just something that I needed.

And now I've built the most popular Ethereum framework so far. Kind of want to go back to a small point you made a little bit in your backstory that struck me, which is that you said the posting by ConsenSys. By the way, will you just fill in for all the listeners what ConsenSys is so everybody knows? Yes. ConsenSys is a startup incubator for the Ethereum ecosystem. So effectively, we have something like 40 different projects or teams.

We call them spokes. And these spokes are working with ConsenSys to become their own companies eventually. Okay, very good. So you had this consensus job post was out there for a graphic designer. And like you said, you don't know graphic design, but you apply it anyway, or you contacted them anyways. And it reminded me of that meme,

I don't know if you guys have seen it, where it's a picture of a cat in front of a computer, like on a keyboard, and it says on the internet, nobody knows that you're a cat. Have you guys seen that one? That's that one? Yeah, it's so true. Like that's, I just, I just, every once in a while, I just kind of think about the power and the beauty of, of the web and you know, what it provides to people in a sense of, you know, not even anonymity in this case, but just like allowing yourself to kind of define who you are, you know, and giving us the confidence and the ability to say, yeah, I'm going to go after that anyways.

You know, I feel like there's a liberty that the web provides that is a beautiful thing. Absolutely. Previous to ConsenSys, I worked at startups. I think it was eight startups in in roughly eight years. So no, no, it'd be seven in eight years. And obviously, if I'm not staying at any of these places, I didn't really feel like those companies were something that I wanted to build my career on. And so far, I've been at ConsenSys for three years, which is almost as long as you can be at consensus. You can't be that much older of a company since Ethereum is about maybe four years old. Right.

And I don't want to leave. I feel like I've been the most influential I've ever been in any company that I've ever worked for. And I see myself, maybe I'm getting to the right age and settling down, but really this is probably going to be my career company for a long time. What is it that you do day-to-day? Just curious. So you started Truffle, but what do you do day-to-day? Yeah, that's changed a lot. So when I started

Truffle, it was literally I was coding every day, most of the time coding or interacting with our users in our Gitter channel. Now, since the team has grown, in three years, we've grown from one to six. And what my job now is mostly vision and management. So effectively, well, this is a story on its own, but when I hired developers, I felt like what I was doing was handing my baby away over to people that were going to go develop it themselves and go figure out what the right way is. And that was actually a hard thing to work together. What we found now is that what I do is I work on the product and where Truffle and the other products are going to go, how those are communicated, you know, go on podcasts like this, for instance. And I'm spending less, a lot less time coding. And so this is kind of a, like, I mean, I would say I'm in that transition period now where

my whole job and what I expected my job to be has completely changed. Well, that's awesome. It sounds like it's an exciting change at this point. Hopefully in the long run, I'm sure it'll probably just continue to move and evolve as the company and the industry does. I know there's a lot of CTO style positions where there's satisfaction to the work and there's also this deep inward desire to, you know, to get into the terminal and the text editor and code things up. Right, right. So hopefully there's some balance there for you.

But nonetheless, coming on podcast and talk about these things, helping to guide a team of talented people sounds like definitely fulfilling work. Yeah, it's fulfilling and a huge learning experience at the same time. to guide a team of talented people sounds like definitely fulfilling work. Yeah. It's fulfilling and a huge learning experience at the same time. Right. You know, I have to take this time to give a shout out to my team, but I've got a great group of people working with me and I couldn't ask for anything less.

When you said the headcount, that was just for Truffle though, right? Not Contents at Large. Oh yeah. Yeah. I was going to say, cause it's like that was a for Truffle though, right? Not consensus at large. Oh yeah. Yeah. I was going to say, cause it's like, that was a little small for consensus at large. Oh, super small for consensus. Super small. So, and in fact, like when I say one to six, I was, I was, you know, worried myself. I'm like, oh, that doesn't sound like a, like big growth. You know, Truffle, we're, we're trying to keep things lean, and so six in a period of three years is okay. Consensus, though, I think we are – I believe we are over 600 people now.

One of the points of clarity for those listening is I'm like, I know the consensus is bigger than one to six. Yeah. So consensus is huge and we're only going to continue to grow as we bring on more projects or as projects scale. For instance, I know that one of our spokes, Metamask, the Metamask team is roughly the same size as Truffle right now, and they are getting huge traction. And we're talking millions of users. And so, you know, that team needs to scale. And this is happening all across the Ethereum Swiss Army Knife. Here's another one, a description. Truffle is a world-class development environment testing framework and asset pipeline for Ethereum, aiming to make life as an Ethereum developer easier. Now, when we had Kevin Awocki on the show with Gitcoin, I'm not sure if he said it on the show or after the show, but he says Truffle is like Ruby on Rails for Ethereum. So those three things, Swiss Army Knife, testing framework, asset pipeline, Ruby on Rails, does that pretty much encapsulate what all Truffle has to offer?

That's a bit of it. Two of those phrases that you said, I actually wrote. So the Swiss Army Knife one. So you agree with those two yeah well kind of actually one of them is pretty old so uh truffle has evolved from from when it was originally created and if you look at truffle now versus where it was uh the features and scope have have completely changed so originally it was meant to only help you build web applications, Ethereum-enabled web applications. And now it's meant to help manage the whole workflow of building an Ethereum-enabled application, no matter what your user interface is, no matter whether it's a console application, a web application, a desktop application, or what have you. So the asset pipeline part of one of those phrases

is no longer true. We're actually, we decided to get out of the asset pipeline game and push that off to libraries that do that better, for instance, like Webpack or Browserify, or whatever we'd like to use. But what we do, and Truffle's main focus, is giving you the tools to build a smart contract. And if you come into Ethereum, you're not going to know what to do. Like the programming, the paradigm, the way you program on Ethereum is completely different from the way you might program in other environments. So this goes back to one of those things that you said where, you know,

things are completely new in this space and that's, that's part of the reason why. But, uh, as far as the rails phrase is concerned, uh, that is, uh,

it's pretty close to true. We are, we are, or I should say rails was an inspiration, uh, for me when I was building truffle originally. So I, I come from a rails background, um, inspiration for me when I was building Truffle originally. So I come from a Rails background on the side. When I was doing all the testing work I told you about for the startups, I had a Rails app that I built. And what Rails does, among other things, is provide that

workflow for web applications. And we do the same thing for Ethereum applications. Very cool. I think a very apt comparison then. Let me give you a little bit of the lay of the land from Adam and my perspective, as well as our listeners, what I would expect in terms of developer knowledge, what we've covered on the show. And then we'll have you walk through, because one of the reasons why we have you on is to a understand what truffle offers but also using truffle as a lens learning what all it takes to build you know these decentralized applications and what all the moving parts are because as we've

said it's all kind of new and different and that means it's also kind of intimidating and maybe difficult to approach. So we've covered Ethereum conceptually. Way back in the day, we had Gavin Wood on the show. We had shows about blockchains and hyperledger, Bitcoin, distributed exchanges. We had shows about the concepts around blockchains, cryptocurrencies, what have you, Ethereum specifically. We've covered smart contracts both generically and a little bit specifically

with regard to Gitcoin, which was our most recent show. And with Gitcoin, we talked a little bit about how that application specifically works with regards to Metamask and Web3 and those kinds of things. That being said, from a developer's perspective, building an Ethereum-based application all the way through,

even after myself having all these conversations, is still kind of a black box. And so why don't you give us the high level of all the parts that are involved, and then we'll kind of dive into the specific regions. Yeah, so if you're building an application for Ethereum, you have two execution environments you need to worry about. You have the execution environment the app is running in. So if it's a web app, that would be the browser. And then you have the execution environment of the Ethereum blockchain. Now, if you're a web developer, you would understand this separation as just client and server architecture.

What makes things different in this case is that every action you want to perform on the Ethereum blockchain has to go through a transaction, and that transaction has to be mined. There's some wait time involved. You have less control over the architecture, and you can't create the responses that you'd like to create if this were typical server client architecture that would return the right answer as a response to the request. Instead, you have to make requests, wait for the results to be mined and on the

blockchain, and then do something with those results. So that kind of turned things on its head a bit, and you have to program a little bit differently. So first off, you have to get code on the Ethereum blockchain, which is a completely separate process than, say, building your own web server. You have to build your front-end application. That's pretty similar to how you would do it now, except you would need software to connect your typical way of building a web application with the Ethereum blockchain. And then you need to take all of the, we'll say the locations of the code, or I guess you've talked about Ethereum, so the addresses of the code and where it exists. You need to take all that and hook it up to the front end

so everything knows how to talk to each other. This episode is brought to you by our friends at Linode. Everything we do here at Changelog is hosted on Linode cloud servers. Pick a plan, pick a distro, and pick a pick a location and in minutes deploy your leno cloud server drool worthy hardware native ssd cloud storage 40 gigabit network intel e5 processors simple easy control panel vms for full control running docker containers encrypted disks or vpns 99.9 uptime guaranteed 24 7 customer support 10 data centers three regions anywhere in the world they've got you covered they also have cloud linode.com which is an open source single page application find that at

github.com slash linode slash manager plan start with one gig of RAM for five bucks a month or high memory plans at 16 gigs head to lino.com slash changelog get four months free with their basic server $20 in hosting credit once again lino.com slash changelog so what does that look like in terms of truffle and the code that's provided in the code that you actually write so the biggest thing you need to do and the first thing that you're you're likely going to do is worry about your contracts that are going to exist on chain so the contracts are the code that is effectively going to run your back end of your application now you can you can build more complex applications that also use a server that are asking the blockchain and all that stuff but let's just ignore that for now and let's just say that the the ethereum blockchain is is your your whole

back end okay Yep, exactly. And so what you need to do is you need to write all those things, which you're using a whole new language. You're writing code in a way that you've never really thought about writing code before. For instance, there have been bugs in the past that two lines were swapped and cost people $150 million. So you're writing code and thinking about security and finances and all these things that generally as coders we don't think about unless we're in the finance world. So when you say you're at a holding language, this is Solidity, right? So this is the language built by the Ethereum team to run on the VM

and to interact with the blockchain. Can you, so you say you write those, those are obviously a big part of your deal, especially if it's in this case of our hypothetical example, it's your entire backend. Are there, where I would start with that and where I'm assuming Truffle comes in almost immediately is I'm, I would love to write a smart contract in complete isolation with like unit tests because like you said swap two lines and you lose a lot of money or you lose somebody's money is there tooling around writing those smart contracts a little bit at a time and testing that they're working

according to you or before you're even doing any of the other stuff yes so you can write your contracts and write tests with them and test them before even deploying them to any Ethereum blockchain. So what Treble is going to do is help you, believe it or not, help you compile those contracts because the compiler itself is pretty simple. So it's going to make that experience nice for you.

It's going to help you write tests in a way, if you're a JavaScript program anyway, that you're familiar with and interact with those contracts within your tests as easy as possible. And then after you're done writing the contracts and testing them, it's actually going to help you provide a simple way of deploying those contracts to your blockchain of choice.

So this could be the mainnet, could be some testnet, could be a network you've set up between a few people. testing, but compilation and deployment produce very important what we call artifacts, which include, for instance, the address of where that code lives on the network. These artifacts are super important because you're going to take this output from Truffle and then you're going to go integrate that into your front end using various different tools and libraries or roll something your own if you like and after doing that you'll be able to easily build a front end that interacts with those contracts that you just built okay let me let me ask you something about solidity as somebody who's intimately familiar with it but also didn't build or design or choose it why solidity why do we need another language one that I've looked at,

doesn't look like it has any particularly interesting aspects to it? Why not just Python or JavaScript for writing the smart contracts? Do you know why that had to be its own thing that now millions of people are learning and struggling through? Right. I think there's a couple reasons. First is we needed a language that compiled down to the EVM, which I know we could probably do with a different language. But it's scoped around things that the EVM needs. For instance, the cost of every instruction has a gas cost to it.

And so Solidity is kind of built around that as far as its internals. But more importantly, the EVM supports, I believe it's 256 bits of information or bytes or shoot, I'm getting this mixed up right now. But regardless, huge, huge data types that effectively don't exist in other languages. And these data types have to be perfect. You're dealing with money. You can't use JavaScript to deal with large numbers because JavaScript only goes up to, I don't know, 14 bazillion, which isn't that large of a number. So my hunch, you know, I'm not from the Ethereum Foundation. My hunch is that they needed a language specific to what it's like to build for smart contracts.

Respect to the needs of smart contracts. Makes sense with the gas primitives and all those things that something specific would make a lot of sense. Now, I think that's where they started. The ideas around smart contract languages is evolving. And so we're thinking, or not we, but the community is working on other ways of incorporating other languages. For instance, I don't know if you've ever heard of EWASM,

but we can get a lot of the languages that currently exist in the world to compile down to EWASM, and then EWASM will be translated to the EVM. EWASM is WebAssembly. What's the E on front of it? Is that like Ethereum WebAssembly? Actually, I believe so, yeah. Okay, see? You, yeah. Okay. See, you're reinventing everything. EFPM, EWASM.

Got to get your e-browser. EGS. What about email? We could do email. Ethereum mail? Absolutely. So I think what they're actually, with the EWASM project, I think what they're actually doing is compiling normal languages down to WebAssembly that somehow Ethereum can know about.

I'm not too well-versed on that project, but I do know that it's supposed to be the big connector of all of our current languages. Now, the hard part there is how do you take advantage of the specific things that make the blockchain the blockchain like how do you design like if i don't know if you're writing java or something how do you specify that this is like a storage variable um a storage variable for those listening is you know just data that's actually going to be stored in the blockchain and you're paying as part of the

transaction to store uh versus like something in memory that is you're just using that as part of the transaction to store versus like something in memory that is you're just using that as part of a computation okay so we're we have some solidities what we have today maybe there's a little bit better things down the road i know there's competing blockchains that are trying to do things like you know a native javascript smart contract language but none of those have the size and steam that ethereum has at this point um but solidity is what we have what about here is before you go there jared the question is um this isn't the only blockchain right you do have other um other i guess places you could do cryptocurrency so we're talking about ethereum here in this case and building on ethereum is that

is the language obviously solidity is for eth. Is there other languages you use elsewhere? This is only for Ethereum. Solidity is, yeah, as far as I understand, Solidity is only used for Ethereum. There are actually other new Ethereum languages, if you're as interested in those. Viper is one that takes its ideas from Python. LLL, which is Lisp-like language, is another one which obviously takes its ideas from Lisp.

I don't know if any of those languages are – if people have written compilers for the other blockchains or if they'll work on other blockchains. Now, I have heard of many other blockchains that use the EVM. So, for instance, they will change the consensus protocol around or change something about the blockchain itself, but still use the Ethereum virtual machine under the hood. And in that case, those languages are likely to work. Very interesting. But for now, we're working with Solidity as the primary language most people working with Ethereum use.

Right. I know there's a Bitcoin team that are building a language called Simplicity, I believe, which is going to be some smart contracts on the Bitcoin blockchain. And it caught my eye because I thought the name Simplicity was awesome for a language. And that was pretty much as far as I went into researching it.

I have no idea the state or... It got you right there with the name. Yeah, I was like, Simplicity, now that's a language I want to use. So back to Solidity then, we talked about testing them in isolation and then generating these artifacts. Are the tests that you write against the smart contracts also written in Solidity?

Or is there more leniency and leverage there to use other tools? They can be. Right now, we support writing your tests in JavaScript as well as Solidity. So you can think of these as two separate but very similar testing frameworks built within Truffle. And both of them take after Mocha. So you build individual tests, and then you have hooks that can happen before or after certain tests are run or before a suite is run. The Solidity ones work slightly differently in that you're actually writing smart contracts that will act as your tests.

So these contracts are being deployed to an internal test network that Trevel spins up as part of running the tests. They're deployed to that network. And then transactions, just like the same transactions you make to the blockchain, are sent that will run those tests, that will run each test function that you've specified. And so the benefits, there's benefits to both JavaScript and solidity testing.

In the JavaScript testing, you get to write tests that kind of act or interact with the blockchain from the outside. Whereas with SolidityTest, you can write more detailed, more fine-grained tests that interact with the individual pieces of code itself. So you can write tighter unit tests, I guess. Now, something on this, which we've been thinking a lot about testing, and as I mentioned, these are Mocha-inspired and actually use Mocha under the hood in order to run. Mocha is one way to write unit tests or write automated tests. What we're trying to do is build a plugin system for Ethereum that will allow other frameworks for writing smart contract tests. So that's on the horizon, probably Truffle 5, which might be a few months away. But with that plugin system, you might see more advanced ways of testing or plugins,

user-contributed plugins that provide different frameworks. Very cool. So that tells the smart contracts and the testing story to a certain degree. Also, we're getting a little bit into the deployment story, which you said, the artifact generation. Deployment, to me, is scary and a black box. But then you also have these Truffle boxes. And so in my mind, I thought, maybe that has to do with the deployment, but I'm not sure.

So can you talk about what Truffle offers in terms of, okay, I've written my smart contracts. There's probably more to my application. We haven't really talked about too much about the client side that interacts with it. Maybe we should go there, but actually let's start there and then we'll get to deployment. I have my smart contracts. What's the other moving parts on the client side

of my application where I'm interacting with those artifacts? Right. So, so the artifacts just provide information to your front end that will allow your front end to easily interact and it'll allow you to write code that's easy to write for those smart contracts. So some of the information, for instance, I mentioned the address of where that contract might exist on the network, but also it includes information about what functions are in your smart contract and the function signatures of those. And what happens when you pull those artifacts into your application, especially if you're using the libraries that we've written,

is it'll actually create JavaScript objects for you that represent those contracts. And then you can make function calls against those contracts and built into that library, it will actually make those transactions for you. So you don't have to worry about the nitty-gritty of sending all the transactions over what we call the RPC protocol, the Ethereum RPC protocol, and how to deal with all that. Instead, you actually have a representation of your contract in JavaScript that you can just call directly. Well, that makes it super easy. It's basically referencing functions and objects, and you don't have to think about any of the other nuts and bolts once you have that set up.

I mean, that's the idea. You still have to understand that your transactions do take time, so it's not like you're making a request to a server, and the server, as part of the response to that request, returns whatever information you're looking for. Instead, the library itself needs to wait perhaps 15 seconds for it to get the right response. And so what we've done is we've written that code for you that effectively makes building that front end a breeze. So you don't have to worry about every transaction or every button click that causes a transaction or whatever. You don't have to worry about what's going on under the hood.

All you have to worry about is did my transaction succeed or did it fail? And we'll take care of the rest from there. So you provide those via callbacks or like async await type of things? How is the actual interface into what Truffle's providing from the JavaScript side look like? Yeah, so right now the library that I've described so far is what we call Truffle Contract. And this is actually a library that's existed for quite a while.

So this one turns everything into a promise. So you can use async await with promises, but it doesn't use callbacks because what generally happens when writing a front end for a smart contract application, or what you generally do is you say, make this transaction, then do this transaction after a specific request happened. There's also other pieces of that. So not all interactions with the blockchain are writes, not all of them are transactions. Sometimes you can call a function that will get executed, but it's just actually just there for reading data. So it doesn't get recorded on the blockchain. It doesn't cost you any ether to do that. And so a lot of the time it becomes like, perform this transaction, read some data, perform another transaction. And so this library provides it to you as a sort of

a promise chain. So I'm doing this, then I'm doing this, then I'm doing this. So you can have easy control flow. Something that we released today actually is a library called Drizzle, which is the next evolution of this idea. So the JavaScript world and the front end world has been moving away from effectively homegrown just transactions, you know, direct interaction with the server and instead you're moving to React and a Redux architecture. Well, wouldn't it be great if you could take those Truffle artifacts that Truffle creates for you, throw them into a library, and you've all of a sudden got a Redux store

that is tailored to your smart contracts. So that's what Drizzle provides, is that if you like the React and Redux world, there's almost no work involved to fit your contracts into your front-end application. Well, if there's anything that us developers do like it's having almost no work involved that's that's always gonna get us to have the the emoji with the heart eyes right for sure so tim how do you get all this stuff finally up and running in production for you know web3 denizens to use it right so um two parts you need to think about as we mentioned before uh you have your contracts

on the ethereum blockchain and then you have the front end so uh the the one we haven't really talked about is the the contracts on the ethereum blockchain uh in putting your contracts on the ethereum blockchain if you're just go do it yourself uh there's a lot you'd have to do so we've mentioned these artifacts before you'd'd have to save all those artifacts, somehow create a way for you to save them in a specific format and then integrate that into your front end and X, Y, and Z to make that work. Instead of worrying about all that during your deployment process,

what you'd rather worry about is the steps of actual deployment, of get this contract on the network, then get this one and pass the right data contract on the network, then get this one and pass the right data to that contract, and then get this one. Perhaps make a few transactions to configure those contracts after they're on the network, and then you're done. That's what you want to think about. So what we have in Truffle is a system that got its ideas, as I mentioned before, from Rails. So our deployment mechanism is actually called migrations. And what you do in migrations is you write steps for deployment.

Effectively, they're small deployment scripts. And you use a library that we provide you as part of the migrations called the deployer. And you just say, I would like to deploy this contract. So you deployer.deploy this contract. And then you can write multiple lines and deploy another one or deploy a contract passing variables. And then what this sets up for you is you get these first sets of contracts that make, let's say, version one of your application out. And then you've already got a system with which you can change, alter,

or perhaps update your contracts later in a migration system very similar to Rails. So the short version of this is ideally you can write deployment scripts with Truffle. These scripts, you get to worry about what you need to do rather than all the nitty-gritty details, and then Truffle will save all that data for you and make it easy for you to integrate with your front end. And then you just push your front end out to CDN somewhere or on your web server and just serve it up.

Yep, so what we found is that the front end is, and how to do the front end and how to build and release the front end is hotly debated and changes effectively depending on your developer preferences. So like I mentioned, we got out of the pipeline game. The way that Truffle is built now, you can use this same workflow to build a web-based application as you can to build a desktop application, for instance. You have the artifacts, and then you integrate that with your front end, depending on what your front end actually is. So what exactly is a front end?

Well, it's the part of the application that the user interacts with. And it's very different depending on what type of application you're working on. If you're working on a web application, it's going to be something that runs in the browser and you have to deal with all the details of deploying a browser-based application, for instance, like taking all of your assets, your JavaScript, and bundling them and putting them into a single file and then somehow pushing that off to a server that's going to host that. For an electron-based application, for instance,

it's kind of similar but a bit different. You have to get those artifacts injected into the application itself and then create builds that are compiled to create the desktop application. But there's even a front end and a console application. And that front end is what you type into the terminal itself. So it's the interface. Exactly. Oh, absolutely. Yes.

Maybe that was the easier way to say it. Yes. The interface. Yeah,'s the interface is always different and whatever interface you're you're working with changes what you're going to do so um truffle doesn't doesn't do that for you anymore and we we guide you how you might do that but otherwise um let you do it yourself gotcha very cool well uh i'll be remiss not to mention another feature of Truffle that made me very excited as it is basically where I live with building Ruby on Rails applications or building Elixir and Phoenix-based applications is Truffle provides an interactive console

for direct contract communication. Please tell me that that's not something you've moved away from, because that right there is how I do most of my coding. It's just dorking around in the console until I figure something out. We have not moved away from that. We 100% still support that. There's two features. Now you can type in Truffle console and connect to a currently running Ethereum client,

so maybe the mainnet or something. Or you can type Truffle Develop and it will spin up an in-memory blockchain for you that you can just use for development. And in both cases, you get a console that takes your contracts that you have, takes those artifacts, turns those into that JavaScript representation of those contracts, and allows you to interact with those right from the console itself.

So you're not typing Solidity in that console, you're typing JavaScript, but you have access to your contracts just like you would if you were writing that code in your front end. Very cool. That is worth the price of admission for me right there, especially since the price of admission

is always zero with open source software. That's actually, that's really great to hear because I don't actually program with the console so much. How do you do it, man? How do you do it? I guess you write tests. I don't even want to say. So actually this is something that we should talk about, but well, I write tests. I don't even want to say. So actually, this is something that we should talk about.

Well, I write tests, but I almost hate to say it. I use console.log a lot in the browser. It's terrible. But one thing that we're working on now, actively working on, and will likely be released in a week or two weeks, depending on how this works, is an interactive Solidity debugger. So this goes back into the things we talked about as far as having to recreate the things that we all love in development.

And here we're going to have a debugger where you can make a transaction and then debug that transaction no matter what Ethereum client you're on or using. It doesn't matter if you're in Gath or Parity or something else or using our own internal Ethereum client. And you could actually see in Solidity code, step through the Solidity code and see what happened. If you've used a debugger and you've used one to figure out tough issues before well you obviously know the

value of this but really this is kind of opening up the black box that is the ethereum uh virtual machine so um that's something that's gonna that's gonna be a huge huge feature and uh should come out in you know like i said a couple weeks cool. Two other quick things that we will mention, as we mentioned before, Truffle Boxes, which you can tell us about real quick. And then also we do want to hear about ETHPM and what all is on offer there. So what are Truffle Boxes?

Yeah, so they're effectively our answer to rolling your own front end. So you have to integrate Truffle's artifacts with different kinds of front ends. What we do with TruffleBoxes is give you boilerplates for how to do that in different styles of applications. So it depends heavily on what you want to use, and front-end developers seem very attached

to some of the libraries that you're using, and for good measure. So we have TruffleBoxes that show you how to use Truffle with React. We have TruffleBoxes that show you how to use Truffle with Webpack in order to build your application. We have TruffleBoxes with 8 to 10 boilerplates of how to build different styles of applications, and we're building more as necessary, as fast as we can.

Very cool. And ETHPM, we're very well familiar with NPM. This has to be an Ethereum-based package manager. What are the kind of packages that you could pull into a Truffle framework app that would do some heavy lifting for you? What are some examples? Yeah, so the basic package that you'd want from FPM

or even NPM is a source package. So literally it downloads the source for you and then it runs as part of your application. The basic package that you'd want from FPM or even NPM is a source package. So literally it downloads the source for you, and then it runs as part of your application. In this case, you would download Solidity code as a source package. But because people can deploy contracts to any network, but let's just say the mainnet for now, because you can deploy contracts to the main net, you could actually create packages that connect your application with their application. So for instance, if you are downloading a package and it contains artifacts of addresses of contracts that the package maintainer deployed,

you could then integrate those easily into your application and build off of their code. I mean, and that's part of the visions of Ethereum or the promise of Ethereum is that, you know, not only we're going to be able to build our own applications and deploy them, but we're going to be able to build applications that build off of everything other people have deployed. So that's the idea of FPM. It's still having a bit of trouble gaining adoption, but we're working on that and hopefully we'll have new versions in the future. This episode is brought to you by Gliffy. Gliffy is the easiest way to visualize any idea.

In a world where it's possible to draw a circle in the cloud and put an arrow to a square with some text in it, there lives a tool with over 4.5 million users who can easily diagram online or directly in Atlassian on Confluence or Jira. And in this segment, Craig Cockrell, part of design at Plastic, shares how his team lives and dies by this tool. For me, using Gliffy is really nice just because I'm able to really not have to worry

about the tool as much. I can sit here and really focus on what I actually want to accomplish. The way that I've described it to other people, in general, is it's something that's very hands-on. Like it feels as though you're really using very material objects and rearranging them on the fly and making that movement from taking this screen and moving it towards the end or reconfiguring that flow.

It's not something where you really need to feel the pain of going through that. It comes so naturally that, you know, the tool is almost secondary. And what I'm trying to focus on and get done is the primary goal. Ideas live or die on the diagrams that people create in Gliffy. If you're not creating that fidelity, it's something that it's very easy for that to just literally fall off to the wayside. Within the company here at our core, a startup, right?

People have a lot of ideas and they have a lot of things, but there's obviously gaps in communication and without something to actually bring to people and bring to the table and show that you've done some level of work, you've done some sort of background, you know, a glyphic diagram is one of the best things that anyone has ever brought to any sort of product inception meeting or anything like that. And that is truly where we can start that collaborative process. Without that, that conversation doesn't happen. The right stakeholders don't get involved. And at that point, you don't have anyone rallying behind you. Without that, that conversation doesn't happen. The right stakeholders don't get involved. And at that point, you don't have anyone rallying behind you. And without, you know,

the group rallying behind a certain project, it just doesn't happen. When anything begins, it's so important that those individuals open Gliffy, in Confluence, get in there, start working, and just get it started. It's just something that allows, you know, a canvas for us to create. All right. It's easy to get started. Try it free in Atlassian or online at glyphe.com slash changelog, or also learn how to get 25% off one year of Glyphe in Confluence or Jira. Those details are shared at glyphe.com slash changelog. Start building your ideas with your team today. And if you don't have a project to work on, draw a duck, set it as your desktop wallpaper, learn how easy it is.

Draw something today at gliffy.com slash changelog. so tim one thing that i've been thinking as you talk especially back when you were talking about the anatomy of a web3 decentralized application is you have to wait because it has to go onto the blockchain, it has to be confirmed, consensus has to happen, these things have to happen on-chain. We've talked a few times, I guess, Adam, I think, was it Preeti Kasaredi who talked about Ethereum scaling and we've had scaling problems,

we've had CryptoKitt've had crypto kitties. All of the transactions going on, the blockchains are causing many people to talk about how we're going to scale. Proof of stake versus proof of work, sharding, all these different things, right? And so the question is, why are we doing all of this? If we get a little bit big picture again, what's the big wins? Because we're talking about the details, but when we look at the forest, instead of these cute little truffle trees, why are we going through all these hoops to get daps? What's the big win?

Everybody looks at CryptoKitties, and some people might laugh or not take it seriously, but it's actually a great example of something you can do on the Ethereum blockchain. And the thing here is that they created, we'll just call it digital art, and created ownership of digital art and something that people can interact with. Now, that use case in and of itself isn't necessarily the most compelling use case. But it brought Ethereum to the forefront of what we can do. like this that create ownership or manage finances or script, you know, trustless interactions with people using the Ethereum blockchain. And it, you know, kind of changes the way we build things. So I want to give you an example. I mentioned CryptoKitties because I want to give you an example of something else that you can do. And this is going on to the vision of Ethereum, they built CryptoKitties because

they thought they were building a fun application that people can interact with. And I'm sure they made, they have a fee system in there, so I'm sure they made quite a lot of money in doing it. Something that Truffle is doing on the side for fun is creating an application that we call the Pouncing Dead. We were going to call it Crypto Zombies, but somebody stole our name. So the Pouncing Dead, and what's cool about this is we can do what I was talking about before of building our own application that extends the use cases of somebody else's application.

So in ours, what you do is you send ownership of your kitty. You send ownership over to what we call the horde. And you essentially sacrifice your kitty over to the horde, and you get a zombie out of it. Oh my gosh. You kill your kitty. But in killing this kitty kitty you get a new uh you get a new token you get a new piece of for for lack of a better word a new piece of digital art and uh what you can do from there is trade them and you know just like you would uh crypto

kitties but you could also feed other people's kitties to your zombie to create even more zombies um and and you know the zombie apocalypse comes out now uh what we can what we can do with that is instead of making money is the pouncing dead um we can uh take that fee structure and um give it to the horde itself and so that whenever you sacrifice a kitty over to the horde that money gets paid out to you we could actually create this really interactive in doing so, you guys reacted yourself like this is so cool

we can create this really interactive system where people are interacting with crypto kitties or interacting with crypto zombies it becomes a narrative that's fun to talk about and fun to interact with. And like I mentioned, this is just one thing that you can do. People are using the Ethereum blockchain to manage provenance of fish or products that get created

and make sure that the authentic things are, you know, finally make it to consumers. People are using it to check out oil production and make sure that we're producing things right, like blood diamonds don't need to happen anymore. We can create applications like decentralized eBay, where you, for instance, eBay is great in that it brings people together, but they, along with PayPal, they take a 17.5% cut, which is outrageous. That doesn't need to happen anymore. The value transfer can happen over Ethereum. And so what we're going to do is reduce the, what we say,

the amount of rent seekers that are in our industry today that are just kind of building an asset and then sitting on that asset and instead put that value over to everybody else. And part of this question was really hard for me to answer because there's so many cool things that people can build, but a lot of the stuff we haven't even thought of yet. The promise of Ethereum is there, and we just need things like CryptoKitties and the Pouncing Dead to show us how cool this stuff is. Well, it's certainly a place to jump in

and in a fun way, understand and learn, you know? Right. It's right for innovation. Yeah. You can see the potential, but all of the uses so far have either been, admittedly, I thought CryptoKitties was kind of brilliant, but as a game, as a piece of digital art,

I love weird internet art things, but not revolutionizing the world. But you can learn better by fun. You learn while having fun. Sure. Very well. I think ICOs, I think crowdfunding was a great example of a capability that was unlocked.

Right. And then we, you know, we see the positives and the drawbacks of that with the scams and what have you. But that's kind of just the market, you know, sorting itself out. But I think we all can agree that a lot, like Adam was saying, it's a good place to jump in and be kind of bleeding edge and have fun and learn something that's um has tons of opportunities but i don't know if any of us have even seen what you know where the real killer use case is where they're coming you know right i have one question before we go to that it's it's um in a world where we have to i think it's always been this way but in a world where where we need verifiability or trust in a world where we have to, I think it's always been this way, but in a world where we need verifiability or trust in a marketplace, like you had said, to ensure authenticity,

how do you attach the real world to a blockchain in terms of knowing that I've authentically sent you this eBay item or given you this blood diamond or non-blood diamond? How do you track real world in blockchain? How does that attach itself? Yeah, so that's a hard part. You only transfer digital value. You can only easily transfer digital value over Ethereum itself. You'll have to use external systems that connect to the blockchain in order to transfer real

world value. So, for instance, I mentioned the eBay example. The value transfer that I mentioned there is only the value transfer of buyer paying seller. It's not the value transfer of the actual product or the physical good being sold, being transferred over. Here, there will always be a level of trust involved when you deal with the physical world. You're going to have to trust FedEx in this case. But FedEx could implement features that track the location of the good and where it's at and who's handling it on the blockchain, if that actually makes sense for them. The FedEx example of actually putting that on there, that may or may not make sense for this example,

because basically we're all fine with going to, you know, checking or tracking number online and using their current existing databases. Like blockchains don't make sense all the time. But there are cases where you might want to track physical goods and where they're coming from and pair identity, which is something we're solving, but pair identity with the blockchain itself. And so you then have this person making a statement that something about the real world is true, whether it's being the location of a physical good or something else.

And so if we can do that right, and we get the identity thing down, then it can unlock quite a bit of things. And it's going to come down to, I suppose I could lie in person to you, talking to you as much as I could make a transaction on the blockchain. But if we can build systems that make that harder or make it very clear that I'm the one who embezzled whatever this thing was, then perhaps we can increase accountability or what have you. Right. The blockchain provides one side of the equation of truth. Right. Right. And then it's up to us to have the other side which is physical truth right yeah or somehow bridge those you know the the analog and the digital systems with rfid chips and you know fedex integrations

although admittedly at that point you know your your your, your trusted third party is FedEx. Um, so yeah, I mean, you're sometimes, sometimes I feel like we're the cat and the cat, cat and the hat, you know, where they have the stain on the tub and they clean off the tub, but now it's on the, you know, it's off the rag and it's on the wall and they're just kind of pushing that, that smudge around and can't actually get rid of it um but it's progress i think yeah right yeah i mean and there's there's some things that i mentioned identity because that's really important to effectively everything we do on the blockchain but for instance if we get identity solved um and you know the politics around voter id laws are such that it's fine, we could actually have secure voting online without the possibility of…

Tampering. Tampering, exactly. Coherent or all the things. Right. You're explaining, I think, where we're trying to go as real-world examples. Like who's using it? Why are they using it? What are they building with it? You know,

we kind of know some examples now, like we'd mentioned ICOs and, you know, fundraising and different things like that, actual value, which is a cryptocurrency or in this case, you know, maybe the FedEx example or eBay,

for example, but other examples might be pretty interesting to, to share. Do you, can you share more about like what people are building with it and why they're building with it? Maybe what the value is happening in a certain community around what they're building? Yeah. So the current things that are being built are mostly around financial transactions.

And that's because our money's been digitized for years now. And so it's really easy to write code or systems that mimic the ones we already have, but in a trustless manner. So for instance, I forget the word, but there's this idea of taking two assets. If both of us own an asset of a different type and we want to swap the risk of owning each asset, we can actually perform those swaps. Those things are terribly hard to do

in the real world of just getting everybody involved. But when it's a blockchain and where you have tokenized assets and people can just send a transaction that gets them into the swap. Everything is taken care of. Again, there's a word for that that I'm looking for. But really, the financial use cases are the ones that are winning out right now. And we're still figuring out how the real world...

Fits into that. Exactly. That's blockchain at large or maybe even Ethereum at large. What about Truffle at large specifically, like Dapps, Web3, this kind of thing? So Truffle, I hate to use this example because it's kind of negative. But if you have a gold rush, somebody's got to build the shovels. And I feel like that's where we're at with Truffle. We need to build the tools that people need in order to unlock these new use cases of the blockchain or the next generation of blockchain applications. And that's where we see ourselves as Truffle.

We know that there's huge opportunity here, but this opportunity isn't going to be taken advantage of if the tools don't exist. So we're working to build the tools. We have a heck of a good time building tools that people find are useful for them, and we get great feedback. And hopefully we can build the platform that people use in order to build that next generation application or that – what did you call it? The app that's going to win, whatever it is. There's a word for that.

The killer app. The killer app. Thank you. The killer app. Yeah. I think it's interesting, though, with what you said using the shovel analogy, you know, to think of the way that, Jared, you were just saying earlier, you know, how you love how the Internet makes it available to you that you can define who you are. And in the same way, you know, our ancestors, you know, maybe even one or two, you know, generations up, parents up, you've got people who literally made physical shovels. And now we're making digital shovels, so to speak. And I think it's just interesting how the world has changed

and it is changing and will continue to change to just essentially we're makers. We're just this age's makers. Very true. Tim, while you were talking there, I did find just probably to trigger your brain on a few of the companies and projects that are using truffle in production you do have some listed um to give you some more you mentioned the stable coins there's one called stable shapeshift which is like a currency exchange colony and aragon which I believe these are like decentralized democratic organization type of operations. And so there's definitely interesting and new things being built with the digital shovels y'all are building.

So it'll be interesting. Yeah, another one on that list who has been an active Truffle user for a long time and have been using Truffle perfectly is Digis Global. And they manage tracking gold – tracking and selling – we'll just actually say – we'll just say tokenizing actual gold so you can sell it and make that – those markets more fluid. That's interesting. You remind me of the, actually, when I asked the question about how can you check a diamond, they actually have a tiny, tiny, well, I guess I don't know how big the laser is, but the laser is probably just as big as it needs to be. But the thing is, it lasers onto the diamond is a sequential number.

And so that number could be a token, so to speak, for the blockchain. They catch it in. Yeah. So there you go, Adam. I can answer your own question in your own podcast. There you go. Why do we even have guests, Adam? You can just answer all your own questions.

Interesting. I love that. Perfectly sized lasers. This is as big as it needs to be. It's not as big as it needs to be. Like, boss, how big is that laser you ordered? He's like, the exact size it needs to be you know it's not as big as it needs to be like boss how big is that laser you ordered he's like the exact size it needs to be okay good excellent well tim uh anything else before we let you go do you have a call to action a way that people can get involved

help out truffle uh help the community effort around this framework and people building on the Ethereum network? Yeah. So I mentioned previously that Truffle is six people. I haven't looked in the last couple of days, but since Truffle's inception, we've had something over 300,000 downloads of Truffle itself, not to mention downloads of Ganache, our blockchain tool. And so we are six people working as hard as we can to build these tools for you. What we need and what helps us the most is your feedback. So whether or not you're building your own application for a company or you're building an application for a company or building something for yourself, we need to hear what problems you're having, uh, what you're getting stopped up on

so we can make our tool better, make our, our documentation better, um, and make the whole developer experience better for you. Um, the best way to do that is to, uh, hit us up on our Gitter channel, which is, uh, gitter.im slash consensus, a Y slash Truffle. Or you can send me an email at Tim at TruffleSuite.com. So please, please reach out. Oh, and I didn't mention that we are heavily tracking our issues list on GitHub for Truffle and Ganache and Drizzle. Please feel free to write an issue there if you're having one. I guess since you mentioned your stats too,

we should also mention that awesome dashboard, which does share a lot of the information you just shared there. So you got, you know, it's actually 327,704 downloads lifetime, which is up 42% from the past month. And there's quite of an uptick there too, from like September, November timeframe to now of downloads. You can see that real time. Yeah, this is open data.

So it's pulled straight from the services that provide you those stats. So for instance, the downloads is pulled directly from NPM. GitHub stars is pulled directly from GitHub. Your browser is actually doing the pulling of that data. So you can keep checking back there. I roughly check that every day or every other day. This huge growth, this huge uptick has actually been really surprising to me.

And just it reflects the growth in the Ethereum community in general, because many of the other upticks, if you're looking at our download graph, are related to us putting out a new major version, where in this case, that uptick just happened. Yeah, to put into perspective, too, for the listeners, we're looking at, I think, 29,925 downloads. and this is total downloads in a month so that number's for that month so roughly 30,000 downloads in November and then come January

they're pushing 47,000 almost 48,000 downloads in the month of January so it's a significant difference I wonder how well this chart correlates on top of the price of ETH as it has also risen quite substantially. We need to stick a plot there.

Because, you know, there's a reason why the people who are selling shovels, we're selling them to, you know, people who are going after gold, because there's a lot of money to be made and lost in this ecosystem, for sure. That's true, absolutely. If it means anything, we're not actually selling any shovel yet.

However, we are thinking about getting into the support and consulting world. So if you're a, well, we'll say new user to Truffle that needs your team onboard or onboarded or you need some custom work done for you. Uh, please reach out. Very cool. Well, Tim, thanks so much for schooling us on all things, uh, shovel making. This has been a lot of fun. Absolutely. Thanks for having me. I really appreciate being here.

All right. That's it for this episode of The Change Log. Thank you for tuning in. And, you know, if you enjoyed this show, do us a favor. Do your friends a favor. Share it with them. Rate us on Apple Podcasts. Go on Twitter and tweet about the show. Post it to Hacker News, Reddit, wherever.

Share the show. Thank you to our sponsors, Rollbarode and glyphe and of course bandwidth for changelog is provided by fastly so go to fastly.com to learn more error monitoring is by rollbar check them out at rollbar.com and we host everything we do on linode cloud servers head to linode.com slash changelog check them out, support this show this show is hosted by myself Adam Stachowiak and Jared Santo editing is by Jonathan Youngblood our beats are by Breakmaster Cylinder

and you can find more shows just like this at changelog.com or wherever you subscribe to podcasts thanks for tuning in Thank you.