“He did not aspire to be the first openly gay athlete in a major American team sport, but he is happy to start the conversation.”

That is the MO of Jason Collins, a 12-year NBA player, most recently playing for my Washington Wizards, who became the first athlete from a major American team sport to come out as gay while still playing.

 His announcement has received praise from the around the NBA, talk show hosts, those in entertainment and has even got a phone call from a Mr. You-Know-Who who lives at 1600 Pennsylvania Avenue.

We should point out that Jason Collins is not the first gay athlete, but he will be the one we will remember simply because he plays a sport that people care about.

Some are calling Jason Collins is a hero. We might rather save the term “hero” for those who show extraordinary bravery in times of fear.

If his coming out should mean anything to anyone, it should mean that no one should be afraid or ashamed of who they are. The average gay or lesbian is not a foreign entity or a creature from the black lagoon, but they can be anybody and everybody, even a 7 foot tall NBA center.

When the last American military forces exited Iraq in December 2011, they left in their wake a society fractured by sectarian strife. A year and a half later, the aftermath is little closer to being resolved than before—and that fact is continuing to exemplify itself in brutal ways.

This April earned a rather ugly distinction as the bloodiest month in Iraq since 2008. More than 700 people have been killed and scores more injured in this month.

They are just the latest victims of the ongoing conflict between supporters of Prime Minister Nouri al-Maliki’s Shiite government and members of Iraq’s Sunni majority.

In just one instance, 36 people were killed by car bombings in a Shiite section of Baghdad—the culmination of months of Sunni protests against the Shiite government.

The attacks have extended beyond the capital, however. Multiple provinces, as well as the cities of Fallujah and Hawija, have also born witness to bloodshed on both sides.

Aside from a potential indication of what is to come, the month of April of Iraq is just one more grim reminder of what America’s presence in Iraq yielded—or perhaps failed to yield, depending on your point of view.

It is but one more footnote to the eight-year conflict’s legacy—alongside thousands more dead or displaced, billions of dollars in war-costs, a broken democracy, and a country seemingly without direction. It will by no means be the last.

From The Verge

Could you live a year without the Internet?

Paul Miller, a blogger for the tech site The Verge, asked himself that question…

Then gave it a try.

From May 1, 2012, to the first of this month, Miller completely unplugged himself; no Twitter, no Facebook, no e-mail. He filled his days the old-fashioned way, reading books made of paper instead of pixels and using real facial expressions instead of emoticons.

According to Miller, the first few months were everything he thought they could be, and more. 

My life was full of serendipitous events: real life meetings, frisbee, bike rides, and Greek literature… I lost 15 pounds without really trying. I bought some new clothes. People kept telling me how good I looked, how happy I seemed. As my head uncluttered, my attention span expanded.

But then, as time went on, he began to settle into a whole different rut. 

By late 2012, I’d learned how to make a new style of wrong choices off the Internet. I abandoned my positive offline habits, and discovered new offline vices. Instead of taking boredom and lack of stimulation and turning them into learning and creativity, I turned toward passive consumption and social retreat.

Miller goes on to detail how he began to lose touch with the world around him, failing to answer letters and voicemails and just generally being left behind by our fast-paced digital society today.

Paul Miller’s experiment was by no means a scientific one, and as a blogger by trade his experience sans-World Wide Web likely differs vastly from Joe Schmo’s.

But, it does raise an interesting question about our society as a whole. Do we spend too much time on the Internet? Is there such a thing as too connected?

There are arguments to be made on both sides. Advocates for unplugging argue that hours upon hours of productivity are lost sitting in front of a screen looking at pictures of  animals in peoples’ clothing or giving their friends electronic thumbs-ups.

The electronic wunderkinds, on the other hand, claim that the Internet makes tasks so easy that people can afford to waste that time.

If we can learn anything from Miller’s experiment, it’s that a change in one’s daily routine is almost always for the better.

Do you spend too much time online? Are you in a rut? Let us know how you feel in the comments below!

I’ve always had trouble getting large groups of shapes from Illustrator over to Photoshop without rasterizing them all in the process. Up until recently the only way I knew how was to copy and paste each shape one by one – a process which soon becomes tedious.

However, recently I discovered a method which takes less than a minute, regardless of how many shapes there are in your file. The only catch is that it involves using Adobe Fireworks.

Here’s a simple three step guide on how it’s done.

Step 1

Once you’re ready to convert your Illustrator file into a fully editable PSD make sure all strokes are outlined. To do this select all of your strokes and click Object > Path > Outline Stroke.  Don’t worry about text as it will remain editable across all formats.

After you’ve done that open your Illustrator file in Adobe Fireworks and the following dialogue box will appear:

 Make sure all of your settings match the image above and click OK.

Step 2

Now that you have your file open in Fireworks you can convert it to a PSD by clicking File > Save As and then selecting the format Photoshop PSD (.psd) from the dropdown menu.

Once you’ve done that, click Options and make sure Maintain Edibility over Appearance is selected from the dropdown menu.

ClickOK followed by Save and then select where you want to save your file.

Step 3

Find your recently saved PSD, open it up in Photoshop and there we have it – a fully editable PSD in a matter of seconds.

Don’t forget if you need a something a little more organised you can rename your layers or paths at any time.

Did you find this helpful or do you have an alternative trick up you sleeve? What other tips would you share for working with Illustrator and Photoshop? Let us know in the comments.

Mighty Mac Bundle – 5 Incredible Mac Apps for only $12!

Do you need to monitor your Linux server’s performance? Most Linux distributions come equipped with many built-in monitoring tools. These tools allow you to retrieve information about system activities, and can be used to find possible causes for your server’s performance issues.

The commands discussed in this article are some of the most basic commands when it comes to system analysis and debugging server issues, such as discovering disk, CPU, memory and network bottlenecks.

1 - top – The Process Activity Command

The top command provides a dynamic, real-time view of the running system (i.e. actual process activity). By default, it displays the most CPU-intensive tasks running on the server and updates the list every five seconds.

Commonly Used Hot Keys

Most Linux distributions come equipped with many built-in monitoring tools.

There are several useful hot keys used with the top command:

• t — toggles summary information off and on.
• m — toggles memory information off and on.
• A — sorts the display by top consumers of various system resources. This is useful for quickly identifying performance-hungry tasks.
• f — enters an interactive configuration screen for top. It’s helpful for configuring top for a specific task.
• o — enables you to interactively select the order of the displayed fields.
• r — issues the renice command.
• k — issues the kill command.
• z — toggles between color and monochrome.

2 - vmstat – System Activity, Hardware and System Information

The vmstat command reports virtual memory statistics: processes, memory, paging, block IO, traps and cpu activity.

Syntax:

# vmstat 3

Sample output:

    procs -----------memory---------- ---swap-- -----io---- --system-- -----cpu------
        r b swpd free buff cache si so bi bo in cs us sy id wa st
        0 0 0 2540988 522188 5130400 0 0 2 32 4 2 4 1 96 0 0
        1 0 0 2540988 522188 5130400 0 0 0 720 1199 665 1 0 99 0 0
        0 0 0 2540956 522188 5130400 0 0 0 0 1151 1569 4 1 95 0 0
        0 0 0 2540956 522188 5130500 0 0 0 6 1117 439 1 0 99 0 0
        0 0 0 2540940 522188 5130512 0 0 0 536 1189 932 1 0 98 0 0
        0 0 0 2538444 522188 5130588 0 0 0 0 1187 1417 4 1 96 0 0
        0 0 0 2490060 522188 5130640 0 0 0 18 1253 1123 5 1 94 0 0 
    

Display memory utilization slabinfo with the following command:

# vmstat -m

And you can retrieve information about active and inactive memory pages with:

# vmstat -a

3 - w – Logged In Users

The w command displays information about the currently logged in users and their processes. Its syntax is:

    # w [user]
    

Running this command gives you output similar to the following:

    17:58:47 up 5 days, 20:28, 2 users, load average: 0.36, 0.26, 0.24
        USER TTY FROM LOGIN@ IDLE JCPU PCPU WHAT
        root pts/0 10.1.3.145 14:55 5.00s 0.04s 0.02s vim /etc/resolv.conf
        root pts/1 10.1.3.145 17:43 0.00s 0.03s 0.00s w
    

4 - uptime – System Uptime

The uptime command not only displays the amount of time the server has been running, but the current time, how many users are currently logged on and the system load average for the past 1, 5, and 15 minutes.

# uptime

Its output will look similar to:

11:57:40 up 96 days, 17:23,  0 users,  load average: 1.17, 1.15, 1.14

5 - ps – The Processes

The ps command reports a snapshot of the current processes. To select all processes, use the -A or -e option.

# ps -A

Running this command on your system will provide similar results to the following:

     PID TTY          TIME CMD
        6538 ?        00:00:00 anytermd
        6543 pts/4    00:00:00 bash
        6855 pts/4    00:00:00 ps
    

To show long format output, add “l” at the end:

# ps -Al

Turn on extra-full mode to show the command line arguments passed to the processes by adding “F”:

# ps -AlF

Add an “H” to see threads (LWP and NLWP):

# ps -AlFH

To see threads after processes, add “m”:

# ps -AlLm

Or print a process tree:

    # ps -ejH
        # ps axjf
        # pstree
    

Display only the process IDs of lighttpd:

# ps -C lighttpd -o pid=

Or:

# pgrep lighttpd

You can also find the top ten processes using the most CPU with:

# ps -auxf | sort -nr -k 3 | head -10

6 - free – Memory Usage

The free command displays the total amount of physical and swap memory in the system, as well as the buffers used by the kernel.

# free

This simple command’s output looks like:

    total used free shared buffers cached
        Mem: 12302896 9739664 2563232 0 523124 5154740
        -/+ buffers/cache: 4061800 8241096
        Swap: 1052248 0 1052248
    

7 - iostat – Average CPU Load and Disk Activity

The iostat command reports CPU and input/output statistics for devices, partitions and network filesystems (NFS).

# iostat

And the obligatory sample output:

    Linux 3.4.5-hardened-v3 (tryit)         12/14/12        _i686_  (1 CPU)
     
        avg-cpu:  %user   %nice  %system %iowait  %steal  %idle
                   2.47    6.52    2.54    1.57    0.00   86.90
         
        Device:            tps    kB_read/s    kB_wrtn/s    kB_read    kB_wrtn
    

8 - sar – Collect and Report System Activity

The sar command collects, reports and saves system activity information. To see the network counter, enter:

# sar -n DEV | more

To display the network counters from the 24th:

# sar -n DEV -f /var/log/sa/sa24 | more

You can also display real time usage using sar:

# sar 4 5

Sample output:

    Linux 3.4.5-hardened-v3 (tryit)         12/14/12        _i686_  (1 CPU)
     
        12:45:25        CPU     %user     %nice   %system   %iowait    %steal     %idle
        12:45:29        all      0.43     19.70      1.07      0.00      0.00     78.80
        12:45:33        all      0.43     19.35      1.51      1.51      0.00     77.20
        12:45:37        all      0.43     18.49      1.94      0.00      0.00     79.14
        12:45:41        all      0.43     19.02      2.14      0.00      0.00     78.42
        12:45:45        all      0.65     18.49      2.37      0.00      0.00     78.49
        Average:        all      0.47     19.01      1.80      0.30      0.00     78.41
    

9 - mpstat – Multi-processor Usage

The mpstat command displays each available processor’s activities, with processor 0 being the first. Use the following command to display the average CPU utilization per processor:

# mpstat -P ALL

And this is the output:

    Linux 3.4.5-hardened-v3 (tryit)         12/14/12        _i686_  (1 CPU)
     
        12:47:46     CPU    %usr   %nice    %sys %iowait    %irq   %soft  %steal  %guest    %idle
        12:47:46     all    2.47    6.52    1.48    1.57    0.00    1.06    0.00    0.00    86.90
        12:47:46       0    2.47    6.52    1.48    1.57    0.00    1.06    0.00    0.00    86.90
    

10 - pmap – Process Memory Usage

The pmap command reports the memory map of a process. Use this command to find the causes of memory bottlenecks.

# pmap -d PID

To display process memory information for pid # 47394, enter:

# pmap -d 47394

Sample output:

    47394: /usr/bin/php-cgi
        Address Kbytes Mode Offset Device Mapping
        0000000000400000 2584 r-x-- 0000000000000000 008:00002 php-cgi
        0000000000886000 140 rw--- 0000000000286000 008:00002 php-cgi
        00000000008a9000 52 rw--- 00000000008a9000 000:00000 [ anon ]
        0000000000aa8000 76 rw--- 00000000002a8000 008:00002 php-cgi
        000000000f678000 1980 rw--- 000000000f678000 000:00000 [ anon ]
        000000314a600000 112 r-x-- 0000000000000000 008:00002 ld-2.5.so
        000000314a81b000 4 r---- 000000000001b000 008:00002 ld-2.5.so
        000000314a81c000 4 rw--- 000000000001c000 008:00002 ld-2.5.so
        000000314aa00000 1328 r-x-- 0000000000000000 008:00002 libc-2.5.so
        000000314ab4c000 2048 ----- 000000000014c000 008:00002 libc-2.5.so
        .....
        ......
        ..
        00002af8d48fd000 4 rw--- 0000000000006000 008:00002 xsl.so
        00002af8d490c000 40 r-x-- 0000000000000000 008:00002 libnss_files-2.5.so
        00002af8d4916000 2044 ----- 000000000000a000 008:00002 libnss_files-2.5.so
        00002af8d4b15000 4 r---- 0000000000009000 008:00002 libnss_files-2.5.so
        00002af8d4b16000 4 rw--- 000000000000a000 008:00002 libnss_files-2.5.so
        00002af8d4b17000 768000 rw-s- 0000000000000000 000:00009 zero (deleted)
        00007fffc95fe000 84 rw--- 00007ffffffea000 000:00000 [ stack ]
        ffffffffff600000 8192 ----- 0000000000000000 000:00000 [ anon ]
        mapped: 933712K writeable/private: 4304K shared: 768000K
    

The last line is very important:

mapped: 933712K total amount of memory mapped to files
    writeable/private: 4304K the amount of private address space
    shared: 768000K the amount of address space this process is sharing with others
    

11 - netstat – Network Statistics

The netstat command displays both incoming and outgoing network connections, routing tables and a number of network interface statistics. It is available on Unix, Unix-like systems, and Windows NT-based operating systems.

 # netstat 

12 - iptraf – Real-time Network Statistics

The iptraf command is an colorful, interactive IP LAN monitor. It is an ncurses-based IP LAN monitor that generates various network statistics including TCP info, UDP counts, ICMP and OSPF information, Ethernet load info, node stats, IP checksum errors and more. It can provide the following info in easy to read format:

• Network traffic statistics by TCP connection.
• IP traffic statistics by network interface.
• Network traffic statistics by protocol.
• Network traffic statistics by TCP/UDP port and packet size.
• Network traffic statistics by Layer2 address.

13 - tcpdump – Detailed Network Traffic Analysis

The tcpdump is a simple command that dumps a network’s traffic. You need, however, a good understanding of the TCP/IP protocol in order to use this tool. For example, to display traffic info about DNS, enter:

 # tcpdump -i eth1 'udp port 53'

To display all IPv4 HTTP packets from port 80 (i.e. print only packets that contain data; not, for example, SYN abd FIN packets and ACK-only packets), enter:

 # tcpdump 'tcp port 80 and (((ip[2:2] - ((ip[0]&0xf)<<2)) - ((tcp[12]&0xf0)>>2)) != 0)'

To display all HTTP sessions to 192.168.1.5:

# tcpdump -ni eth0 'dst 192.168.1.5 and tcp and port http'

14 - strace – System Calls

The strace command traces system calls and signals. This is useful for debugging the webserver and other server problems.

The following command runs strace against /bin/foo and captures its output to output.txt:

 # strace -o output.txt /bin/foo

15 - /proc – Various Kernel Statistics

The /proc file system provides detailed information about various hardware devices and other Linux kernel information. Common /proc examples are:

    # cat /proc/cpuinfo
        # cat /proc/meminfo
        # cat /proc/zoneinfo
        # cat /proc/mounts 
    

Conclusion

And there you have it: fifteen useful commands that let you monitor different aspects of your Linux system. Naturally, these commands are only a small subset of the many that Linux provides. But for day to day operations, they are usually enough.

Have a favorite command? Let’s keep the conversation going within the comments area.

by Jessica McNeely and Mollie Sprung

Responsive design is about more than just layout; it’s about designing for the Web, which means, mostly, for people with browsers. And that’s just about everything we know about the people who visit our websites: they are probably using a browser. All the rest we just don’t know.

Up until not so long ago, we used to base our designs on some rather general assumptions about screen size and input type. With the rise of devices with various screen sizes and alternative ways to interact, these assumptions have turned out to be unreliable. We need to upgrade the defaults that we use when we start designing our websites.

A Closer Look

People keep saying that the Web has changed. But has it really? Let’s take a look at all of the things that have actually changed.

Screen Sizes

In the 1990s, the Web was 640 pixels wide. In the early 2000s, it grew to 800 pixels. A few years later, we decided it should be 1024 pixels. But five years ago, all of a sudden, something strange happened. A device with a very small screen entered the market. Suddenly, our ideas about the size of the Web did not work anymore. Later on, tablets entered the market. People hold these things however they want. Today, the height of the viewport could be bigger than the width! But is that new? Not really.

Screen sizes, shown in a non-flexible medium. (Photo and work: Aram Bartholl)

We never really knew what size the window of our visitors would be. We just assumed it was at least the random pixel width that we felt comfortable with. These numbers were always arbitrary, and there were always people who could not see the entire website. We simply ignored them.

“Everyone Has a Mouse”

We’ve always assumed that everyone uses a mouse. Even though we knew that this was not always true, most designs completely ignored alternative ways of interacting. People who had to use a keyboard, for whatever reason, had a very hard time interacting with our websites.

But because most people did use a mouse, and because back then many designers thought that designing only for the majority was OK, we created websites that were unusable for a lot of people. And this turned out to be a growing number. Many mouseover interactions are completely dysfunctional on a touch device. Because people love these devices, and even managers and designers use them, they are harder to ignore.

“Everyone Has Broadband Internet”

Another thing we always assumed was that everyone had a super-fast Internet connection, at least as fast as our own. And if they didn’t already have it, they’d have it soon. This was again mostly true; speeds were increasing. But today, more and more people use crappy, unreliable 3G connections all the time. If you’ve ever travelled on a train in The Netherlands, you know what I mean. And if you’ve ever had to rely on the mythical “free hotel Wi-Fi,” then you know for sure that the assumption about the ever-increasing speed of our Internet connections is just not true. This is a big change in our thinking; we really should consider these users. This will have a major impact on what our designs look like.

“Everyone’s Computer Gets Faster Every Year”

It used to be true that computers would get faster and faster. If you waited half a year before buying a computer, you would get one that was twice as fast, for the same price. This was true of new desktop computers, but mobile devices have priorities other than processor speed. The most important thing for a phone, for instance, is battery life: you really don’t want to have to charge it after every phone call.

And there’s another trend: instead of creating ever-faster devices, many manufacturers are starting to sell ever-cheaper devices. Many people care about price and battery life more than about processor speed. This is also not new: what happened to your old computers? You probably sold them or gave them away. People keep using old stuff. Not everyone has the same hardware as we designers do.

“All Monitors Are Calibrated”

Well, we always knew this to be untrue, right? Only the monitors of visual professionals are calibrated. Most other monitors don’t display colors accurately, and many monitors are downright crappy. Most mobile phones that I’ve tested have pretty decent screens, until you start using them outside, in the sunshine. If you’re lucky, you can read the content, but you definitely cannot see the subtle gradients in low-contrast designs.

I haven’t even mentioned “modern” black and white screens. These, too, are not new. People have always used crappy monitors, and people with bad eyesight have always visited your websites. It’s just that more and more people are seeing a subpar color palette. Instead of buying a state of the art monitor, buying a cheap monitor and several low-end devices to test your work on might be a better investment.

All of these things are not new. In 2002, John Allsopp wrote the monumental article “A Dao of Web Design.” People such as Jeremy Keith and Roger Johansson have written about all of these facts for years and years. And yet, somehow, we’ve always managed to actively ignore them. But we really can’t anymore. The Web actually did change in the last five years, with new devices, new browsers and many, many cool new features. We need new defaults. The old ways of creating websites just don’t work anymore.

This Is Responsive, the excellent resource about responsive design by Brad Frost.

In the past few years, we’ve been actively researching new ways to deal with all of these different screen sizes. But apart from responsive design, there are many more challenges in today’s ever-growing pile of devices. We have to find new patterns of interaction: we need interfaces that work on any device. Maybe we have to reconsider that enormous photo carousel on the home page, now that we know that not everyone has a cheap and fast connection. New defaults are emerging, and I’ve collected a few for you here.

The things in this article are not new. Many clever people have written about them in many articles and many books. But these ideas, like all good stories, have to be repeated many times so that people understand and remember them.

New Default: Activate

I initially titled this section “New Default: Touch.” But I came to realize that “touch” has a different meaning for everyone. Some people, like me, think of a single tap when we hear the word. Others think about swiping and complex gestures. That’s why I settled on the heading “New Defaults: Activate.” All devices, no matter what kind of input they offer, let the user activate something in some way.

With a mouse, it’s a click; with a touch device, it’s a tap; on a keyboard, it’s the “Enter” key. There are ways to activate things by voice, and by waving your arms in the air. And many devices offer more than one way to interact. The only thing that all of these devices have in common is the action of activating. Most of them are capable of doing many other things, too, but all of them can activate stuff.

Only recently have we really started thinking about alternative methods of user input. We used to assume that everyone uses a mouse. Hiding content and showing it on mouseover was considered to be a decent design pattern. And it used to work for most people — until all of these wonderful touch devices entered the market. What should a device without a mouse do when content can be revealed only with a mouse? Different devices have different solutions. Let’s look at a simple drop-down menu.

See a live example of this navigation pattern.

When you hover over a menu item, a submenu appears. But apart from hovering over an item, you can also simply click on it to follow the link. Now, what should happen when you tap on the item with a touch device? Should the submenus appear, or should the link activate? Or both? Or should something else happen? On iOS, something else happens. The first time you tap a link like that, the submenu appears; in other words, the hover event fires. You have to tap a second time to actually follow the link. This is confusing, and not many people will tap a second time. On Android, the submenu appears and the link is followed simultaneously. I don’t have to explain to you that this is confusing.

It’s very well possible to think of complex solutions whereby you define different interactions for different input devices. But the better solution, I think, is to make sure that the default interaction, the activate event, just works for everybody. If you really need to, you could choose to enhance this default experience for certain users.

For instance, if you are certain that someone is using a mouse, you could enable some mouseover interactions. Or if you’re sure that someone has fat fingers, you could make small buttons a bit bigger. But only do so in addition to the default activate interaction, and only if there’s no doubt about it, and only if the enhancement would really make things better. Those are quite a few ifs, and some of them, such as the mouse usage, are very hard to detect — especially on devices that offer more than one way to interact, such as a laptop with an optional mouse, touch pad, camera, microphone, keyboard and touchscreen. Give it some serious thought. Do you really need to optimize for a mouse?

New Default: Small Screens

Growing is easy. Most things grow. Babies grow, trees grow, curious minds grow. They don’t grow by themselves, but you don’t need much energy to make things bigger. This is just what things do when they live. While shrinking things is definitely possible, it’s also much harder. You could, for instance, compress a car to a fraction of its original size. A compressed car does have a certain aesthetic appeal to it, but it is definitely not as useful as it was before. The same goes for websites. Shrinking a desktop website does not always result in a pleasant experience on a small screen.

Cedro di Versailles by Italian artist Giuseppe Penone clearly shows that things grow. On the other hand, the work Papalote Goliad by American artist John Chamberlain shows that shrinking can be aesthetically appealing but may result in less useful results.

To build a responsive website that works on all kinds of screens, designing for a small screen first is easiest. It forces you to focus on what’s really important: if it doesn’t fit in this small square, it is probably not terribly important. It forces you to think better about hierarchy, about the right order of components on the page.

The same principle that we follow for interactions — whereby we design the activate event first and enhance it later — applies to graphic design. We should start designing the things that we know everyone will see. That’s the content. No matter how big or small a screen is and no matter how minimal the feature set of a browser, it will be able to show letters. Because this is about the only thing we know for certain — since color is absent on most Kindles, most of the latest CSS doesn’t work on old browsers, and layout is of minor importance on small screens — starting with the text is logical.

I wrote an in-depth article about defining breakpoints on the basis of typography, so I won’t repeat every detail here. But the basic idea is that you start by designing the relationship between the different font sizes. Almost everyone, no matter what device they have, will be able to see this. When the typography is done, you would start designing the layout for bigger screens; you can think of this as an enhancement for people with bigger screens. And after that, when the different layouts are done, you could add the paint. And by paint, I mean color, gradients, borders, etc.

I’ve presented this as a very strict way of working; in real life, of course, things are not as rigid. I’m not talking about “activate only” or “small screen only.” When I say to start with typography, I don’t mean that you aren’t allowed to think about paint at the same time. Rather, I’m trying to find the things that all of these different devices, with all of their different screen sizes and all of their different features, have in common. It just seems logical to first design this shared core thoroughly. The strange thing is that this core is often overlooked: Web professionals tend to view their own creations with top-of-the-line devices with up-to-date browsers. They see only the enhancements. The shared core with the basic experience is often invisible.

New Default: Content

The way we designed our websites until recently was by putting a header with the logo and navigation at the top, putting the subnavigation on the left, putting some widgets on the right, and putting the footer at the bottom. When all of that was done, we’d cram the content into the little space that was left in the middle. All of the things we created first — the navigation, the widgets, the footer — they all helped the visitor to leave the page. But the visitor probably wanted to be there! That was weird. It was as if we were not so confident in our own content and tried our best to come up with something else that our guests might like.

But rather than pollute the page with all kinds of links to get people out of there, we should really focus on that thing in the middle. Make sure it works. Make sure it looks good. Make sure it’s readable. Make sure people will understand it and find it useful. Perhaps even delight them with it!

Once you’re done with the content, you can start to ask yourself whether this content needs a header. Or a logo. Or subnavigation. Does it need navigation at all? And does it really need all of those widgets? The answer to that last question is “No.” I’ve never understood what those widgets are for. I have never seen a useful widget. I have never seen a widget that’s better than white space.

Compare a typical news website’s attention to widgets with Medium’s complete focus on content.

By starting with the content first, you can come up with some very interesting solutions. For instance, does the logo really need to be at the top of every page? It could very well go in the footer on many websites; such as in digital style guides or on pages for registered users. Many links that we used to put in the subnavigation might work better in relevant spots in the main content.

For instance, the option to add extra luggage to a flight booking might be most effective right there in the overview of the flight, instead of in the middle of a list of links somewhere on the left of the page. And when looking at the hierarchy of a page, does the main navigation look more important than the main content? Most of the time it shouldn’t be, and I usually consider the navigation to be footer content. A simple “skip” link at the top of the page could either take the visitor to the navigation or fetch the navigation and show it at the top of the page.

In this era of responsive Web design, we need many new clever solutions. As we’ve seen here, our old defaults don’t work anymore. We need to reconsider how we work with interaction, how we approach design and how we shape our content. But we need to think about one other very important thing, and that is where our content comes from.

New Default: The API

Luke Wroblewski wrote a fantastic article about designing an application for the command line first, and then enhancing it for different needs. This is not just a nerdy idea, but a very practical idea, too. If you are able to design and develop your own application, you could test the functionality relatively easily before even starting to think about what it will look like on different devices. This requires designers to work with developers to design a feature that at first works only from the command line. If the feature does not work as expected, then you merely have to change the API, rather than also a bunch of visual designs. Once the API works as you want it to, enhancing it for all of the devices and screen sizes that you want to support becomes easier.

Most of the time, you wouldn’t design the entire API of the application that you’re building. Most companies would choose a content management system (CMS) of sorts or a specialized tool to help them achieve what they want to do. I’ve always been amazed that CMSes are so often chosen only by technical people and business people. This causes many problems during the design process.

Developers and business people have different goals than designers. Developers want stuff that is easy to develop on. Business people want stuff that’s cheap. But designers want to make the best and most beautiful things possible. These goals can easily conflict.

I’m not saying that designers alone should choose the system, but they should definitely be a part of the decision-making process. I’m convinced that the selection of CMSes will improve. And I’m convinced that CMS makers will start to improve their products once designers get involved. Right now, all CMSes I know of deliver hostile cruft unless you tweak them extensively.

But it works the other way around, too. If designers are involved in the selection process, they will have a say in the choice of tool and will understand how it works, what’s possible, what’s easy and what’s hard. This will result in designs that are based in part on the tool, not just on imagination. This is an important part of the design process that has not yet been optimized. Right now, the command line and the systems that deliver the content we design for are the domain of the developers, and designers have nothing to do with them. That is a pity. Just as you would want to take advantage of the knowledge of developers in the design process, you would want to take advantage of the knowledge of designers in the development process.

Progressive Enhancement

If you review the sections above, you’ll see that what I’ve described is nothing other than progressive enhancement. You start with the content, then design the content and optimize it for different screen sizes and devices, and after that you can further optimize for very specific features such as mouse usage and fat fingers. Many Web developers build websites according to this principle. They transform the beautiful Photoshop documents that they receive into all of the different layers described above.

This can work out fine if the developer has a good sense of design and a delicate attention to detail. But if they don’t — which is often the case — this can easily result in crappy usability and ugly details. I’m not saying that designers shouldn’t use Photoshop anymore. If that’s your tool, go ahead and use it. But do remember that you’re designing the layers of the Web, not the layers in Photoshop. There’s much more to the Web than a single beautiful image. People will see our creations in innumerable ways. We design for all of these people — remember that. We don’t just design for the CEO with a laptop. We also design for the people on the train and the people with “free hotel Wi-Fi.”

Tools

I’ve mentioned Photoshop a few times because it’s still widely misused for designing websites. One reason we have a hard time with progressive enhancement in the design process is due to a lack of good Web design tools. The tools we use are built to wow; they mostly help you to create the “paint,” not to design the core. Fortunately, more tools are popping up with very specific functions in the design process. These are micro-tools such as the International Measure Slider, which helps you to define breakpoints in your grid; tools such as Gridset, which helps you to create grids for different screen sizes; and excellent tools that help you to define typography. By incorporating these tools into our design workflow, we might start making better stuff.

Conclusion

The Web has always been a weird, borderless, flexible medium. In the last couple of years, we’ve started to realize that designing for this medium is fundamentally different from the design work we’ve done previously. The fixed dimensions and the singular ways of interacting that formed the basis of all types of media that we’ve worked with for centuries just don’t work on the Web. This truly is a unique medium.

We have to find new defaults, new starting points for our design process. I’ve explained some of these new defaults here, but of course there are many more. The way we work with forms, for instance, could probably use a whole series of articles by itself. Some new starting points are well established by now, but I’m sure many more will be invented in the near future. I am curious to hear about new patterns and new defaults that you have discovered and have used successfully in your projects.

(al)

© Vasilis van Gemert for Smashing Magazine, 2013.