Part

These are the notes of my talk at SmartWebConf in Romania. Part 1 covered how Impostor Syndrome cripples us in using what we hear about at conferences. It covered how our training and onboarding focuses on coding instead of human traits. In Part 2 I showed how many great things browsers do for us we don’t seem to appreciate. In this final part I’ll explain why this is and why it is a bad idea. This here is a call to action to make yourself feel better. And to get more involved without feeling inferior to others.

This is part 3 of 3.

• Part 1: never stop learning and do it your way
• Part 2: you got what you asked for, time to use it
• Part 3: give up on the idea of control and become active

Part 2 of this series ended with the explanation that JavaScript is not fault tolerant, and yet we rely on it for almost everything we do. The reason is that we want to control the outcome of our work. It feels dangerous to rely on a browser to do our work for us. It feels great to be in full control. We feel powerful being able to tweak things to the tiniest detail.

There is no doubt that JavaScript is the duct-tape of the web: you can fix everything with it. It is a programming language and not a descriptive language or markup. We have all kind of logical constructs to write our solutions in. This is important. We seem to crave programmatic access to the things we work with. That explains the rise of CSS preprocessors like Sass. These turn CSS into JavaScript. Lately, PostCSS even goes further in merging these languages and ideas. We like detailed access. At the same time we complain about complexity.

No matter what we do – the problem remains that on the client side JavaScript is unreliable. Because it is fault intolerant. Any single error – even those not caused by you – result in our end users getting an empty screen instead of the solution they came for. There are many ways JavaScript can fail. Stuart Langridge maintains a great flow chart on that called “Everyone has JavaScript, right?“.

There is a bigger issue with fixing browser issues with JavaScript. It makes you responsible and accountable for things browser do. You put it onto yourself to fix the web, now it is your job to keep doing that – for ever, and ever and ever…

Taking over things like page rendering, CSS support and page loading with JavaScript feels good as it fixes issues. Instead of a slow page load we can show a long spinner. This makes us feel good, but doesn’t help our end users much. Especially when the spinner has no timeout error case – like browser loading has.

Fixing a problem with JavaScript is fun. It looks simple enough and it removes an unknown browser support issue. It allows us to concentrate on building bigger and better things. And we don’t have to worry about browser issues.

It is an inspiring feeling to be the person who solved a web-wide issue. It boosts our ego to see that people rely on our brains to solve issues for them. It is great to see them become more effective and faster and free to build the next Facebook.

It gets less amazing when you want to move on and do something else. And when people have outrageous demands or abuse your system. Remy Sharp lately released a series of honest and important blog posts on that matter. “The toxic side of free” is a great and terrifying read.

Publishing something new in JavaScript as “open source” is easy these days. GitHub made it more or less a one step process. And we get a free wiki, issue tracker and contribution process with it to boot. That, of course, doesn’t mean we can make this much more complex if we wanted to. And we do as Eric Douglas explains.

Releasing software or solutions as open source is not the same as making it available for free. It is the start of a long conversation with users and contributors. And that comes with all the drama and confusion that is human interaction. Open Source is free as in puppy. It comes with responsibilities. Doing it wrong results in a badly behaving product and community around it.

Help stop people falling off the bleeding edge

If you embrace the idea that open source and publishing on the web is a team effort, you realise that there is no need to be on the bleeding edge. On the opposite – any “out there” idea needs a group of peers to review and use it to get data on how sensible the idea really is. We tend to skip that part all too often. Instead of giving feedback or contributing to a solution we discard it and build our own. This means all we have to do is to deal with code and not people. It also means we pile on to the already unloved and unused “amazing solutions” for problems of the past that litter the web.

The average web page is 2MB with over 100 http requests. The bulk of this is images, but there is also a lot of JS and CSS magical solutions in the mix.

If we consider that the next growth of the internet is not in the countries we are in, but in emerging places with shaky connectivity, our course of action should be clear: clean up the web.

Of course we need to innovate and enhance our web technology stack. At the same time it is important to understand that the web is an unprecedented software environment. It is not only about what we put in, it is also about what we can’t afford to lose. And the biggest part of this is universal access. That also means it needs to remain easy to turn from consumer into creator on the web.

If you watch talks about internet usage in emerging countries, you’ll learn about amazing numbers and growth predictions.

• Bruce Lawson: Ensuring a performant web for the next billion people (SOTB2015) (Bruce’s slides)
• Tim Kadlec Better by Proxy (Mobilism 2015) (Tim’s Slides)

You also learn about us not being able to control what end users see. Many of our JS solutions will get stripped out. Many of our beautiful, crafted pictures optimised into a blurry mess. And that’s great. It means the users of the web of tomorrow are as empowered as we were when we stood up and fought against browser monopolies.

So there you have it: you don’t have to be the inventor of the next NPM module to solve all our issues. You can be, but it shouldn’t make you feel bad that you’re not quite interested in doing so. As Bill Watterson of Calvin and Hobbes fame put it:

We all have different desires and needs, but if we don’t discover what we want from ourselves and what we stand for, we will live passively and unfulfilled.

So, be active. Don’t feel intimidated by how clever other people appear to be. Don’t be discouraged if you don’t get thousands of followers and GitHub stars. Find what you can do, how you can help the merging of bleeding edge technologies and what goes into our products. Above all – help the web get leaner and simpler again. This used to be a playground for us all – not only for the kids with the fancy toys.

You do that by talking to the messy kids. Those who build too complex and big solutions for simple problems. Those doing that because clever people told them they have to use all these tools to build them. The people on the bleeding edge are too busy to do that. You can. And I promise, by taking up teaching you end up learning.

View full post on Christian Heilmann

These are the notes of my talk at SmartWebConf in Romania. Part 1 covered how Impostor Syndrome cripples us in using what we hear about at conferences. It also covered how our training and onboarding focuses on coding. And how it lacks in social skills and individuality. This post talks about the current state of affairs. We have a lot of great stuff to play with but instead of using it we always chase the next.

This is part 2 of 3.

• Part 1: never stop learning and do it your way
• Part 2: you got what you asked for, time to use it
• Part 3: give up on the idea of control and become active

Lunch eaten by native: news at 11

When reading about the state of the web there is no lack of doom and gloom posts. Native development is often quoted as “eating our lunch”. Native-only interaction models are sold to us as things “people use these days”. Many of them are dependent on hardware or protected by patents. But they look amazing and in comparison the web seems to fall behind.

The web doesn’t need to compete everywhere

This is true, but it also not surprising. Flash showed many things that are possible that HTML/CSS/JS couldn’t do. Most of these were interesting experiments. They looked like a grand idea at the time. And they went away without an outcry of users. What a native environment have and what we do on the web is a comparison the web can’t win. And it shouldn’t try to.

The web per definition is independent of hardware and interaction model. Native environments aren’t – on the contrary. Success on native is about strict control. You control the interaction, the distribution and what the user can and can’t see. You can lock out users and not let them get to the next level. Unless they pay for it or buy the next version of your app or OS. The web is a medium that puts the user in control. Native apps and environments do not. They give users an easy to digest experience. An experience controlled by commercial ideas and company goals. Yes, the experience is beautiful in a lot of cases. But all you get is a perishable good. The maintainer of the app controls what stays in older versions and when you have to pay the next version. The maintainers of the OS dictate what an app can and can not do. Any app can close down and take your data with it. This is much harder on the web as data gets archived and distributed.

The web’s not cool anymore – and that’s OK

Evolution happens and we are seeing this right now. Browsers on desktop machines are not the end-all of human-computer interaction. That is one way of consuming and contributing to the web. The web is ubiquitous now. That means it is not as exciting for people as it was for us when we discovered and formed it. It is plumbing. How much do you know about the electricity and water grid that feeds your house? You never cared to learn about this – and this is exactly how people feel about the web now.

This doesn’t mean the web is dead – it just means it is something people use. So our job should be to make that experience as easy as possible. We need to provide a good service people can trust and rely on. Our aim should be reliability, not flights of fancy.

It is interesting to go back to the promises HTML5 gave us. Back when it was the big hype and replacement for Flash/Flex. When you do this, you’ll find a lot of great things that we have now without realising them. We complained when they didn’t work and now that we have them – nobody seems to use them.

Re-visiting forms

Take forms for example. You can see the demos I’m about to show here on GitHub.

When it comes down to it, most “apps” in their basic form are just this: forms. You enter data, you get data back. Games are the exception to this, but they are only a small part of what we use the web for.

When I started as a web developer forms meant you entered some data. Then you submitted the form and you got an error message telling you what fields you forgot and what you did wrong.

<form action="/cgi-bin/formmail.pl">
  <ul class="error">
    <li>There were some errors:
      <ul>
        <li><a href="#name">Name is required</a></li>
        <li><a href="#birthday">Birthday needs to 
          be in the format of DD/MM/YYYY</a></li>
        <li><a href="#phone">Phone can't have 
          any characters but 0-9</a></li>
        <li><a href="#age">Age needs to be 
          a number</a></li>
      </ul>
    </li>
  </ul>
  <p><label for="name">Contact Name *</label>
     <input type="text" id="name" name="name"></p>
  <p><label for="bday">Birthday</label>
     <input type="text" id="bday" name="bday"></p>
  <p><label for="lcolour">Label Colour</label>
     <input type="text" id="lcolour" name="lcolour"></p>
  <p><label for="phone">Phone</label>
     <input type="text" id="phone" name="phone"></p>
  <p><label for="age">Age</label>
     <input type="text" id="age" name="age"></p>
  <p class="sendoff">
    <input type="submit" value="add to contacts">
  </p>   
</form>

This doesn’t look much, but let’s just remember a few things here:

• Using labels we make this form available to all kind of users independent of ability
• You create a larger hit target for mobile users. A radio button with a label next to it means users can tap the word instead of trying to hit the small round interface element.
• As you use IDs to link labels and elements (unless you nest one in the other), you also have a free target to link to in your error links
• With a submit button you enable user to either hit the button or press enter to send the form. If you use your keyboard, that’s a pretty natural way of ending the annoying data entry part.

Nothing ground-breaking, I admit, but a lot of useful functionality. Functionality you’d have to simulate if you did it all with SPANs and DIVs. And all this without a single line of JavaScript.

Enter JavaScript

Then we got JavaScript. This enabled us to create higher fidelity forms. Forms that tell the user when something went wrong before submitting. No more uneccesary page reloads. We started to build richer interaction models like forms with optional fields depending on the content of others. In my 2006 book Beginning JavaScript with DOM Scripting in Ajax I had a whole chapter dedicated to forms (code examples are here). All of these enhancements had the problem that when JavaScript for some reason or another didn’t work, the form still was happily submitting data to the server. That meant and still means that you have to validate on the server in addition to relying on client-side validation. Client side validation is a nice-to-have, not a security measure.

Enter HTML5 and browser convenience features

HTML5 supercharged forms. One amazing thing is the required attribute we can put on any form field to make it mandatory and stop the form from submitting. We can define patterns for validation and we have higher fidelity form types that render as use-case specific widgets. If a browser doesn’t support those, all the end user gets is an input field. No harm done, as they can just type the content.

In addition to this, browsers added conveniences for users. Browsers remember content for aptly named and typed input elements so you don’t have to type in your telephone number repeatedly. This gives us quite an incredible user experience. A feature we fail to value as it appears so obvious.

Take this example.

<form action="/cgi-bin/formmail.pl">
  <p><label for="name">Contact Name *</label>
     <input type="text" required id="name" name="name"></p>
  <p><label for="bday">Birthday</label>
     <input type="date" id="bday" name="bday" 
     placeholder="DD/MM/YYYY"></p>
  <p><label for="lcolour">Label Colour</label>
     <input type="color" id="lcolour" name="lcolour"></p>
  <p><label for="phone">Phone</label>
     <input type="tel" id="phone" name="phone"></p>
  <p><label for="age">Age</label>
     <input type="number" id="age" name="age"></p>
  <p class="sendoff">
    <input type="submit" value="add to contacts">
  </p>   
</form>

There’s a lot of cool stuff happening here:

• I can’t send the form without entering a contact name. This is what the required attribute does. No JavaScript needed here. You even can rename the error message or intercept it.
• The birthday date field has a placeholder telling the user what format is expected. You can type a date in or use the arrows up and down to enter it. The form automatically realises that there is no 13th month and that some months have less than 31 days. Other browsers even give you a full calendar popup.
• The colour picker is just that – a visual, high-fidelity colour picker (yes, I keep typing this “wrong”)
• The tel and number types do not only limit the allowed characters to use, but also switch to the appropriate on-screen keyboards on mobile devices.
• Any erroneous field gets a red border around it – I can’t even remember how many times I had to code this in JavaScript. This is even style-able with a selector.

That’s a lot of great interaction we get for free. What about cutting down on the display of data to make the best of limited space we have?

Originally, this is what we had select boxes for, which render well, but are not fun to use. As someone living in England and having to wonder if it is “England”, “Great Britain” or “United Kingdom” in a massive list of countries, I know exactly how that feels. Especially on small devices on touch/stylus devices they can be very annoying.

<form action="/cgi-bin/formmail.pl">
<p>
  <label for="lang">Language</label>
  <select id="lang" name="lang">
    <option>arabic</option>
    <option>bulgarian</option>
    <option>catalan</option>
    […]
    <option>kinyarwanda</option>
    <option>wolof</option>
    <option>dari</option>
    <option>scottish_gaelic</option>
  </select>
</p>  
<p class="sendoff">
  <input type="submit" value="add to contacts">
</p>   
</form>

However, as someone who uses the keyboard to navigate through forms, I learned early enough that these days select boxes have become more intelligent. Instead of having to scroll through them by clicking the tiny arrows or using the arrow keys you can start typing the first letter of the option you want to choose. That way you can select much faster.

This only works with words beginning with the letter sequence you type. A proper autocomplete should also match character sequences in the middle of an option. For this, HTML5 has a new element called datalist.

<form action="/cgi-bin/formmail.pl">
  <p>
    <label for="lang">Language</label>
    <input type="text" name="lang" id="lang" list="languages">
    <datalist id="languages">
      <option>arabic</option>
      <option>bulgarian</option>
      <option>catalan</option>
      […]
      <option>kinyarwanda</option>
      <option>wolof</option>
      <option>dari</option>
      <option>scottish_gaelic</option>
    </datalist>
  </p>  
  <p class="sendoff">
    <input type="submit" value="add to contacts">
  </p>   
</form>

This one extends an input element with a list attribute and works like you expect it to:

There is an interesting concept here. Instead of making the select box have the same feature and roll it up into a combo box that exists in other UI libraries, the working group of HTML5 chose to enhance an input element. This is consistent with the other new input types.

However, it feels odd that for browsers that don’t support the datalist element all this content in the page would be useless. Jeremy Keith thought the same and came up with a pattern that allows for a select element in older browsers and a datalist in newer ones:

<form action="/cgi-bin/formmail.pl">
  <p>
    <label for="lang">Language</label>
    <datalist id="languages">
    <select name="lang">
        <option>arabic</option>
        <option>bulgarian</option>
        <option>catalan</option>
        […]
        <option>kinyarwanda</option>
        <option>wolof</option>
        <option>dari</option>
        <option>scottish_gaelic</option>
      </select>
    </datalist>
    <div>or specify: </div>
    <input type="text" name="lang" id="lang" list="languages">
  </p>  
  <p class="sendoff">
    <input type="submit" value="add to contacts">
  </p>   
</form>

This works as a datalist in HTML5 compliant browsers.

In older browsers, you get a sensible fallback, re-using all the option elements that are in the document.

This is not witchcraft, but is based on a firm understanding of how HTML and CSS work. Both these are fault tolerant. This means if a mistake happens, it gets skipped and the rest of the document or style sheet keeps getting applied.

In this case, older browsers don’t know what a datalist is. All they see is a select box and an input element as browsers render content of unknown elements. The unknown list attribute on the input element isn’t understood, so the browser skips that, too.

HTML5 browsers see a datalist element. Per standard, all this can include are option elements. That’s why neither the select, nor the input and the text above it get rendered. They are not valid, so the browser removes them. Everybody wins.

A craving for control

Browsers and the standards they implement are full of clever and beautiful things like that these days. And we’ve loudly and angrily demanded to have them when they got defined. We tested, we complained, we showed what needed to be done to make the tomorrow work today and then we forgot about it. And we moved on to chase the next innovation.

How come that repeatedly happens? Why don’t we at some point stop and see how much great toys we have to play with? It is pretty simple: control.

We love to be in control and we like to call the shots. That’s why we continuously try to style form elements and create our own sliders, scroll bars and dropdown boxes. That’s why we use non-support by a few outdated browsers of a standard as an excuse to discard it completely and write a JavaScript solution instead. We don’t have time to wait for browsers to get their act together, so it is up to us to save the day. Well, no, it isn’t.

Just because you can do everything with JavaScript, doesn’t mean that you should do it. We invented HTML5 as the successor and replacement of XHTML as it had one flaw: a single wrong encoding or nesting of elements and the document wouldn’t render. End users would be punished for our mistakes. That’s why HTML5 is fault tolerant.

JavaScript is not. Any mistake that happens means the end user looks at an endless spinner or an empty page. This isn’t innovation, this is building on a flaky foundation. And whilst we do that, we forgot to re-visit the foundation we have in browsers and standards support. This is a good time to do that. You’d be surprised how many cool things you’ll find you only thought possible by using a JavaScript UI framework.

But more on that in part 3 of this post.

View full post on Christian Heilmann

I just got back from SmartWebConf in Romania. I gave the closing talk. I wanted it to be of a slower pace and more reflective than what I normally deliver. I messed that up, as I got passionate about the subject again, but it was for the better. I am happy and humbled about the feedback I got. Many people thanked me for putting their worries into words. That’s why I offer the recording and slides here, and write a longer post about the ideas covered in them.

This is part 1 of 3.

Part 1: never stop learning and do it your way
Part 2: you got what you asked for, time to use it
Part 3: give up on the idea of control and become active

The screencast recording is on YouTube (if you want to download it, I use Youtube-dl)

The Slides are on Slideshare and have been featured on their frontpage.

The end of a conference is always a wonderful time. You are inspired, fascinated, excited, hopeful and ready to apply and play with all the cool stuff you heard. You had interesting talks with people. You found out that other people have the same problems and worries you have. You’re driven to tackle them head on (the problems, not the other people). That’s what happens when the presenters and organisers did their jobs right.

The problem is that these fuzzy feelings tend to evaporate when you go back to work. Conferences are a cocoon of being with people who get you – as they have the same ideas and deliveries.

Going back to your daily work can make you feel not as good any more. You go online. You get overwhelmed by the avalanche of stuff you find on our industry’s social media channels. You feel you should know a lot more than you do and use all the clever solutions the cool kids use. Instead, you look at a huge list of bugs you need to plough through. You look at the product you worked on for a year. And you suffer the convoluted processes it has. And you get frustrated by the code you’d love to clean up but can’t touch.

The impostor syndrome rears its ugly head and brings those darker feelings.

• That feeling that you don’t belong…
• That feeling that you’re not good enough…
• The feeling that you can’t contribute anything useful…
• The feeling that you should apologise for not using the newest and coolest…

All these are bullshit and you should not spend a second of your precious time on them. You don’t have to impress anyone, you don’t have to beat others. All you need to worry about is being a better you tomorrow than you are today. You can do this in many ways. Be a kinder person. Learn something new. Question your biases. Try to understand why someone dislikes what you do. And many more.

In our little world, we started to put ridiculous pressure onto each other. And it is based on one thing: engineering and technology. OK, that’s two things but one tends to lead to the other.

We turned engineering into a religion. With all the dogma and holy wars that comes with that.

This manifests itself in a few ways:

• We value code over everything else. We made “learning to code” a proper fetish and the answer to everything. And we keep stretching the term “code” to painful proportions. Everything you type and follows some logic or instructs a runtime to do something is considered code. The thinking behind it becomes secondary, which can be terrible. Writing good HTML is not about instructing a machine to do something with it. Writing good JavaScript is not about writing out a lot of content.
• We measure our worth by quantity and visibility, not by how we contribute. As Sarah Mei put it on Twitter
  

  Here’s my github contribution graph. I write code all fucking day. I want to do something different outside of work.

  Is she less of a coder as she strives to make a difference in her job rather than her free time? Is our creative work disconnected from our deliveries?

• We consider automation the end goal of everything. Humans should do other things than menial tasks that computers can do better. We value libraries and scripts and methodologies that automate tasks more than repetition. Repetition is considred failure. It could also be good for building up muscle memory. By automating all our tasks, we rob new developers of the learning why these automatisation tools are so useful. We remove them from the original problem. And they could learn a lot by facing these problems instead of relying on a magical solution they don’t understand.

This is dangerous thinking. Being human, we are more than number crunching machines. We can’t work at the breakneck speed of machines. Taking time off doing nothing is an important part of our mental health. By creating machines to make our lives easier, we might eventually end up with a world that doesn’t need us. This can be good, but the economics of it are pretty screwed up. CPG Grey’s Humans need not apply is an interesting 15 minute show about this.

This unhealthy focus on technological solutions for all our problems lead to a change in our hiring practices that annoy me. It seems we celebrate social ineptitude in our hiring and training. We have ridiculous brain teaser questions in interviews like the Fizz Buzz Text, which helps

filter out the 99.5% of programming job candidates who can’t seem to program their way out of a wet paper bag.

Arrogance like this doesn’t go unpunished. For example Estelle Weyl showed that a few lines of CSS can solve the Fizz Buzz test. That she framed her tweet as a “CSS interview question” scares me. CSS is not about cryptic coding puzzles, it is about describing interfaces and interactions. Once more we bring something that has an important role to play back to “code”. Thus we make it more palpable for the engineering crowd. A crowd that had not much respect for it in the first place.

Interview questions like these are scary, arrogant and short-sighted. We keep complaining about a lack of diversity in our market. Yet we put trip-wires like these in our onboarding process instead of celebrating diversity. And don’t get me started on the concept of hackdays to increase diversity. There is no silver bullet to force integration. If we want to be more diverse, we have to change our hiring practices. We also need to adapt our promotion and compensation paths. Right now our market values the “rockstar ninja coders” who are in constant competition with their peers. That’s not a good start to build teams.

Diversity isn’t a goal – it is a beginning. Your products will be more resilient, interesting and delivered faster with diverse teams than with a group of likeminded people. You add spices to food when you cook it. This is what diversity can bring to our market.

The way we teach shouldn’t be about hypothetical examples but about the medium we work in. Three years ago Brett Victor released Learnable Programming, a hands-on training course taking a different approach to learning to “code”. We should have more of these, and less of yet another resource to learn the coolest and newest.

There is no shortage of resources to learn our craft from these days. The problem with a lot of them is that they assume a lot of knowledge and expect a certain environment.

Learning is a personal thing. If you feel stupid trying to follow a learning resource, don’t use it. You’re not stupid – you’re using the wrong resource. We all are wired differently. If you don’t understand something – ask the person teaching the subject to explain it. If there is an aggressive answer or none at all, you know that the goal of the teaching resource was not to educate, but to show off. That’s fine, but it shouldn’t be something that frustrates you. Maybe you don’t need this new knowledge. Find something that makes you happy instead. Something that you are much better at than others are because you like doing it.

Continued in part 2, where I will look at what we have and why we don’t use it.

View full post on Christian Heilmann