Connections (source: O'Reilly).

With the rise of native apps and the Internet of Things (IoT), you might think we’re leaving the Web behind.

We’re not. The Web continues to be the easiest way for developers to connect people and computers. Whether you think you’re “on the Web” or not, Web tools power a huge chunk of communications and a vast number of interfaces. While HTML, CSS, and JavaScript are common, even in installable apps, even native apps and back-end systems use JSON, HTTP, and Web services to communicate. IoT devices may not always use those protocols directly, but many of them have a Web interface lurking somewhere.

Other languages and approaches absolutely have their place, especially in the many environments where constraints matter more than connection, but the Web core is everywhere: in your phone, your apps, the kiosks you find in stores and museums. It lurks invisibly on corporate networks helping databases and messaging systems communicate.

That enormous set of Web-related possibilities includes more than a set of technologies, though. Tools and techniques are great, but applying them yields a richer set of sometimes happy and sometimes controversial conversations.

I’ll be exploring a core set of nine key themes over the next few months, but I’ve started with brief explanations below. These short tellings set the stage for deeper explorations of the Web’s potential for changing both computing and the broader world, as well as what you need to learn to join the fun.

Those pieces digging deeper will appear on this site, but you can also stay in the loop on our latest analysis and coverage through our weekly Web Platform newsletter.

“Web scale” is any size

When people selling performance and monitoring talk about “Web scale,” they usually mean the huge end of the spectrum. What will you do when a million people want to talk with you at once? Web tools and approaches offer many more scales, however:

  • Build an iPhone or Android app with HTML, CSS, and JavaScript.
  • Create an internal application meant for 10 people.
  • Program a container that designers can present and content creators can fill.
  • Grow an application over time from a tiny core to many capabilities.
  • Communicate with embedded devices over a network.
  • Compete to cram a game into 1K or 10K of code.
  • Distribute applications from servers to clients to peers.

The details may change with the scope of the application and the size of the organization, but Web culture and Web technology have phenomenal reach.

Cross-pollinating Web communities

Web projects are integration projects, combining skills from a number of disciplines. Lousy interfaces can obscure brilliant code, and ingeniously engineered back-end systems can still fail when they hit resource limits. “Content” lurks in many guises, requiring support not only from writers and illustrators but from video specialists, game designers, and many more. Marketers have built businesses on the Web, and influence conversations from design to analytics.

Web development models include far more than code. Designers and content creators are full members, driving tools that work for them. Tools like Git that originated in programming, meanwhile, are finding new homes among Web designers.

Related: Read more about cross-pollinating Web communities.

Explosion of Web tools and approaches

The Web keeps changing as it grows. The classic tools — HTML, CSS, and JavaScript — are all in motion again, important enough for feuds to erupt in and among standards bodies. Web components offer new ways to package new pieces, helping developers contain their projects and share them. The layer above the standards core is much more fluid, filled with largely open frameworks and developer tools, with critical contributions from players large and small. At every level of the Web, you can find more than one kind of architecture.

The result is massive growth in tools and choices:

  • Douglas Crockford was right: JavaScript is a powerful language, and keeps finding new use.
  • CSS applies declarative approaches that are becoming more important.
  • Frameworks for MVC variants keep appearing and growing.
  • Layout frameworks are becoming ordinary as well.
  • Traditional Web layering still works, but single-page apps and isomorphic/hybrid approaches expand the range of architectural models for different use cases.
  • Is it a site? An app? Just a service? The Web supports more and more delivery models.
  • HTTP 2.0, WebSocket, and WebRTC expand the range of commonly available communications options from heavy client-server to light client-server to peer-to-peer.
  • seeks to rebuild the client stack completely, on WebGL and JavaScript.

The Web appears to be fractal, and diversity is sign of life.

Know a full stack, even if you don’t work it every day

A very few brave developers still customize every aspect of their sites and apps, from polishing interface design on the front end to optimizing database connections on the back end. Many more people choose standard sets of tools — the LAMP stack or MEAN stack — and hope that they can stay within the lines enough to get help. Building effective Web systems, though, means understanding how the layers of applications interact and their communications styles. At the very least, it means understanding the layers with which your work interacts.

Related: Read about full-stack tensions on the Web

Discipline is a choice

The Web’s hypertext foundation might be the ultimate GOTO mess, but allows us to create order and structure while supporting flexibility. Search layers coherence on top of the connections described by the tangled Web. JavaScript is often criticized for messiness, but CSS is a spartan declarative programming language. Meanwhile, Hack is adding discipline to PHP. Programmers can learn from HTTP and the architectural choices of the Web. Appropriate discipline has many different meanings in different cultures and contexts, guaranteeing that everyone will be irritated sometime. The relationship between different kinds of discipline and long-term maintenance costs may also be, well, unexpected.

Building Web services and building on Web services

Cool mashups have become businesses foundations, making it easier to distribute responsibilities. The “stack” takes on new meaning when different people control different pieces of it. Service-Oriented Architecture (SOA) builds on Web foundations in the enterprise, and public services extend to the world. You don’t have to build the whole application yourself. Instead, you create your unique aspects and the glue you need to assemble services — payment, mapping, storage, and much more — others provide.

Web identity, privacy, and security: Keep me safe

Even credit-card data — just a few numbers! — is difficult to remember and forget appropriately. Identity, security, and privacy issues all orbit these questions, and interact in challenging ways. Each of those three words can have different meanings for different players on the Web. Openness and safety are also a complicated mix. Browser security and privacy settings remain finer-grained and more restrictive by default (when other things are working) than mobile OS security and privacy settings, too. That helps, but we know shockingly little about how to get this right.

Related: Read more about security on the Web.

Engaging in depth on the Web

The Web is no longer just a scroll of text and graphics on a screen. Sometimes there is no screen, as devices use Web protocols to send data — which often then gets presented through a Web interface. Devices know where we are and how we’re moving, and new APIs and gadgetry give JavaScript access to hardware. Other times the screen contains graphics, drawing in users with much more sophisticated and interactive imagery. New communications protocols — WebRTC and WebSockets — open new frontiers in lightweight and peer-to-peer communications. New APIs are letting developers create and manipulate audio and video, not just present it.

Data drives the Web, the Web drives data

First, we were obsessed with how many visitors we had. Then, we were obsessed with where our site ranked with search engines. Today, we’re learning more and more about how visitors use Web sites and apps, and applying that data to better interfaces and more effective communications. We’re also building sites on other kinds of data, making the Web an interface for data and not just documents. Not everything has to be quantified, but things that can be quantified help.

In the months ahead I’ll take a deep dive into each of these themes through analysis, interviews, and ongoing coverage. These explorations work best when there’s an active feedback loop, so please share your thoughts through Twitter (@simonstl) and email (

Article image: Connections (source: O'Reilly).