Vox

Leitura de 16 min

17: Volt and Isomorphism with Ryan Stout, part one

Summary

In this first part of a two-part interview, host Jonathan Cottrell speaks with Ryan Stout, the creator of the Volt web framework for Ruby. The conversation centers on the concept of isomorphic development, which Volt embodies by allowing developers to write Ruby code that runs on both the client and server sides. Ryan explains that this approach aims to reduce the complexity and duplication inherent in traditional web development, where different systems and mental models are required for front-end and back-end work.

Ryan discusses the current state of Volt, noting that while it has a growing community and is being used for various projects, it is not yet fully ready for large-scale production deployment due to some missing features. However, he emphasizes that the development team is rapidly closing this gap. The framework is positioned as a tool for rapid prototyping and full-stack development, appealing to developers who want to build applications quickly with fewer distinct tools and technologies.

The interview touches on the community aspects of Volt, including regular office hours held via Google Hangouts where the core team interacts with users, and the use of a GitHub-integrated chat tool (similar to HipChat) for asynchronous communication. Ryan provides a beginner’s perspective, explaining that Volt simplifies development by making client-side and server-side models behave identically and automatically syncing data, allowing developers to think of building a single, cohesive application rather than two separate ones.

Jonathan shares his initial experience trying Volt, describing the ‘jarring’ but enlightening moment when he realized his Ruby puts statements were outputting to the browser console instead of the terminal, highlighting the fundamental shift in mindset required. Ryan elaborates on the technical details, explaining that most Volt code runs on the client, with validations and logic executed on both sides for security, and mentions ongoing work to enable server-side pre-rendering of views for SEO and performance.

The episode concludes with a preview of the second part of the interview and encouragement for listeners to explore Volt framework, build something with it, and engage with the show through reviews and social channels.

Recommendations

Practices

  • Office Hours (Google Hangouts) — A regular practice adopted by the Volt project and other open-source communities, where core team members hold scheduled video calls to discuss the project’s direction, implementation details, and engage with the community in a face-to-face format.

Tools

  • Volt — A Ruby web framework that enables isomorphic development, allowing code to be written once and run on both the client and server sides. It is presented as a tool for rapid prototyping and simplifying full-stack development.
  • GitHub-integrated chat tool — A chat application similar to HipChat or IRC but geared around GitHub projects, used by the Volt community for persistent, searchable, asynchronous communication. It facilitates discussion among contributors and users.

Topic Timeline

  • 00:00:00 — Introduction to Ryan Stout and the Volt framework — Host Jonathan Cottrell introduces the episode and guest Ryan Stout, creator of the Volt framework. Volt is described as a Ruby web framework that allows code to run on both the front-end and back-end, promoting isomorphic development. The interview is announced as a two-part series.
  • 00:00:54 — Defining isomorphic development and Volt’s purpose — Ryan discusses the term ‘isomorphic development,’ clarifying he didn’t coin it but uses it to describe Volt’s goal of sharing code between client and server. He explains that this sharing simplifies development by reducing duplication and allowing more logic to be handled by the framework, rather than manually written by developers.
  • 00:02:28 — Current production readiness of Volt — Ryan addresses the production readiness of Volt, stating it is not yet fully ready for large-scale, critical deployments due to missing features. He notes a strong community is building on it and that the team is quickly closing the feature gap, expecting to see larger production apps soon.
  • 00:03:41 — Community engagement through office hours and chat — Ryan describes the Volt community’s engagement practices, including regular Friday office hours via Google Hangouts where the core team discusses the project’s future. He also mentions using a GitHub-integrated chat tool (similar to HipChat or IRC) for persistent, asynchronous communication among contributors and users.
  • 00:05:30 — Beginner’s perspective on Volt’s value proposition — Ryan explains Volt’s value from a beginner or full-stack developer’s perspective. He highlights the cost of learning separate front-end and back-end systems and the complexity of syncing them. Volt aims to unify these by having models behave the same on client and server, with automatic syncing, allowing developers to build a single, cohesive application.
  • 00:07:46 — Jonathan’s hands-on experience with Volt — Jonathan shares his personal experience trying Volt, noting the initial disorientation when puts output appeared in the browser console instead of the terminal. This moment underscored the fundamental difference from frameworks like Rails, requiring a shift in mindset to account for code running on the front-end.
  • 00:09:01 — Technical details: what runs where and future features — Ryan clarifies where code executes in Volt: most code, except tasks, runs on the client. Validations run on both sides for security. He mentions an upcoming blog article to explain this and discusses work on server-side pre-rendering of views for SEO, after which the client-side JavaScript takes over dynamically.
  • 00:10:38 — Conclusion and call to action — Jonathan thanks Ryan and previews the second part of the interview. He encourages listeners to leave a review on iTunes, check out Volt at voltframework.com, and try building something with it. He also provides his Twitter handle and email for listener contact.

Episode Info

  • Podcast: Developer Tea
  • Author: Jonathan Cutrell
  • Category: Technology Business Careers Society & Culture
  • Published: 2015-02-11T12:50:00Z
  • Duration: 00:11:48

References

Podcast Info

Transcript

[00:00:00] Hey everyone and welcome to Developer T. My name is Jonathan Cottrell. I’m your host and

[00:00:06] today I have the privilege of interviewing Ryan Stout. Ryan is the creator of Volt, which

[00:00:13] is a web framework for Ruby that allows you to write just one place, allows you to write

[00:00:19] Ruby and that Ruby actually works both on the front end and the back end. It’s a

[00:00:24] powerful framework. We talk a little bit more about that in depth during the interview.

[00:00:29] The interview is two parts, so you’ll want to make sure that you catch the second part

[00:00:32] later on this week. I talked to Ryan for quite a while after the interview and I think that

[00:00:39] Volt has a fantastic future. I believe it’s something that all developers, all web developers

[00:00:45] at least should be keeping their eye on. I hope you enjoy the first part of the

[00:00:49] interview with Ryan Stout. Ryan, welcome to the show.

[00:00:54] Hey, thanks for having me.

[00:00:57] So today we’re going to be talking with you about the term that you kind of coined,

[00:01:05] the isomorphic development. I really appreciated that you took on the opportunity and made

[00:01:14] that term your own. Volt is a framework that embodies the spirit of that term

[00:01:22] isomorphic development of writing code once. I’m excited to talk to you about that. We’ll

[00:01:30] talk about the specifics of the framework, but the basic idea is that Volt allows you

[00:01:35] to have a front end and a back end system all developed in Ruby, right?

[00:01:39] That’s right. I should just say too that some other people had used the term isomorphic

[00:01:44] before I actually started using it. I can’t actually take credit for that. The general

[00:01:52] idea is as web developers, we end up writing a lot of the same things on the back end and

[00:01:59] the front end. So Volt is really sort of an attempt to share that code. Once you

[00:02:07] have the same code on the front end and the back end, it really kind of opens up

[00:02:12] a lot of other simplifications is how I would put it. You can kind of push a lot

[00:02:18] more code into the framework instead of needing to manually write all these things.

[00:02:23] Sure. The framework is ready for production today, right?

[00:02:28] Actually, I wouldn’t say it’s quite ready. There’s quite a few things that we’re still

[00:02:34] kind of working on. We have a pretty big community that’s building a lot of things on

[00:02:41] it, but I definitely would say if there’s something you’re going to go try and put in

[00:02:47] front of a really large group of people right away, it’s probably not there yet, more

[00:02:52] so because of missing features, if anything. But we’re pretty quickly closing that gap,

[00:02:58] I think. So as time goes on, we’ve kind of got this big list of things and we’re

[00:03:04] checking them off pretty quickly. So I think in a pretty short term, you’re going

[00:03:08] to see larger and larger production apps on it, and we hope very soon.

[00:03:15] Yeah, I think, you know, and so part of what we’re going to talk about here in a couple

[00:03:19] minutes is like comparing, not comparing, but really talking about this in view of something

[00:03:26] like Rails or Sinatra and where it sits and what it’s good at versus what those things

[00:03:31] might be, I won’t say better, but more suited for. So I’m interested to see what

[00:03:38] your opinion is on that, but before we talk about that, I want to talk about

[00:03:41] this thing that you’re doing on Fridays, like pretty regularly, right, which is the

[00:03:46] office hours.

[00:03:47] Yeah, so I’ve started to see a lot of open source projects doing this, and I really

[00:03:51] like the idea. They’re basically doing a Google Hangout and, you know, there’s a

[00:03:56] regular scheduled time for it. So I know a lot of people, they kind of, they want

[00:04:01] to kind of have this more like face to face experience with kind of the core

[00:04:07] team and developers on projects. And so it’s nice because you can kind of go on there

[00:04:12] and myself and a bunch of the other big contributors will kind of discuss some

[00:04:17] things as far as the future of Volt and the direction and, you know,

[00:04:21] implementation specific things. And so it’s nice because a lot of people just kind

[00:04:26] of sit and listen and so they can kind of get a feel for what’s going on.

[00:04:30] So we do that. And then the other thing that we’ve been using a lot is

[00:04:34] I don’t know if you’ve seen that. It’s sort of similar to like a hip chat or something like that.

[00:04:40] OK.

[00:04:42] But it’s really geared around your GitHub projects.

[00:04:47] Oh, I have seen that. I was trying to remember it because I knew I had heard

[00:04:50] that and I had seen it somewhere and I’ve actually gone and looked at it.

[00:04:54] I haven’t actually participated on it, but I know about it.

[00:04:58] Yeah, so we use that quite a bit. It’s sort of like a nicer interface

[00:05:03] around. It’s sort of similar to what you’d use IRC for, but, you know,

[00:05:06] it’s web based and then there’s mobile apps and things like that.

[00:05:10] So it’s nice. Kind of gives you that.

[00:05:12] Also gives you a little bit more asynchronousness than IRC does

[00:05:16] since messages are persisted and you can search them and things like that.

[00:05:21] So we’ve been using that a lot and we actually have a lot of people kind of

[00:05:24] at any given point there’s somebody in the room kind of talking about something.

[00:05:28] That’s really cool. Yeah.

[00:05:30] So if I’m coming, well, let’s start from the beginner perspective.

[00:05:35] If I’m coming into this world as a beginner web developer and Volt is like

[00:05:40] the first thing that I’ve experienced, I think it’s a it’s kind of different

[00:05:45] than the average framework, of course. Right.

[00:05:48] So can you kind of give a beginner developers perspective on

[00:05:54] like a 30 second history of why Volt exists and what it does different from,

[00:05:59] you know, an average framework?

[00:06:02] Yeah, I think one of the things maybe to put things in perspective, too,

[00:06:07] is I’ve always kind of been what I would consider a full full stack

[00:06:12] developer. And by that, I mean, I would do front end and back end.

[00:06:16] And a lot of people come to me with kind of prototype ideas and are like,

[00:06:20] let’s let’s do this and see, you know, if it goes.

[00:06:24] And so for me, kind of the top priorities are being able to build

[00:06:28] something quickly and then also not needing too many tools,

[00:06:35] I guess, if that makes sense. So yeah, yeah, there’s there’s kind of an

[00:06:38] inherent cost right now as far as if you’re a front end and a back end

[00:06:43] developer, you’ve got to learn two totally different systems and then you

[00:06:47] also have to learn kind of all the technologies to sync in between.

[00:06:51] And while that’s not hard, I mean, it’s something you can definitely do.

[00:06:55] There’s kind of all this added complexity of, you know,

[00:06:58] you’re thinking one way on the client and you’re thinking another way on the

[00:07:00] server. And so what what we try to do with Volt is basically make those two

[00:07:08] so that they behave very similarly.

[00:07:11] So we have where, you know, when you’re writing models, for example,

[00:07:15] it doesn’t really matter whether you’re on the client or the server.

[00:07:18] They behave the same way.

[00:07:19] And then when they’re on the client, they just kind of automatically

[00:07:22] sync back to the server.

[00:07:24] And so things like that really let you kind of simplify things because you’re

[00:07:28] not you’re you’re sort of just building one large app instead of you’re

[00:07:35] building a front end app and a back end app, if that makes sense.

[00:07:38] Yeah, absolutely. And so I familiarized myself with Volt recently.

[00:07:46] I actually like, you know, got things going on my machine and

[00:07:50] started playing around with controllers and all that.

[00:07:53] And so what was it was really odd at first because I’m used to writing puts

[00:08:00] and seeing that output in my my console, right?

[00:08:04] I’m sorry, in my in my terminal.

[00:08:06] And so I was like, I was looking at looking for it in my terminal

[00:08:09] because I still was wrapping my brain around how the framework works.

[00:08:13] And then I looked over and I was like, maybe I’m looking at maybe

[00:08:16] something’s not acting like I expected to.

[00:08:20] And I looked in the browser and I saw like Ruby looking out like object

[00:08:25] to string output in the console.

[00:08:28] I was like, that is that it was jarring for me.

[00:08:31] But I think it was a good jarring because I realized this is

[00:08:34] fundamentally a different way of doing things.

[00:08:37] And I can’t think about it the same way that I think about, you know,

[00:08:40] Rails development or Snatch or whatever, because fundamentally I have

[00:08:45] to keep in mind that this is going to the front end too, right?

[00:08:50] Like it’s not just one it’s not it’s not like separated necessarily,

[00:08:56] but it’s the same concern.

[00:08:59] And it’s actually interesting, you know, one of the questions

[00:09:01] we get a lot is what’s running on which side?

[00:09:06] I’m actually working on a blog article now to kind of help explain that.

[00:09:09] But one of the ways I like to tell people is that pretty much

[00:09:14] everything you’re writing but tasks except for tasks actually runs

[00:09:19] on the client side and then certain things.

[00:09:22] So, for example, when you save a model, it’s going to run the

[00:09:25] validations on the client side and on the server side so that,

[00:09:30] you know, someone can’t tamper with it on the client side, you know.

[00:09:34] But generally, actually a lot of a lot of volt is sort of more

[00:09:38] resembles a front end framework.

[00:09:41] And then you get the niceties of, like I said, you don’t have to

[00:09:44] rewrite your validations and permission logic can be shared and all that.

[00:09:48] So and then kind of the other thing that we have in the works is being

[00:09:54] able to render your views preemptively on the server.

[00:10:00] And then once that once the page loads and downloads all the

[00:10:03] JavaScript, the compiled the Ruby compiled to JavaScript, once

[00:10:08] that’s loaded, it’ll it’ll kind of tie into the bindings and

[00:10:12] automatically pick up from there.

[00:10:13] So so that’d be nice once we get that out because you’ll get, you know,

[00:10:17] where a search engine can crawl your page and it looks like a, you know,

[00:10:22] normal back end serve page.

[00:10:23] But then you get the dynamic updating on the front end.

[00:10:26] Right. Right. Yeah.

[00:10:27] Which up until this point, just for anybody who’s wondering,

[00:10:31] that’s something that you have to do piece by piece in other

[00:10:35] framework lands.

[00:10:38] Thanks so much to Ryan for being on the show.

[00:10:41] Make sure you catch the second part of that interview later on this week.

[00:10:45] We’ll release it through iTunes as usual and all of our normal channels.

[00:10:50] I hope you’re enjoying the show.

[00:10:51] If you are enjoying it, drop into iTunes and leave us a review.

[00:10:55] It’s the best way to help other developers just like you find

[00:10:59] developer tea.

[00:11:01] Make sure you check out Volt.

[00:11:03] You can go to Volt framework dot com and take a look and play

[00:11:06] around with Volt.

[00:11:08] And then maybe you can build something as a challenge between now

[00:11:11] and the next time that you listen to to Ryan.

[00:11:17] As always, you can connect with me on Twitter at developer tea,

[00:11:21] or you can email me at developer tea at gmail dot com.

[00:11:25] You can always check out the show at developer tea dot com,

[00:11:28] where there’s also a contact link in the nav at the top.

[00:11:32] And of course, until next time, enjoy your tea.

Visão de gráfico