Suppose you’re not sure about something regarding a programming language. What do you do? You google it, of course.

But…

How do you know you found the right answer? Can you trust that site you found?

Consider this discussion:

Jeffrey: “The HTML ‘a’ tag is named after the word anchor.”

Friend: “No it isn’t. It’s just a letter, the first letter of the alphabet. An anchor is something else.”

Jeffrey: “I’m right.”

Friend: “No. I’m right. You’re wrong.”

Jeffrey: “No, I’m right.”

Friend: “No, I’m right.”

Jeffrey: “No, I’m right.”

Where does it end? Do we take it out back and see who is the strongest? Or maybe the loudest? Does the loudest person win?

In the world of computer programming, we need to know a way to find the definitive answer to something, regardless of individual opinions and who can shout the loudest.

But who has the definitive answer?

Most technologies have an official standards committee. The members of that committee write the official standards documents, including a type of document called a “specification” that has the final word.

And THAT is where we find the definitive answer.

Remember this, as you move forward in your career. It doesn’t matter who can shout the loudest on Stack Overflow. What actually matters is what the official specification says. THAT is the final word.

The key, then, is to locate the standards for any technology. (The specification itself is usually a document that describes the language in gory detail, and is often intended to be read by people who create compilers and similar such tools for the language.)

Tip: Many (but not all!) standards live within various organizations in the European Union, and these organizations have members who are both individuals, as well as companies with big names like Microsoft, Oracle, and others. These are the organizations that:

…create the standards that others in the industry agree to abide by.

So what is the answer to the HTML “a tag” question? It really did originally stand for “anchor” at the time I had the above conversation. You can see the original HTML specification, dating back to 1991, along with the point that a stands for anchor, here: https://info.cern.ch/hypertext/WWW/MarkUp/Tags.html#4

The meaning, however, has evolved, and the “a” tag has over the years meant less about “anchors” and more about links. But it did, in fact, originally stand for the word anchor.

Standards are a good thing

Now suppose you and your friends are going to create a new, really cool web browser. It’s going to have some amazing new features nobody has seen. But: Will it properly display web pages people create? If the browser opens a news website, for example, will it render properly, just as it does in Google Chrome?

And if somebody makes a really cool website that looks awesome in your browser, will it similarly look awesome in Chrome?

In order to make that happen, you have to make sure your new browser abides by different standards. Yes, as a free entity, you are totally free to create a very different type of browser, even if some sites won’t render properly. But will people appreciate that?

Probably not. If you do your own thing and the web sites people visit look wrong and messed up, they’re going to be pretty unhappy and not bother installing your browser, no matter how amazing and cool it is. And on the flip side, if there are some websites that look awesome in your browser, but look a mess in Chrome, while displaying a message that to use the website people need to switch to your browser, will people really do that, switch to your browser? Probably not. They’ll probably think it’s malware.

So in other words: You’ll want to create your cool new browser such that websites appear as they should as per different standards.

It is upon you to locate the standards, and abide by them.

And thus we have standards. And indeed most languages and technologies have standards.

As programmers, software developers, software engineers, data scientists, you name it, we need to abide by these standards that our peers have agreed on. So the question is: Where do we find the standards?

The Ultimate Authority

Anyone can make a website claiming to be the ultimate authority on a technology, such as Python or HTML. But they could easily have incorrect information. Instead, then, we need to look at the actual standards.

So together – you and I – we can recognize three “levels” of standards:

1. The official standards. These are published by committees such as those in the European Union mentioned earlier. These are the final say, the final word on the technology.
2. Almost-official. These are websites run by organizations that have vowed to publish documentation as close to the standards as possible. They may occasionally have incorrect information, but that’s rare, and if they discover it’s incorrect, they fix it ASAP. So you can treat such sites effectively as standards: Hence, “Almost official.”
3. Trustworthy. These are websites that over time have proven they do a pretty good job of abiding by standards, but do occasionally get careless. The reason I group this separately from number 2 (almost-official) is many of these websites have suffered from incorrect information in the past, but have vowed to clean up and try their hardest to stay as close to the standards as possible. Still, be careful with such sites. Some (not all!) occasionally get information wrong. Verify anything you read.

Now let’s look at different technologies and see where you can find their official information. After that we’ll look at “almost-official” sites and “trustworthy” sites.

Where to Find the Standards and Specifications

Python

Official website: https://www.python.org/

Python documentation: The links change as the new versions come out, so best not to bookmark the docs. Instead go to the main page (etc)

Python was originally created over 3 decades ago by one man, one of the most respected computer scientists to ever live, a man named Guido van Rossum. His goal was to create a language that’s easy and intuitive. 

Over the years, Python has had a lot of ups and downs, at some times seeming like it’s going to just die off. But in the last decade or so, it started picking up more and more steam, to the point that today it’s one of the most popular languages. Data scientists love to use it. Right now it appears it will be around a long time.

Python is not overseen by an official third-party standards organization. Instead Python has its own organization, the Python Software Foundation. This foundation oversees the development of the python language and its standard libraries.

Python’s official website is here: https://www.python.org/ To find the official documentation, click the Documentation link at the top, and then in the little window that opens, click the Python Docs button. (Use this method rather than bookmarking the page that opens, as that page is version specific. When newer versions of Python come out, you’ll probably want to see the latest version.)

One quick note about Python versions: Python 3 was for the most part built “from the ground up” as a brand new language similar but not identical to previous versions. As Python grew in popularity, people started identifying some fundamental problems with the language and its implementation. Python 3 fixes most of these problems, except the problem is that not all earlier Python code, the most recent being Python 2.7, is compatible with Python 3. It took several years during which both Python 2.7 and Python 3 were in use. But since then, the majority of projects and apps that use 2.7 have been updated to Python 3. Today most people use Python 3. If you’re starting a new project with Python, use Python 3. There’s little reason to use the older 2.7.

JavaScript, also called ECMAScript

[Talk about how it was created, and how it has an “official” name that few people use]

JavaScript was originally created by one person at Netscape, an early company in the browser world. It was named JavaScript, even though it had little if any resemblance to the language called Java. It was later accepted for a standard by the organization called ECMA (which stands for European Computer Manufacturers Association). Within ECMA, it was given the name ECMAScript. While that’s technically the “official” name for the language, almost nobody calls it that. We all just call it JavaScript.

Every major browser today includes a JavaScript engine in it. This means that JavaScript code can run inside the browser. That in turn means the browsers are more than just web browsers; they are platforms for building applications.

JavaScript can also be run outside a browser using different platforms, the most common being Node.js.

So where does the official JavaScript standard live? In ECMA’s web site. However, there’s a bit of a problem. The official specification is not really intended to be read by developers and programmers. Its main purpose is to guide language developers, that is, the people building the JavaScript engine that runs inside the browsers. For the rest of us, that’s not all that useful.

This is where the almost-official documentation saves us.

The majority of the JavaScript programming community instead considers the Mozilla Mozilla Developer Network (MDN)’s documentation to be the next best thing to the official documentation. The people at MDN work very hard to make sure that their documentation is as correct as it can be.

Therefore, most of us use MDN as the official documentation, even if it’s technically not official.

Head to their main page at: https://developer.mozilla.org/

At the top, click References and in that menu, click JavaScript.

From there you’ll find several excellent tutorials, as well as a language reference.

TypeScript

While JavaScript is an easy language to learn, it’s also very easy to create bugs with it. For many of us who have been using JavaScript for many years, this isn’t really a problem; we prefer to simply “be careful.” However, in reality that’s not really enough. We need a language with stricter rules.

There were some attempts to create other languages that can be converted into JavaScript (a process called transpiling). One such example is a language called CoffeeScript, which was introduced in 2009. CoffeeScript had a lot of support and many of its features found their way into newer versions of JavaScript, in some sense making CoffeeScript obsolete.

Still, problems persisted in JavaScript. Microsoft decided to make its own language called TypeScript that was very similar to JavaScript and could be transpiled into JavaScript code. This language had a lot of similarities with Microsoft’s own C# language. Within a couple years after its introduction, TypeScript gained a huge following and is now one of the most popular languages.

One important feature of TypeScript is that it is a “superset” of JavaScript, meaning it can run pure JavaScript code. While this might not seem like a big deal at first, it allows TypeScript code to import pure JavaScript libraries and run them just fine.

Remember, TypeScript is transpiled to JavaScript, which means you write code in TypeScript, the compiler generates JavaScript code, and that JavaScript code is what runs in the browser or in the node.js environment.

Typescript’s official documentation can be found at its official website, https://www.typescriptlang.org/

Java

Java has an interesting history. Prior to its invention in the early 1990s, the majority of programming languages, such as C, C++, Pascal, and Fortran, were compiled, meaning a tool would take code that you write, and through several steps build a machine code. Machine code is the native language of a microprocessor, and it’s written using a language called assembly language. But since different computers used different microprocessors, if you wanted your code to run on a different type of computer, you would have to “port it,” meaning you would have to get a compiler for that other computer, and spend a lot of time getting your code to run on that computer. That was a lot of work. At the time the PC and the Mac were already the two main desktop computers, and they had radically different processors; PCs had Intel, and Macs had Motorola. However, around that same time, Apple had started moving to yet another processor, one called PowerPC. (This is actually a very small, trivial description of the history. The real history is complex and messy. Check out the article here. https://en.wikipedia.org/wiki/PowerPC )

Regardless, programming across multiple platforms was difficult. Then a guy named James Gosling had an idea: Why not create an engine that was fast and was available on every platform and could run its own “compiled” code? The compiled code would look a lot like assembly language. And with that he would create a language: Java. People could write Java code, and the engine, called the Java Virtual Machine (JVM), would be available on all the popular computers. Then people wouldn’t have to port their code.

Originally the intention was that the JVM would be very fast, but in fact, it was horribly slow. However, with time computers would become much faster and more efficient, and the JVM would get faster, especially as the JVM developers explored ways to convert the code inside the JVM to native machine code, among other advances. (If you’re really curious, check out Wikipedia’s article here: https://en.wikipedia.org/wiki/Java_performance )And today, the JVM is indeed incredibly fast.

The first version of Java was released in 1996 by a company called Sun Microsystems, who was known for making powerful desktop computers that software developers loved. They ran an operating system that was based on the original Unix operating system, of which today’s Linux is a descendant.

Sun owned the rights to Java, and it has never been handed over to a standards organization. (Sun briefly tried in 1997, but then backed out.) Instead they created a process for updating the language called Java Community Process. This isn’t technically a standards organization, but very similar to one.

In 2009, Oracle acquired Sun and to this day controls Java, but still through the Java Community Process. (The acquisition was not without problems, however, including the fact that Google used Java as its language for the Android operating system. You can read about it here: https://en.wikipedia.org/wiki/Acquisition_of_Sun_Microsystems_by_Oracle_Corporation )

While Java isn’t part of an official standards organization, its official language documentation lives on through the Oracle website. You can find it here: https://docs.oracle.com/en/java/ 

C#

I think it’s obligatory to put C# immediately after Java in this list. 

C# was invented by a guy named Anders Hejlsberg, who is one of the world’s foremost experts on computer language. Seriously, this guy knows his stuff. He created a pretty awesome language in the 1990s called Object Pascal, which was eventually adopted for a very cool tool called Delph at a company named Borlandi. (However, see my notes at the end of this doc about the future of Delphi.) Anders went on to work for Microsoft, where he took his knowledge a step further and developed the language called C#.

(Side note: I need to chime in. Another important person in the development of the original Delphi was a late friend of mine named Danny Thorpe, one of the smartest people I’ve ever met. Sadly he passed away a few years ago. Although he was technically a tester at the company during the development of Delphi, he’s the one who came up with the name Delphi, and he had a lot of technical input into the product. He eventually became Chief Scientist at Borland. He died in 2021 from cancer.)

Here’s the thing about C#. I can’t verify this (please don’t sue me, because this might be wrong) but I had heard from people that Microsoft originally wanted to use Java as their main language, but couldn’t procure the rights to it. So they went with it anyway, and simply renamed it to C#. I have no idea if this is true, but it’s what I heard. It could be wrong. And here’s more about the similarity, including words from the original creators of both languages: https://en.wikipedia.org/wiki/C_Sharp_(programming_language)#History You can be the judge.

Regardless, C# has grown to one of the most important back-end languages, along with the dotnet framework. Like Java, it’s compiled to a language similar to assembly language (called bytecode) and it runs inside of a runtime environment, in this case the Common Language Runtime. Although the first release was in 2000, two and a half decades ago, it has continually evolved and progressed, and is now an amazing language. (Interesting side note: It progressed well beyond Java with many features that later seemed to find their way into Java itself.)

And that said, C# has an official home page where you can find definitive answers. It was created by Microsoft and still lives on the Microsoft website at: https://learn.microsoft.com/en-us/dotnet/csharp/ Scroll down to find the C# Language reference, including advanced parts of C# such as LINQ (pronounced link).

But wait, there’s more! C# is only part of the story. The rest is the .NET Framework. (Pronounced dot net framework.) This includes a massive library supporting the C# language. This library includes classes such as lists and dictionaries, but even far more advanced classes such as those for connecting to remote websites and reading data. 

The main dotnet framework starts with this page: https://dotnet.microsoft.com/en-us/ But once there, you’ll want to click the Docs link at the top. From there you’ll find a popup window with LOT.

Probably the most important is the ASP.NET Core link under “Web.”

SQL

SQL is a bit of an oddball. While there is an official SQL specification overseen by the International Organization for Standardization (ISO), the major SQL vendors have taken it upon themselves to add additional features that go far beyond the standard SQL language. And beyond that, they’ve ignored some of the standards.

As far as going beyond the language, the reason is that SQL by itself is only for querying and updating data. But when using SQL, programmers have a need for additional features that SQL doesn’t provide. And that’s where the vendors have created their own “extensions” to SQL. The vendors then publish their own documentation detailing their own official extensions to SQL.

But to complicate things more, the vendors tend to ignore a lot of the official standard, and each has their own way of doing even minor things such as what characters to put around column names. (The official standard says to use double quotes, but MySQL uses back ticks, while SQL Server uses square brackets, for example.)

And while you might be interested in reading the official standard documents from ISO, you can, but one issue: You have to pay for it to download it, and it ain’t cheap–like over $200. But for real: why bother when the different vendors provide documentation specific to their database systems, and it’s free. Here’s where you can find the official vendor-specific documentation:

Oracle: https://docs.oracle.com/database/121/SQLRF/toc.htm 

Microsoft SQL Server: t-sql (which stands for “Transact SQL): https://learn.microsoft.com/en-us/sql/t-sql/language-reference?view=sql-server-ver16 

MySQL: https://dev.mysql.com/doc/refman/8.0/en/ (This one is a bit messy because there is just so much there. There are links for installing MySQL, as well as links for security, backup and recovery, and more. What I recommend is glance at the left side, which lists everything about the documentation, and become familiar with it. If you’re a MySQL developer, you’ll want to know exactly where the different documentation lives. On the left is all of it. Spend some time on “Data Types” and “Functions and Operators” and “SQL Statements.” That should be a good starting point.

PostgreSQL. PostgreSQL, often shortened to just “postgres” is the programmer’s SQL database. In other words, it has a high learning curve, but programmers love it. My serious advice is to start with MySQL, as it’s much easier to install and use. Practice, and then move up to PostgreSQL.But if you’re determined to learn PostreSQL, head to this link: https://www.postgresql.org/docs/ and click on the one labeled as “Current”. From there you’ll find a massive amount of information, starting with “What is PostgreSQL” and “A brief History of PostgreSQL”. You can skip down to the tutorial, with “Getting Started.”

An interesting note about SQL: It was originally part of a “crazy” in the late 1980s to develop what at the time they called “Fourth generation languages.” Without going into too much background (including why this was supposedly the 4th), the plan, the idea, the hope, was to develop programming languages that were so easy to use that you didn’t need to be a programmer to use them. Instead you would use what at the time people claimed passed as “natural language.” In my opinion, the attempt utterly failed. People found that no matter how much English appears in SQL, it’s still a programming language, and you need to have a basic understanding of programming concepts. But that’s why its keywords are all English words, and why some of its keywords are actually two words (such as ORDER BY). It was supposed to be an intuitive language that anyone could code, like this (compliments of ChatGPT):

SELECT CONCAT_WS(‘, ‘, SUBSTRING_INDEX(GROUP_CONCAT(name ORDER BY amount DESC), ‘,’, 3)) AS top_3_transactions, MAX(level) AS max_level, SUM(amount) AS total_amount FROM (

  SELECT t1.name, t1.amount, COUNT(*) OVER () AS level

  FROM transactions t1

  JOIN transactions t2 ON t1.parent_id = t2.id

) AS subquery;

Can you imagine your typical non-technical business owner being able to understand that mess? But hey! It uses English words like SELECT, FROM, JOIN, and the simple word AS. (By the way, here’s the prompt I gave ChatGPT: Show me an overly complex SQL query statement that’s difficult for most humans to read. Keep it under 15 lines.)

React

React was originally created by Facebook to support their advanced usage of JavaScript and front end development in their flagship product, the Facebook website. They later released it as an open source product. Facebook eventually got reorganized into a company called Meta, which now oversees React.

Interesting background about Facebook’s influence on not only JavaScript frameworks but browsers as well: Regardless of one’s opinion of Facebook, in its early days it was, along with Google Maps and GMail, one of the most advanced JavaScript based websites ever created at the time. It pushed JavaScript to its limits, and the results were quite impressive. In fact, prior to Facebook, most front end developers were forced to support ancient web browsers, such as the despised and rightfully-maligned Internet Explorer (IE) 6 (which actively resisted standards and tried to create its own standards, thank you very much Microsoft). When Facebook started picking up steam around 2008 or so, many computers, especially those that were within corporate settings, still had IE 6 installed on them. And if people creating apps in the browser wanted their apps to gain acceptance, they pretty much had to support IE 6. As somebody who was involved in the development of such apps, I can say it was an utter nightmare. We basically all had to have two products with their own code base: One for IE 6, and one for all the other browsers. Then something interesting happened, something that few people have even written about, but many of us know deep in our hearts is true. Around that time, and this part is fact, Facebook stopped supporting IE 6. If you tried to open Facebook’s website on IE 6, you would get a message that it’s not supported, and it would revert to the most awful text-based version of the website.

Now interestingly – and you can read what you want into this – very quickly, within about a year tops, most corporations suddenly upgraded their browsers to new versions and stopped using IE 6. And that’s when IE 6 finally died and we no longer needed to support it. Few people actually said it was “because the corporate employees wanted to check Facebook at work, even though they were told not to,” but I think most of us quietly knew that to be the truth.

I could be wrong. But that’s the truth as I saw it. And I suspect it’s true.

Angular

During the early 2010s, there were many, many JavaScript libraries that appeared, with the goal of modernizing web development. Why was that important? Because developing front end apps for the web was, to be blunt, a pain in the a… er, behind. Some amazing libraries appeared, the most notable being JQuery. But they still had a lot of shortcomings.

The main reason is browsers are built upon HTML, and HTML was never originally intended to be used alongside a programming language. It had some bizarre ways of doing things, but that’s because it’s primary purpose was presenting information–not building apps.

I’m typing this document into Google Docs, which runs entirely in the browser. I’m pretty confident that the original developers of the Web never imagined that such an app would be running in the browser. The goal was to present content, like an online newspaper, with very little interaction besides simple forms (where you type in things and click Submit).

But when JavaScript came along, suddenly browsers became an app development platform. Unfortunately, the whole platform was a mess. It was nothing like the tools we had at the time for developing desktop applications. Desktop apps were incredibly easy to create, especially with tools like Visual Basic. Drop some buttons on a window, double-click to add some code, write some database code, and you were rolling.

Web applications were nothing like that and far from easy. The whole platform was a mess for applications. Soon libraries like JQuery appeared that simplified it to a point. But it was still a nightmare.

Gradually better JavaScript libraries came along. One such library, created by Google and released in 2010, was called AngularJS. While it was arguably better than JQuery, it was still pretty difficult. One notable “feature” was that it was SLOW. You would arrive at a website that had AngularJS, and there would be some spinning icon and you would wait… and wait… and wait until it finally loaded.

Thankfully, the AngularJS team decided to rebuild the whole thing from the ground up, while using newer browser and JavaScript features. (And indeed they did – it uses some seriously complicated but lesser known browser features that thankfully are standard across all browsers today, including some black magic called Shadow DOM. Google it! It’s pretty fascinating.)

The new platform was called, simply Angular, as opposed to its predecessor, AngularJS. (The author of this page, Jeffrey Cogswell, considers Angular his favorite front end framework.)

The official website is found at: https://angular.io/

On the front page at the top is a link simply labeled DOCS. There you will find tutorials as well as the official documentation. (Angular isn’t part of a standards organization, so this is where you’ll find everything officially related to it.)

Tip when using Angular: The developers move fast and update the framework regularly. Occasionally they “deprecate” various features, meaning they declare them outdated. For those features, you’re advised to update to the newer features that replace them. Fortunately, though, even after deprecation, they keep the older features around for a bit so your code won’t break. But definitely stay on top of such changes as you move forward.

Vue.js

Vue.js is a fascinating example of how to build an open source product all by yourself into something that is amazing and in terms of community and adoption, utterly huge. This is a success story. It’s a front-end framework that was originally created in 2014 by one person, Evan You. He worked at Google and was frustrated with the original AngularJS product that they created. (See above for AngularJS’s history and how that’s a different product from today’s Angular.) And so he built a JavaScript framework that from the start was utterly amazing to use and program with.

Because Vue.js is technically a “small” project (with huge adoption), it’s not part of an official standards organization. Instead, everything you can find is at its official website: https://vuejs.org/ The documentation is available at the top in a link labeled Docs.

Tip: The author of this article you’re reading, Jeffrey Cogswell, loved it when it came out, and felt it was the first step into finally modernizing Web development to the point that it rivaled the desktop apps of 20 years ago. Finally! What’s also interesting is that when Google introduced Angular, the replacement for AngularJS, it had a lot of similarities to Vue.js. I’m going to do something I don’t normally do on these pages. I’m going to encourage you to sponsor or donate to the Vue.js development. The developer, Evan You [link to https://evanyou.me/ ],  has created an amazing product and deserves it. Go here to help: https://vuejs.org/sponsor/  And as the phrase goes “put my money where my mouth is, you will see me, Jeffrey Cogswell, wearing a Hemmingway Hat, listed as an individual backer in the “current sponsors” list. Please match!

HTML

HTML was originally part of a standards group devoted to Web technologies, called the World Wide Web Consortium (W3C). Then later in the first decade of the 2000s, something messy happened. The W3C chose to abandon HTML as we knew it in favor of something called XHTML 2.0. People, including a lot who were involved in creating the standards, were not happy. For those of us who were on the sidelines watching, all we can say is it was a mess. I can’t even begin to describe what happened, other than I remember seeing online disagreements among people who were involved in the HTML standards–disagreements that bordered on fights and brawls. This led to a separate group forming called WHATWG. I think even those of us who were not involved but standing on the sidelines watching received a few black eyes. Here’s a partial – and only partial but sanitized – history of what happened: https://en.wikipedia.org/wiki/WHATWG . Meanwhile, here’s an excellent read that talks about some of the “disagreements” (and even uses the word “fight” but then points out that the two groups are working happily together again in what the author describes an “odd relationship”): https://webdesign.tutsplus.com/a-brief-history-of-html5–net-23064a 

Today you can find information on HTML at both the W3C and WHATWG websites. However, it’s not the easiest to read. Like JavaScript, most of us developers rely on Mozilla Developer Network’s documentation. Again, this is the “next best thing” to the official documentation. It’s so close, it practically is official.

You can find the documentation at https://developer.mozilla.org/ Click the References link, and in the menu that opens, click HTML. Here you’ll find a fantastic set of resources, including tutorials, guides, and then the almost-but-not-quite-official reference guides.

One thing to keep in mind: Among the online disagreements came a decision that the fifth version of HTML, often written as HTML5, would simply be renamed “HTML” with no version at all. Instead it would be a “living standard.” Many of us scoffed at the idea at first, but in the years since, it has proven to be effective. Rather than periodically release a new standard that the browser developers have to scramble to adopt, updates would happen more frequently, and the browser developers would make regular but much smaller updates as well. This fits well with today’s established way of developing software, “continuous delivery,” whereby software is continually updated.

CSS

CSS stands for Cascading Style Sheets, and it dates all the way back to 1996. At the time, creating styles on a web page (fonts, font colors, font sizes, layout, you name it) was an utter nightmare. Then the World Wide Web Consortium (W3C) finally gave us a way to simplify such things. If you could call it simple. It was actually pretty complex and messy, but it was way better than what we previously had. Thankfully in the decades that have followed, CSS has improved and, while there’s a bit of a learning curve (tip: learn selectors, both how they relate to CSS and elements on your page), once you understand it, it’s actually pretty simple.

CSS is still owned and maintained by the W3C. But as is so common, their documentation is far from perfect.

I recommend Mozilla Developer Network’s documentation.  It falls in the “almost official” category. To find it, head to https://developer.mozilla.org/ and at the top, click References, and then in the menu that opens, click CSS. There you will find tutorials and “almost official” references.

There’s also a pretty good site for learning about CSS. It’s called css-tricks. For many, many years it was run by a man named Chris Coyier who over the decades has established himself as an expert in all-things CSS. (Seriously: This guy knows his stuff and had – keyword had – what was probably the best site on CSS ever to live. He then sold it to Digital Ocean. What’s interesting to me about this is Digital Ocean, while a cloud computing company, has had some of the best documentation on things like setting up apps on different Linux flavors. I’ve used their documentation and found it helpful. It made sense that they would purchase CSS-Tricks so that Chris Coyier could finally move on to other ventures. I commend him. Good job building an amazing site and good job with the exit plan! You go! But then the site went stagnant for a very long time. (More story here: https://chriscoyier.net/2024/02/28/where-im-at-on-the-whole-css-tricks-thing/ ) But in the few weeks since this blog post appeared, it seems Digital Ocean has (maybe?) started focusing on the site again. There’s new content. But here’s the thing: New content or not, there’s a lot of amazing resources on the site where you can learn everything you need to know about, for example, flex boxes. I definitely recommend reading the site–not for official documentation, but for amazing lessons. CSS isn’t easy! This site helps. We can hope that Digital Ocean (are you hearing us, Digital Ocean, speaking as a long-time customer) will continue adding new, good content.

PHP

PHP is a fascinating language. A lot of people love it. Probably even more people hate it. It’s an older language, and for its time, it was actually quite good. It was one of the first languages where you could embed code in an HTML page, and the code would produce output which would replace the code itself, rendering a new HTML page that would be sent down to the browser. That all took place on the back end. The PHP engine ran on the back end, and so no PHP code would be sent to the browsers–which couldn’t understand PHP anyway. Only the rendered HTML would. It worked very well, and still does. It had a massive library including excellent database connectivity.

It’s also a very messy language, and has for the most part been surpassed by other back end technologies, including node.js with its various templating engines, and C#, and Java. However, it does live on, especially with what’s probably the biggest PHP app on the planet: WordPress.

Nevertheless, PHP lives on, and new releases continue to come out. The latest releases include modern technologies to help it run much faster. The newer versions also include features previously only found in other languages. 

It’s not a part of an official standards organization, but for some time there was a group of individuals known as the PHP Group that oversaw its development. While the PHP Group lives on, PHP is now being sponsored by a big player in the software developer tools world, JetBrains, with their creation of The PHP Foundation.

The official documentation for PHP can be found at its official website, https://www.php.net/ . Click on the Documentation link at the top of the page. (Interestingly, the links take you to the latest version, not specific versions. So you’re probably safe bookmarking various pages in the documentation.)

C++

C++ was originally an extension to the original C language to include object oriented capabilities. Since then it has grown, with many additional features added. It was created by one of the biggest names in the computer science community, Bjarne Stroustrup. (Those of us who have met him can say he’s a very nice guy and we all have huge respect for him.) It was originally created in 1985, about four decades ago. Since its creation, it’s now overseen by the International Organization for Standardization (ISO).

The official C++ standard includes as part of the language an official library called  the STL (which stands for Standard Template Library – the reason for the word “template” is that templates play such an important role in C++ code).

Within the ISO is a standards committee that maintains official standards for C++. While they have a website, it’s really not all that useful. (Here it is https://isocpp.org/std/the-standard ) If you manage to get hold of the standard (it costs money) you’ll see it’s really intended to be read by developers who create C++ compilers. And the page I just linked to even admits as much, calling it a “mind-numbingly detailed technical document intended primarily for people writing C++ compilers…”

Instead, we need to look elsewhere for good documentation. The two most popular–also mentioned in the above link–are:

https://en.cppreference.com/w/

https://cplusplus.com/ 

Both sites have a lot of good material. Both fall somewhere between “almost official” and “trustworthy,” (probably closer to “almost official).

Additionally, probably the most commonly used C++ library that’s not actually part of the C++ standard is a library called Boost. Interestingly about Boost is that it’s become a bit of a testing grounds for libraries that eventually end up part of the STL. Many of the Boost developers are also part of the standards committee. Boost has an official page along with official documentation: https://www.boost.org/ (Don’t be fooled by the outdated look, the library is still maintained.)

Going Forward: Updates and More Languages

Note from Jeffrey: My plan is to maintain and update this page as languages change. I also plan to add more languages in the weeks and months to come. Meanwhile, here are the language I’ll write about, along with their official links:

• Bootstrap: Because CSS frameworks matter too! Head to https://getbootstrap.com/ 
• C (It’s ISO. You gotta pay money. Lots of money for the PDF. But do we care about C anymore? Maybe.)
• Rust: https://www.rust-lang.org/ 
• Go: https://go.dev/ 
• Ruby: https://www.ruby-lang.org/en/ 
• Objective C: Should I even include this? I’m curious to hear your thoughts in the comments. Apple has officially retired the language, and now wants people to use Swift. Objective C was originally used when Steve Jobs was fired from Apple, and he started NeXT computers. It’s a derivative of the original C language, but with object oriented programming, sort of a competitor to C++. Then Apple eventually hired Jobs back, and the NeXT computers came with him, and they morphed into the next generation of Macintosh computers. But the language has been retired.
• Swift: Apple’s replacement of Objective C: https://www.swift.org/ 
• Kotlin: https://kotlinlang.org/ 
• R: https://www.r-project.org/ 
• Lua: I don’t personally know a single human being that knows Lua. Or any aliens from another star systems for that matter. But here’s the official website: https://www.lua.org/ 
• Dart was going to be “the next big thing” that Google created. Maybe it is? Here’s the site: https://dart.dev/ 
• F#. I have to include F# (pronounced f-sharp). Nobody actually uses it. (Here comes the hate mail, because yeah, people really do use it, and it’s pretty darn cool, but has a HUGE, HUGE, HUGE learning curve and for that reason… well, nobody actually uses it. Other than some extremely intelligent people. Thus ends the hate mail. Hopefully.) It’s somewhat an implementation of another language called OCaml. If you want to learn it, I commend you. Here’s the link: https://fsharp.org/  And here’s where you can learn more about OCaml: https://ocaml.org/ 
• Scala: This language is interesting because it was originally created to target the Java Virtual Machine. And today it’s pretty much the standard language for developing for Android. I’ll probably add this one next to the main list above. (Read more at https://en.wikipedia.org/wiki/Scala_(programming_language) ) Meanwhile, here’s the official site: https://www.scala-lang.org/ 
• Erlang: Erlang seems like a VERY cool language. I hope to learn it sometime before I die. Even if I never actually use it. Learn more at https://www.erlang.org/ 
• Visual Basic (also VB, and VB.NET). Ahhhh Visual Basic. It actually has a very cool history. An amazing software developer named Alan Cooper originally created it and sold it to Microsoft. The original version was such a breath of fresh air in the world of making programming easier. Then Microsoft created the .NET runtime (similar to the Java runtime) and created a language that targeted it called VB.NET. Here’s the official documentation: https://learn.microsoft.com/en-us/dotnet/visual-basic/ (Yes, VB.NET lives on.)
• Fortran. Nevermind.
• COBAL. Great-grandpa Fred who used COBOL died a decade ago, but left some code that needs updating. Unfortunately, nobody remembers how to code in it.