- It's all content
- Marking up plain text
- Converting plain text to HTML
This chapter is from the book
This chapter is from the book
This chapter is from the book
Marking up plain text
As Rieger pointed out, it’s not enough to simply use plain text. We need to structure our textual content with HTML. There are several ways to do this, from writing the HTML by hand in a text editor to using a WYSIWYG editor. However, my preference is plain text markup, for which I use Markdown, although many other plain text markup languages exist.1
Plain text markup languages like Markdown let you write text in a very human-readable way (similar to how you would write in a text-based email program) and offer you tools to convert this human-readable format to HTML quickly and easily. Simple conventions denote structure. For example, a hash symbol (#) in Markdown denotes a level 1 heading. A word enclosed in asterisks (*hello*) denotes emphasis, in the same way you might use italics in a word processor.
The best thing about using plain text markup is this: if your client or another party has created the content you’ll use in your design, using a plain text markup syntax means all you have to do is copy the textual content, paste it into a text editor, and make use of the simple markup conventions. This is much simpler than, say, turning the text into HTML by hand.
The book page text in Markdown
The following is some text we’ll use for the book site design. This is the minimum amount of content I’d like to use to communicate with visitors to the page. Save the following text (or your own example text) to your project folder and call it whatever you please. Since it represents the content of a home page, I’m calling it index.markdown.
# Responsive Design Workflowby Stephen HayIn our industry, everything changes quickly, usually for the better. We have more and better tools for creating websites and applications that work across multiple platforms. Oddly enough, design workflow hasn't changed much, and what has changed is often for worse. Through the years, increasing focus on bloated client deliverables has hurt both content and design, often reducing these disciplines to fill-in-the-blank and color-by-numbers exercises, respectively. Old-school workflow is simply not effective on our multiplatform web.Responsive Design Workflow explores:- A content-based approach to design workflow that's grounded in our multiplatform reality, not fixed-width Photoshop comps and overproduced wireframes.– How to avoid being surprised by the realities of multiplatform websites when practicing responsive web design.– How to better manage client expectations and development requirements.– A practical approach for designing in the browser.– A method of design documentation that will prove more useful than static Photoshop comps.## Purchase the bookResponsive Design Workflow is available in paperback or as an e-book. The book is available now and can be ordered through one of the booksellers below.– [Order from Amazon.com]– [Order from Peachpit Press]– [Order from Barnes & Noble]## Resources[Lists of resources per chapter?]## Errata[Lists of errata per chapter?]
Now this is interesting. In previous chapters, we discussed how problems can arise from insufficient thinking about how content will actually work—think back to the example where I “forgot” that we might need some sort of navigation. This may seem an unlikely example, but we’ve all experienced situations where we realize that things have been omitted or not thought through. Working in small steps from the content out can expose issues and avoid these problems. This Markdown document exposes a flaw in my thinking about resources and errata that becomes clear when we start designing the page in text. If I have both resources and errata for some of the same chapters, I’ll get something like this:
## Resources* [Chapter 1](http://www.example.com/resources/chapter1)* [Chapter 2](http://www.example.com/resources/chapter2)* [Chapter 3](http://www.example.com/resources/chapter3)## Errata* [Chapter 1](http://www.example.com/errata/chapter1)* [Chapter 2](http://www.example.com/errata/chapter2)* [Chapter 3](http://www.example.com/errata/chapter3)
Although this won’t get us arrested, it’s redundant. It makes more sense to have a page for each chapter, and having anything relevant to a given chapter on that particular chapter’s page. This means that I’m going to change my mind at this point in the process (clients tend to do that, as you probably know).
Keep in mind that any mind-changing going on at this point is not only not a problem, it’s also a good thing. Better to make content-related and structural changes now.
Instead of Resources and Errata, I want a list of chapters, with each item being a link to that particular chapter’s page, which can contain sections for Resources and Errata. Come to think of it, we’ll need to put up code samples as well, so the chapter pages are a great place to put those.
What changes mean at this point
Changes at this point in the process entail relatively non-labor-intensive edits to one or more of three things: the content inventory, the content reference wireframes, and the structured text design (that is, your Markdown document).
Of course, since our example is currently one page, changing these is simple. Remember that most websites, no matter how big, are a combination of user interfaces for interaction and containers for content that’s poured in from a database. The focus of the first three steps in this workflow is these larger entities: types of pages, types of user interfaces, and types of content. While you’re free to use these steps to design individual pages, you probably won’t want to do that for the individual articles in a site like nytimes.com.
Think in terms of types. Think in terms of components. There are never many page types, so don’t think too much about pages. One of my most challenging conversations with a client involved me explaining that I didn’t have to redesign their site’s 10,000 pages. Rather, we had to spend a lot of time analyzing their content, and then I would design about 10 or 12 pages (plus a battery of small components). I would be designing a system. Not individual pages.
The change I’ve made to the book page means there’s another page type, since the content of that page type dictates that it should be different than the home page. That last point is important. There’s been a lot written about designing the user interface first. I agree in most cases, but not all. The user interface serves a purpose and contains content relevant to that purpose.
Both purpose and content are the foundation of the interface. And that thinking is also part of the whole design process.
Before we make the changes to our example, let’s think about what these changes mean for us while utilizing the responsive workflow:
- We need to create a content inventory for the second page type and change the existing one accordingly. This would have to be done within any workflow that involves content inventories, not just the workflow described in this book.
- We need to create a new wireframe and modify the existing one. In plain English: we need to remove one box from our existing wireframe and create another HTML page with a few boxes on it. Oh, the pain.
- We need to change the last section of the Markdown document and create an additional one. Since we don’t actually have resources or errata yet, we’ll have to define the “shape” of that content by coming up with a real-world example we can test and discuss with the client.
These steps are not difficult. If you’re a graphic or visual designer, you may not find it exciting. In fact, someone else can do these steps. But that person is absolutely part of design, and as I mentioned previously, all parties should be involved. Yes, the client, too—especially the client. You’ll reap the benefits later.
Now, contrast this with the waterfall process. In the traditional workflow, there is no designing in text step. The wireframes are detailed and intricate. The content inventory may or may not exist. So the problems with changes start with wireframes. Sure, we need to change the text in the Markdown document, much as we’d change text in a complex wireframe. But the main difference is that when designing in text, the changes we make are text-based. Detailed wireframes contain text, but this text is still presented in a highly visual form in relation to other elements on the page. There may be no color, but there is typography. There is layout, to a certain extent. By contrast, plain text markup is all the same font and denotes only textual structure. Changes in a Markdown document don’t require typographical changes or changes in layout. New pages don’t require a new layout. We’re not at that point in our process yet, so changes are much easier to make.
Content reference wireframes are also very easy to change. After all, they’re just boxes, aren’t they? They become more important down the line, but for now, we’re compartmentalizing changes. Content changes should be content changes, not content-typography-layout changes.
This approach allows us to “help” the content. In return, content will help us down the line. Because we’ve given it the attention it deserves, it will help us with layout, with determining breakpoints, and with many other aspects of the design. There are always cases where huge changes to a project will come during the final stages of design, and this process is designed to minimize the chance of those changes occurring—and minimizing the impact of those changes if they do occur.
It’s about thinking
Again, the book page is a very simple example, but this could just as easily have been a sign-up page for a product or service (or any other page or component), where designing in text might help you make better decisions. As with content inventory and content reference wireframes, designing in text gives you an opportunity to change things before doing so endangers the schedule or results in high costs.
We’re designing in text here simply by putting text down in a Markdown document. That fact should make it clear that the process of designing in text is not about Markdown; it’s about thinking. It’s (as in the first two steps) about content and its structure.
Personally, this is one of my favorite steps in the workflow. The beauty is not only in its simplicity, but also in the fact that once you convert this document into HTML, you have a mobile-ready mockup of a web page in structured text that you can load into virtually any browser that parses HTML. This is a huge advantage.