DEV Community: Jack Giffin

Is ACM (Association for Computing Machinery) a joke, a hoax, a scam, or what?

Jack Giffin — Thu, 13 Feb 2025 04:20:35 +0000

I couldn’t find much information about this, so here is a blog post of my findings and initial reactions. I’m curious what other people’s thoughts are and especially curious if there is an aspect of ACM I’m not seeing.

ACM
Advancing Computing as a Science & Profession
We see a world where computing helps solve tomorrow’s problems–where we use our knowledge and skills to advance the profession and make a positive impact.

(From https://www.acm.org/about-acm)

OK, that all sounds good to me so far! I agree 100% with ACM’s expressed sentiments.

Browsing around, we can see ACM tackles a number of high visibility public promotions, such as the Turing Award: https://amturing.acm.org/

So far, the ACM seems like a force for good and gets plenty of funding and attention that ACM can put to use for good.

Next, let’s check out ACM’s Ethics Page:

1.1 Contribute to society and to human well-being, acknowledging that all people are stakeholders in computing.
1.2 Avoid harm.
1.3 Be honest and trustworthy.
1.4 Be fair and take action not to discriminate.
1.5 Respect the work required to produce new ideas, inventions, creative works, and computing artifacts.
1.6 Respect privacy.
1.7 Honor confidentiality.

(From https://www.acm.org/code-of-ethics)

I love ACM’s ethics! These ethics exactly line up with mine and most-every other Free Open Source Software developer I know! Infact, the only people I’ve ever met who don’t share the above ethics are people who don’t contribute to open source software.

Surely, the ACM must be all aboard the FOSS train to world goodness and upholding their ethical guidelines, no? Let’s check that out:

[1 real search result; the rest are people with “FOSS” in their last name:]
"Open Source Workshop Explores FOSS in Universities"

Opensource.com, March 31, 2014
Universities' application of free and open source software (FOSS) was the focus of an open source workshop held at ACM's annual meeting of its Special Interest Group in Computer Science Education (SIGCSE).

(From https://www.acm.org/search#stq=foss&stp=1)

What?! But ACM seemed so good?! How could ACM not be on board the FOSS train and have zero mentions of FOSS on their website?! (The only mention of FOSS on ACM is a single sponsored article from a different website, shown above.)

To clarify and explain this to people out of the loop about open source software, understand that FOSS is the one and only one way actual, tangible technological progress ever happens on Earth, especially including the sociological aspects of ethical software. Due to this, failure to espouse FOSS exactly equates to failure to promote innovation and exactly equates to failure to promote ethical software.

Put another way, the only evidence supporting ACM’s purported values is a complete lack thereof. In the best case (giving ACM the benefit of the doubt), ACM deserves an award for BETI (my own phrase, Bureaucratic Excellence in Total Ignorance) and funnels their resources at the futile endeavor of encouraging wolves to play nice with chickens in the hen house. In the worst and most assuming case, ACM is well aware their efforts are in vain and is a front for distracting the public’s attention and funding away from more worthwhile causes.

Either way, I presently do not see how the world benefits from ACM given ACM’s inability to uphold their own purported values. Is there some aspect of ACM I’m missing that redeems them? Let me know in the comments

FAQ list:

What about ACM’s support of research? Infact, ACM actively sabotages research by hiding research articles behind paywalls. Anyway, this doesn’t harm innovation much as the overwhelming majority of peer-reviewed CompSci literature is aimless dribble that accomplished exactly nothing. All CompSci innovation and progress happens in open source. The little literature that has contributed significantly to CompSci was all (without exception) published alongside open source code demoing its implementation, oftentimes a feature-complete reference library

How To License Open Source Code Properly

Jack Giffin — Thu, 15 Dec 2022 00:06:23 +0000

(This article is pending review/edits by a lawyer. As always, this article and the information herein is provided WITHOUT ANY WARRANTY and is provided without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. So, only use this article as a starting point and never use this article as a substitute for a lawyer.)

Many open-source software projects only add a LICENSE file and stop there. This quick-and-dirty approach to licensing software is okay and certainly much better than no license or brief mention of the license in the README, but it can leave much to be desired in the event of legal scrutiny.

Even for trivial projects, it's vital to always exercise due diligence with licensing. The law does not follow common sense—the law may superficially appear to follow common sense as many laws are created with common sense in mind—and it's much better to proactively bulletproof everything than to deal with the ensuing mess in the unlikely event of a legal matter. Oftentimes, it's not even the software creator/copyright-holder who suffers but a user of your software, and I imagine you wouldn't want to jeopardize the users of your software.

A Primer/Introduction On The GNU GPL

For those unfamiliar with the GNU GPL, let me elucidate the ironic contrast between the extreme simplicity of the GNU GPL and the many many pages of text it takes to legally enforce it.

The GNU GPL can be summarized down to one statement: enforce that every successive recipient passing your software forwards inherits all the same rights/abilities for what they can do with the software. A crucial implication of this definition is that certain freedoms—particularly, the ability to distribute your software closed-source—are restricted in order to safeguard the propagation of other freedoms—particularly, access to the source code. So, to spell it out in more words, every aspect of the GNU GPL centers around enforcing the 4 basic software freedoms everyone should have:

(Source: https://www.gnu.org/graphics/amihud-4-freedoms.html)

Permissive licenses like the MIT, Apache, CC0, and Unlicense all fail to enforce that any of the software freedoms propagate forwards to the end users at of the software (because, for example, permissive licenses allow inclusion in closed-source software, and the recipients of that closed-source software don't enjoy the software freedoms.) These permissive licenses encourage unjust exploitation of the software with incorporation/adaption into closed-source business software. And, it doesn't stop there. Catalyzing the spread of closed-source software has significant ramifications further down the line where it's abused to force users (especially business users) to pay exorbitant fees for continued access to their content, it's used as a fear-tactic to trick users into thinking they need useless software (the scam that is anti-virus software), and it's used to lock customers in and prevent them from switching to a different solution (vendor-lockin).

So, why is the GPL so long? Because the court of law doesn't care about common sense (because common sense is debatable as it is not written down anywhere); every condition and contingency must be laid out in plaintext. For example, there's a ton of text explaining how GPL software can't be used in permissively licensed software (instead, it must be combined and the combination of GPL+permissive must be GPL-licensed). To explain, allowing GPL code to be used in non-GPL code would lead to the situation of, for example, adding a MIT-licensed helloworld.c file to a GPL-licensed project and calling the resulting combination project MIT-licensed to bypass the GPL. It's simply not possible to objectively lay down an all-encompassing bulletproof list of rules for where to draw the line between allowing GPL usage in permissive software and not allowing its usage, which is why the GPL must default to the only objective option available, which is to forbid any usage of GPL code in non-GPL code. (Actually, there is one way to draw the line—shared object file linking—and the LGPL/Lesser-GPL permits LGPL-software's inclusion in proprietary/permissive software only in this way. However, the LGPL is problematic as it encourages closed-source/permissive software, so try to avoid LGPL usage.)

On the other end of the spectrum is the AGPL/Affero-GPL, or, as I like to call it, the Awesome GPL. The AGPL is the same word-for-word as the GPL except that the AGPL adds a section expanding the scope of the user/customer of the software to anyone interacting with the software over a network. This addendum closes the SaaSS—service as a software substitute—loophole. For example, this website, dev.to, is AGPL software: https://github.com/forem/forem. As Forem demonstrates, the AGPL has a convenient ace up its sleeve— anti-competitive retaliation—which means that a competitor would be unsuccessful trying to start a competing business using Forem's source code because dev.to is already established and Forem will be able to request the source code for their competitor's fork (either directly by becoming a paying customer of their competitor or indirectly by paying a 3rd party to become a customer) and take all of their competitor's improvements/features. (Actually, a competitor could be successful if Forem stopped caring about its users and mistreated its customers, as its customers would then prefer switching to the same-software different-business competitor. And, users would be able to painlessly switch because the GPL guarantees the inspectability of the source code, so there's nothing Forem could do to prevent its competitor from developing software to ease users' migration to its system.) Libraries should not be licensed under the AGPL because it can needlessly complicate matters for certain projects. For example, if you have a super complex CI/CD system deeply integrated with an AGPL-licensed HTTP server, then you have to figure out some way for users visiting the website to run the AGPL HTTP server on their computer if they request source code, which could be a doozie. Always remember that the mission of the GPL is to promote software freedom, not to be a pain in the ass to deal with.

For further reading on the GPL, I highly recommend reading through https://www.gnu.org/licenses/license-compatibility.html and https://www.gnu.org/licenses/gpl-faq.html.

Licensing Steps

Now that we understand the GNU GPL, let's dive into how to apply it to our project. The following overview comes straight from the horse's mouth:

Get a copyright disclaimer from your employer or school.
Give each file the proper copyright notices. Make sure to clearly identify which versions of the license users can use.
Add a COPYING file with a copy of the GNU GPL or GNU AGPL.
(If using the LGPL, which is discouraged) Also add a COPYING.LESSER file with a copy of the GNU LGPL.
Put a license notice in each file.
(Optionally) make the program display a startup notice.
(If using the AGPL) make the program offer copies of its source code.

Hot links to the license files:

GNU GPLv3 (recommended for software): https://www.gnu.org/licenses/gpl-3.0.txt
GNU GPLv2 (recommended for browser JS/HTML/CSS): https://www.gnu.org/licenses/gpl-2.0.txt
GPL AGPL (recommended for HTTP/remote service software and discouraged for libraries): https://www.gnu.org/licenses/agpl-3.0.txt
GNU LGPLv3 (discouraged): https://www.gnu.org/licenses/lgpl-3.0.txt

Please continue reading as the process is not as straightforward as the simple list above might lead you to believe.

Giving Files Copyright Notices

Even this detail is not as trivial as it may seem as Richard Stallman recommends expressing explicit support for both your chosen version of the GPL and additionally any later version (read https://www.gnu.org/licenses/identify-licenses-clearly.en.html):

/* SPDX-License-Identifier: GPL-3.0-only or GPL-3.0-or-later */
/*
 * Brief description of the software written in C or C++ or
 *  or C# of Rust or Node.JS or a million other languages.
 *
 * Copyright (C) 2023 Your name <email@address.com>.
 * 
 * This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
// code...

For other comment styles and files prefixed with a shebang, put the notice text immediately after all necessary lines at the top of the file:

#!/usr/bin/env python3
# SPDX-License-Identifier: GPL-3.0-only or GPL-3.0-or-later
#
# Brief description of the software written in C or C++ or
#  or C# of Rust or Node.JS or a million other languages.
#
# Copyright (C) 2023 Your name <email@address.com>.
# 
# This program is free software: you can redistribute it and/or modify
#  it under the terms of the GNU General Public License as published by
#  the Free Software Foundation, either version 3 of the License, or
#  (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
#  but WITHOUT ANY WARRANTY; without even the implied warranty of
#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#  GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
#  along with this program.  If not, see <https://www.gnu.org/licenses/>.

# code...

Dual-License Your Software

There are many cases of software that interacts closely with—yet independent of—other separately licensed (potentially proprietary) software, and any offered example snippets/peeks of the other software side are themselves licensable software. If these snippets are licensed under the GNU GPL, then usage of these snippets would be subject to the full terms of the GNU GPL, so it's important to analyze the context of usage of these snippets and decide whether to dual-license the snippet under permissive licenses. If you are unsure, then it's likely that your software does not need this extra work done; very little software needs this. Nobody cares about how these small snippets are used, so there's no harm in removing all possibilities of legal liability.

My proposed solution for this problem is to create a README-snippets.md file which contains all the code snippets from the README and is dual-licensed under the all-permissive BSD 0-clause license (see 0BSD on SPDX).

First, create a section in your README.md explaining the licensing structure for your project.

<!-- Example section in README.md -->
### Licensing Structure

This project has a complex licensing structure defined by the following rules in order from lowest priority to highest priority.
1. By default, all files are licensed under SPDX either GPL-3.0-only or GPL-3.0-or-later. See the `LICENSE` file for more information.
2. The `README-snippets.md` file is additionally provided under the SPDX 0BSD license. See the [0BSD license](README-snippets.md#0bsd-license) section of the README-snippets.md for the license text.
<!-- more points about licensing structure as needed... -->

Second, create the README-snippets.md file containing a dump of all your documentation's code snippets and license it under the 0BSD license.

<!-- Example contents of README-snippets.md -->
<!-- SPDX-License-Identifier: 0BSD or GPL-3.0-only or GPL-3.0-or-later -->

### Code Snippets Dump

This page is a dump of all the code snippets in the documentation licensed under the BSD 0-clause license so that you may freely use these snippets for any and all purposes.

\`\`\`
uint32_t popcnt32(uint32_t x) {
    x = (x & 0x55555555) + (x >> 1 & 0x55555555);
    x = (x & 0x33333333) + (x >> 2 & 0x33333333);
    x = (x & 0x0f0f0f0f) + (x >> 4 & 0x0f0f0f0f);
    x = (x & 0x00ff00ff) + (x >> 8 & 0x00ff00ff);
    x = (x & 0x0000ffff) + (x >> 16 & 0x0000ffff);

    return x;
}
\`\`\`

<!-- dump more snippets... -->

### 0BSD License

This project is _primarily_ (not exclusively) licensed under SPDX either GPL-3.0-only or GPL-3.0-or-later. A copy of the BSD 0-clause license is provided here only for this file to be licensed under the SPDX 0BSD license. See the [Licensing Structure](README.md#licensing-structure) in README.md for an authoritative explanation of the licensing structure of this project.

> BSD Zero Clause License
> 
> Copyright (C) YEAR by AUTHOR EMAIL
> 
> Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted.
> 
> THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

This way, in the event of litigation of one of the users of your software, the user can claim they got the snippet code from the all-permissive README-snippets.md file under the BSD 0-clause license, which should quash any dispute.

If you have a more complex organization of documentation than just stuffing it all in your README, then it would probably be best to create a special documentation page where you dump all of your code snippets and license that documentation page under the BSD 0-clause license.

Emphasize that this extra work is rarely needed, as explained in the first paragraph of this section. Typically, only CLI software such as a script interpreter might need this README-snippets.md workaround.

Advertising the GNU GPL license

It would be considerate of you to advertise that your software is licensed under the GNU GPL (and which GNU GPL) at the top of your README with logos. This mitigates the possibility of users accidentally using your software in contexts such as developing proprietary software where it can't be used.

|![gplv3-only](https://www.gnu.org/graphics/gplv3-with-text-136x68.png) |![gplv3-or-later](https://www.gnu.org/graphics/gplv3-or-later.png)|
|-|-|

# This is The README header for the project

Here's what that looks like:

This is The README header for the project

Displaying Licensing Information At Startup

Whether you need to publish licensing information greatly depends upon the scope of your software:

If you are writing a library, you shouldn't publish or provide any APIs for licensing information; a library should be submissive and obedient, not vociferous and overextending.

If you are writing a GUI application, then just show the license as part of the "About This"/"Info" menu. (And, it's considered best-practice to also provide the user with a pop-up where they can read a locally-stored copy of the entire GPL license):

Copyright (C) <year>  <name of author>

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <https://www.gnu.org/licenses/>.

If you are writing interactive CLI software, then produce the following text at startup. If you are unsure whether your CLI software is interactive, then I can guarantee it's not interactive.
```
<program>  Copyright (C) <year>  <name of author>
This program comes with ABSOLUTELY NO WARRANTY; for details type 'show w'.
This is free software, and you are welcome to redistribute it
under certain conditions; type 'show c' for details.
```
You would need to modify 'show w' and 'show c' to reflect the commands you provide with your interactive CLI. The 'show w' or 'show warranty command prints sections 15-17 of the GNU GPL license (from gpl-3.0.txt or whichever version of the GPL you are using.) The 'show c' or 'show copying' command prints the full text of the GNU GPL license.

If you are writing non-interactive CLI software, then the most common behavior is to show the license as part of the --version long-hand argument:

~$ gzip --version
gzip 1.10
Copyright (C) 2018 Free Software Foundation, Inc.
Copyright (C) 1993 Jean-loup Gailly.
This is free software.  You may redistribute copies of it under the terms of
the GNU General Public License <https://www.gnu.org/licenses/gpl.html>.
There is NO WARRANTY, to the extent permitted by law.

Written by Jean-loup Gailly.

Some programs additionally provide --license, such as gzip, though this is not strictly mandatory:

~$ gzip --license
gzip 1.10
Copyright (C) 2018 Free Software Foundation, Inc.
Copyright (C) 1993 Jean-loup Gailly.
This is free software.  You may redistribute copies of it under the terms of
the GNU General Public License <https://www.gnu.org/licenses/gpl.html>.
There is NO WARRANTY, to the extent permitted by law.

Inform your users so they know their rights

The GPL can be quite scary as it's often chalked up to be some humongous complicated "viral" license and this can sometimes scare people away. So, I always try to include a quick short blurb hitting the most relevant/important aspect(s) of the GPL and how they apply to this particular software project. That way, users of my software can both see how benign the GPL is and they can know how to properly use my software without getting into legal trouble.

Listed below are some example blurbs you can copy and paste into your README depending on the type of software you are developing.

Example blurb for software libraries:

### The GNU GPL/General-Public-License

<YourLibraryName> is free and, more importantly, libre software, being licensed under either GPL-3.0-only or GPL-3.0-or-later, which secures the rights of end users of software incorporating <YourLibraryName>.

**Notice:** This library can _only_ be used in GPL-licensed software. So, for example, your software must be licensed under version 3 or later of either the GPL or AGPL licenses in order to incorporate this GPLv3 or GPLv3-or-later library.

Below is a copy of the legally-binding disclaimer you implicitly agree to by using this software.

> This program (<YourLibraryName>) is free software: you can redistribute it
> and/or modify it under the terms of the GNU General Public License as
> published by the Free Software Foundation, either version 3 of the
> License, or (at your opinion) any later version.
>
> This program is distributed in the hope that it will be useful,
> but WITHOUT ANY WARRANTY; without even the implied warranty of
> MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
> GNU General Public License for more details.
>
> You should have received a copy of the GNU General Public License
> along with this program.  If not, see <https://www.gnu.org/licenses/>.

Example Blurb For interpreter/compiler/scripting-language software:

### The GNU GPL/General-Public-License

<YourInterpreterName> is free and, more importantly, libre software, being licensed under either GPL-3.0-only or GPL-3.0-or-later, which secures the rights of end users of software incorporating <YourInterpreterName>.

**Notice:** The *GPL-3.0-only or GPL-3.0-or-later* license only applies to the script interpreter. The code in the scripts you execute with this software is independent of and abstracted from the GNU GPL license, so this software may be freely used to run script files of any license. Only modifications to this software itself involve the GPL license.

Below is a copy of the legally-binding disclaimer you implicitly agree to by using this software.

> This program (<YourInterpreterName>) is free software: you can redistribute it
> and/or modify it under the terms of the GNU General Public License as
> published by the Free Software Foundation, either version 3 of the
> License, or (at your opinion) any later version.
>
> This program is distributed in the hope that it will be useful,
> but WITHOUT ANY WARRANTY; without even the implied warranty of
> MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
> GNU General Public License for more details.
>
> You should have received a copy of the GNU General Public License
> along with this program.  If not, see <https://www.gnu.org/licenses/>.

(Notice: this gets tricky because it becomes problematic where your GPL interpreter software ends and where the user's potentially proprietary software ends. In this case, it's best to license the standard library of your scripting language under the GNU LGPL license and write a formal specification of your scripting language to shift the perspective towards the user writing their scripts to target a general language specification, not a GPL-licensed language implementation)

Example Blurb For Interactive/GUI Software

### The GNU GPL/General-Public-License

<YourGUISoftwareName> is free and, more importantly, libre software, being licensed under either GPL-3.0-only or GPL-3.0-or-later, which secures the rights of end users of software incorporating <YourGUISoftwareName>. The main implication of this license is that pieces of code taken from (even if modified) <YourGUISoftwareName> cannot be used in non-GPL-licensed software. However, GPL-licensed code can still be combined with non-GPL code if the licenses are compatible (visit [https://gplv3.fsf.org/wiki/index.php/Compatible_licenses](https://gplv3.fsf.org/wiki/index.php/Compatible_licenses)) license and you license the resulting software combination under GPL-3.0-only or GPL-3.0-or-later (preferably both.)

**Notice:** The GPL has no effect on you unless you delve into this project's source code. So, use this software freely for whatever purpose. Just make sure to read up on the GPL if you delve into the source code.

Below is a copy of the legally-binding disclaimer you implicitly agree to by using this software.

> This program (<YourGUISoftwareName>) is free software: you can redistribute it
> and/or modify it under the terms of the GNU General Public License as
> published by the Free Software Foundation, either version 3 of the
> License, or (at your opinion) any later version.
>
> This program is distributed in the hope that it will be useful,
> but WITHOUT ANY WARRANTY; without even the implied warranty of
> MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
> GNU General Public License for more details.
>
> You should have received a copy of the GNU General Public License
> along with this program.  If not, see <https://www.gnu.org/licenses/>.

Example Blurb for CLI Software and Software that generates files.

### The GNU GPL/General-Public-License

<YourCLISoftwareName> is free and, more importantly, libre software, being licensed under either GPL-3.0-only or GPL-3.0-or-later, which secures the rights of end users of software incorporating <YourCLISoftwareName>. The main implication of this license is that pieces of code taken from (even if modified) <YourCLISoftwareName> cannot be used in non-GPL-licensed software. However, GPL-licensed code can still be combined with non-GPL code if the licenses are compatible (visit [https://gplv3.fsf.org/wiki/index.php/Compatible_licenses](https://gplv3.fsf.org/wiki/index.php/Compatible_licenses)) license and you license the resulting software combination under GPL-3.0-only or GPL-3.0-or-later (preferably both.)

**Notice:** The *GPL-3.0-only or GPL-3.0-or-later* license only applies to this software. The files you create using this software are your own original works, subject to your copyright and whatever purpose/license you choose.

Below is a copy of the legally-binding disclaimer you implicitly agree to by using this software.

> This program (<YourCLISoftwareName>) is free software: you can redistribute it
> and/or modify it under the terms of the GNU General Public License as
> published by the Free Software Foundation, either version 3 of the
> License, or (at your opinion) any later version.
>
> This program is distributed in the hope that it will be useful,
> but WITHOUT ANY WARRANTY; without even the implied warranty of
> MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
> GNU General Public License for more details.
>
> You should have received a copy of the GNU General Public License
> along with this program.  If not, see <https://www.gnu.org/licenses/>.

Addendum: Using Code from StackOverflow

All code snippets on StackOverflow are licensed under the latest version of Creative Common's CC-BY-SA license (currently v4.0 here). When using StackOverflow, it's crucial to always cite the StackOverflow post:

// popcnt32 was adapted from https://stackoverflow.com/a/14010273/5601591 
uint32_t popcnt32(uint32_t x) {
    x = (x & 0x55555555) + (x >> 1 & 0x55555555);
    x = (x & 0x33333333) + (x >> 2 & 0x33333333);
    x = (x & 0x0f0f0f0f) + (x >> 4 & 0x0f0f0f0f);
    x = (x & 0x00ff00ff) + (x >> 8 & 0x00ff00ff);
    x = (x & 0x0000ffff) + (x >> 16 & 0x0000ffff);

    return x;
}

It's that simple. Make special note of the fact that I extensively modified the function to the point where it no longer resembles the one I got from the StackOverflow answer. Those modifications don't matter; I used the StackOverflow answer as a starting point, it doesn't harm anything to cite the StackOverflow answer, and it alleviates any legal ramifications. For example, there might be a CCTV camera recording what I'm doing.

this and super in JavaScript

Jack Giffin — Sun, 07 Feb 2021 02:30:13 +0000

Prototyping in JavaScript

Before one can understand this and super, one must understand prototypes. Below is a demystification of how Object.* methods work in terms of __proto__.

// !!! DO NOT INSERT THIS INTO YOUR CODE !!! //
Object.setPrototypeOf = function(object, proto) {
    object.__proto__ = proto;
    return object;
};
// !!! DO NOT INSERT THIS INTO YOUR CODE !!! //
Object.getPrototypeOf = function(object) {
    return object.__proto__;
};
// !!! DO NOT INSERT THIS INTO YOUR CODE !!! //
Object.create = function(proto, props) {
    var _object = {__proto__: proto};
    if (props) Object.defineProperties(_object, props);
    return _object;
};
// !!! DO NOT INSERT THIS INTO YOUR CODE !!! //

Prototypes work like this: accessing object.property searches object for "property". If object does not have "property", then object.__proto__ is searched. Then, object.__proto__.__proto__ is searched. This keeps going until __proto__ is null:

console.log(Object.prototype.__proto__); // logs `null`
var ap = Array.prototype.__proto__;
console.log(ap === Object.prototype); // logs `true`

Below is a demystification of how property lookups are performed. Getting object.property will exhibit the same behavior as propertyLookup(object, "property") all the time.

function propertyLookup(_o, prop) {
    var obj = _o;
    do {
        var desc=Object.getOwnPropertyDescriptor(obj, prop);
        if (desc) {
            if (desc.get) return desc.get.call(_o);
            return desc.value; // handles all other cases
        }
    } while (obj = obj.__proto__);
    return undefined; // unneccecary because this is default
}
function propertyAssign(_o, prop, _value) {
    var obj = _o;
    do {
        var desc=Object.getOwnPropertyDescriptor(obj, prop);
        if (desc) {
            if (desc.set) {
                desc.set.call(_o, _value);
                return _value;
            }
            if (desc.get) return _value; // no way to handle
            if (!desc.writable) return _value;//won't handle
            if (obj === _o) { // keep property description
                desc.value = _value;
                Object.defineProperty(obj, prop, desc);
                return _value;
            }
            break; // handles all other cases
        }
    } while (obj = obj.__proto__);
    Object.defineProperty(obj, prop, {
        value: _value,
        writable: true,
        enumerable: true,
        configurable: true
    });
    return _value;
}

`this`

this as that happens for function f in 3 and only 3 circumstance in JavaScript as of 2021:

Property access: that.callWithThat(), that["callWithThat"](), and that[0]() (or any index)
Function methods: f.call(that), f.bind(that), f.apply(that), and Reflect.apply(f, that)
Constructors: new f and Reflect.construct(f, [], that)

`that.callWithThat()`

Whenever you access a property you proceed to call, the object you accessed becomes the this of the function you called. Observe:

function method() {
    console.log( this.name );
}
var inner = {
    name: "inner",
    handle: method
};
var outer = {
    name: "outer",
    handle: method,
    inner: inner
};

inner.handle(); // logs "inner"
outer.handle(); // logs "outer"
outer.inner.handle(); // logs "inner"

var handle = outer.handle; // or var { handle } = outer;
handle(); // throws an error because `this` is undefined

Note that the prototype of the function does not matter one bit:

var utils = {
    print: function() {
        console.log( this.value );
    }
};
utils.print.value = "Hello!"
utils.print(); // logs `undefined`
utils.value = "World!";
utils.print(); // logs `World!`

However, you can do some interesting trickery using named functions:

var moldable = {
    setProto: function protoMethod() {
        Object.setPrototypeOf(this, protoMethod);
    },
    printFoob: function() {
        console.log(this.foob);
    }
};
moldable.setProto.foob = 10;
moldable.printFoob(); // logs undefined
moldable.setProto();
moldable.printFoob(); // logs `10`

You can also make a non-deterministic object (albeit a very very slow object) via getters:

var options = [
    {value: 50},
    {value: "dinosaur"},
    {value: true},
    {value: 1e+99}
];
var nondet = {
    get status() {
        Object.setPrototypeOf(this, options[
            Math.random() * options.length | 0
        ]);
        return "OK";
    }
};
console.log(nondet.value); // logs `undefined`
console.log(nondet.status); // logs `OK`
console.log(nondet.value); // logs something random
console.log(nondet.status); // logs `OK`
console.log(nondet.value); // logs something random

The same goes with arrays:

var arr = ["ArrayName", function() {
    console.log( this[0] );
}];
arr[1](); // logs "ArrayName"

2. Function methods

Function methods manually set the this property. Below is the simplest possible demystification of the function methods:

// !!! DO NOT INSERT THIS INTO YOUR CODE !!! //
Function.prototype.call = function(proto, ...args) {
    proto.__call_method = this; // `this` is a function
    return proto.__call_method(...args);
};
// !!! DO NOT INSERT THIS INTO YOUR CODE !!! //
Function.prototype.bind = function(proto, ...args) {
    var that = this; // `this` is a function
    return function() {
        proto.__call_method = that;
        return proto.__call_method(...args, ...arguments);
    };
};
// !!! DO NOT INSERT THIS INTO YOUR CODE !!! //
Function.prototype.apply = function(proto, argsList) {
    proto.__call_method = this; // `this` is a function
    return proto.__call_method(...argsList);
};
// !!! DO NOT INSERT THIS INTO YOUR CODE !!! //

There are many problems with the simplistic demonstration above:

A __call_method property is left on the proto object.
The methods don't work when proto is null or a primitive
The methods don't have the correct function names
The bind method returns an object with a prototype
The apply method doesn't work when the arguments list is null

For the sake of completeness, below is a standard-compliant demystification of how the function methods work:

// sliceFrom has very similar behavior to Array.prototype.slice
function sliceFrom(array, start) {
    var result = [];
    for (var k=0, i=start, len=array.length; i < len; k++, i++)
        result[k] = array[i];
    return result;
};
// !!! DO NOT INSERT THIS INTO YOUR CODE !!! //
Function.prototype.call = function call(that) {
    if (that == null) return this(...sliceFrom(arguments, 1));
    var proto=typeof that == "object" ? that : that.__proto__;
    var uuid = Symbol();
    proto[uuid] = this;
    var returnValue = proto[uuid](...sliceFrom(arguments, 1));
    delete proto[uuid];
    return returnValue;
};
// !!! DO NOT INSERT THIS INTO YOUR CODE !!! //
Function.prototype.bind = function bind(that) {
    var f = this, superArgs = sliceFrom(arguments, 1);
    if (that == null) return function() {
        f(...superArgs, ...arguments);
    };
    var proto=typeof that == "object" ? that : that.__proto__;
    var uuid = Symbol();
    proto[uuid] = this;
    function Binded() {
        return proto[uuid](...superArgs, ...arguments);
    };
    Binded.prototype = undefined;
    return Binded;
};
// !!! DO NOT INSERT THIS INTO YOUR CODE !!! //
Function.prototype.apply = function apply(that, _args) {
    var args = _args == null ? [] : _args;
    if (that == null) return this(...args);
    var proto=typeof that == "object" ? that : that.__proto__;
    var uuid = Symbol();
    proto[uuid] = this;
    var returnValue = proto[uuid](...args);
    delete proto[uuid];
    return returnValue;
};
// !!! DO NOT INSERT THIS INTO YOUR CODE !!! //

The only two discrepancies from the standard behavior of function methods is the introduction of a symbol upon the proto, which can be revealed via Object.getOwnPropertySymbols and the fact that the prototype is still in the function returned from Function.prototype.bind.

3. `new` constructors

new f sets the value of this to be Object.create(f.prototype). This is true for functions and classes alike.

function constructor() {
    console.log(this.__proto__ === constructor.prototype);
    console.log(Object.getOwnPropertyNames(this).length);
}
new constructor(); // logs `true` and `0`

When f is a plain old function (not a class), it can return an object, which will become the new value of the new f. Observe:

var refObject = {name: "John"};
function construct() {
    return refObject;
}
console.log(new construct().name) // logs `"john"`
console.log(new construct === new construct); // logs `true`

classes are mostly just sugar syntax for plain old constructors. Below is how one would mix the two together.

function Value(initial) {
    this.value = initial;
}
Value.prototype.get = function() {
    return this.value;
};
Value.prototype.set = function(newvalue) {
    this.value = newvalue;
};
class UnsetError extends Error {} // special error type
class MaybeValue extends Value {
    constructor(value, state) {
        super( value );
        this.isset = !!state;
    }
    get() {
        if (!this.isset)
            throw new UnsetError("MaybeValue not ready");
        return super.get();
    }
    set(newvalue) {
        this.isset = true;
        super.set( newvalue );
    }
}
var val = new MaybeValue;
try {
    console.log( val.get() ); // throws error
} catch(e) {
    if (!(e instanceof UnsetError)) throw e; //propagate
    val.set("example value"); // initialize the value
}
console.log( val.get() ); // logs `"example value"`

The real power of classes comes into play with extending native constructors:

class MyArray extends Array {
    constructor() {
        super("hello", ...arguments);
    }
    set(index, value) {
        this[index] = value;
    }
}

var arr = new MyArray;
arr.set(1, 10);
arr.set(2, 20);
console.log( arr.length ); // logs 3, just like a native array
console.log( arr[0] ); // logs `"hello"`
arr.length = 0;
console.log( arr[2] ); // logs `undefined` like a native array

In the above example, we extended the Array constructor, and our MyClass behaved exactly as a native array would. There is no pretty way to achieve this same behavior with old constructors. The solution below is how it would be done, and it's pretty ugly and slow because you have to emulate the behavior of length with a getter and setter.

var lengthSymbol = Symbol("length");
var arrayDescriptor = {
    get: function() {
        var max = this[lengthSymbol];
        for (var key in this)
            if (max < key && Math.floor(key) === +key)
                if (this.hasOwnProperty(key))
                    max = +key;
         return max;
    },
    set: function(_val) {
        var value = +_val;
        if (value < 0 || Math.floor(value) !== value)
            throw RangeError("Invalid array length");
        this[lengthSymbol] = value;
        for (var key in this)
            if (value <= key && Math.floor(key) === +key)
                delete this[key];
    }
};
function extendArray(proto) {
    Object.setPrototypeOf(proto, Array.prototype);
    proto[lengthSymbol] = 0;
    Object.defineProperty(proto, "length", arrayDescriptor);
}
function MyArray() {
    this[0] = "hello";
    for (var k=1, i=0, len=arguments.length; i < len; k++, i++)
        this[k] = arguments[i];
    this[lengthSymbol] = k;
}
extendArray( MyArray.prototype );
MyArray.prototype.set = function(index, value) {
    this[index] = value;
};

var arr = new MyArray;
arr.set(1, 10);
arr.set(2, 20);
console.log( arr.length ); // logs 3, just like a native array
console.log( arr[0] ); // logs `"hello"`
arr.length = 0;
console.log( arr[2] ); // logs `undefined` like a native array

`super`

super means exactly the same thing as this.__proto__ except that super is a keyword so JavaScript won't execute (it raises a SyntaxError) when super is put in the wrong place.

var object = {
    __proto__: {
        value: [1, 2, 3],
    },
    value: ["a", "b", "c"],
    printThisValue: function() {
        console.log(this.value);
    },
    printSuperValue() {//same as printSuperValue: function()
        console.log(super.value);
    },
    printThisProtoValue: function() {
        console.log(this.__proto__.value);
    }
};
object.printThisValue(); // logs ["a", "b", "c"]
object.printSuperValue(); // logs [1, 2, 3]
object.printThisProtoValue(); // [1, 2, 3], same as super

`new.target` v.s. `this`

They both serve different purposes, but they are both local to the function being called. new.target is either undefined or a callable function whose .prototype property was used to create this:

function printTarget() {
    // Both new.target and this are undefined here
    console.log(new.target);
};
new function c() {
    console.log(new.target === c); // logs `true`
    var p = new.target.prototype; // c.prototype
    console.log(p === this.__proto__); // logs `true`
    printTarget(); // logs `undefined`
};

However, without new, new.target is undefined everywhere:

(function() {
    console.log(this); // logs `[1,2,3]`
    console.log(new.target); // logs `undefined`
}).call([1,2,3])

new.target, just like this, is still visible in local arrow functions, as these arrow functions allow this and new.target to pass through.

new function c(){
    this.hello = 427;
    (() => {
        console.log(this.hello);
        console.log(new.target === c);
    })(); // logs `427` and `true`
}

new.target has the same lifespan as this and persists within arrow expressions beyond the scope of the original instantiation. The value of this and new.target are frozen in time at the location where the arrow function is created.

(new function c(){
    this.hello = 427;
    return msg => {
        console.log(msg);
        console.log(this.hello);
        console.log(new.target === c);
    };
})("Foob"); // logs `"Foob"`, `427`, and `true`

new.target is important because, without it, userland functions are unable to determine whether they are supposed to initialize an object.

Correctly understanding `proto`

The very first snippet at the top of this post exhibits wrongful behavior in the following two circumstances:

when the object doesn't inherit from Object.prototype, for example, Object.create(null)
When __proto__ is shadowed (e.x. Object.defineProperty({}, "__proto__", {value: "test"}) would not change the internal proto and further attempt to read the object's __proto__ would yield "test")

To see this in action, observe the following code:

var n = new Number( 47 );
console.log( Object.keys( n ) ); // logs []
console.log( JSON.stringify(n) ); // logs "4.7"
console.log( n.toExponential() ); // logs "4.7e+1"

// This is equivalent to n.__proto__ = n.__proto__
n.__proto__ = Number.prototype;
console.log( Object.keys( n ) ); // logs []
console.log( JSON.stringify(n) ); // logs "4.7"
console.log( n.toExponential() ); // logs "4.7e+1"

n.__proto__ = null;
console.log( Object.keys( n ) ); // logs []
console.log( JSON.stringify(n) ); // Uncaught TypeError: can't convert n to number
console.log( n.toExponential() ); // Uncaught TypeError: n.toExponential is not a function

// Because n no longer inherits from Object.prototype, __proto__ is now an ordinary property
n.__proto__ = Number.prototype;
console.log( Object.keys( n ) ); // logs ["__proto__"]
console.log( JSON.stringify(n) ); // Uncaught TypeError: can't convert n to number
console.log( n.toExponential() ); // Uncaught TypeError: n.toExponential is not a function

It errors because __proto__ is actually a non-special ordinary property on Object.prototype. Thus, the correct way to describe __proto__ is to write the getters and setters for Object.prototype.__proto__ in terms of Object.getPrototypeOf and Object.setPrototypeOf.

// !!! DO NOT INSERT THIS INTO YOUR CODE !!! //
Object.defineProperty(Object.prototype, "__proto__", {
    configurable: true,
    enumerable: false,
    get: function() {
        return Object.getPrototypeOf( this );
    },
    set: function(newProto) {
        Object.setPrototypeOf( this, newProto );
    }
});
// !!! DO NOT INSERT THIS INTO YOUR CODE !!! //

The above code will always exhibit the proper behavior of __proto__. See this for yourself by running Object.getOwnPropertyDescriptor(Object.prototype, "__proto__") in the console and observing the native getter and setter methods defined there.

That's all. I hope this article helped expand your knowledge of JavaScript's inner workings.