#free source code

[trappedinafantasy37]

Let's talk a little bit about Minthara and her oath real quick. Now, a question that I have seen pop-up in a few places between Reddit, Tiktok, and even Tumblr, is how the in the hells Minthara isn't already an oathbreaker. Well, I have 3 potential theories as to why that is.

Because it is merely a game mechanic and Larian did not want your only potential paladin to be an oathbreaker upon recruitment.

Her original oath to Lolth never broke because she never willingly joined the Absolute and her oath to the Absolute was made under false pretenses.

When she joins your group, she makes a new oath in your name instead.

Personally, I think that Minthara's oath is actually a mixture of 2 and 3. Yes, it is possible for a paladin to have multiple oaths at the same time. It just isn't a recommended practice in tabletop DnD because they can sometimes contradict each other, some oaths will straight up break other oaths, or the players just are unable to manage them properly. In this case, I do believe that Minthara has two oaths, one to Lolth and one to you.

I have not been able to find any reference to how paladin oaths work when the paladin is being coerced or mind controlled. But from what I have read in DnD lore, when a paladin makes an oath they have to do so willingly, deliberately, and consciously. None of those things occurred for Minthara when she took up her oath to the Absolute which is why it did not break her oath to Lolth (because it otherwise would have as she would have been sworn to destroy the Absolute for Lolth). And, technically speaking, the god that the oath is sworn to cannot go in and break the oath. Only the paladin can break their own oath. I only think gods can revoke divinity from their clerics. So, even if Lolth was truly pissed at Minthara, Lolth herself cannot just break Minthara's oath. That is something only Minthara can do. Minthara's original oath to Lolth still being intact is not necessarily indicative that she still has Lolth's favor, it just means she hasn't yet broken the terms of that oath. Even a crisis of faith (which Minthara is going through) won't break the paladin's oath either.

Another thing that is important to note is that as of 5e, a paladin actually does not need to make their oaths in the name of a god or before a god as their divinity is powered solely by the oath itself. Paladins are able to just summon divine smites and other holy based powers by sheer force of will and conviction (which is pretty damn sexy if you ask me). I mean, oathbreaker paladins still have access to divinity as well. Of course, paladins can still make an oath in the name of a god and most typically do, it's just that gods are not the source of power behind that oath. An oath is nothing but a vow, a promise that the paladin makes *to* a god, not the other way around. It does not even need that gods approval. So Lolth abandoning Minthara will also not break Minthara's oath either because Lolth is not the one who made an oath to Minthara.

So, it is very much possible that when Minthara joins your group, she does make a new oath in your name as oaths don't need gods. But, Minthara herself does not actually know how to live her life without having some kind of god figure so she just kinda puts you in that spot for the time being. I mean, she literally prayed to multiple gods and you were the one that answered. Which is also one of the many reasons why she does to along with what you want to do (even if she disagrees) because the oath she made to you would keep herself in check and keep her from acting against you. Minthara already is a very loyal person, but if you have any doubts on Minthara's loyalty, just keep in mind that she is quite literally oath bound to do whatever you tell her to do and will not betray you.

Minthara also never goes out of her way to become an oathbreaker, even after you free her from the Absolute. To be precise, you have to command her to break her oath. And of course, she will do so willingly knowing the consequences. Despite her oath being broken, she will still abide by the tenants of that oath. But she does enjoy the freedom that comes with being an oathbreaker and now nothing will hold her back from achieving her goals. However, she also says she does not know if her oath will still stand when all the nonsense with the Absolute is resolved and she even implies that if you do take the Absolute, she will no longer have an Oath of Vengeance, but an Oath of Conquest (which I think fits her better than vengeance if I'm being honest).

Minthara also makes quite a few suggestions to you that would actually break you oath if you are a paladin. Such as making an oath to Gortash, or making certain choices in regards to the vampire spawn. But, Minthara never does any of these things herself and I think that is purposeful. She knows these actions are oathbreaking type of actions. She attempts to orchestrate a fight between Dame Aylin and the wizard knowing fully well that it will break Aylin's oath. And she really wants you to go snitch on the wizard (although I just think it's because of her disdain for wizards rather than her being a little scoundrel to mess with Aylin's oath).

She is very very careful to keep herself in the position that she is because she doesn't want to be an oathbreaker initially. She is also very careful to tell you to do all these things. The language that she uses in regards to her oaths are also very important. Her original oath to Lolth would have her sworn to destroy the Absolute. But, we also know that Minthara very much has other ideas for the Absolute that do not involve destroying it (but oaths only break from oath breaking actions, not oath breaking thoughts). And her oath to you, she very specifically says that she is sworn to destroy all those who serve the Absolute, which is not exactly the same kind of oath she has with Lolth.

But, there is only one instance in this game in which Minthara will willingly become an oathbreaker and you do not have to command her to be one and that is if and only if you claim the brain. Her choosing not to destroy the brain when she had the opportunity to breaks her oath to Lolth. Now, the oath that she makes to you is where it becomes very very tricky. The oath she made to you, she specifically uses the language to "destroy all those who serve the Absolute". Her oath gets broken to you because she has become someone who serves the Absolute. But, there's more than that. If you become the Absolute, you also enthrall all your other companions which would make them servants of the Absolute and she also does not destroy them. Ironically, her choosing to serve you as the Absolute, breaks the oath she made to you because she has gone back on what she said she was going to do in your name. But most importantly, she chose not to get vengeance for herself.

Her oath to you was never to help you become the Absolute. Her oath was specifically to assist you with destroying the Absolute and all those who serve it. Her choosing not to destroy the Absolute and everyone who serves it, breaks both of her oaths. So, the Minthara that greets you at the gallows is now an oathbreaker. But, as I mentioned earlier, Minthara has already expressed the notion of taking up a completely different oath if you were to claim the Absolute. She helped you become the Absolute, knowing it was going to break her oath, and she had the intention of immediately replacing it with an Oath of Conquest, making her the first official paladin of the Absolute.

The fact that she wants you to become Absolute at all and that she prefers being an oathbreaker is why I read her as a canon oathbreaker. But she will never break her oath out of betrayal, but because of loyalty and devotion. She breaks her oath trying to make you as powerful as you can be. I have also discussed previously that her devotion is her fatal flaw and her choosing to remain devoted to you could potentially get her back in the same position you found her (that is if you betray her and choose to use the Absolute to reenthrall her). Her becoming solely devoted to you officially removes any and all ties she has to Lolth. But it causes Minthara to remain stagnant in which she doesn't learn anything, she doesn't change at all, and she doesn't grow.

She will live the rest of her life devoted to someone that isn't herself and act in the name of someone that isn't herself. She will live the rest of her life helping you achieve your goals and ambitions and what she wants is kinda secondary to all that because she has propped you up on a pedestal. She has always lived her life in service of a god and she does not know how not to. Many of the things that she has done in her life are not because she wanted to do them, but because she had the burden of expectations either from Lolth, from her family, or from Menzoberranzan culture and her oath kept her bound to these expectations. And she is falling back into that cycle with you because you failed to show her that there was another way and that she could be devoted to herself. You failed to show her that she does not need a god and she can indeed choose for herself.

[bloodypixels]

Angel Nurse ⟢ Google Doc Muse Template

A multi-page single muse Google docs template based on a Japanese singer Momone Chinoi!

RBLOG 2 USE, DO NOT REMOVE CREDIT

Note: This is my first ever Google docs template, so I apologize for it being a bit bad… I’ve seen so many cool docs, and I thought, after editing so many of them, why not make my own? I hope it’s usable at least!

[hhexed]

[mostlysignssomeportents]

"Open" "AI" isn’t

Tomorrow (19 Aug), I'm appearing at the San Diego Union-Tribune Festival of Books. I'm on a 2:30PM panel called "Return From Retirement," followed by a signing:

https://www.sandiegouniontribune.com/festivalofbooks

The crybabies who freak out about The Communist Manifesto appearing on university curriculum clearly never read it – chapter one is basically a long hymn to capitalism's flexibility and inventiveness, its ability to change form and adapt itself to everything the world throws at it and come out on top:

https://www.marxists.org/archive/marx/works/1848/communist-manifesto/ch01.htm#007

Today, leftists signal this protean capacity of capital with the -washing suffix: greenwashing, genderwashing, queerwashing, wokewashing – all the ways capital cloaks itself in liberatory, progressive values, while still serving as a force for extraction, exploitation, and political corruption.

A smart capitalist is someone who, sensing the outrage at a world run by 150 old white guys in boardrooms, proposes replacing half of them with women, queers, and people of color. This is a superficial maneuver, sure, but it's an incredibly effective one.

In "Open (For Business): Big Tech, Concentrated Power, and the Political Economy of Open AI," a new working paper, Meredith Whittaker, David Gray Widder and Sarah B Myers document a new kind of -washing: openwashing:

https://papers.ssrn.com/sol3/papers.cfm?abstract_id=4543807

Openwashing is the trick that large "AI" companies use to evade regulation and neutralizing critics, by casting themselves as forces of ethical capitalism, committed to the virtue of openness. No one should be surprised to learn that the products of the "open" wing of an industry whose products are neither "artificial," nor "intelligent," are also not "open." Every word AI huxters say is a lie; including "and," and "the."

So what work does the "open" in "open AI" do? "Open" here is supposed to invoke the "open" in "open source," a movement that emphasizes a software development methodology that promotes code transparency, reusability and extensibility, which are three important virtues.

But "open source" itself is an offshoot of a more foundational movement, the Free Software movement, whose goal is to promote freedom, and whose method is openness. The point of software freedom was technological self-determination, the right of technology users to decide not just what their technology does, but who it does it to and who it does it for:

https://locusmag.com/2022/01/cory-doctorow-science-fiction-is-a-luddite-literature/

The open source split from free software was ostensibly driven by the need to reassure investors and businesspeople so they would join the movement. The "free" in free software is (deliberately) ambiguous, a bit of wordplay that sometimes misleads people into thinking it means "Free as in Beer" when really it means "Free as in Speech" (in Romance languages, these distinctions are captured by translating "free" as "libre" rather than "gratis").

The idea behind open source was to rebrand free software in a less ambiguous – and more instrumental – package that stressed cost-savings and software quality, as well as "ecosystem benefits" from a co-operative form of development that recruited tinkerers, independents, and rivals to contribute to a robust infrastructural commons.

But "open" doesn't merely resolve the linguistic ambiguity of libre vs gratis – it does so by removing the "liberty" from "libre," the "freedom" from "free." "Open" changes the pole-star that movement participants follow as they set their course. Rather than asking "Which course of action makes us more free?" they ask, "Which course of action makes our software better?"

Thus, by dribs and drabs, the freedom leeches out of openness. Today's tech giants have mobilized "open" to create a two-tier system: the largest tech firms enjoy broad freedom themselves – they alone get to decide how their software stack is configured. But for all of us who rely on that (increasingly unavoidable) software stack, all we have is "open": the ability to peer inside that software and see how it works, and perhaps suggest improvements to it:

https://www.youtube.com/watch?v=vBknF2yUZZ8

In the Big Tech internet, it's freedom for them, openness for us. "Openness" – transparency, reusability and extensibility – is valuable, but it shouldn't be mistaken for technological self-determination. As the tech sector becomes ever-more concentrated, the limits of openness become more apparent.

But even by those standards, the openness of "open AI" is thin gruel indeed (that goes triple for the company that calls itself "OpenAI," which is a particularly egregious openwasher).

The paper's authors start by suggesting that the "open" in "open AI" is meant to imply that an "open AI" can be scratch-built by competitors (or even hobbyists), but that this isn't true. Not only is the material that "open AI" companies publish insufficient for reproducing their products, even if those gaps were plugged, the resource burden required to do so is so intense that only the largest companies could do so.

Beyond this, the "open" parts of "open AI" are insufficient for achieving the other claimed benefits of "open AI": they don't promote auditing, or safety, or competition. Indeed, they often cut against these goals.

"Open AI" is a wordgame that exploits the malleability of "open," but also the ambiguity of the term "AI": "a grab bag of approaches, not… a technical term of art, but more … marketing and a signifier of aspirations." Hitching this vague term to "open" creates all kinds of bait-and-switch opportunities.

That's how you get Meta claiming that LLaMa2 is "open source," despite being licensed in a way that is absolutely incompatible with any widely accepted definition of the term:

https://blog.opensource.org/metas-llama-2-license-is-not-open-source/

LLaMa-2 is a particularly egregious openwashing example, but there are plenty of other ways that "open" is misleadingly applied to AI: sometimes it means you can see the source code, sometimes that you can see the training data, and sometimes that you can tune a model, all to different degrees, alone and in combination.

But even the most "open" systems can't be independently replicated, due to raw computing requirements. This isn't the fault of the AI industry – the computational intensity is a fact, not a choice – but when the AI industry claims that "open" will "democratize" AI, they are hiding the ball. People who hear these "democratization" claims (especially policymakers) are thinking about entrepreneurial kids in garages, but unless these kids have access to multi-billion-dollar data centers, they can't be "disruptors" who topple tech giants with cool new ideas. At best, they can hope to pay rent to those giants for access to their compute grids, in order to create products and services at the margin that rely on existing products, rather than displacing them.

The "open" story, with its claims of democratization, is an especially important one in the context of regulation. In Europe, where a variety of AI regulations have been proposed, the AI industry has co-opted the open source movement's hard-won narrative battles about the harms of ill-considered regulation.

For open source (and free software) advocates, many tech regulations aimed at taming large, abusive companies – such as requirements to surveil and control users to extinguish toxic behavior – wreak collateral damage on the free, open, user-centric systems that we see as superior alternatives to Big Tech. This leads to the paradoxical effect of passing regulation to "punish" Big Tech that end up simply shaving an infinitesimal percentage off the giants' profits, while destroying the small co-ops, nonprofits and startups before they can grow to be a viable alternative.

The years-long fight to get regulators to understand this risk has been waged by principled actors working for subsistence nonprofit wages or for free, and now the AI industry is capitalizing on lawmakers' hard-won consideration for collateral damage by claiming to be "open AI" and thus vulnerable to overbroad regulation.

But the "open" projects that lawmakers have been coached to value are precious because they deliver a level playing field, competition, innovation and democratization – all things that "open AI" fails to deliver. The regulations the AI industry is fighting also don't necessarily implicate the speech implications that are core to protecting free software:

https://www.eff.org/deeplinks/2015/04/remembering-case-established-code-speech

Just think about LLaMa-2. You can download it for free, along with the model weights it relies on – but not detailed specs for the data that was used in its training. And the source-code is licensed under a homebrewed license cooked up by Meta's lawyers, a license that only glancingly resembles anything from the Open Source Definition:

https://opensource.org/osd/

Core to Big Tech companies' "open AI" offerings are tools, like Meta's PyTorch and Google's TensorFlow. These tools are indeed "open source," licensed under real OSS terms. But they are designed and maintained by the companies that sponsor them, and optimize for the proprietary back-ends each company offers in its own cloud. When programmers train themselves to develop in these environments, they are gaining expertise in adding value to a monopolist's ecosystem, locking themselves in with their own expertise. This a classic example of software freedom for tech giants and open source for the rest of us.

One way to understand how "open" can produce a lock-in that "free" might prevent is to think of Android: Android is an open platform in the sense that its sourcecode is freely licensed, but the existence of Android doesn't make it any easier to challenge the mobile OS duopoly with a new mobile OS; nor does it make it easier to switch from Android to iOS and vice versa.

Another example: MongoDB, a free/open database tool that was adopted by Amazon, which subsequently forked the codebase and tuning it to work on their proprietary cloud infrastructure.

The value of open tooling as a stickytrap for creating a pool of developers who end up as sharecroppers who are glued to a specific company's closed infrastructure is well-understood and openly acknowledged by "open AI" companies. Zuckerberg boasts about how PyTorch ropes developers into Meta's stack, "when there are opportunities to make integrations with products, [so] it’s much easier to make sure that developers and other folks are compatible with the things that we need in the way that our systems work."

Tooling is a relatively obscure issue, primarily debated by developers. A much broader debate has raged over training data – how it is acquired, labeled, sorted and used. Many of the biggest "open AI" companies are totally opaque when it comes to training data. Google and OpenAI won't even say how many pieces of data went into their models' training – let alone which data they used.

Other "open AI" companies use publicly available datasets like the Pile and CommonCrawl. But you can't replicate their models by shoveling these datasets into an algorithm. Each one has to be groomed – labeled, sorted, de-duplicated, and otherwise filtered. Many "open" models merge these datasets with other, proprietary sets, in varying (and secret) proportions.

Quality filtering and labeling for training data is incredibly expensive and labor-intensive, and involves some of the most exploitative and traumatizing clickwork in the world, as poorly paid workers in the Global South make pennies for reviewing data that includes graphic violence, rape, and gore.

Not only is the product of this "data pipeline" kept a secret by "open" companies, the very nature of the pipeline is likewise cloaked in mystery, in order to obscure the exploitative labor relations it embodies (the joke that "AI" stands for "absent Indians" comes out of the South Asian clickwork industry).

The most common "open" in "open AI" is a model that arrives built and trained, which is "open" in the sense that end-users can "fine-tune" it – usually while running it on the manufacturer's own proprietary cloud hardware, under that company's supervision and surveillance. These tunable models are undocumented blobs, not the rigorously peer-reviewed transparent tools celebrated by the open source movement.

If "open" was a way to transform "free software" from an ethical proposition to an efficient methodology for developing high-quality software; then "open AI" is a way to transform "open source" into a rent-extracting black box.

Some "open AI" has slipped out of the corporate silo. Meta's LLaMa was leaked by early testers, republished on 4chan, and is now in the wild. Some exciting stuff has emerged from this, but despite this work happening outside of Meta's control, it is not without benefits to Meta. As an infamous leaked Google memo explains:

Paradoxically, the one clear winner in all of this is Meta. Because the leaked model was theirs, they have effectively garnered an entire planet's worth of free labor. Since most open source innovation is happening on top of their architecture, there is nothing stopping them from directly incorporating it into their products.

https://www.searchenginejournal.com/leaked-google-memo-admits-defeat-by-open-source-ai/486290/

Thus, "open AI" is best understood as "as free product development" for large, well-capitalized AI companies, conducted by tinkerers who will not be able to escape these giants' proprietary compute silos and opaque training corpuses, and whose work product is guaranteed to be compatible with the giants' own systems.

The instrumental story about the virtues of "open" often invoke auditability: the fact that anyone can look at the source code makes it easier for bugs to be identified. But as open source projects have learned the hard way, the fact that anyone can audit your widely used, high-stakes code doesn't mean that anyone will.

The Heartbleed vulnerability in OpenSSL was a wake-up call for the open source movement – a bug that endangered every secure webserver connection in the world, which had hidden in plain sight for years. The result was an admirable and successful effort to build institutions whose job it is to actually make use of open source transparency to conduct regular, deep, systemic audits.

In other words, "open" is a necessary, but insufficient, precondition for auditing. But when the "open AI" movement touts its "safety" thanks to its "auditability," it fails to describe any steps it is taking to replicate these auditing institutions – how they'll be constituted, funded and directed. The story starts and ends with "transparency" and then makes the unjustifiable leap to "safety," without any intermediate steps about how the one will turn into the other.

It's a Magic Underpants Gnome story, in other words:

Step One: Transparency

Step Two: ??

Step Three: Safety

https://www.youtube.com/watch?v=a5ih_TQWqCA

Meanwhile, OpenAI itself has gone on record as objecting to "burdensome mechanisms like licenses or audits" as an impediment to "innovation" – all the while arguing that these "burdensome mechanisms" should be mandatory for rival offerings that are more advanced than its own. To call this a "transparent ruse" is to do violence to good, hardworking transparent ruses all the world over:

https://openai.com/blog/governance-of-superintelligence

Some "open AI" is much more open than the industry dominating offerings. There's EleutherAI, a donor-supported nonprofit whose model comes with documentation and code, licensed Apache 2.0. There are also some smaller academic offerings: Vicuna (UCSD/CMU/Berkeley); Koala (Berkeley) and Alpaca (Stanford).

These are indeed more open (though Alpaca – which ran on a laptop – had to be withdrawn because it "hallucinated" so profusely). But to the extent that the "open AI" movement invokes (or cares about) these projects, it is in order to brandish them before hostile policymakers and say, "Won't someone please think of the academics?" These are the poster children for proposals like exempting AI from antitrust enforcement, but they're not significant players in the "open AI" industry, nor are they likely to be for so long as the largest companies are running the show:

https://papers.ssrn.com/sol3/papers.cfm?abstract_id=4493900

I'm kickstarting the audiobook for "The Internet Con: How To Seize the Means of Computation," a Big Tech disassembly manual to disenshittify the web and make a new, good internet to succeed the old, good internet. It's a DRM-free book, which means Audible won't carry it, so this crowdfunder is essential. Back now to get the audio, Verso hardcover and ebook:

http://seizethemeansofcomputation.org

If you'd like an essay-formatted version of this post to read or share, here's a link to it on pluralistic.net, my surveillance-free, ad-free, tracker-free blog:

https://pluralistic.net/2023/08/18/openwashing/#you-keep-using-that-word-i-do-not-think-it-means-what-you-think-it-means

Image: Cryteria (modified) https://commons.wikimedia.org/wiki/File:HAL9000.svg

CC BY 3.0 https://creativecommons.org/licenses/by/3.0/deed.en

[anarchistfrogposting]

The “no one would ever work for free” crowd never really considered the eternal bond between humans and increasingly complex tools

[ask-seb]

How would I go about learning about computer programming? Any advice for absolute beginners?

hm… well, i guess there's two primary ways you can start.

firstly, you could take a course. there are some online that are free to start with, like harvard's cs50, but i personally think the second option is a bit more fun and hands on.

the second option is to take some time to look up coding basics and experiment a bit through a small personal project. you can learn about the basic structure of computer programs and how programming languages work by watching youtube videos, or browsing stack overflow... and from there you can start small by making little programs that can do simple things. after that, it'll be a good foundation into coding more complex things.

good luck.

[capricioussun]

A very silly Halloween uf papyrus monday

Alt colours + Lore™️ below the cut ✨

Every few years I go as Josh Dun for Halloween, but this year I spent any costume money on actually going to see them. So instead I am living vicariously through my monstersona Source, and they bothered Edge into being Clancy with them <3

[frostplays]

Inanimate Insanity having an ARG was not what I expected to happen this year

[slitherpunk]

not gonna lie it's taking a Lot of willpower to stick with godot

[therevengeoffrankenstein]

step 1: post "'we're pretty boys for secret girls' from 'austin, we have a problem' by fall out boy is a trans coded lyric."

step 2: turn phone on vibrate

step 3: ....

[digitalbundlekit]

daman game source code free demo

[kaiasky]

kaiagpt, how do I learn to program better? I write so many bugs

Bugs are a frustrating but unavoidable part of the programming experience. Perhaps instead of focusing on avoiding bugs, you could work on improving your debugging skills to squash those bugs faster. Here are some things you could try.

Learn to use a unit testing framework and write tests for your code as you go. That way, if your code doesn't function how you expect, you'll be able to tell immediately!

Practice using a debugger to step through your code. A debugger can let you investigate the state of your variables during execution, and can often be much faster than print-statement based debugging.

Familiarize yourself with refactoring tools. If your code is messy, it's often a good idea to clean it up by refactoring it. Knowing how to find all uses of a symbol will make this cleanup easier.

Beyond that, like with any skill, developing as a programmer involves practice. Try and learn something from every bug you fix, and soon you'll find yourself making those errors less and less.

[vanishingmoments]

people in the notes of that post make me kinda sad

[vryivs]

unpopular hot take but I prefer when things are subtext because then if I don't like them i can simply ignore them

[frog707]

No bug is too old, no coder is too young ...

[quietmarie]

What is Async Anyway?

Explaining async/await and general concurrency concepts in programming languages.

A lot of modern languages have async/await syntax built directly into them, and the construct can be extremely useful. Examples of languages that include these concepts are JavaScript, C#, Python, and Swift, and even modern relatively low-level languages like Rust have this syntax. Even though it's usually thought of as a more advanced feature, I think it is really not that hard to use once you get the hang of it, and it is super useful and rewarding when you really understand it.

This is going to be a bit of a long and pretty technical post, but I hope it can give you some confidence to know what async/await really does when you use it, and maybe it can help you use it more effectively. Keep in mind that I will not be able to go over everything in super deep detail, and that I am going to simplify stuff, but it should give you an idea how these systems work.

I am a little curious about eventually following this up with a post looking at how these systems compare under the hood in different programming languages, so let me know if you'd be interested in that.

Big post under the cut.

Parallelism and Concurrency

Computers today can do many things at the same time. And I mean that literally: in one instant, a modern CPU can be working on multiple instructions. That's because a single CPU has multiple cores that can all execute code (mostly) independent from each other. This is called parallelism, and the way we as programmers interact with that is through threads. Most programming languages, especially "lower level" ones, have a way for programmers to create a thread that will run some part of your code. Creating a thread is telling the computer that it can, and should, run the code in your threads in parallel (although various systems such as the OS still have discretion over when and if that actually happens).

Parallelism is not quite concurrency tho. Where parallelism is about your computer literally doing multiple things at once, concurrency is about your computer doing multiple things, but not at once. With concurrency, you kind of pretend you're doing a parallelism. But in reality, stuff doesn't happen at the same time. Instead, your system (runtime) does some work on task A a bit, then on task B, then maybe again on task A, etc., but doesn't work on the two at the same time. So, in a concurrent system it might look like task A and B are progressing simultaneously from the outside, but work actually only happens in sequence.

Let's Talk About I/O

I/O stands for input/output and describes data in your program that comes from elsewhere, or that gets sent elsewhere. So for example, user input is I/O. And similarly, a web request can be I/O, whether you send it or receive it. So let's use that as an example: you send a web request to some API to fetch you the cutest bunny images and facts:

But the service is taking its sweet time to respond.

Fact: Loading bunny fact…

With how we did it here, we halt execution of the entire thread until the response comes in (at least in most languages, more on that later). In this case, we call get a blocking method because it, well, blocks the thread without actively doing useful work.

What if we could instead use the thread for other tasks instead of just sitting there, twiddling our thumbs and waiting on the server? This smells of concurrency…

Callbacks

Callbacks are a way for programmers to avoid that period of thumb twiddling. The new getWithCallback function now returns immediately, but it doesn't return a value. Instead, we have to register the code we want to run once the server responds with the function:

The function we pass to getWithCallback is called the callback, and it gets called by the client* only once the response arrives. Oh look, here it is:

Fact: A rabbit's life span is about 8 years, though sterilized rabbits (those who are spayed/neutered) can live as long as 10-12 years.

*"The client calls it" is a big simplification, there might be a lot more stuff happening here. But the important bit is that the client magically does not need to block to wait for the response.

Promises and Futures

What JavaScript calls Promises and what a lot of the other languages call Futures is essentially sugar sprinkled on callbacks - it makes our callback code a little nicer. Callbacks can commonly create a concept called "callback hell", where you have to call a function that takes a callback inside the function that takes a callback inside the function that takes a callback…

(Code modified from https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Using_promises)

To avoid this, functions now can return a Promise instead of taking a callback. Promises represent the promise that, while a concrete value might not exist right now, it will in the future. Once the value exists, we say the Promise resolves. The code above with Promises would then look like this:

It still doesn't look perfect, and there are things you can do to make it look a little nicer, but it's so much less nested. The callback in the then function will be called once the value is ready, and the callback itself can also return a Promise. The then function then returns a Promise which will get resolved once the future from the callback is resolved. Many other languages have a concept similar to JavaScript's Promise, and it's often called something like Future or Task (because it would be too easy to have consistent naming across languages).

Now keep in mind neither of those solutions above are really "concurrency" in the definition we used above. This is because the thread we call, for example, getWithCallback on still completely belongs to us. We could keep using it, and we would not get interrupted to execute the callback. Depending on the language and runtime, the callback might get executed on a different thread, or the runtime might have to wait until we are completely done with what we were doing to then use our thread to call it. The same thing goes for the callbacks in the then method of promises.

Async/Await

And async/await is just some sugar and magic fairy dust on top of Promises (or Futures or whatever). It makes our code look like it should be blocking, but in reality it isn't. Here's what our bunny image code looks like with async/await:

So here, a couple things happen. First, the Promise is created and the web request is initiated. Then, the Promise is awaited. For that, (if the Promise is not resolved at this point already,) the task first yields, meaning it tells the runtime that it is not doing any useful work at the moment, and that the thread it ran on can be used for other tasks. The runtime then makes a note of where to continue execution when that Promise resolves, and looks around for other tasks that currently need executing to put them on that thread. After a while passes, the Promise resolves, and once the runtime has some resources available for us (maybe because another task just yielded), execution on our original task is continued with the API response.

Fact: A rabbit's teeth never stop growing! Many people believe they need to chew to keep their teeth short. While they do enjoy chewing, it's the normal wear from where their top and bottom teeth meet that keeps a rabbit's teeth short.

This is more in line with the concurrency we sought out above. We can interleave other computations while our task is still running, but during times where it is not doing any useful work. (Still, because you may have multiple threads your tasks can run on and move between, it might not always be 100% technically accurate to call this system concurrent.) This is also why it is important to not block for long in async contexts: if you're hogging the thread for too long, you're stopping other tasks from progressing and throwing a lot of the benefits you gained from doing it concurrently in the bin. Most async runtimes will give you some option to run expensive or blocking code elsewhere, so that you can keep the benefits you gain from async.

So that's the explanation what async/await does, and the broad strokes of how it works. If you have any more questions regarding the topic, feel free to ask! I think it'll be fun to occasionally write a longer post on interesting things I've learned, so if you have topic suggestions, don't be afraid to tell me!

Further links and sources

Don't Block The Event Loop! - Why you should avoid blocking in Node.js, and what pitfalls to look out for.

I got the bnuuy images and facts from the animality API. The licenses on the images are not super clear, but I'll assume it's okay for me to use them here with credit because it's an open API.

I lifted the definitions and some of the explanation for parallelism and concurrency from Steve Klabnik's talk on Rust's Journey to Async/Await. The talk is more technical and very focused on Rust, but it's a great talk.

I referenced the mdn web docs at various points, they're a great resource.

I created the code screenshots using the carbon app.