Everyone agrees: When designing a content or markup language, simple is better. Yet as intuitive as this may seem, the development arc of technology runs counter to this imperative – always evolving in terms of complexity. If we are looking to get more done with content, why do we want a relatively unsophisticated language to assist us?
Building blocks of complexity
First, it helps to understand the rationale for the evolving complexity. As technological capabilities expand – combined with users coming of age with expanded capabilities – innovation naturally pushes the boundaries of current content languages, particularly as we find ourselves needing to express and support more complex and dynamic content. The companies at the fore of innovation have subsequently made developing new programing languages to support expanding infrastructure an imperative. This has led to a boom in different programming languages of varying levels of complexity, particular according to Viral Shah, one of the creators of the programming language Julia.
"Lightweight languages have endured for years."
"Big tech companies tend to have their own programming languages — Go at Google, Hack at Facebook, Swift at Apple, Java at Oracle [sic; Sun developed Java for different reasons], C# at Microsoft, or Rust at Mozilla," Shah told VentureBeat. "If you think about it, this makes sense: Software is the core competency of traditional tech companies — they can afford to have their legions of professional programmers use 'hard' languages like C++ and Java, which are great for performance and deployment, but less good for exploration and prototyping."
What Shah is pointing out is one of the key principles that makes lightweight markup languages crucial: While these companies have the capabilities to design their own languages that suit development needs, at the core of each are less sophisticated languages. In this respect Java and C++ are the building blocks supporting increased complexity.
The lasting power of markup
Similarly, when it comes to content – including tagging and metadata – lightweight languages have endured for years alongside more complex, proprietary solutions. Something like Markdown has been a favorite of bloggers, web writers and editors, developers, academics, technical writers and scientists looking for simple ways to translate simple text into HTML and XML, acting essentially as shorthand.
"Years ago, I started coding websites with HTML and then structuring documentation with XML, but Markdown allows me to use plain text for similar purposes," Carlos Evia, Ph.D., director of professional and technical writing and associate professor of technical communication in the Department of English and Center for Human-Computer Interaction at Virginia Tech told The Content Wrangler. "My Markdown files can become HTML and XML deliverables with one or two lines of commands or a few keystrokes."
Lightweight markup languages like Markdown thrive on their simplicity, bringing with them built-in constraints. As such, they area rarely the be-all, end-all for content creators and instead act as a vital component in a more sophisticated authoring tool chain. But this is the key to its staying power: With no end in sight for innovation and development of new languages, being able to author content in a simple language allows that content to be more portable a future iteration. Rather than having to parse artifacts of an outmoded language when transferring in older content, with simpler languages, the content remains relatively "pure" and thus more easily repurposed.
"The constraints of markup languages are one of their virtues."
Constrained, yet free
Mark Baker, writing for Every Page Is Page One, points out that the constraints of markup languages are one of their primary virtues. He points out these constraints essentially translate into a style guide, limiting the possibility for errors or deviations from house style. He also points out that simpler languages can interface with software and algorithms more easily, supporting automation and creating more naturalistic content.
"Every markup language has at least one program to process it and turn it into output (at a minimum, HTML)," Baker writes. "Those programs work because they know the constraints of the language. They know all the structures that are allowed to exist in the content, and all the combinations they are allowed to exist in, and they know how to format each of them."
He goes on to outline how this can extend well beyond formatting into API documentation, allowing for more sophisticated source tracking, combining sources into a single reference entry, error checks and validating the written content to make sure it conforms with the actual function definitions in the code.
Which brings us back to the main point: a relatively unsophisticated language with known constraints leaves authors free to create more compelling and dynamic content. It is informal proof of the mantra that "simple is better."