Writing and deploying software made simple (again)

Joule started as an experiment to push the boundaries of making web development simple and enjoyable again. Sign up for an account.

Making things on the web used to be simple. I remember using Geocities’ file editor to edit the HTML page for my website. Don’t get me wrong; it had issues. But it was brilliantly simple.

http://www.pcrobin.com/hpu/geocities/geocities.htm

Knowing when you forgot to close an HTML tag was difficult. And tracking down why the resulting HTML wasn’t rendering correctly was frustrating.

Making a change only to find out that your entire page had red blinking text was common. It was part of the learning process and it exposed many of us to programming. You learned by doing, whether you hand-coded the HTML or copied it from another site.

I miss those days.

Joule is the by-product of asking ourselves a simple question. Can we apply the “learn by doing” approach to writing back-end applications?

View source for back-end applications

In the 90s, “view source” was more than being able to look at HTML and Javascript through your browser. It was effective and powerful because you could run code by copying and pasting it into your browser. You would make changes, refresh the page and get immediate feedback.

That environment has never been around for the back-end. There wasn’t an easy way to interact with code. There’s lots of missing context and unknown dependencies that are hard to make sense of.

So we decided to test our hypothesis that it was possible.

Joule is the “view source” for back-end applications

Making it easy for people to look at the source code for a Joule was the first hurdle. We decided that every Joule would be a GitHub repository. For example, this Joule creates a group text message chat channel using Twilio. (source on GitHub)

Being on GitHub makes the viewing the code easy but what about “learning by doing”?

Every Joule is created from another Joule and deployed within seconds. Creating a Joule creates a repository in your GitHub account and deploys it. Every time code is changed and pushed to master your Joule gets redeployed with the latest code. Again, within seconds.

Learning by doing

It’s convenient that Joules automatically redeploy themselves when code is pushed to Github. But it’s a drag to have to commit and push code while you’re fiddling with it. This is why every Joule comes with a playground you can use to interact with right on your computer.

Here’s an example of forking our joule-node-boilerplate Joule and playing around with it. Try it by creating your own Joule.

These 5 commands will work for every Joule. You can make changes to the code, run npm test and see the changes as if it were deployed. It’s that simple and we have documentation on how locally developing a Joule works.

Writing software made simple again

Joules are simple. There’s a single entry point when you call a Joule. A personalized Hello World example is 15 lines of readable code that anyone can play with.

I took some time off from working on the Joule platform and hacking away at making some actual Joules.

I haven’t been able to put my finger on what makes hacking Joules so fun. It’s been nice to focus on code and nothing else. I didn’t have to stand up servers, deploy builds or set up lots of boilerplate code just to get started.

It feels reminiscent of the good ol’ days.

Our quickstart documentation is a great place to start learning about Joule.