-
15 votes
-
John Boyega: 'I’m the only cast member whose experience of Star Wars was based on their race'
17 votes -
Does Google know me better than I know myself?
5 votes -
Trump eliminates federal anti-racism training, calling it “a sickness”
30 votes -
Comixology releases over 200 issues of Black Panther comics for free
11 votes -
Kabaddi: The ancient game that's gone pro
11 votes -
Bill Joy's greatest gift to man – the vi editor (2003)
7 votes -
What games have you been playing, and what's your opinion on them?
What have you been playing lately? Discussion about video games and board games are both welcome. Please don't just make a list of titles, give some thoughts about the game(s) as well.
20 votes -
Octo Ring, the webring for GitHub
14 votes -
Supersonic baseball cannon (World's fastest baseball)
7 votes -
Auto industry TV ads claim right-to-repair laws would benefit "sexual predators"
18 votes -
Back to the land - Alice Driver writes about her father, a potter, and his ongoing project of building his own tomb as his final creative act
6 votes -
Mercenary black riders and the evolution of cavalry warfare in the 16th century
4 votes -
Why GitHub won't help you with hiring
10 votes -
Digital pregnancy tests just contain a regular paper strip test and the battery, microcontroller, LEDs, photodiodes, screen, etc. are all to read whether it shows one line or two
16 votes -
The new neuroscience of stuttering
8 votes -
Rwandan single mothers turn to online babysitting of Japanese kids
12 votes -
GWU investigating whether White professor invented her Black identity
7 votes -
Unstaffed, digital supermarkets transform rural Sweden – Lifvs start-up has opened nineteen stores across the country, choosing remote places that have lost their local shops
15 votes -
Conlang Critic: Lingwa de Planeta
4 votes -
How Recettear changed PC gaming forever
3 votes -
Denmark's left-leaning parties have agreed to change the country's sexual violence laws to allow sex without explicit consent to be prosecuted as rape
21 votes -
Justice (Part 1)
26 votes -
Why IRC is Still Good in $CURRENT_YEAR
29 votes -
Inside Amazon’s secret program to spy on workers’ private Facebook groups
7 votes -
A tildes thread for toki pona, the minimalist conlang
Toki Pona is a minimalist conlang famous for having a vocabulary of under 130 words. There are communities of speakers on all major social media platforms. This is an introduction thread for...
Toki Pona is a minimalist conlang famous for having a vocabulary of under 130 words. There are communities of speakers on all major social media platforms. This is an introduction thread for speakers, learners or the toki-curious to introduce themselves. I'll advise on learning resources, or just answer general questions if anyone is interested.
I'm a toki pona speaker and creator of the YouTube channel 'seme li sin?' which translated news stories into toki pona.
mi wile e ni: kulupu wawa pi toki pona lon lipu Tetesu. jan ale pi toki pona li jan pona mi. sina ken la o kepeken e toki pona lon lipu ni!
26 votes -
I’m moving across the country in a few days
I’m moving from the Midwest to California on Tuesday to start graduate school (I’ve been in an post-baccalaureate research position for the last two years). I’ve been so busy packing and making...
I’m moving from the Midwest to California on Tuesday to start graduate school (I’ve been in an post-baccalaureate research position for the last two years). I’ve been so busy packing and making sure I see friends that I think it hasn’t truly hit me yet. I’ve lived around Chicago my whole life, even during college, so I suppose I’m a bit nervous about the change of location and being so far from friends and family. I’m incredibly excited of course to begin this new phase, but nervous nonetheless.
Have any of you all ever had big moves in the past? Any advice for settling in a new locale?
14 votes -
Louisiana’s weak environmental laws are keeping residents in the dark about health risks in the wake of Hurricane Laura's path through dozens of major petrochemical plants and oil refineries
8 votes -
makesite.py - Simple, lightweight, and magic-free static site/blog generator
7 votes -
Should we be able to view comments/posts where mods/admins are doing their roles and not doing them separately?
What I mean by this is: Sometimes @Deimos posts something related to his mod/admin work, like saying he will be locking a thread or adding something new, but that's not all he does, he makes...
What I mean by this is:
Sometimes @Deimos posts something related to his mod/admin work, like saying he will be locking a thread or adding something new, but that's not all he does, he makes regular topics and comments about regular things, he doesn't have need to use an alt-account for that. I feel that when he's talking or posting about his mod/admin work and talking about anything else that interests him should be able to be viewed separately.
Thoughts?
9 votes -
US gives first-ever OK for small commercial nuclear reactor
19 votes -
A brief look at programming paradigms
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...
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 yourx
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 ofincrement($x)
produces a different result. Meanwhile the second example doesn't change$x
and so the return value ofincrement($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 ourNotificationSystem
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.
25 votes -
-
What's your go-to special dish for cooking?
Maybe you make it every weekend or just when you've got some caloric budget to burn.
14 votes -
Impact of Go AI on the professional Go world
11 votes -
Black Panther titles are free on Comixology
8 votes -
RIP Jack Rickard, founder of Boardwatch magazine
6 votes -
Online voting is much more difficult to do securely, and a fundamental problem with the concept is that most voters won't be able to understand whether it's secure or not
21 votes -
The elements of wok hei: J. Kenji López-Alt shows you how the elusive smoky flavors and aromas of stir-fry can be achieved in your home kitchen
10 votes -
From its origins airing the banter of bored firefighters to its robust classical programming today, Dallas’s WRR-FM has filled an unusual niche on the airwaves for nearly a century
4 votes -
Five women affected by child marriage tell their stories – and of their struggles to protect others
7 votes -
The use of Snap packages in Ubuntu 20.04 LTS is hurting usability and user-friendliness
9 votes -
An exploration of Project Zero Issue 2046, a seemingly unexploitable and simple bug in the V8 JavaScript engine that turns out to be exploitable in a very complex manner
7 votes -
How does Tildes enable you to express yourself in contrast to reddit/other?
Tildes uses different systems than reddit. How has that enabled you to comment and share things that you wouldn't have otherwise? I'm interested mostly to contrast my own experience with others.
37 votes -
Amazon deletes 20,000 product reviews written by seven of its top ten UK reviewers after a Financial Times investigation found they were written for profit
18 votes -
ThinkPad X1 Carbon with Fedora preloaded available for purchase
22 votes -
What we’ve learned by comparing cash to job training
9 votes -
A secure operating system
11 votes -
CO-VIDs: The semiotics of "cuck"
12 votes -
Weekly thread for news/updates/discussion of George Floyd protests, racial injustice, and policing policy - week of August 31
This thread is posted weekly - please try to post relevant content in here, such as news, updates, opinion articles, etc. Especially significant updates may warrant a separate topic, but most...
This thread is posted weekly - please try to post relevant content in here, such as news, updates, opinion articles, etc. Especially significant updates may warrant a separate topic, but most should be posted here.
9 votes -
Malware in the wild using DNS-over-HTTPS (DoH) to pull payload
8 votes