We need you! Please consider supporting Clarkesworld via Patreon or with a digital subscription.

Science Fiction & Fantasy






Another Word:
It's Good to Be Lazy and Foolish

I’ve been employed in three professions that all involve working with a lot of text: programming, law, and creative writing. I’d like to show you what I’ve learned from the first two that I think can be helpful to writers.

Among software developers, there’s a generally accepted belief that the most productive programmers are lazy and dumb.


Okay, allow me to explain. Laziness is a virtue among programmers because lazy programmers are interested in doing their jobs in a way that maximizes using the creative parts of their brains and minimizes tasks that are better left to the machine.

Here’s an example.

Programmers are often faced with the need to modify text across many lines across multiple files in some systematic manner. This could be because of a change in the interface definition of a module (e.g.  all instances of GreatLibrary_procedure() now have to be changed to AwesomeLibrary_function()), because of a change in coding style or naming convention (so all instances of AwsomeLibrary_function() have to be changed to awesome_library_function()), or because of some quirk of the syntax of the language (e.g., in Python, indentation of lines is important for control flow, so frequently blocks of code have to be indented or unindented as a unit).

Text editors used by programmers are optimized to make many of these systematic changes easier, though one often has to learn arcane commands for how to invoke these capabilities (just look up vi and emacs). A programmer who is not lazy, who is focused on getting the job done and meeting the daily lines-of-code metric, will learn the minimum amount necessary, open up the files, and get to work. If that means pushing the tab key at the beginning of each line twenty times, or opening every file in a directory of three hundred and running the same search-and-replace sequence one by one, so be it. Two hours later, the changes are still not complete, and the programmer is suffering from carpal tunnel syndrome—and by the way, they missed a couple of files in this tedious process. But to the inexperienced manager, it seems the programmer is working hard.

The lazy programmer, on the other hand, will seem to hardly be working in the interim. They spend the time to learn the text editor. They study its commands and syntax and scripting language and support for regular expressions until they can wield it like a robotic servant. This process might take hours. But when they’re done, they’ll write a few lines of magical incantation, and voilà, all three hundred files will be changed perfectly and instantaneously.

The sort of laziness I’m praising, in other words, is an aversion for drudgery. It might be quicker in the short term to push the tab key twenty times in a row, but it’s more fun to learn how to use the macro system to accomplish the same thing in three or four keystrokes. Instead of copying-and-pasting a block of code, they’d rather refactor that into a separate function. Instead of extending and elaborating on a bad foundation, they prefer to rewrite the system from scratch so it’s more solid. Instead of doing things the way it has always been done, they prefer to find a more elegant and beautiful shortcut. Thus, they invest the time into intellectually stimulating tasks that may (or may not) pay off later, even if that means they won’t write the lines of code demanded of them that day.

So what about “dumb?” Rather than keep on using that word, which is probably outdated, I prefer to think of the quality I’m praising as “foolishness,” in the sense of “stay hungry, stay foolish.” This is related to the aversion of drudgery. Foolish programmers know that they’re not the best at their job and believe that there is probably a better way.

The foolishness that I’m praising is related to this aversion of drudgery. These types of programmers know that they’re not the best at their job and believe that there is probably a better way. They’re curious about new text editors, new programming languages, new design patterns, etc., because they think someone smarter has invented a way to do the job better, a way that they can adopt so that they can be even lazier.

When I became a lawyer, however, I found out that the way the profession approached text was very different (caveat, I’m obviously talking from my very limited experience in corporate law, and I must note that I generally had very positive experiences with my mentors). Lawyers seem intent on treating contracts as a patchwork of magical phrases that must be preserved exactly as they are, and laziness is actively discouraged. For example, if some complicated clause drafted with the typical pleonastic legalese (“sell, convey, license, lease, rent, assign, or otherwise transfer”) is needed multiple times in a contract—perhaps with minor variations—then the safe thing to do is to copy and paste that language everywhere and adapt as necessary, instead of refactoring into something more elegant. And if that means a great deal of drudgery for the associates and legal secretaries, that’s even better, because lawyers are paid by the billable hour.

To some degree, this is understandable, as lawyers live in perpetual fear that changing a single word in some well-worn bit of legalese will cause a judge to suddenly decide to give the clause a new interpretation. Besides, every lawyer lives in mortal fear of admitting that they don’t know something, and so being foolish is not even an option—the words from the form document must remain exactly as they are because they contain magic. Thus, refactoring is out, as is any attempt to make things more elegant and concise. When in doubt, just add more words and clauses to dangle from a rickety, unstable framework until contracts turn into messy, ridiculous structures full of hoarded junk that hasn’t been touched since the 18th century. But hey, that means even more copying-and-pasting and proofreading and reference checking and modifying for subject-verb agreement . . . and more billable hours!

I think writers should think more like programmers and less like lawyers. Instead of striving hard to meet some daily word count goal, I advocate giving yourself permission to be lazy. It’s fine to spend the time to work out worldbuilding details that will never go into the finished story because it’s intellectually stimulating and fun. It’s fine to think about how to accomplish characterization and worldbuiding, and advancing the plot all in the same scene, even if that means you end up writing fewer words that day. It’s fine to throw away a draft and start a new story from scratch if continuing to work on the flawed draft feels like drudgery and deprives you of joy. It’s more than fine to refuse to do the same thing you’ve done many times (and may have found success with) because it now feels tedious—better to be lazy and think of something new to try.

And it’s perfectly valid for writers to admit that they are foolish, that they don’t know what they’re doing. Such an attitude leaves one open to influences from everywhere, not just the right critiques or the best books. If you see a story resonating with readers but doing things in an unusual way, try to understand why it works. If you see writers succeed by following a different career path than you’ve envisioned for yourself, try to see if they have lessons to teach you. If you hear advice that is counterintuitive or sounds dumb, try to resist the urge to dismiss it out of hand and see if there is, in fact, something in it that you can learn.

Above all, don’t be like the lawyers who treat template contracts as sacred spells that must be preserved at all costs. Writing is a kind of magic, but it’s the living magic of making a connection between the reader’s mind and yours, not the dead magic of judges’ interpretations. Take risks; leave out things that “everyone” claims you must have; add in things that “no one” thinks will work; experiment; mix it up; rewrite the rules if you don’t like them; tell, if you don’t believe it should be shown; dare to boldly stick in that adverb, write the story that only you can write.

Tell a friend, share this on:

ISSUE 104, May 2015

Best Science Fiction of the Year

galactic empires

writers of the future


Ken Liu

Ken Liu is an author and translator of speculative fiction, as well as a lawyer and programmer. A winner of the Nebula, Hugo, and World Fantasy awards, he has been published in The Magazine of Fantasy & Science Fiction, Asimov's, Analog, Clarkesworld, Lightspeed, and Strange Horizons, among other places.

Ken's debut novel, The Grace of Kings (2015), is the first volume in a silkpunk epic fantasy series, The Dandelion Dynasty. It won the Locus Best First Novel Award and was a Nebula finalist. He subsequently published the second volume in the series, The Wall of Storms (2016) as well as a collection of short stories, The Paper Menagerie and Other Stories (2016).

In addition to his original fiction, Ken is also the translator of numerous literary and genre works from Chinese to English. His translation of The Three-Body Problem, by Liu Cixin, won the Hugo Award for Best Novel in 2015, the first translated novel ever to receive that honor. He also translated the third volume in Liu Cixin's series, Death's End (2016) and edited the first English-language anthology of contemporary Chinese science fiction, Invisible Planets (2016).

He lives with his family near Boston, Massachusetts.



Also by this Author



Amazon Kindle

Amazon Print Edition

Apple iBookstore



Weightless EPUB/MOBI