So there is this game called Valheim that recently released. You may or may not have recently read the article where they claim to have sold over a million copies around a week after release.

I bought it to give it the 2-hour smell test and it seems pretty darn good. However, this game seems best played with others and I doubt my friend group will end up playing this. Renting a server seems pretty cheap so I was wondering how interested you would be in a Tildes community server? I would be down for paying for a month and seeing where it goes from there.

It looks like min slots for a server would be 10 slots but I would imagine that's okay since we all wouldn't be in the same time zone. I can scale this up if the demand is there.

Thoughts?

Other Info:

What is Valheim, the Viking game blowing up on Steam?

Server is set up!

Game is password protected but if you click me, you will find what you need.

You are invited to cut right to the heart of things for the first Tildes Writing Club event. Let's road test the club with brief fiction or verse. Got a sonnet that needs airing? Want to weave a brief spell and dip before the magic fades? Let's read it!


Length: less than 500 words of prose, or 30 or fewer lines of poetry.
Theme: Optional. But if you're in search of inspiration, @acdw suggests you work with this palette: love/unlove/hate/red/heart/viscera.
Guidelines: Post your short work in the submissions topic, which will open on 2/14. Throughout the next couple of weeks, leave feedback for at least two other submissions. Brief rules for a brief, trial-run writing event. To opine on the rules that are taking shape for 3/1, reply here.

I've always wanted to be able to run probabilities when considering doing something that could infect me with coronavirus. I know how many people test positive, how many are dying and how many are getting tested. But what I really want to know is what are the odds that a mask-less interaction with one person will infect me.

Maybe it's a random itch.io find; maybe it's a minor title from a long forgotten console; maybe it's a dev project your friend asked you to play test. Whatever it is, you think it's neat, and you never see it mentioned anywhere.

Tell us about the game -- what is it? Why is it noteworthy? Do you think it deserves more recognition than it's gotten? Why do you think it's as hidden away as it is?

The first two image links in the spoilerbox of my Timasomo update don't work (as in aren't clickable or turn the text into a link), but others do.

Bug?

I am looking for practical ways to prove the Earth is round using materials accessible to the average person. I have zero interest in disproving Flat Earth folks.

I am inspired by Dan Olson's (Folding Ideas) excellent video where he is able to do this measuring the curvature of a lake near his home that has a very specific geography that lends itself to this sort of experiment. I've seen all sorts of ways to prove this measuring shadows and poles, using gyroscopes, etc. and wanted to know if there are any practical guides for proving once and for all that the Earth is round for yourself relying on nothing more than experimentation.

What I'm not looking for:

• Math relying on flight times/charts
• Video/picture evidence
• Deductive proofs built on agreed upon premises
• Expensive tests
• Extremely time consuming projects
• Underwhelming results (relying on a probabilistic argument for a round Earth from the evidence.)

What I am looking for:

• Practical experiments
• Things I could potentially do without spending much money
• Tests that aren't largely comprised of accepting someone else's research
• Potentially math-heavy evidence
• Results that are strong and conclusive

I've thought of finding some easy to test version of Eratosthenes' proof using two poles. I've also thought about using a balloon and sending something to space like what is done in this Tom Scott video. Nothing seems well documented in such a way as for me to be able to follow it at home.

TL;DR: I think it would be a meaningful experience to have the power to prove the Earth is round by myself, for myself. I can only compare this desire to the desire a child with a telescope has when wishing to observe Saturn or Mars themselves for the first time. It's not to prove anything or to settle doubts, but for the personal value of independently observing this astronomical fact oneself.

So a few weeks back someone posted an article here about Super Recognizers. These are people that can instantly remember 80% of a persons face and can identify that face easily later on. It talked about how these people are getting hired by police departments across the world.

It caught my attention because my wife has always been freakishly good at facial recognition and recall. Well, she took the test, which led to another test, and today she received her official invitation to join Super Recognizers International!

This is a big deal because her company is about to go under and she has been considering leaving lately. This will open up doors for her to find work she can do from home on a flexible schedule. Thanks @skybrain for posting that article and thank you to the Tildes community for being here!

Shadow of War keeps crashing on me now, which has provided the inspiration for me to finally sit down and get this off my chesticles. I think bad things happen in my brain when I read the news too much or don't get enough exercise.

I remember when tormenting NPCs in games used to make me feel very sad. I was almost driven to tears by the villagers in Black & White being flattened under a carelessly dropped boulder, in fact. Over the years, though, I've found that my capacity for cruelty toward NPCs has grown considerably. I'll give a long example:

So, got any confessions of your own? Is this a potential indicator of psychopathy? How many musically talented Pushkrimps have you recruited?

I'm interested in hearing your stories.

• What are/were your symptoms like?
• Do you know how/when you were exposed?
• What was your timeline of events, including symptoms, testing, quarantining, etc.?
• Did it affect other aspects of your life (e.g. employment, relationships, etc.)?
• Have you fully recovered?
• What's something about your experience that you haven't seen a lot of mentions of elsewhere?

And of course, feel free to share anything else not asked in these questions.

If you personally have not had it but someone close to you has, feel free to share your experiences with that as well.

META: If this topic is better served in ~health.coronavirus feel free to move it!

Are you an “old timer” in the computer industry? I’m writing a story about the things programmers (and QA people) had to do to test their software. It’s meant to be a nostalgic piece that’ll remind people about old methods — for good or ill.

For example, there was a point where the only way to insert a breakpoint in the code was to insert “printfs” that said “I got to this place in the code!” And all testing was manual testing. Nothing was automated. If you wanted a bug tracking system, you built your own.

So tell me your stories. Tell me what you had to do to test software, way back when, and compare it to today. What tools did you use -- or build? Is there anything you miss? Anything that makes you especially glad that the past is past?

C’mon, you know you wanted a “remember when”!

Based on replies to this comment there seems to be a decent amount of interest around the topic of reworking voting, so I thought I would start a thread to get some more input. We already had similar discussions about a year ago but it looks like some people's opinions may have shifted somewhat? and as was noted in the comment thread, 1 week wasn't really enough to accurately assess the value of something like making vote counts invisible.

Things to consider:

• Do you think how voting works changes your/other's behavior on this site? and if it does, is this change positive or negative?
• Would you support reworking/modifying voting? If so, how?
• How long should we test said modifications if they are made?
• anything else you consider relevant

Collect and code, until it is done.

And now it is.

Ladies (the few that we have, I mean holy ^FUCK ), gents and everyone inbetween, welcome to the results of the 2020 Tildes census, which is only 34% less horrifying than 2020 itself. And you better believe I'm going to keep this up for the whole post, because fuck the responses this year, while greater in numbers, were occasionally still [REDACTED].^{thanks, thought police}

In the year of the lord, 2020^{CAN YOU PLEASE END ALREADY}, we got 350 responses in, which is a whopping 100 more than last year. I don't know how many accounts we have in total, no one does, and I'm too lazy to calculate the percentages right now because I'm calculating as we go so from the point of me writing this to clicking Post Topic an hour or two will probably pass.^{Update: I went to bed, so like 10 hours passed} Absolute numbers is all you're going to get here, so fuck me, fuck you and fuck off.^{I need some alcohol}

Anyway, let's go through the census. I let JotForms compile this nice graphical report that is pretty much useless because it completely breaks once either sexuality, gender or the myriad of various operating systems the people on here have get involved. But it's still funny seeing it struggle. Have a link to the PDF. So back to good Excel, my old nemesis.

Aggregated Data

Thankfully, this time around you'll have access to generate all this shit yourself, HERE YOU GO. The thing is in JSON, so easily deserializable, etc etc. I'm sure you people are skilled enough at typing the words into the IDEs to magic the data into your memory.

Important info: Empty answers are usually marked NO ANSWER, in case of numerical values it's usually -1 for age, -2 for the Kinsey scale (-1 is taken) and -69 for the 3 political values from the Sapply test, as these range from -10 to 10. Yes I made the default value -69. It's everyone's favourite number after all. Also, for some absolute FUCKED reason one of the values has 3 more entries than the other ones, I'm sure it has a totally VALID reason that has nothing to do with people entering bullshit. NOTHING.^{FuckingKILLME}

Also I can't be bothered to edit the "wrong" data out, i.e. typos in languages etc, so those are all in, maybe someone with more compassion than me can do that.

Kowalski, Analysis

First of all, I'm going to less graphs this year because it's fucking hard to aggregate things like ethnicity when you get responses ranging from black to a literal link of someone's You23AndMe results. Yes. I mean props to you for that but like, uh, FUCK, what am I going to do now? YOU ARE ALL MAKING THIS WAY TO FUCKING HARD. ლ(ಠ_ಠ ლ)

This propagates to basically all responses and next year I'm probably going to captain a way straighter course with less options, because I can't fucking MAKE FANCY GRAPHS WHEN YOU GIVE ME TOO MANY INDIVIDUAL RESPONSES^{FUCKINGKILLME}

Personal Shit

Geography

Not much has changed, the US still dominates, Canada second, though the British are catching up. I'm sure you'll have your tea party eventually. Though with good ol' Boris in charge I don't know if annexing the yanks is such a good idea. Also, as there are no invidual option here for everyone to FUCK IT UP it's the most sane graph of them all. No fucked colours this year, I promise, it's all scale.

Fancy Graph #1: Geography

Age

Fancy Graph #2: Age by decile For those wanting to repeat this, watch out, as the age by decile and specific age questions were exclusionary. You'll have to combine the results to get the same numbers. I hope. Unless I fucked up. Equal possibility.

Also whoever entered 28.9, because of you I had to make the age field in my code a double instead of an integer. Fuck you.

Gender etc.

I honestly thought this was going to be the wildest answer, but y'all are such a minority that it's fairly sane. The real clusterfuck starts after this question. Also whoever wrote prefer not to say, DID YOU NOT READ THE PART ABOUT THE OPTIONAL ANSWERS, [REDACTED] PLEASE [REDACTED] AAAHHHHHHHHHHHHHHHHHH-

Anyway as I said, fairly standard results.

Fancy Graph #3: Gender

Trans? Value
NO ANSWER 13
no 312
yes 23

Yeah I'm not gonna make a graph for a yes/no question, if that's bigoted you may scream at me in the comments.

Sexuality

I MADE THE SCREENSHOT BUT I FORGOT TO ADD IT FUCK FUCK FUCK FUCK

Kinsey

Also forgot about you. Average is 1,37, idk what else to do.

Ethnicity

This was a mistake. 124 wrote white. 23 wrote caucasian. One person wrote causcasion. One person wrote that it's illegal to ask this question in their country. Someone wrote I bleed red white and blue.

THIS WAS A MISTAKE.

Kill me. Safe to say, that Tildes is, as someone put it perfectly: white af. Yes this was also a reply. KILL ME.

Language

Fancy Graph #3,5: Language^{This was added later, and I'm really not updating the others.}

Religion

I'm just gonna let the graph speak for itself, I don't have it in me to keep the anger up.

Fancy Graph #4: Religion

Politics, Education, Work

This is where the fun begins. No, honestly not really.

Politics

If I average out our Sapply values, we get this compass result. Yeah we're all communists. So whoever said in their dislike the alt right people on this platform, I really don't know what you mean. If anything we need more to achieve PEAK CENTRISM. In all honesty, the people saying that this sub is a leftist echo chamber (there were a few), you may have a point.

When we get to the magical field of how everyone identifies themselves politically, well, let's just say^{ah, there's the rage again} I'M NOT GONNA REPEAT THIS NEXT YEAR, GREAT FUCKING IDEA. Whoever entered confused, I FUCKING AGREE. SINCE WHEN IS PINK A FUCKING POLITICAL AFFLIATION? We do have a pirate though.^Nice

You may wade through the rest OF [REDACTED] YOURSELF in the published data.

Education

Tildes is an educated lot, contrary to popular my belief after making this census. A good chunk of people have a Bachelors, Masters, PhD. Still only one MD though, so if you have a medical emergency take it up with... checks notes ^{Ah fuck I can't reveal anything.} ...Take up with them. ^{JK please call your local emergency line when you need help}

Fancy Graph #5: Education

Work

Actually fairly sensible results, except a few, like that one person that entered not STEM, thanks for not giving me any useful information. You have the ability TO NOT ENTER SOMETHING. THIS GOES FOR THE PERSON WHO ENTERED meh AS FUCKING WELL, [REDACTED].

Fancy Graph #6: Work

Technology

Fancy Graph #7: Computer Operating Systems

Fancy Graph #8: Mobile Operating Systems

Basically just like religions. You all have to many options, since we're all communists now according to average, and options are bad, you MAY ONLY USE WINDOWS VISTA FROM THIS POINT ON, OR THE GESTAPO WILL PAY YOU A VISIT ^{fuck, wrong mass murderers}

About Tildes

Have Acc? Value
NO ANSWER 7
yes 312
no 29

For consistency, and it didn't fit into the picture in a nice way.

Fancy Graph #9: Various Tildes Statistics

Most people migrated off reddit, followed by Hackernews. The rest is various random shit, include like 5 different ways of "I don't know", but the one person replying Gab surprised me. Didn't think people would hop on Tildes off Gab, since Gab is basically extreme rightwing Twitter and Tildes is like, the antithesis to that. Leftist userbase, longform discussion.

The long replies

Once again, can't graph the shit outta this, so here's the collection of them. One reply per line. Had to format some replies to fit this format, I know someone did bullet points, apologies.

What do you like about Tildes?

What do you dislike about Tildes?

What would you change about Tildes?

Final notes

To keep my sanity in check, although when I read this post, that probably didn't work out too well, I kept some notes.

1. Someone suggested to ban all Europeans off the platform. You now have the stats, so I'm going to let you guess from where they are. Fucking hilarious.

2. Someone very cordial managed to write an entire blog post into one of the final freeform boxes. I appreciate the feedback and I'm sure Deimos does as well, but why did you have to make so many empty lines? TBH it's more on Jotform for not removing linebreaks when giving you the CSV, it breaks the entire format.

3. We should have a prize for that person who fit a textbook into the box for ethnicity, also amazing, you mad fucking lad (or lass, but statistics are on my side, lol)

In closing, most answers were good and interesting, except for the part where I let you run wild with the politics question, holy fuck, but that's on me. To the people that reduced my IQ by a few points, well I took the piss outta you already, so I hope you have a great day. Everyone else, I hope you [REDACTED] on a few [REDACTED]. Wait, I think I mixed something up here.^{As you may have guessed, don't take this too seriously}

As always, see you all next year, same time?^{Unless I get banned, which seems like a good possibility when I proofread all this, so much angerI need to get laid, or drunkActually how high does this go?}

Cheers, I'm gonna go C͉̠̰͚͚͓ͪ̿̋̏̚O͓̯͕̙͕͎͈̫̦͐̊́Ṅ͕̮̣̺̖̣̖̈ͥͦ͊̽͒͠S̶̵̹̜͔͖͗͂̋̔̈̒͊̚Ú̷͔͍͇̪̥͍ͭͭ̔ͨ̄̇̅̕M̵͈̮͉̹͈͕̻̎̓E̛̯̝̭͉̼̍̎̐̋̑̎ ̷̵̮͔̬̙̠̣̬͉ͭ͒S̨͙̼̟̻̜̈̄͋̄̇ͨ͛́͟͞Ò̡̧͙̩̓̄͂̓͗́M̹̰̲̆̌E̴̡̲̟ͯ ̹͇̲̩͍ͨͨ͒̑͊̌͒͆̕͡F̵͊̊̾ͭ҉̘̲̝͎̥͔̠̺̙O̧̡̱̠̙ͤ͒ͪO̬̯̪͉͙̩̅͂̀̏ͫ̄̓͂D͎͓͍͔͙̰͕̒̒͒̓̃̍͂ͭ̀͢
Grzmot

Overview

If you've spent any significant amount of time programming, then you've probably heard discussions about imperative, functional, and declarative programming. These discussions are often mired in technical knowledge and require a fair amount of intuition when trying to grasp the differences between the examples placed in front of us. These different programming styles, usually called programming "paradigms", are discussed as if they exist within a vacuum with complete and total isolation from one another. This only furthers the confusion and frustration among newer programmers especially, which runs counter to the goal of instructing them.

In this post I'll be taking a look at the oft-neglected intersections where these paradigms meet with the hope that the differences between them will be better understood by reframing our existing knowledge of programming basics.

Note: I'll be using PHP for my code examples and will try to provide comments when necessary to point out language quirks.

Understanding Fundamentals is Imperative

Let's start by first reviewing the most basic, fundamental programming paradigm: imperative programming. The term is a bit strange, but the important thing to understand about it is that imperative programming refers to writing software as a series of instructions where you tell the computer how to solve a specific task. For example, if we need to add together a bunch of numbers inside of an array, we might write code that looks like this:

$numbers = [ 8, 31, 5, 4, 20, 78, 52, 18, 96, 27 ];
$sum = 0;
foreach($numbers as $number) {
    $sum += $number;
}

This is a pretty typical example that you've probably encountered in some form or another at some point in your programming studies or career--iterate over an array one element at a time from the first element to the last and add the current element to some accumulating variable that starts at 0. The kind of loop you use may differ, but the general format of the solution looks the same. This is very similar to the way the computer itself performs the task, so the code here is just a relatively human-friendly version of the actual steps the computer performs. This is the essence of imperative programming, the basic building blocks of everything you learn early on.

Abstract Concepts

As the software we write gets larger and more complex, we then tend to rely on "abstractions" to simplify our code and make it easier to understand, reuse, and maintain. For example, if we've written a program that adds arrays of numbers together, then we probably aren't doing that in only one place. Maybe we've written a tool that generates reports on large data sets, such as calculating the total number of sales for a particular quarter, gross profit, net profit, remaining inventory, and any number of other important business-related metrics. Summing numbers could be so common that you use it in 30 different places, so to avoid having to maintain 30 separate instances of our number adding code from above, we define a function:

function sum($numbers) {
    $sum = 0;
    foreach($numbers as $number) {
        $sum += $number;
    }

    return $sum;
}

We do this so frequently in our code that it becomes second nature. We attach so many names and terms to it, too: DRY, abstraction layers, code reuse, separation of concerns, etc. But one thing experienced programmers learn is to write their functions and object and interface methods in such a way that anyone who uses them doesn't need to care about the underlying implementation details, and instead only need to worry about the method name, expected arguments (if any), expected return type (if any), and expected behavior. In other words, they don't need to understand how the function or method completes the intended action, they only need to declare what action they want performed.

A Declaration of Understanding

Anyone who has looked into the concept of the declarative programming paradigm should find those last words familiar: "they don't need to understand how the function or method completes the intended action, they only need to declare what action they want performed". This is the oft-touted explanation of what declarative programming is, the difference between detailing "how" and declaring "what", and I believe that it's this great similarity that causes imperative and declarative programming to become heavily entwined in a programmer's mind and makes it difficult to understand. Take this common example that authors tend to use to try to detail the difference between declarative and imperative programming:

// imperative
function sum($numbers) {
    $sum = 0;
    foreach($numbers as $number) {
        $sum += 0;
    }

    return $sum;
}

// declarative
function sum($numbers) {
    return array_reduce($numbers, fn($x, $y) => $x + $y, 0);
}

The authors will go on to state that in the imperative example, you tell the computer how to sum the numbers, whereas in the declarative example you don't tell the computer how to do it since you don't know anything about the reduce implementation, but intuitively it still feels as if you're telling the computer how to perform its task--you're still defining a function and deciding what its underlying implementation details are, i.e. the steps it needs to take to perform the task, even if its details are abstracted away behind function or method calls that could have varying implementation details of their own. So how the hell is this any different from defining functions like we do in imperative programming?

The answer is simple: it isn't. We've used so many names and terms to describe functions and methods in our ordinary imperative programming, but the truth is that a well-defined function or method serves as a declarative interface to an imperative implementation. Put differently, declarative programming is defining and utilizing simple interfaces that describe what you want accomplished while the underlying implementation details are inevitably written using imperative code.

Functional Differences

Now we can finally tackle one of the biggest trends in programming right now: the functional programming paradigm. But to understand this paradigm, it's important to understand what a "function" is... from a mathematical perspective.

Yes, I know, math tends to be a enthusiasm sink for many, but don't worry, we're not actually going to be doing math. We only need to understand how math treats functions. Specifically, math functions usually look something like f(x) = {insert expression here}, which is loosely equivalent to the following code:

function f($x) {
    return {insert expression here};
}

The important thing to note about functions in math is that you can run them a theoretically infinite number of times on the same input x and still get the same return result. Unlike in a lot of the programs we can write, math functions don't produce side effects. Files aren't written to or destroyed, database entries aren't deleted, some global counter somewhere isn't incremented, and your x doesn't suddenly change. The idea behind functional programming is to embody some of that nature of mathematical functions because they're predictable and always reproducible, and therefore simple to test as well. For example, take the following:

// not functional
function increment(&$x) { // pass by reference--$x will be modified outside of this function!
    $x++;
}

$x = 1;
increment($x);
increment($x);
increment($x);

// functional
function increment($x) { // pass by value--$x will NOT be modified outside of this function!
    return $x + 1;
}

$x = 1;
$y = increment($x);
$y = increment($x);
$y = increment($x);

Note that the first example will change the value of $x on each call, meaning each subsequent call of increment($x) produces a different result. Meanwhile the second example doesn't change $x and so the return value of increment($x) is always the same. This may seem like a silly example, but in larger, more complex software this can be significant. So now that we have an understanding of functions from a mathematical perspective, we have everything we need to actually understand what functional programming is.

Functional programming is a subset of declarative programming. Just like in declarative programming, you use simple interfaces to tell the program what you want to do rather than how to do it. But unlike declarative programming as a whole, functional programming imposes some additional restrictions on what you should and shouldn't do:

• You should encapsulate behavior in pure functions, which always give a consistent output for a given input and don't have side effects.

• You should write functions in such a way that you can compose them together, allowing you to combine and chain behavior to produce new functions or use the output of one as the input for another.

• You should avoid side effects as much as possible.

• You should avoid mutable state (e.g. changing the values in a variable).

• You should avoid sharing state between components.

These restrictions would require an entirely separate post on their own to properly cover and have been covered so many times in so many ways by others elsewhere that it would be superfluous for me to try to add anything more. It's important to note, however, that these restrictions are imposed because they provide some key benefits. By avoiding side effects and by avoiding mutable and shared states, the code you write becomes more predictable and tracing the behavior of an algorithm becomes far simpler. By writing pure, composable functions, you create reusable building blocks that can be strung together in virtually any configuration with predictable results. This makes writing, reading, maintaining, and debugging code easier and less error-prone.

That said, I feel that it's important to note that in the real world when writing practical software that users can interact with, it's simply not possible to completely avoid side effects or mutable state. The very act of creating and updating database entries is itself an act of mutating state, which runs contrary to functional programming principles and is essential for many important software projects. But even if you can't adhere strictly to functional programming principles, it's possible to benefit significantly from being aware of them and integrating them into your own software development strategies.

Let's consider a more practical example to illustrate this. Imagine that you've built a social media website and you're trying to test a push notification system that will be triggered when your user receives a new message. Now imagine your code and unit tests look something like this:

function sendNotification(&$message) { // pass by reference--$message will be modified outside of this function!
    $notification_system = new NotificationSystem();
    if(!$message['sent_push_notification']) {
        $notification_system->sendPushNotification($message);
        $message['sent_push_notification'] = true;
    }
}

function testSendNotification() {
    $message = [
        'user_id'=>'{some_id}',
        'contents'=>'Hi!',
        'sent_push_notification'=>false
    ];

    sendNotification($message);
    sendNotification($message);
}

At a quick glance you probably wouldn't be aware of why the second message didn't send, but the fact that our sendNotification() function mutates the state of the data provided to it is the culprit. This is code that doesn't adhere to functional programming principles since the data provided to it is mutated. As a result, running the function multiple times on the same variable doesn't result in the same behavior as the first call. If we wanted to work around this without adhering to functional programming principles then we would need to manually set $message['sent_push_notification'] = false; between function calls, which makes our unit tests potentially more error-prone. Alternatively we can make a simple change to adhere better to those functional principles:

function sendNotification($message) { // pass by value--$message will NOT be modified outside of this function!
    $notification_system = new NotificationSystem();
    if(!$message['sent_push_notification']) {
        $notification_system->sendPushNotification($message);
        $message['sent_push_notification'] = true;
    }

    return $message;
}

function testSendNotification() {
    $message = [
        'user_id'=>'{some_id}',
        'contents'=>'Hi!',
        'sent_push_notification'=>false
    ];

    sendNotification($message);
    sendNotification($message);
}

Now both notifications will be sent out, which is what we would intuitively expect. You should also notice that the above is also a blend of imperative, declarative, and functional programming. Our function definitions have imperative code, our sendNotification() function adheres to the functional programming principle of avoiding mutable state (well, mostly), and our NotificationSystem object provides a declarative interface for sending a push notification for a message.

Final Thoughts

By viewing these three paradigms not as completely separate concepts but as layers on top of one another, where functional programming is a type of declarative programming which is implemented using imperative programming, we can stop being confused by their similarities and instead find clarification in them. By understanding that imperative programming is the backbone of everything, that declarative programming is just simplifying that backbone with simple interfaces, and that functional programming is simply adding some additional guidelines and restrictions to the way you write code to make it more consistent, reusable, and predictable, we can start to see that we're not choosing one programming paradigm over another, but instead choosing how much consideration we place on the design of the programs we write. Except in purely functional languages, functional programming isn't some alien concept distinct from imperative or declarative programming, but is instead a natural evolution of the two.

There are a lot of details I've glossed over here. Each of these programming paradigms is far too detailed to include a proper analysis in an already lengthy post that tries to separate them from each other and clarify their differences. Blog articles exist in a thousand different places that can do each one far more justice than I can, and programming languages exist that completely cut imperative programming out of the picture. But for your average programmer slinging JavaScript, C, Rust, PHP, or what have you, I hope that this serves as a crucial starting pointing to understanding just what in the hell these functional programming enthusiasts are on about.