Free PeepCode Blog

Elixir is for programmers

Wed Jun 19 21:00:00 +0000 2013

This article is heavily styled and is best viewed at PeepCode!

words and design Geoffrey Grosenbach
photography Paula Lavalle

The early 2000’s were an exciting time for dynamic programming languages.

Excitement was high for the upcoming Perl 6. It ran on a brand new VM built specifically for dynamic languages and included dozens of experimental syntax sugars such as the hyper operator, which could run a calculation on every element of an array (somewhat like map). I attended the Seattle Perl User Group every month where you couldn’t ignore the anticipation!

It was during these years that I first heard about a weird language that used indentation to define scope (now known as Python). And on January 1, 2001, Dr. Dobb’s journal published an article by Dave Thomas introducing Ruby to the West.

That’s not even counting the other languages I tried out for a few weeks each such as REBOL, RealBasic, and AppleScript.

There must be something special about the start of a decade, because I’m feeling that same kind of excitement and seeing that same kind of experimentation again. At the beginning of May we filmed a 2 hour video with Elixir creator José Valim. Elixir is a language that runs on the Erlang VM but is inspired by the syntax and concepts of many other languages including Ruby, Python, and even Lisp.

It’s not just a transpiler like CoffeeScript; it makes real Erlang .beam bytecode. According to some, parts of Elixir are even more optimized than Erlang itself. It benefits from all the concurrency and deployment options available to Erlang programs. Elixir can call Erlang functions and vice versa.

I don’t pretend to be an Elixir expert (that’s why we worked with José, who is), but I left the session with a lot of enthusiasm for Elixir’s design and features. Here are a few of them.

Smart `assert`

A programming language like Ruby loses a lot of data when you run it. It quickly loses access to the original source code. If you write a test with Ruby’s basic assert, it can only tell you that the test passed or that it didn’t; it can’t tell you why. Projects like ruby2ruby have tried to bridge this gap but haven’t had support from the core team.

Elixir works directly with your source code to do smart things. Tests rarely need more than the built-in assert, yet meaningful errors can be displayed. Take this Elixir code:

test "makes bacon" do
  assert Bacon.make_bacon() == "avocado"
end

By reading it, we can see that it’s erroneously making bacon but looking for "avocado". We expect that it will fail. If this were a test in Ruby (or any other language), we would see an error such as expected true, got false. Not too helpful.

In Elixir, we see this:

** (ExUnit.ExpectationError)
             expected: "bacon"
  to be equal to (==): "avocado"
at test/bacon_test.exs:14

Elixir knows that == is being used in the assertion, and shows you the values on either side of == when the test fails. Now that’s a useful error!

Multi-block control flow

For years I’ve wanted to be able to write my own control flow structures, such as an each...else that runs an else block if the each is empty (Handlebars templates have this).

The only way to do that in Ruby would be to pass several lambdas to a method, which would be ugly.

In Elixir, the relationship between single line functions and multi-line blocks is well thought out.

These two are equivalent:

# Single line
if(condition, do: a, else: b)

# Multiple lines
if condition do
  a
else
  b
end

In the single line version, if is a function that takes two arguments: the condition and the clauses. The clauses are do and else.

The multi-line version needs no explanation.

But the fact that these two are equivalent means you can write a macro that works just like a built-in. Because that’s how the built-ins are written, too! (source)

Consistent use of `do`

Developers who love Ruby like the fact that they can override built-in operators and write DSLs that look like built-in Ruby syntax.

But many of Ruby’s syntactical elements are off limits. You can’t write Ruby code that works like a class definition, or an if, or a case...when. Why? class has an end, but no do. There’s no way to write a custom method that takes a block without do.

Elixir is consistent.

Need a module? It’s defmodule...do. Need an if? It also uses do. Same with def.

defmodule MyModule do
  def my_function do
  
  end
end

If you want to write a macro that works like the language does, you can. Because Elixir is implemented with the same tools available for you to use.

Built-in TDD

I find it extremely difficult to learn a new language if I can’t write unit tests. My confidence in writing JavaScript and many other languages went way up once I started using a decent test runner.

With Elixir, it’s built in. Use the mix command to generate a new app and you’re ready to go with a unit test. Run mix test to run the test suite. Done.

It even has conveniences like a test function that takes a quoted descriptive message as the name of the test.

test "extracts m3u8 from index file" do
  m3u8s = Streamers.extract_m3u8 index_file
  assert Enum.first(m3u8s) == Streamers.M3U8[program_id: 1, bandwidth: 110000, path: m3u8_sample]
  assert length(m3u8s) == 5
end

And it can run your tests concurrently with a single async option (docs).

Mind-blowing metaprogramming: `upcase`

One of the most ingenious techniques that José mentioned didn’t make it into the final cut of our video.

To capitalize a word, Elixir could implement a single upcase function that keeps a list of Unicode letters in memory and figures out how to translate between them.

Instead, it generates a function definition for each letter. They look roughly like this (source):

def upcase("é" <> rest) do
  ["É"] ++ upcase(rest)
end

A few things are going on here. Elixir can match functions on the number, type, and content of its arguments. So it looks for a letter such as é. It knows the upper case version of the letter, then sends the rest of the string to the next letter’s upcase function.

Pretty cool!

Conclusion

Elixir has many of the features that I look for in a programming language. Its authors have stolen useful features from other languages, it focuses on making it easier to write complex applications, and it has a healthy balance between performance and syntax.

Elixir isn’t the only way to write concurrent applications, but it’s definitely one I’ll be experimenting with for a few months. If you want to learn what it’s about, check out our fast-paced two hour video at PeepCode:

PeepCode iOS App Update: Fast Playback Option

Wed Jun 05 17:15:00 +0000 2013

This article is heavily styled and is best viewed at PeepCode!

by Geoffrey Grosenbach and Paula Lavalle

A new version of the PeepCode iOS app is free on the App Store! It fixes some bugs and adds a new useful feature.

Fast Playback

The 1.5x button plays downloaded videos much faster.

We’ve designed PeepCode videos to be consumed however you want to. Watch straight through to become familiar with a framework such as Ember.js (whether or not you choose to build anything with it). Or go step by step to interactively type along with the code in your text editor. Or relax after work watching Refactoring with Ben Orenstein on your TV.

And now there’s a new way: at 1.5x speed. Download a video in the app and you’ll see an extra button in the playback controls when you play a video you’ve downloaded.

We’ve already benefited from this on a recent plane flights to La Conf in Paris. We watched the 40 minute long Gallery CSS in about 25 minutes. Even less for Troubleshooting. Two hour Play by Play videos can be viewed in under an hour and a half.

Design & Implementation

Custom 1.5x button.

Fast playback isn’t built into the iOS movie player, so we had to build most of this from scratch. Our iOS developer built a new playback control with a spot for the 1.5x button. Our designer created a custom button that fits the color and style of the native buttons.

Should Apple implement fast playback in the future, we can revert to the native playback controls by changing a single line of code.

Someone already pointed out that this doesn’t work for streaming locally or to AppleTV. Would that even be possible? Our minds raced. We could re-encode all videos on the server at a faster speed and stream the faster version to AppleTV. Possible? Yes. Tell us if you would find this useful in a future update of the app.

Get the app on the App Store. Upgrade to PeepCode Unlimited for full-length download and streaming!

Did you know…if you’ve ever had a PeepCode Unlimited subscription, you can renew now for only $109! Or tell your employer to contact us for a business subscription.

Teaching Developers

Tue May 21 23:45:00 +0000 2013

This article is heavily styled and is best viewed at PeepCode!

Written by Geoffrey Grosenbach · Design by Paula Lavalle

The only thing more difficult than learning something new is teaching it.

At PeepCode, we put a lot of time into creating great explanations of difficult concepts. We won’t publish a video until we’re confident that it explains the topic better than anything else out there. And feedback from people who have viewed our videos on Ember.js, Ruby on Rails, JavaScript and other topics show that we’re doing just that.

Summary

Here’s some of what we’ve learned about explaining technical topics to developers.

Teach one thing at a time
Tell a story
Use appropriate terminology
Know your audience

The Goal

The goal of any tutorial is to get back into the mind of someone who doesn’t understand the topic. If an explanation only makes sense to people who already know what you know, then it’s not a very good explanation.

But that insight alone doesn’t tell you how to explain well. Instead, it might help to think about how developers go wrong when trying to explain a concept.

They try to teach too many things at once. This overwhelms the student.
They are disorganized. Teaching things out of order makes the student do too much work to sort it out in their mind.
They use the wrong words. Throwing an unknown term into an explanation can intimidate a student or even cause fear.
They don’t know who they are speaking to. I don’t know of any single explanation that works for all people at all levels of learning. When developers are unclear about their audience, they risk delivering ideas that will confuse everyone listening.

Here are four solutions to these problems.

Teach one thing at a time

This is the biggest problem I see, and it’s the first strategy you should use to improve your explanations.

Decide what you’re trying to teach, and only talk about that. You’ll have to intentionally block out the 10 other things you want to communicate. If a concept is important enough, dedicate a separate chapter, slide, or day to it. Then focus on the one thing you’re trying to teach right now.

This is extremely difficult for developers. We love details. We love to debate some tiny nuance of a program before it even runs. We like discovering edge cases that no one else has thought about.

And we’re afraid. We’re afraid that when we conclude a presentation, one person in the audience will be able to say “Hah! You forgot to mention X!” Or “You were wrong on this one point!”

To teach well, you need to get over these fears. You need to allow yourself to say something that’s 99% true, even if you know someone will correct you for the 1%. Because mentioning that 1% in your explanation will probably hinder you from sticking to teaching just one thing at a time.

To teach well, you need to abandon your insurance policy of saying “We’ll cover this other thing later.” That disclaimer is only there to comfort you, not to help the student. Teach the one thing you’re trying to teach now, then teach one other thing later when you’ve finished teaching the one thing you’re teaching now.

In fact, leaving out an important concept or saying something that’s only 99% true can be used to your advantage. It can help you tell a story.

Tell a story with problems and solutions

Stories are great because they hold our attention. The story could go anywhere, but we also have a hunch about what will happen next. That anticipation keeps our interest: “Will it turn out like I think it will, or will something unexpected happen?”

Malcolm Gladwell is a great storyteller. Many of his stories use problems as a way to hold attention and lead to a solution (or continue the cycle with another problem and another solution).

A person figured this thing out. But then they discovered they were partly wrong. And it gave them a new insight into how it really worked. So they applied that knowledge to something else. And then…

When explaining a technical concept, start with a partial explanation that’s easy to understand. In order to make it understandable, you might have to leave out some details. But filling in those details now becomes the next part of your story.

For example:

Solution: Fixtures are Rails’ built-in way for feeding data to your tests. They are a concise way to describe all the data your application needs.

Problem: But fixtures become difficult to maintain when you have many different pieces of data.

Solution: It turns out they aren’t the only way. There are also factories. Here’s how factories work…

Problem: But there’s a problem with factories…

So teach one concept at a time. If you have to leave out a glaring edge case or alternate option, use it to organize your thoughts into problems and solutions that lead from one to the other.

When you’re telling a story, you need to use words. But be careful what words you use…

Beware of Terminology

In every hobby, field of study, or domain, a set of words emerges.

Mountain bikers want to grin while flowing through chunder. Skateboarders are stoked about gnar. Philosophers try not to equivocate about their ideology. Agile developers want to be clean while they keep their objects dry.

These words—big and small—are shortcuts. They make it easy for experts to discuss advanced topics after they already understand the basics.

If you are teaching experts about advanced topics, then you should use these shortcut words.But if you are teaching people who are not experts, then using domain-specific language will confuse them.

For any term, one’s relationship to the word falls under one of these categories:

I have never heard it before, and have no idea what it means.
I have heard it a few times but don’t understand it.
I have a basic understanding of the word.
I have thorough understanding. It’s part of my vocabulary. I can use it to explain other concepts.

Part of your job as a teacher is to help students add new words to their vocabulary. Finding their place in the list above will help you know which words to teach, and which ones to use.

Know your audience

Finally, understand your audience. I’m mentioning it last, but it should happen first in your preparations.

Are you teaching beginners or experts? Backend programmers or front-end? People with a computer science degree or the self-taught?

This determines what terms you can use. Your professional audience will be frustrated if you spend large amounts of time explaining things they already know. Your beginner audience will be confused if you assume they are fluent in concepts they have never heard about.

This is the first part of your preparations for teaching, but is also the most uncertain. The people who show up for your presentation or consume your material online might not be the audience you prepared it for.

Conclusion

There is a massive need for great explanations on all kinds of topics. Without good explanations, many open source projects will fail. It’s pretty simple: if people don’t know to use your software, they won’t.

So teach one thing at a time that flows from one idea to another with the appropriate words for the intended audience.

And if you think you want to take a crack at explaining a technical topic, contact us. We’re always looking to pay skilled teachers to make videos for us!

Troubleshooting Strategies Poster

Thu May 09 12:10:00 +0000 2013

This article is heavily styled and is best viewed at PeepCode!

by Geoffrey Grosenbach

7 Strategies Video

Troubleshooting is a skill that transcends programming languages, frameworks, and even time.

My first few years of professional programming were full of frustration. I would frequently run into problems and have no clue about how to solve them. I treated them as unexpected and unwanted interruptions.

Now I know that encountering and fixing problems is part of the developer’s job description. It’s a rare day that ends without unexpected behavior from code, a deployment, or another library.

But with the right plan, these unexpected events can be resolved quickly. Here’s the order of events we use regularly at PeepCode:

Gather data
Isolate the fault
Form a hypothesis
Read the documentation
Describe the problem
Read the code
Try another angle

Free poster!

Download this free poster, print it out, and hang it on your office wall for easy reference. Works on US Letter or A4. Also available in color.

7 Strategies Poster

Or watch our video for explanations and stories behind these troubleshooting strategies.

Start a PeepCode subscription for $200 or renew for $109! Full access to all videos and our iOS app. Or tell your employer to contact us for a business subscription quote.

New Memes

Sat Apr 06 00:20:00 +0000 2013

This article is heavily styled and is best viewed at PeepCode!

by Geoffrey Grosenbach and Paula Lavalle

Oh man, I want a looping gif of @coreyhaines and @tenderlove doing the COMPUTERING motion at the same time.
— ashe dryden (@ashedryden) March 8, 2013

Wish granted! Use the following in your presentations, status updates, meme generators, or just for laughs!

Buy the full-length Play by Play or tell your boss to buy you a PeepCode Unlimited subscription for full access to all our videos and our iOS app.

COMPUTERING

Every day we’re computering.

Solo Computering

“This is how I program.”

High Five!

High five.

Bingo!

Aww yeah!

That’s the word!

“That’s the word!”

Cold Stare

Cold stare.

Stand back!

Whoa!

Facepalm

So the reason is…

What?

What? No. No.

Watch the full-length Play by Play with Aaron Patterson and Corey Haines

Did you know…if you’ve ever had a PeepCode Unlimited subscription, you can renew now for only $109! Or tell your employer to contact us for a business subscription.

The PeepCode iOS App

Fri Mar 22 02:03:00 +0000 2013

This article is heavily styled and is best viewed at PeepCode!

by Geoffrey Grosenbach and Paula Lavalle

From the It Just Makes Sense department

Stream to your Apple TV! We’re watching Play by Play with Corey Haines and Aaron Patterson.

As a bootstrapped company, it’s not always clear what the next step is, but an iOS app for viewing PeepCode videos has been one of the longest standing requests we’ve received. Which makes sense! It’s almost as if these devices were perfectly designed for watching PeepCode videos. The new iPhone 5 is the right dimensions for displaying HD video, which is what all our new videos have been filmed in since the end of last year (and some before that).

So we (finally) took the plunge and built an iOS app. We worked with expert iOS developer (and PeepCode author) Alex Vollmer of Radiant Capsule, and while he did most of the heavy lifting we certainly put in a lot of work and learned a lot along the way.

Solving the Progress Bar Problem

Download progress shows both percentage and remaining MB.

Desiging a good progress bar is famously difficult. Given that our audience is technical and speaks MB and GB, we settled on a great solution that works specifically for the content we’re delivering.

We decided to combine a standard progress bar with a numerical percentage. This works well for any videos under 100MB. But large videos might appear to be stalled if we can only show 100 points of progress. If a video is 500MB, it might take a minute or more to download 1/100th of it (5MB) and show progress.

So we also show you the number of MB remaining. This gives visual feedback that’s useful for videos larger than 100MB. The end result is that for any video you’ll download, progress is frequent and keeps you updated.

Delivering Instant Gratification

The UI shows progress in two steps.

One of the things we find frustrating about video streaming applications is all the waiting.

Starting an HTTP video stream can involve an API call, requests for 2 metadata files, and another request for a media file…all before you see a single frame of video.

We wanted to improve on that by showing you some progress along the way. So you’ll see an initial spinner when you click the “Play” button on the cover. When the first API call has completed, you’ll be taken to the video player where the video will start to stream.

Splitting progress into two visual steps makes the application feel more responsive than it would if we just sent you directly to the video player where you would have to wait for 5 or 10 seconds. It’s part of the attention we’ve put into the UI of this application to make it enjoyable to use.

Note: Video streams start at low quality while the device figures out what bandwidth is available. If you have a good Internet connection, you’ll see better quality video after a few seconds. We’re working on adding full HD streams to videos, too.

The Value of a Flaky Development Server

It’s not easy to bootstrap a multimedia application that requires client, server, and media.

Due to misbehaving third-party libraries, our first implementation of a video streaming server would sometimes monopolize 100% of the server’s CPU and hang, or never return a response at all. This was bad news for the iOS client application since it couldn’t get the data it needed to start streaming a video.

Or was it? The early flakiness forced Alex to add more error checking code to the iOS client, and better error messages for the user. And it forced us to write the server code to look for timeouts or blank API responses. Overall, it made our code more robust.

Brother Baba Budan, Melbourne

And yes, we rewrote the server so it doesn’t use 100% CPU anymore. In fact, it’s been smooth sailing since the launch.

Keeping it Simple

We’ve launched version 1.0 with a simple but straightforward feature set: PeepCode Unlimited subscribers can download or stream any video we’ve published in the last two years. We’re starting with only PeepCode Unlimited subscribers so we can fine-tune our streaming infrastructure and determine what mirrors we need around the world for a top notch download and streaming experience. So far everything has been running very well.

Anyone with a PeepCode account of any kind can use the app to stream previews of current videos.

Interesting Features

The app will remember the playback time of each video you’ve watched. If you have iCloud, it will sync that across all your devices. So you can watch part of Play by Play with Aaron Patterson and Corey Haines on your iPhone, then resume watching on your iPad at the same time in the video.
We’ve done extensive testing, literally all around the world (Seattle, Melbourne, Kauai, San Francisco). We hope to add video streaming mirrors for an even better experience.
Stream to your AppleTV with AirPlay. Play by Play looks fantastic on an HDTV.
Smart download doesn’t drain your battery if you leave the app. It resumes when you’ve re-launched the app and are back in Wi-Fi range. (Our developer tested this by walking down the street until he was out of range).
Download full quality videos or stream up to half resolution. Our new HD videos look amazing on the iPhone 5!
We built a custom, self-contained Sinatra server for streaming video. This will make it easier for us to deploy extra streaming or download servers around the world or whenever needed.
A series of command line scripts together with remote APIs makes it a breeze to encode video for all the necessary formats and copy it to our servers.

Try it!

We’re proud of this application, our first shipping iOS application. For a 1.0, it covers most of what’s needed for a great mobile experience.

Possibly the best evidence of how useful this application is was how much we started using it in-house! On the bus, at home streamed to an Apple TV, or on a plane. The last three months of rigorous testing and refinement have been a lot of fun.

Try it out with any PeepCode account. Or upgrade to PeepCode Unlimited for full-length streaming!

Did you know…if you’ve ever had a PeepCode Unlimited subscription, you can renew now for only $109! Or tell your employer to contact us for a business subscription.

Watch on the iPad, too!

Jake Mitchell is One of the Topfunky Ones

Fri Nov 30 21:15:00 +0000 2012

This article is heavily styled and is best viewed at PeepCode!

by Geoffrey Grosenbach

Software developers are hard to find. Good ones are even harder.

We’re fortunate to have found one.

Jake Mitchell has degrees in Computer Science and Mathematics. He’s a polyglot programmer with experience in many languages and frameworks. Jake’s the kind of person who you’ll find implementing a TIFF image parser in CoffeeScript that renders to the HTML canvas. For fun.

Jake started working full time at PeepCode about a month ago and has already implemented some useful backend code and started on a new video series for us. If you’ve ever wanted to understand how cryptography works, you’ll want to keep an eye out for it.

You can follow Jake on Twitter here. Subscribe to PeepCode here.

Jamming at the Pioneer Valley Roller Derby in Massachusetts. Photo by Susan Farber

Awesome Business Card

Tue Oct 30 16:45:00 +0000 2012

This article is heavily styled and is best viewed at PeepCode!

words Geoffrey Grosenbach

card design Paula Lavalle

While waiting in line to buy the original iPad, I gave someone my business card. He said it was an amazing card. In fact, it was the second best business card he had ever seen.

“Only the second best?” I asked. “What did the best one look like?”

“It was a plain looking card,” he said, “but if you sprinkled water on it for a week, it would grow grass in the shape of the company logo.”

I knew it was time to improve our game.

Refresh

Earlier this year we ran out of our old business cards. And PeepCode has grown since three years ago! We now have at least five people who need an awesome card to hand out at tech conferences, at nerd parties, and to random strangers.

We put our best designer on the job. We contracted Evolution Press for advice on paper, ink, foil, paint, and lead type.

Glossy black ink together with silver foil and white lettering make for a combination that can’t really be represented on screen.

Although it doesn’t contain any grass seeds (can you even take those through international customs?), we’re extremely happy with it.

We’ll be at Cascadia JS and other conferences in the next few months. Find us and ask for one!

Commanding Your Text Editor

Thu Oct 18 20:00:00 +0000 2012

This article is heavily styled and is best viewed at PeepCode!

words Geoffrey Grosenbach

design Paula Lavalle

The process of writing code is much different from the process of editing code. It’s easy to confuse the two since they both involve mashing buttons on a keyboard while staring at a computer screen.

Vim users know this already. Their editor works in two completely different ways depending on whether they are adding new words to a document or changing existing words.

They also know that there’s more to text editing than moving around with the arrow keys and selecting one letter at a time. But you don’t have to memorize hundreds of commands. I think only these six will handle most of the editing that you’ll do every day.

Delete whole words (before and after the cursor)
Create a newline and put the cursor there (above or below)
Search in a file
Switch files
Indent code automatically
Use completion

1. Delete Whole Words

Steve Yegge writes that it’s much faster to delete an entire word and retype it than it is to navigate to and correct a single letter (see his post on Effective Emacs).

There’s not much else to say here: learn to delete the word before the cursor and the word after the cursor. You’ll immediately find yourself using it constantly throughout the day.

This one is even built in to Mac OS X, so it works in any text editing application (Sublime Text, Pages, TextMate).

Mac OS X

Delete next word:

Delete previous word:

Vim

Delete next word:

Delete previous word:

Emacs (and Terminal)

Delete next word:

Delete previous word:

2. Add Lines

The novice learns to make a newline by moving the cursor to the end of the line and hitting the ENTER key. Or a newline above by moving the cursor up one line, to the end of that line, hitting ENTER, then indent…shouldn’t this be easier?

The Pro can add a newline above or below from any point in the line. You don’t have to move your cursor at all.

Textmate

Newline below

Vim

Newline below

Newline above

Emacs

Newline up/down snippet

Sublime Text

Newline below

Newline above

Thanks to Joaquin Vicente

3. In-file Search

Search isn’t just for finding words. It’s an efficient way to navigate.

And live search is much faster than using a search dialog. Hit the hotkey and start typing the word. BAM! You’re there. It’s great for navigation instead of using the arrow keys to navigate within a file.

Emacs-style Ctrl-s is also available in TextMate.

Textmate

Live search

Vim

Live search

Hit n to repeat search.

Emacs

Search foward:

Search backward:

Sublime Text

Search forward:

Hit Cmd-i again to repeat search.

4. Fuzzy File Search

Programming happens in files, usually several. TextMate’s fuzzy file search revolutionized my use of my text editor. But it only searches filenames, not directory paths.

This is why I wrote PeepOpen, and I still use it every day.

I think Sublime Text has the best built-in fuzzy file finder of any current text editor. It’s not initially clear that it does this, but it searches on paths as well as filenames. The search score on the left is completely useless to me, but the file and path are a huge improvement over TextMate.

TextMate

Search by filename

Vim

Search open buffers by filename

:b filename

Emacs

Search filenames (using PeepOpen or textmate.el)

Sublime Text

Built-in fuzzy file search

5. Automatic Indentation

Now we’re getting into more advanced features, but still ones that I use constantly.

When using languages without syntactically significant whitespace (e.g. CoffeeScript), I let the editor do the formatting for me. It works 90% of the time, and for the other 10% I’d rather modify my code to work with the built-in formatting than do it manually.

Most developers would refuse to use a text editor without syntax highlighting. To me, auto-indentation is a show stopping feature.

Textmate

For some languages only

Vim

Select a range with V

Emacs

cleanup-buffer

Bound to C-c n

Sublime Text

Only available with language-specific plugins

6. Completion

Let’s admit it: the simple text-based auto-completion in open source text editors doesn’t come close to matching Microsoft Visual Studio from a decade ago.

I hope that a decade from now, I can use a text editor that understands not only the words I’m typing, but their meaning within the application. Without bogging down the rest of the editor or toasting my battery, of course!

In the meantime, I like the way Emacs completes words from all open buffers. TextMate and Sublime Text are limited to only words in the current file, which rarely includes the keywords or methods I’m looking for.

Textmate

For current file only

Vim

Next completion

Previous completion

Emacs

Using dabbrev-expand

Sublime Text

Current file only

SPACE

Conclusion

Learning these basic text manipulations has improved my editing speed. More importantly, I spend less time thinking about my text editor and more time thinking about the content of the text itself.

Try it! I bet you’ll use each of these multiple times in the first day you learn to do them.

PeepCode's Birthday!

Sat Sep 22 01:00:00 +0000 2012

This article is heavily styled and is best viewed at PeepCode!

by Geoffrey Grosenbach

PeepCode is now 6 years old!

The last month has been a good sample of the excitement that has been happening for us this past year. In September we:

Published a live Play by Play design video and finished a draft of a new tutorial.
Moved into a small office suite in an artistic building a block from Seattle’s Pike Place Market. It’s an inspiring place shared by fashion designers, web developers, and CAD drafters.
Hired a full time Developer Educator to help us produce more tutorials and launch new kinds of videos. Jake Mitchell starts at PeepCode next month!
Gave a presentation at the new Seattle Sass Meetup.
Started a redesign of our website.

Vision

My title is Senior Visionary, which I take as a daily challenge.

It’s fulfilling to look back and see some of the people we’ve worked with over the last six years who have gone on to do even greater things.

In 2008 we published Scott Chacon’s book on Git Internals. He later went on to become a co-founder of GitHub.
In 2010 we launched the Play by Play series starting with Gary Bernhardt. I had watched him write code and knew that his unique skills were something that had to be experienced in real time. It was an immediate success and he went on to start his own business, Destroy All Software.
Earlier this year, Ben Schwarz published HTML5 Browser Caching with us and is now a member of the CSS Working Group on the W3C.

People

Two years ago, I was confident that I could run this business best if I operated on my own. Fortunately I discovered there’s a better way!

Right now, 8 employees and contractors work on PeepCode every week and I can’t imagine working without any one of them. We have skilled people who work on marketing, sales, development, finance, design, customer service, and production.

Adding their fresh ideas and hard work to my own has made a huge difference in the profitability of the business and the kinds of projects we can accomplish. Now that we’re adding our first full-time developer, we’ll be digging into our notebooks of ideas and launching some new ideas we’ve been waiting to work on!

Place

I like variety. In addition to traveling to and speaking at conferences, I enjoyed working without a fixed office for several years. It seemed like the way to go when running an online business with remote contractors.

But now that we have a consistent space to work from, I realize its value. Planning is much easier (every day starts at the office). And even though much of our work happens on screen, it still helps to have a fixed place to record drafts of new tutorials before they go out for transcription.

If you’re freelancing, working remotely, or starting a business, I highly recommend finding an office space to work from, even if only occasionally.

Our Supporters!

Thank you for subscribing to PeepCode and supporting our original productions over these years. We’re proud of the people we’ve promoted, the ideas we’ve brought to light, and the explanations we’ve delivered. Your support has made it happen!

Free PeepCode Blog

Elixir is for programmers

Smart assert

Multi-block control flow

Consistent use of do

Built-in TDD

Mind-blowing metaprogramming: upcase

Conclusion

PeepCode iOS App Update: Fast Playback Option

Fast Playback

Design & Implementation

Teaching Developers

Summary

The Goal

Teach one thing at a time

Tell a story with problems and solutions

Beware of Terminology

Know your audience

Conclusion

Troubleshooting Strategies Poster

Free poster!

New Memes

COMPUTERING

Solo Computering

High Five!

Bingo!

That’s the word!

Cold Stare

Stand back!

Facepalm

What?

The PeepCode iOS App

Solving the Progress Bar Problem

Delivering Instant Gratification

The Value of a Flaky Development Server

Keeping it Simple

Interesting Features

Try it!

Jake Mitchell is One of the Topfunky Ones

Awesome Business Card

Refresh

Commanding Your Text Editor

1. Delete Whole Words

Mac OS X

Vim

Emacs (and Terminal)

2. Add Lines

Textmate

Vim

Emacs

Sublime Text

3. In-file Search

Textmate

Vim

Emacs

Sublime Text

4. Fuzzy File Search

TextMate

Vim

Emacs

Sublime Text

5. Automatic Indentation

Textmate

Vim

Emacs

Sublime Text

6. Completion

Textmate

Vim

Emacs

Sublime Text

Conclusion

PeepCode's Birthday!

Vision

People

Place

Our Supporters!

Smart `assert`

Consistent use of `do`

Mind-blowing metaprogramming: `upcase`