In this grass where we sit,
I saw many full moons lit

Kissed them shivering in the wind,
felt like solution, formed decision, ultimate end

But the frenzy always fades,
pretty mirage in the haze

Silly me...

I just met you yesterday
And once again tremble my veins

I love single-location films, and use them as inspiration for my own very-constrained filmmaking endeavors. This is a space where great screenwriters and filmmakers shine, coming up with creative solutions to keep things fresh and enticing with little to no variation in ambiance. Some examples:

• 12 Angry Men (1957)
• Straw Dogs (1971)
• Dog Day Afternoon (1975)
• El Angel Exterminador (Exterminating Angel, 1962)
• Phone Booth (2003)
• Coherence (2013)
• The Invitation (2015)

But I want more! Any ideas?

I should add that my motivation for this question is research for my next production, and because of practical concerns I'm only looking for single-location films in which the main location is small and simple enough that its sub-divisions cannot be considered a location of their own. For example: according to my criteria, a large house or apartment would be a single location, because its subdivisions (living room, bathrooms, bedrooms, etc) can be considered as logical parts of the main one. A shopping mall, a large condominium or an apartment complex would not be a single-location, because its many buildings and apartments are distinct and independent enough to function as locations of their own. When in doubt, try applying production pragmatics instead of pure logic. If something is logically not really another location, but would be just as hard to manage as another location (a whole new set design), it is a location. Thanks!

I'm looking for some feedback on a feasible mechanism for structuring a few API endpoints where a purely RFC-spec compliant REST API wouldn't suffice.

I have an endpoint which returns $child entries for a $parent resource, let's call it: /api/parent/:parentId/children. There could be anywhere from a dozen to several hundred children returned from this call. From here, a child entity is related to a single userOrganization, which itself is a pivoting entity on a single user. The relationship between a child and user is not strictly transitive, but can each child only has one userOrganization which only has one user, so it is trivial to reach a user from a child resource.

Given this, the data I need for the particular request involves retrieving all user's for a parent. The obvious, and incorrect solution to the problem is to make the request mentioned above, and then iterate through and make an API request to retrieve each user. This is less than very good as this would obviously be up to several hundred API calls.

There's a few more scalable solutions that could solve this problem, so any input on these ideas is great; but if you have a better proposal that also works, I'm keen to explore that!

Include user relationships in the call by default.

This certainly does solve the problem, but it's also pumping down a load of data I don't necessarily need. This would probably 2x the amount of bytes travelling along the wire, and in 8 out of 10 calls, that extra data isn't needed.

Have a separate /api/parent/:parentId/users call.

Another option that partially solves the issue: I need data from both the child and the user to format this view, so I'd still need to make the initial call I documented earlier. Semantically, it feels a bit odd to have this as a resource because I don't consider a user to be nested under a parent in terms of database topology.

Keep the original call, but add a query parameter to fetch the extra data

This comes across as the 'least worst' idea objectively, in terms of flexibility and design. Through the addition of the query parameter, you could optionally retrieve the relationship's data. This seems brittle and doesn't scale well to other endpoints where it could be useful though.

Utilize a Stripe expands-style query parameter.

Stripe implements the ability to retrieve all related records from an API endpoint by specifying the relations as strings. This is essentially the same as the above answer, but is scaled to all available API endpoints. I love this idea, but implementing it in a secure way seems fraught with disaster. For example, this is a multi-tenancied application, and it would be trivial to request userOrganization.user.organizations.users. This would retrieve all other organisations for the user, and their users! This is because my implementation of expands simply utilises the ORM of my choice to perform a database join, and of course the database has no knowledge about application tenancy!

Now, I do realise this problem could easily be solved by implementing a GraphQL API server, which I have done in the past, but unfortunately time and workload constraints dictate implementing a GraphQL-based solution is infeasible. As much as I like GraphQL, I'm not as proficient in that area as compared to implementing high quality traditional APIs, and the applications I'm working on at the moment are focusing on choosing boring technology, and not using excessive innovation tokens.

Furthermore, I do consider the conceptuals around REST APIs to be more of an aspirational sliding scale, rather than a well defined physical entity, because let's face it, the majority of popular APIs today aren't REST-compliant, even Stripe's isn't, and it's usually both financially healthier and feature-rich to choose a development path that results in a rough product that can be refined later, than aiming for a perfect initial release. All this said, I don't mind proposals or solutions to my problem that are "good enough". As long as they aren't too hacky! :)

Today's problem description: https://adventofcode.com/2019/day/25

Join the Tildes private leaderboard! You can do that on this page, by entering join code 730956-de85ce0c.

Please post your solutions in your own top-level comment. Here's a template you can copy-paste into your comment to format it nicely, with the code collapsed by default inside an expandable section with syntax highlighting (you can replace python with any of the "short names" listed in this page of supported languages):

<details>
<summary>Part 1</summary>

```python
Your code here.
```

</details>

Today's problem description: https://adventofcode.com/2019/day/24

Join the Tildes private leaderboard! You can do that on this page, by entering join code 730956-de85ce0c.

Please post your solutions in your own top-level comment. Here's a template you can copy-paste into your comment to format it nicely, with the code collapsed by default inside an expandable section with syntax highlighting (you can replace python with any of the "short names" listed in this page of supported languages):

<details>
<summary>Part 1</summary>

```python
Your code here.
```

</details>

Today's problem description: https://adventofcode.com/2019/day/23

Join the Tildes private leaderboard! You can do that on this page, by entering join code 730956-de85ce0c.

Please post your solutions in your own top-level comment. Here's a template you can copy-paste into your comment to format it nicely, with the code collapsed by default inside an expandable section with syntax highlighting (you can replace python with any of the "short names" listed in this page of supported languages):

<details>
<summary>Part 1</summary>

```python
Your code here.
```

</details>

Today's problem description: https://adventofcode.com/2019/day/22

Join the Tildes private leaderboard! You can do that on this page, by entering join code 730956-de85ce0c.

Please post your solutions in your own top-level comment. Here's a template you can copy-paste into your comment to format it nicely, with the code collapsed by default inside an expandable section with syntax highlighting (you can replace python with any of the "short names" listed in this page of supported languages):

<details>
<summary>Part 1</summary>

```python
Your code here.
```

</details>

Today's problem description: https://adventofcode.com/2019/day/21

Join the Tildes private leaderboard! You can do that on this page, by entering join code 730956-de85ce0c.

Please post your solutions in your own top-level comment. Here's a template you can copy-paste into your comment to format it nicely, with the code collapsed by default inside an expandable section with syntax highlighting (you can replace python with any of the "short names" listed in this page of supported languages):

<details>
<summary>Part 1</summary>

```python
Your code here.
```

</details>

Today's problem description: https://adventofcode.com/2019/day/20

Join the Tildes private leaderboard! You can do that on this page, by entering join code 730956-de85ce0c.

Please post your solutions in your own top-level comment. Here's a template you can copy-paste into your comment to format it nicely, with the code collapsed by default inside an expandable section with syntax highlighting (you can replace python with any of the "short names" listed in this page of supported languages):

<details>
<summary>Part 1</summary>

```python
Your code here.
```

</details>

Today's problem description: https://adventofcode.com/2019/day/19

Join the Tildes private leaderboard! You can do that on this page, by entering join code 730956-de85ce0c.

Please post your solutions in your own top-level comment. Here's a template you can copy-paste into your comment to format it nicely, with the code collapsed by default inside an expandable section with syntax highlighting (you can replace python with any of the "short names" listed in this page of supported languages):

<details>
<summary>Part 1</summary>

```python
Your code here.
```

</details>

Today's problem description: https://adventofcode.com/2019/day/18

Join the Tildes private leaderboard! You can do that on this page, by entering join code 730956-de85ce0c.

Please post your solutions in your own top-level comment. Here's a template you can copy-paste into your comment to format it nicely, with the code collapsed by default inside an expandable section with syntax highlighting (you can replace python with any of the "short names" listed in this page of supported languages):

<details>
<summary>Part 1</summary>

```python
Your code here.
```

</details>

Today's problem description: https://adventofcode.com/2019/day/17

Join the Tildes private leaderboard! You can do that on this page, by entering join code 730956-de85ce0c.

Please post your solutions in your own top-level comment. Here's a template you can copy-paste into your comment to format it nicely, with the code collapsed by default inside an expandable section with syntax highlighting (you can replace python with any of the "short names" listed in this page of supported languages):

<details>
<summary>Part 1</summary>

```python
Your code here.
```

</details>

Today's problem description: https://adventofcode.com/2019/day/16

Join the Tildes private leaderboard! You can do that on this page, by entering join code 730956-de85ce0c.

Please post your solutions in your own top-level comment. Here's a template you can copy-paste into your comment to format it nicely, with the code collapsed by default inside an expandable section with syntax highlighting (you can replace python with any of the "short names" listed in this page of supported languages):

<details>
<summary>Part 1</summary>

```python
Your code here.
```

</details>

Today's problem description: https://adventofcode.com/2019/day/15

Join the Tildes private leaderboard! You can do that on this page, by entering join code 730956-de85ce0c.

Please post your solutions in your own top-level comment. Here's a template you can copy-paste into your comment to format it nicely, with the code collapsed by default inside an expandable section with syntax highlighting (you can replace python with any of the "short names" listed in this page of supported languages):

<details>
<summary>Part 1</summary>

```python
Your code here.
```

</details>

Today's problem description: https://adventofcode.com/2019/day/14

Join the Tildes private leaderboard! You can do that on this page, by entering join code 730956-de85ce0c.

Please post your solutions in your own top-level comment. Here's a template you can copy-paste into your comment to format it nicely, with the code collapsed by default inside an expandable section with syntax highlighting (you can replace python with any of the "short names" listed in this page of supported languages):

<details>
<summary>Part 1</summary>

```python
Your code here.
```

</details>

Today's problem description: https://adventofcode.com/2019/day/13

Join the Tildes private leaderboard! You can do that on this page, by entering join code 730956-de85ce0c.

Please post your solutions in your own top-level comment. Here's a template you can copy-paste into your comment to format it nicely, with the code collapsed by default inside an expandable section with syntax highlighting (you can replace python with any of the "short names" listed in this page of supported languages):

<details>
<summary>Part 1</summary>

```python
Your code here.
```

</details>

Today's problem description: https://adventofcode.com/2019/day/12

Join the Tildes private leaderboard! You can do that on this page, by entering join code 730956-de85ce0c.

Please post your solutions in your own top-level comment. Here's a template you can copy-paste into your comment to format it nicely, with the code collapsed by default inside an expandable section with syntax highlighting (you can replace python with any of the "short names" listed in this page of supported languages):

<details>
<summary>Part 1</summary>

```python
Your code here.
```

</details>

Today's problem description: https://adventofcode.com/2019/day/11

Join the Tildes private leaderboard! You can do that on this page, by entering join code 730956-de85ce0c.

Please post your solutions in your own top-level comment. Here's a template you can copy-paste into your comment to format it nicely, with the code collapsed by default inside an expandable section with syntax highlighting (you can replace python with any of the "short names" listed in this page of supported languages):

<details>
<summary>Part 1</summary>

```python
Your code here.
```

</details>

Today's problem description: https://adventofcode.com/2019/day/10

Join the Tildes private leaderboard! You can do that on this page, by entering join code 730956-de85ce0c.

Please post your solutions in your own top-level comment. Here's a template you can copy-paste into your comment to format it nicely, with the code collapsed by default inside an expandable section with syntax highlighting (you can replace python with any of the "short names" listed in this page of supported languages):

<details>
<summary>Part 1</summary>

```python
Your code here.
```

</details>

Today's problem description: https://adventofcode.com/2019/day/9

Join the Tildes private leaderboard! You can do that on this page, by entering join code 730956-de85ce0c.

Please post your solutions in your own top-level comment. Here's a template you can copy-paste into your comment to format it nicely, with the code collapsed by default inside an expandable section with syntax highlighting (you can replace python with any of the "short names" listed in this page of supported languages):

<details>
<summary>Part 1</summary>

```python
Your code here.
```

</details>

Today's problem description: https://adventofcode.com/2019/day/8

Join the Tildes private leaderboard! You can do that on this page, by entering join code 730956-de85ce0c.

Please post your solutions in your own top-level comment. Here's a template you can copy-paste into your comment to format it nicely, with the code collapsed by default inside an expandable section with syntax highlighting (you can replace python with any of the "short names" listed in this page of supported languages):

<details>
<summary>Part 1</summary>

```python
Your code here.
```

</details>

Today's problem description: https://adventofcode.com/2019/day/7

Join the Tildes private leaderboard! You can do that on this page, by entering join code 730956-de85ce0c.

Please post your solutions in your own top-level comment. Here's a template you can copy-paste into your comment to format it nicely, with the code collapsed by default inside an expandable section with syntax highlighting (you can replace python with any of the "short names" listed in this page of supported languages):

<details>
<summary>Part 1</summary>

```python
Your code here.
```

</details>

Today's problem description: https://adventofcode.com/2019/day/6

Join the Tildes private leaderboard! You can do that on this page, by entering join code 730956-de85ce0c.

Please post your solutions in your own top-level comment. Here's a template you can copy-paste into your comment to format it nicely, with the code collapsed by default inside an expandable section with syntax highlighting (you can replace python with any of the "short names" listed in this page of supported languages):

<details>
<summary>Part 1</summary>

```python
Your code here.
```

</details>

Today's problem description: https://adventofcode.com/2019/day/5

Join the Tildes private leaderboard! You can do that on this page, by entering join code 730956-de85ce0c.

Please post your solutions in your own top-level comment. Here's a template you can copy-paste into your comment to format it nicely, with the code collapsed by default inside an expandable section with syntax highlighting (you can replace python with any of the "short names" listed in this page of supported languages):

<details>
<summary>Part 1</summary>

```python
Your code here.
```

</details>

Today's problem description: https://adventofcode.com/2019/day/4

Join the Tildes private leaderboard! You can do that on this page, by entering join code 730956-de85ce0c.

Please post your solutions in your own top-level comment. Here's a template you can copy-paste into your comment to format it nicely, with the code collapsed by default inside an expandable section with syntax highlighting (you can replace python with any of the "short names" listed in this page of supported languages):

<details>
<summary>Part 1</summary>

```python
Your code here.
```

</details>

Today's problem description: https://adventofcode.com/2019/day/3

Join the Tildes private leaderboard! You can do that on this page, by entering join code 730956-de85ce0c.

Please post your solutions in your own top-level comment. Here's a template you can copy-paste into your comment to format it nicely, with the code collapsed by default inside an expandable section with syntax highlighting (you can replace python with any of the "short names" listed in this page of supported languages):

<details>
<summary>Part 1</summary>

```python
Your code here.
```

</details>

Today's problem description: https://adventofcode.com/2019/day/2

Join the Tildes private leaderboard! You can do that on this page, by entering join code 730956-de85ce0c.

Please post your solutions in your own top-level comment. Here's a template you can copy-paste into your comment to format it nicely, with the code collapsed by default inside an expandable section with syntax highlighting (you can replace python with any of the "short names" listed in this page of supported languages):

<details>
<summary>Part 1</summary>

```python
Your code here.
```

</details>

Today's problem description: https://adventofcode.com/2019/day/1

Join the Tildes private leaderboard! You can do that on this page, by entering join code 730956-de85ce0c.

Please post your solutions in your own top-level comment. Here's a template you can copy-paste into your comment to format it nicely, with the code collapsed by default inside an expandable section with syntax highlighting (you can replace python with any of the "short names" listed in this page of supported languages):

<details>
<summary>Part 1</summary>

```python
Your code here.
```

</details>

Original page is unencrypted so I'm posting the article here.

EDIT: Latest update

This is something so rudimentary that I'm a little embarrassed to ask, but I've also tried looking around online to no avail. One of the hard parts about being a Linux newbie is that the amount of support material out there seems to differ based on distro, DE, and also time, so posts from even a year or two ago can be outdated or inapplicable.

Here's my situation: I'm a newbie Linux user running Pop!_OS 19.10 with the GNOME desktop environment. Occasionally, games I'm playing will hard crash and lock up my system completely, leaving a still image of the game frozen on the screen indefinitely. The system stays there, completely unresponsive to seemingly any inputs. It doesn't happen often, but when it does it's almost always when I'm running a Windows game through Steam's Proton layer. I suspect it also might have something to do with graphics drivers, as I'll at times notice an uptick in frequency after certain updates, though that might just be me finding a suspicious pattern where none exists.

Anyway, what I don't know how to do is gracefully exit or recover from these crashes. No keyboard shortcut seems to work, and I end up having to hold the power button on my computer until it abruptly shuts off. This seems to be the "worse case scenario" for handling it, so if there is a better way I should go about this, I'd love to know about it.

EDIT: I really want to thank everyone for their help so far. My initial question has been answered, and for posterity's sake I'd like to post the solution here, to anyone who is searching around for this same issue and ends up in this thread:

• Use CTRL+ALT+F3/F4/F5/F6 keys to access a terminal, where you can try to kill any offending processes and reboot if needed.
• If that fails, use ALT+SYSRQ+R-E-I-S-U-B.

With that out of the way, I've added more information about the crashes specifically to the thread, primarily here, and some people are helping me out with diagnosing the issue. This thread is now less about the proper way to deal with the crash than it is about trying to identify the cause of the crash and prevent it in the first place.

Discuss: namespace clashes expose and ensure instabilities in user-side solutions to interface problems.

Case in point -- the RemindMeBot, which will send a timed reminder message to anyone who calls it in a reddit comment with the phrase "RemindMe!", has been cloned and iterated upon by another bot, Kzreminderbot, which responds to the exact same trigger phrase. Both bots reply to the comment threads where they are summoned. Kzreminderbot has slightly more diverse features, including email/text notification, but the interesting thing here (I think) is the impotence of the response from the creator of RemindMeBot, who has added a link in their comment replies to send annoyed feedback to the second bot.

We talk occasionally about the scramble for usernames on new services, but this is an slightly novel example of the cascading hierarchies of website design. A feature which reddit lacked is added by a bot, but that bot is too provisional to cover the hole which it was meant to fill.

I could use some clarity, as I feel like most of what I'm reading regarding home security is either FUD or marketing. I don't trust most of the comments I read online, as almost everything about this seems predicated on creating fear in me so that I'll pay up.

Simplisafe and Frontpoint are supposedly easy (and Simplisafe is quite cheap), but reviews online are mixed, and many people seem to think a self-installed wireless system is garbage no matter who it's from or who's doing the monitoring. Is this true, or is this just stratrgic doubt trying to drive me to a different or more expensive solution? I don't know!

Also, ADT sent me an ad that was a straight up lie. The person on the phone had to guess at how they might be able to stack discounts to even get close to the price I was looking at on their flyer, and the best she could offer was ~50% higher than what was shown, with their higher tiers costing well over double the price in the ad. I politely terminated the call.

My home security needs are simple. All I need is basic protection, and, honestly, I'm less concerned about a break-in than I am a fire. That's what I'd want to make sure I have solid monitoring for. My stuff can be replaced, but my home itself and my dog cannot.

Can anyone help me cut through all of the crap out there and just give me accurate information? What's my best bet?

A little over a year ago I created an unofficial matrix room for the tildes community. I believed at the time, and still do, that the infrastructure supporting the community should be founded on open, sustainable software, and matrix was an interesting new solution in this space similar to the Discords and Slacks of the world. Though the room is bridged with the IRC chat activity has remained relatively low compared to Discord.

Unfortunately I haven't had the time to properly moderate this channel. Though the community's involvement there has remained civil I do not think I'm active enough to ensure things stay that way.

As such I am looking for an interested person or persons to take over this channel over the next week or so and if no suitable replacements are found will be shutting the room down until further notice.

Thanks everyone,

Used to love reading the IMDB boards after checking out a flick. Up until, of course, Amazon's takeover and purging. Now I feel dirty using the site to check out info about films, and am trying to break the habit of using it as my 'go-to' site.

Letterboxd and TheMovieDatabase seem to be the 2 most credible alternatives. Any other suggestions on the Web3.0 (or 2.5) solution to a great community to kick back, contribute and learn with others about film?

A long time ago, there was a discussion about anonymous comment posting. I’d link it if I wasn’t typing at mobile, but it shouldn’t be too hard to find.

How did things about anonymous posting evolve, @Deimos? Do you plan to eventually make something like this?

There are plenty of topics such as this one which would IMO strongly benefit from anonymous comments - I can definitely see much higher participation if that was the case.

Regarding the abuse, I won’t reiterate all the points made in the thread ^{[todo: link]} and purposed solutions, but what about turning anonymous posting on only in some topics, perhaps where the topic author manually turned them on? We could have them for sensitive topics while holding people accountable for their words in all the political topics.

I want to adopt these technologies b/c I'm moving to a home w/o WiFi: I'll only use mobile networks in order to save some money. But the general pipeline and setup are hard to digest, and I'm not sure if I really understand what are the implications for my privacy, except for the fact that DNS queries are encrypted so I don't leak domain names. This is especially important to me because Turkish internet law and the censorship mechanism is really intrusive, with DPI & DNS blocking. My current ISP does not fiddle with my HTTPS traffic, but I won't have that with my mobile network.

I'm also considering a VPN, but major VPNs are blocked here. To what extent do the purposes of VPNs and these DNS solutions overlap? Assuming most of my important traffic is over HTTPS+DoH/T, how safe am I, and most importantly how much can I penetrate the censorship mechanisms?

So given the outbreak of severe lung disease apparently related to vaping, mentioned in recent Tildes threads here, here, and here, I thought I'd provide some semi-informed opinion and experience.

I've had to kick a nasty smoking habit more than a few times, and the last effort was only partially successful. I stayed hooked on nicotine gum, got jaw problems, and switched to vaping.

Vaping was cool! You can play with the electronic gadgets, get involved in the vaping equivalent of hot-rodding and over-clocking communities, play with liquid formulas, build coils, and do all kinds of intricate hobby-type stuff... while slowly poisoning yourself. Vaping was cheap, both by comparison with cigarettes, and with the FDA-approved nicotine-cessation systems. I'd been spending $50/week on gum, but $20/month for the liquids.

I was breathing outrageous dragon clouds, going through 50 ml of liquid a week, and getting nowhere near nicotine freedom. Despite careful avoidance of noticeably irritating flavors, I was getting back to the good old smoker's cough in the morning.

I've since formulated a super-simple homegrown nicotine mint recipe (below) that's as minimally toxic as I can manage, and very slowly gotten down to the equivalent of a cigarette or two a day.

So here's my advice:

1. Avoid pre-made e-liquids and cartridges. There's no telling what's in them; in the U.S., at least, there are no labelling requirements other than nicotine concentration.

2. Avoid flavorings altogether. "Generally Regarded As Safe", the FDA designation for flavorings, only applies to food ingredients. Many common flavor chemicals are known as toxic to inhale. Extracts are often complex mixtures, and there's little data on how all the constituents may interact in your lungs.

I'm not going to provide advice on "safe" ones - just don't use flavorings.

3. If you must vape, do so at the lowest possible temperature. Even unflavored liquids can create toxic byproducts when heated.

You can get pure, unflavored USP-calibrated nicotine liquid base, in a wide range of concentrations, from the same vendors that sell other e-liquid ingredients. I personally preferred propylene glycol (PG) base, because it vaporizes at a lower temperature, and forms less toxic heat decomposition byproducts than glycerin.

4. Don't vape. Nicotine inhalation has some pharmacological advantages - quick brain hit, few or no gastrointestinal effects, but lungs really want clean air. If you're seriously nicotine addicted, you can continue on oral or dermal products with less risk. If you're in a country that doesn't charge outrageously for drugs, there are regulated nicotine nasal sprays.

If you're in a country that does charge outrageously even for over-the-counter medicines, my solution follows.

So, the latest and greatest version, the ultimate plug-and-play version, of the cheap garage DIY nicotine mint:

SAFETY WARNINGS:
Nicotine is a deadly, neurotoxic poison, even on skin contact.
-Do not use nicotine solution concentrations greater than 24 mg/ml at home. Even this concentration is potentially hazardous - wear gloves, work on a washable tray to contain any spills, purchase the smallest size containers you can. Higher concentrations are extremely dangerous without special precautions I won't discuss here.

• Store all nicotine products, treated mints, and potentially contaminated tools and materials far out of the reach of children and pets, preferably under lock and key.

• Wash any exposed skin under running water as soon as possible. Call a Poison Control Center immediately if you suspect that there's been an incident of ingestion or extensive skin contact with nicotine liquid.

• Store mints and materials only in properly labeled, secure containers. [I've found a labelled medicine bottle eliminates social awkwardnesses about not sharing candy.]

• Work on a washable surface, wipe up, wash down with soap and water, and safely dispose cleaning materials for any spills.

• Following these instructions is at your own risk. Based on my knowledge and experience, this nicotine mint recipe is safer than smoking or vaping, but to an unknown degree. You should consult a doctor and/or use approved pharmaceuticals.

Tools and materials:

• Intact 1-qt. (1 L) Ziploc or other sealable polyethylene bag

• 10 ml syringe, optionally with 12- or 14-gauge Luer-lock blunt needle

• Nitrile gloves

• 24 mg/ml (2.4%) nicotine USP solution in propylene glycol** (There are many potential vendors.)

• 8-pack of Altoids "Arctic" flavor sugar-free mints* (cheapest available price on Amazon)

This recipe makes approximately 389 mints at 1.2 mg/mint nicotine strength. Divide or modify it at risk of your own math.

Instructions:

1. Open tins of mints and empty them into the Ziploc bag.

2. Wear gloves. Using the syringe, measure and add 20 ml of nicotine to the bag. (Nicotine solution comes in sealed bottles. To minimize risk of spills, you can use a blunt needle tip on the syringe to pierce the seal and withdraw nicotine liquid without fully opening the bottle.)

3. Completely seal the Ziploc bag. Massage the mints and nicotine liquid together until uniformly distributed and completely coated.

4. Let stand at least overnight, turning and mixing the mints every few hours, until all the liquid is completely absorbed.

Use:

Dosing is similar to nicotine lozenges - hold a treated mint under your tongue until dissolved, repeat no more than a total dosage of 24 per day.

*There are other sugar-free mints that are usable, but I've found sorbitol mints work best for this purpose, and the 0.5 gm per mint size gives a nicely steady nicotine release for 15 - 20 minutes.

**You can use a lower concentration, but the dosage in the final recipe will vary accordingly. Exceeding 20 ml per 8-pack of mints may leave them sticky, and if the liquid isn't fully absorbed, you can become ill from handling the mints. Don't do it.

The Problem

A large problem in internet communities is internet debates that devolve into metadiscussions on credibility. This likely isn't bad, because the default alternative is generally large-scale misinformation campaigns.

Examples

Tildes hasn't been free of this, naturally; for a (very) recent example, see this thread on Andrew Yang's climate change proposals.

I, personally, have partaken in a thread that seemed as if it might head in the same direction; take a look at this thread, on gun suicides of a certain population & aggravating factors of them. A third-party delivering a breadth of sources seemed to have stopped it in its tracks, however.

Solution

It does seem to me like something that could be solved—or at least mitigated—at the platform level, with a feature that would allow other users to cite sources for a comment in question, ideally with community ranking of those sources.

Getting rid of the question of credibility in casual discussions in a way that doesn't interrupt the flow of dialogue seems like something that would undoubtedly help The Conversation™ flourish, while simultaneously preventing disinformation catastrophes.

MAJOR SPOILER WARNING

What I Did

The game took me around twenty hours to beat, and I stretched that out over the course of about two months. Sometimes I would dive in deep and play non-stop for an hour or two, but most of the time it was me playing it almost piecemeal, for ten or fifteen minutes at a time. Enough to get through one or two panels that I had been stuck on and then stop again.

I would have liked to do longer gaming sessions with it, but I found that I sort of had finite mental resources to apply to the game. I would hit a panel, be thoroughly perplexed, stare at it for 10 minutes while trying different solutions in my head, on paper, and in the game. Nothing would work, so I'd stop the game. The next day I would boot it up and, more often than not, have the solution in a minute or two--sometimes even the first try! I think my brain was working on these in the background.

Something that helped me massively was not letting myself get intimidated by the game. As I would work myself farther and farther down a strand of puzzles, I would instinctively start to feel the pressure that they were getting harder and harder each time. Rather than feed into that feeling, I simply reassured myself that each puzzle was its own thing, and each one had a solution right there, staring me in the face. I just had to find it.

What I Loved

I think the game is gorgeous. Stunning. Beautiful. An absolute joy to look at. It made me realize that we don't often get vibrant color in games that aren't pixel art. I also think the world is beautifully designed. The island is a memorable place with lots to explore.

I also loved the game's ability to teach you its rules wordlessly. The line puzzles aren't just puzzles--they're a language. The whole game felt like some geometric force was trying to communicate with me, but first it had to teach me its alphabet, grammar, and syntax.

Furthermore, I can't tell you how many times I would fight for a solution to a difficult puzzle, feeling it was nearly impossible all the way, only to find the seemingly one right answer. The only way it could possibly work. The next panel? The same damn layout but with an added rule that ruined my prior solution! I loved that the game made me rethink my own thoughts and forced me to see, quite literally, that there is often more than one way to solve a problem.

What I Felt

I was probably 12 to 14 hours into the game when I accidentally stumbled onto the knowledge that there were lines that could be activated outside the panels. I can't remember where I was but holy hell can I remember the feeling. I've got goosebumps right now as I type this from revisiting it in my memory. It was the sublime feeling you get from a great plot twist. There was a sense of revelation, the feeling of frission, and a newfound respect and appreciation for the design that went into the game.

What's sad is that it shouldn't have taken me that long. I saw the circles and lines throughout the environment as I made my way around the island and just assumed that it was a sort of visual motif, or maybe a stylistic flair, much like the game's sort of cartoony, polygonal look. Finding out that I could, in fact, trace them just like every other line I'd been making for the past ten hours was absolutely flooring to me. Experiencing that moment is one of the high points in all of my gaming history. It was the moment the game went from "this is definitely a clever game!" to "FUCK...this game is SO. DAMN. SMART." After that moment I think I spent two hours frantically running around the island hunting environmental lines. Now that I knew what to look for, they were EVERYWHERE. Hiding in plain sight! I was stunned. In absolute awe.

At probably about the 15 hour mark, I found the movie room and had the input for one movie. It was a scene in which a man lights a candle and attempts to walk across a courtyard, and each time the candle goes out, he returns to the beginning. I took this to be a metaphor for the game--specifically that it is about the journey rather than the destination. As such, this was the point that I realized I wasn't going to get some revelatory story at the end of the game, and that making it to the end of the game, while definitely a goal, was not what gave the game meaning.

The sub-takeaway from the film was the idea that the effort is worth it. The man in the film could have just crossed the courtyard and lit the candle at the end. The fact that he didn't showed self-restraint and a committment to the rule. I took this to be a comment on how the game is played. I could have looked up solutions to the puzzles online and just inputted them easily as a way of breezing through the game. While it would get me to where I was going (the end), what was the point? My playthrough was the lit candle route--harder because I was forcing myself to put in the work rather than taking the easy way out.

Oh, and did I mention that the film also had an environmental line at the end you could activate if you went behind the screen while it was running? Genius. This game is SO. DAMN. SMART.

What I Didn't Love

Because I didn't pay attention to detail and made assumptions when I shouldn't have, I didn't realize that I could enter the mountain without all the beacons activated. My gamer mind simply saw OBVIOUS GATED DESTINATION and OBVIOUS DESTINATION GATE KEYS and went "yup, gotta get all of these to unlock the end!" As such, I overplayed my game a bit by doing all of that first. I was all set for entering the mountain to be the ending, especially because the village beacon felt like a "final exam" to the game, incorporating all of the other puzzle types. I kept coming back to it after learning a new symbol/rule and would chip away here and there until I finally got through all of it.

As such, when I got into the mountain and there were even more puzzles I was miffed. My steam had run out. Add to that I'm pretty susceptible to motion sickness in games, so the flashing, scrolling, and color-cycling puzzles were deeply unpleasant for me. I literally had to look away from the screen for the scrolling ones. I solved them on paper and inputted them with the panels in my peripheral vision.

The double-sided room below those was equal parts brilliant and frustrating, though I was impressed as hell with the room with the four sub-puzzles that fed into the larger one on the floor. Unfortunately, I ended the game on quite a low note, as the pillar puzzles at the very end turned my stomach on account of the rotating camera. I was able to power through those only because I knew I was so close to the end.

What I'm Left With

While I didn't love the ending, I, as previously mentioned, don't think it's about that. The game gave me 20 hours of puzzle-solving bliss in a beautiful, rich environment. It gave me legitimate chills when I figured out its secret. It made me think, it made me work, and it made me feel legitimately fulfilled. Good puzzle games make you feel baffled and then they turn around and make you feel brilliant. This one made me feel all sorts of brilliant.

The game has so many legitimately clever moments. I loved the pagoda area where you have to look through branches at the right angle to see the solution. The last puzzle has two pieces of the answer, but a section is missing. After traipsing around, trying every possible visual angle, I look down and find a branch broken off at my feet. The missing piece. Brilliant.

It was filled with little things like these. Little thoughtful twists or nudges. Each puzzle strand was an iterative sequence, and each time you thought you knew where it was headed, they'd push it further. Then further. More and more. Often in ways you wouldn't expect. It's not just that the idea of the game is good but that its execution is so rich and thoughtful that it makes me reverent.

As for post-game stuff (because I know there's a ton I haven't gotten to), I'm taking a break from the game right now, but I might return to it a little later. I kept screenshots of puzzles I didn't solve or environmental elements that I was pretty sure were really activatable but that I couldn't quite figure out (the brown railroad tracks in the white limestoney area, for example).

I have the inputs for a couple more movies that I haven't watched, so I'll probably go back for those. I know there's a challenge area as well, and I'm presumably equipped for it given that I did all of the beacons, but I don't know if I'm up for that. Not just yet, at least.

What You Can Help Me With

For those of you that have gone through the post-game content, do you recommend it? Are there certain things I should focus on? I'm not terribly concerned about spoilers, but if there's something "big" like the environmental line revelation, maybe just give me a hint or point me in the right direction.

I also have a couple of lingering questions. Feel free to answer them unless you feel that it's better if I try to figure it out by myself.

• What do the individual, standalone panels lying around the island do (the gray ones with the triangles)? I've figured out the rule, I just don't know their purpose.

• Does finding all the environmental lines serve any larger purpose?

• Is there story or lore in the game? Does the island or its frozen inhabitants get explained? I activated a few audiologs, but those were mostly philosophical ponderings rather than narrative.

• How on earth do I get that environmental line with the railroad tracks? Of all the ones that I haven't been able to figure out how to get, that one's bothering me the most.

Finally, to anyone who's played the game (which is hopefully anyone who read this), I'd love to hear your experience and thoughts. What was The Witness like for you?

EDIT: Writing the post inspired me to go back into the game instead of sleeping. I watched two other videos I had found inputs for. One was a woman talking about freeing yourself from want, and the other was a man talking about science and knowledge. Interesting stuff.

Then I started exploring and I found an environmental line made by the negative space in the sky when properly bounded by a cloud and wall from the exact right angle. This game is SO. DAMN. SMART.

EDIT 2: Disregard where I said I was going to take a break from the game. I'm diving back in. I want to explore and find these environmental lines. It's so satisfying when you find one.

There was one on a bridge leading from the village towards the foresty area with the orange trees. I could see it from the ground and knew it definitely was one, but I could never quite position myself right to actually trace it. I tried climbing in the castle area since it seemed like I needed to be elevated, but that didn't work. I tried it from the rooftops in the village, and that didn't work. Then I looked: the tower in the middle of the village! I'd forgotten to try from there because once I got to the top of that I headed straight for the mountain. Sure enough, that was the spot.

Also, can we talk about how the sound is so satisfying when you get one? So good.

EDIT 3: The game might be trying to teach me a lesson in freeing myself from want. Now that I'm fired up to dive back into it, it's hard crashing after I start it up. It loads fine and I can walk a few steps, then it locks up my whole system.

I'm running it on Linux through Proton and tried all the different Proton versions assuming that was the culprit (it has crashed before) but the outcome is the same. I might be technologically barred from going further, which I guess is in the spirit of the game's ending and philosophy, right?

EDIT 4: My OS had some graphics library updates for me today, and after installing them I'm back in business--no more crashing! (Sub edit: I spoke too soon. It crashed after about half an hour, but that's way better than what I was getting before). I spent a while traipsing around the island, looking for environmental lines. It's amazing how, in hindsight, so many areas or destinations that I thought were just kind of dead space are actually strategic locations for environmental lines.

A good example is the very beginning of the game. You can get onto the roof of the overhang you first walk out from. At the beginning of the game I got up there, saw some pillows, and just thought it was set dressing in an ultimately useless space. Nope! Not only is there an environmental line you can get from there, but there's an audiolog as well if you're paying attention to detail (which, of course, I wasn't in my first go-around).

Firstly, I apologise for the rant. I guess this is a meek follow-up to my submission earlier in ~comp, questioning how to deploy Docker into production. Since then, I haven't been able to dedicate much time to solving any of the issues I've outlined in that thread, but what I will say is that docker has caused me nothing but pain, and I have realised zero benefits from attempting to utilise it. Right from the start, the syntax for docker, docker-compose, and Dockerfiles is confusing and full of edge cases which no one explains to you in the hype of actually discussing it:

• These 'images' you build grow to insane sizes unless you carefully construct and regiment your RUN, COPY, and other commands.
• Docker complains to you about leaving empty lines in multi-line RUN commands (which is itself, as I see it, basically a hack to get around something called a "layer limit"), even if it contains a comment (which is not an empty line) and does not provide a friendly explanation on how to solve this issue.
• There's basically no good distinction between bind mounts and volumes, and the syntax is even more confusing: declaring a volumes entry in a docker-compose.yml? You have no good idea if you're creating a volume or a bindmount.
• Tutorials & documentation tends to either assume you're a power user who knows this sort of thing, or are so trivial they don't accurately represent a real-world solution, and are therefore basically useless.

I've suffered endless permissions issues trying to run portions of my application, such as being unable to write to log files, or do trivial things like clearing a cache—that I have tried a dozen different ways of fixing with zero success.

Then, when I run some things from within the docker container, such as tests, they can take an excruciatingly long time to run—only then did I discover that this is yet another docker issue. The whole point of docker is to abstract away the host OS and containerise things and it can't even do that.

So now I'm regenerating and rebuilding images and containers every 5 minutes trying to find a configuration that appears to work with the slow and complicated syntax of docker rm $(docker ps -aq) -f followed by docker rmi $(docker images -q) followed by docker-compose -f docker-compose.yml -f docker-compose.dev.yml up -d, followed by docker container exec -it php sh.

Docker-sync, kubernetes, docker-compose, images, containers. It's legitimately too much. I'm not a dev-ops or infrastructure guy. I just want to write code and have my app work. I don't have the money to employ anyone to solve this for me (I'm not even employing myself yet).

I guess you can say I've learnt my lesson. I'm sticking to git and a simple VPS for future endeavours. I don't know how you folks who manage to hype docker do it, and I don't know what I'm doing wrong, but Docker doesn't like me, and I don't like it.

I'm sharing in case some of you are having a similar issue at work or at home, and to hear your opinion and/or similar stories!

I've been using Ubiquiti access points in my home for a few years now, and overall, they've worked very well. 3 APs giving near perfect 5GHz VHT80 coverage on DFS channels. LAN transfers are about 600-650mbit on laptops, which has proven to be plenty for wireless clients in my home. Keep in mind that this is a pretty basic setup... besides the APs, there's just the ISP provided GPON ONT which is also a typical all-in-one ISP solution (router, switch, AP, firewall, DHCP server...) with it's Wi-Fi turned off.

As I said, I was pretty happy with the results, however there was one feature that I could never get to work just right; roaming. You could be walking around the house watching a live stream and the stream would pause for 5-8 seconds until the roaming transition was over. Strangely, with VoIP calls, roaming would be about 3-5 seconds. Even enabling fast roaming features (which I believe is simply 802.11r) on the AP's controller would not give the results I was looking for. After days of tweaking TX power settings, channel selection and trying to implement Minimum RSSI (which I ended up not using), I finally gave up and resigned myself to the 4-6 seconds (oh, the humanity) of roaming time.

Fast forward to about two months ago and I added a new router to the setup (UBNT ER-4) and a switch (UBNT USW-24). Setup went smooth, already had some cat.6 cabling around the house, now it was time to actually use it. Had some fun setting up a guest Wi-Fi network on it's own VLAN, which was always a concern of mine; having "untrusted" devices connect to my network. The access points do client isolation on guest networks by default, but in my mind it wasn't enough as I have some file servers and time machines on the network.

Anyways, a few days after doing the setup I'm walking around the house with a livestream on my mobile and suddenly realize that it's not losing the connection. I try with a VoIP call and it worked flawlessly. I start walking around faster and still, the phone is roaming without an issue. I was very excited!

I'm thinking it must be the router that somehow solved the roaming issue. My first theory was that the DHCP server on the ER-4 was doing it's thing much faster than the ISP's device, allowing the wireless clients to actually roam faster. So I do a web search and I find some very relevant info. It was a thread on a forum and reddit thread with a sysadmin that was about to give up on the APs because of roaming issues. In both threads, there were replies about what switch were they using.

Apparently, some switches (Cisco and HP were mentioned), have a "MAC aging" interval setting which is way too high by default, or they simply have bugged firmware that doesn't allow the switch to "re-learn" the MAC address of a device on a different switch port. I assume that ISP provided "el-cheapo" gear has similar issues.

So, if you're having roaming issues with your wireless clients, check your switches!!!

Anyways, just wanted to share this story. Thank you for reading. :-)

Here in 2019 the overwhelming majority of all currency is virtual and commerce on any appreciable scale occurs electronically. But consider a sci-fi/space opera setting where reasonably fast FTL is commonplace, but FTL communications are not possible. Obviously one could still "communicate" at FTL with a courier, but you would still be limited to the speed of the courier ship. You certainly wouldn't have instantaneous communication between star systems, meaning there can be no interstellar electronic banking: transactions would take years to complete.

The Traveller tabletop RPG uses exactly this setup: FTL travel is common, FTL communication does not exist. In Traveller you have the Third Imperium minting currency that is accepted essentially everywhere, the currency is Imperial Credits and they're printed on polymer bills. The result is an effectively cash-only economy.

But what if your setting has no centralized government? Do people revert to using gold? Are there fleets of merchant ships schlepping precious metals around the cosmos, as if the American Old West has been transplanted into space? Would they come up with a cryptographic solution? Could something like a blockchain work without instantaneous communication cross the entire network that accepts the cryptocurrency?

What if quantum computing is widespread in your setting, rendering most forms of encryption obsolete? That would seem to eliminate the blockchain based option, FTL comms or not, and once again send us back to needing a fiat currency, or a gold standard.

This is kind of a question for Tildes as well as a discussion topic on Social Media more generally. For context, "The Right to be Forgotten" is an idea being kicked around in international law and human rights circles. It's kind of a corollary to the "right to privacy" and focuses on putting some guardrails around the downsides of having all information about you being archived, searchable, and publicly available forever and ever. It's usually phrased as a sense that people shouldn't be tied down indefinitely by stigmatizing actions they've done in "the past" (which is usually interpreted as long enough ago that you're not the same person anymore).

This manifests in some examples large and small. Felony convictions or drug offenses are a pretty big one. Another public issue was James Gunn getting raked over the coals for homophobic quotes from a long time ago. Even on a smaller scale, I think plenty of young people have some generalized anxiety about embarrassing videos, photos, Facebook statuses, forum posts, etc. that they made when they were young following them around the rest of their lives. For example, Alexandria Ocasio Cortez had people try to shame her for dancing to a Phoenix song in an amateur music video. An even darker version of this happens with people who might be the victims of targeted harassment. Often doxxing happens by people digging through peoples' histories and piecing together clues to figure out who they are or at least narrow down where they're from, where they work, etc.

In the context of Tildes, this would basically be a question of how do we feel about peoples' comment history lingering forever? Do we care about/agree with this "right" in principle and if we do, what should be done about putting it into practice?

The root of the issue is the existence of archives of data about yourself that is 1.) searchable, 2.) publicly viewable, 3.) under someone else's control, 4.) forever. Even if the ability to delete comments exists, it's infeasible for any individual to pore over the reams of data they create about themselves to find the stuff that might be problematic. The solutions would revolve around addressing any one of those numbered items. Unfortunately, hitting any of those has upsides and downsizes. Some examples:

Some people like being able to look back on old contributions and having them get deleted after a period of time (hitting problem #4) would be a bummer unless there is a system to selectively archive stuff you want to save from atrophy, which would be a function/feature that would take a ton of thought and development. What's more, there is no point in just saving your own comment if everyone else's stuff is gone because comments without context are indecipherable. It could work in a more selective way, so rather than a blanket atrophying of posts, but then you have the context issue again. Someone you were having a discussion with might choose to delete their entire comment history and there goes any sense of logic or coherence to your posts.

We could address the searchable bit by automatically or selectively having posts pseudonymed after a period of time. But in a lot of cases a pseudonym won't work. People tend to refer to each other by username at times, and some people have a distinctive enough style that you could probably figure it out if they're well known and long-tenured.

That's just some general food for thought. I'll yield the floor

Hello! After spending many development hours in my past years running on Virtualbox/Vagrant-style setups, I've decided to take the plunge into learning Docker, and after getting a few containers working, I'm now looking to figure out how to deploy this to production. I'm not a DevOps or infrastructure guy, my bread and butter is software, and although I've become significantly better at deploying & provisioning Linux VPS's, I'm still not entirely confident in my ability to deploy & manage such systems at scale and in production. But, I am now close to running my own business, so these requirements are suddenly going from "nice to have" to "critical".

As I mentioned, in the past when I've previously developed applications that have been pushed onto the web, I've tended to develop on my local machine, often with no specific configuration environment. If I did use an environment, it'd often be a Vagrant VM instance. From here, I'd push to GitHub, then from my VPS, pull down the changes, run any deployment scripts (recompile, restart nginx, etc), and I'm done.

I guess what I'm after with Docker is something that's more consistent between dev, testing, & prod, and is also more hands off in the deployment process. Yet, what I'm currently developing still does have differing configuration needs between dev and prod. For example, I'd like to use a hosted DB solution such as DigitalOcean Managed Databases in production, yet I'm totally fine using a Docker container for MySQL for local development. Is something like this possible? Does anyone have any recommendations around how to accomplish this, any do's and dont's, or any catches that are worth mentioning?

How about automating deployment from GitHub to production? I've never touched any CI/CD tools in my life, yet I know it's a hugely important part of the process when dealing with software in production, especially software that has clients dependent on it to function. Does anything specifically work well with Docker? Or GitHub? Ideally I want to be avoiding manual processes where I have to ssh in, and pull down the latest changes, half-remembering the commands I need to write to recompile and run the application again.

Preface

It's not uncommon for a written piece of code to be both brief and functionality correct, yet difficult to reason about. This is especially true of recursive algorithms, which can require some amount of simulating the algorithm mentally (or on a whiteboard) on smaller problems to try to understand the underlying logic. The more you have to perform these manual simulations, the more difficult it becomes to track what exactly is going on at any stage of computation. It's also not uncommon that these algorithms can be made easier to reason about with relatively small changes, particularly in the way you conceptualize the solution to the problem. Our goal will be to take a brief tour into what these changes might look like and why they are effective at reducing our mental overhead.

Background

We will consider the case of the subset sum problem, which is essentially a special case of the knapsack problem where you have a finite number of each item and each item's value is equal to its weight. In short, the problem is summarized as one of the following:

• Given a set of numbers, is there a subset whose sum is exactly equal to some target value?

• Given a set of numbers, what is the subset whose sum is the closest to some target value without exceeding it?

For example, given the set of numbers {1, 3, 3, 5} and a target value of 9, the answer for both of those questions is {1, 3, 5} because the sum of those numbers is 9. For a target value of 10, however, the first question has no solution because no combination of numbers in the set {1, 3, 3, 5} produces a total of 10, but the second question produces a solution of {1, 3, 5} because 9 is the closest value to 10 that those numbers can produce without going over.

A Greedy Example

We'll stick to the much simpler case of finding an exact match to our target value so we don't have to track what the highest value found so far is. To make things even simpler, we'll consider the case where all numbers are positive, non-zero integers. This problem can be solved with some naive recursion--simply try all combinations until either a solution is found or all combinations have been exhausted. While more efficient solutions exist, naive recursion is the easiest to conceptualize.

An initial assessment of the problem seems simple enough. Our solution is defined as the set of array elements whose total is equal to our target value. To achieve this, we loop through each of the elements in the array, try combinations with all of the remaining elements, and keep track of what the current total is so we can compare it to our target. If we find an exact match, we return an array containing the matching elements, otherwise we return nothing. This gives us something like the following:

function subsetSum($target_sum, $values, $total = 0) {
    // Base case: a total exceeding our target sum is a failure.
    if($total > $target_sum) {
        return null;
    }

    // Base case: a total matching our target sum means we've found a match.
    if($total == $target_sum) {
        return array();
    }

    foreach($values as $index=>$value) {
        // Recursive case: try combining the current array element with the remaining elements.
        $result = subsetSum($target_sum, array_slice($values, $index + 1), $total + $value);

        if(!is_null($result)) {
            return array_merge(array($value), $result);
        }
    }

    return null;
}

Your Scope is Leaking

This solution works. It's functionally correct and will produce a valid result every single time. From a purely functional perspective, nothing is wrong with it at all; however, it's not easy to follow what's going on despite how short the code is. If we look closely, we can tell that there are a few major problems:

• It's not obvious at first glance whether or not the programmer is expected to provide the third argument. While a default value is provided, it's not clear if this value is only a default that should be overridden or if the value should be left untouched. This ambiguity means relying on documentation to explain the intention of the third argument, which may still be ignored by an inattentive developer.

• The base case where a failure occurs, i.e. when the accumulated total exceeds the target sum, occurs one stack frame further into the recursion than when the total has been incremented. This forces us to consider not only the current iteration of recursion, but one additional iteration deeper in order to track the flow of execution. Ideally an iteration of recursion should be conceptually isolated from any other, limiting our mental scope to only the current iteration.

• We're propagating an accumulating total that starts from 0 and increments toward our target value, forcing us to to track two different values simultaneously. Ideally we would only track one value if possible. If we can manage that, then the ambiguity of the third argument will be eliminated along with the argument itself.

Overall, the amount of code that the programmer needs to look at and the amount of branching they need to follow manually is excessive. The function is only 22 lines long, including whitespace and comments, and yet the amount of effort it takes to ensure you're understanding the flow of execution correctly is pretty significant. This is a pretty good indicator that we probably did something wrong. Something so simple and short shouldn't take so much effort to understand.

Patching the Leak

Now that we've assessed the problems, we can see that our original solution isn't going to cut it. We have a couple of ways we could approach fixing our function: we can either attempt to translate the abstract problems into tangible solutions or we can modify the way we've conceptualized the solution. With that in mind, let's take a second crack at this problem by trying the latter.

We've tried taking a look at this problem from a top-down perspective: "given a target value, are there any elements that produce a sum exactly equal to it?" Clearly this perspective failed us. Instead, let's try flipping the equation: "given an array element, can it be summed with others to produce the target value?"

This fundamentally changes the way we can think about the problem. Previously we were hung up on the idea of keeping track of the current total sum of the elements we've encountered so far, but that approach is incompatible with the way we're thinking of this problem now. Rather than incrementing a total, we now find ourselves having to do something entirely different: if we want to know if a given array element is part of the solution, we need to first subtract the element from the problem and find out if the smaller problem has a solution. That is, to find if the element 3 is part of the solution for the target sum of 8, then we're really asking if 3 + solutionFor(5) is valid.

The new solution therefore involves looping over our array elements just as before, but this time we check if there is a solution for the target sum minus the current array element:

function subsetSum($target_sum, $values) {
    // Base case: the solution to the target sum of 0 is the empty set.
    if($target_sum === 0) {
        return array();
    }

    foreach($values as $index=>$value) {
        // Base case: any element larger than our target sum cannot be part of the solution.
        if($value > $target_sum) {
            continue;
        }

        // Recursive case: do the remaining elements create a solution for the sub-problem?
        $result = subsetSum($target_sum - $value, array_slice($values, $index + 1));

        if(!is_null($result)) {
            return array_merge(array($value), $result);
        }
    }

    return null;
}

A Brief Review

With the changes now in place, let's compare our two functions and, more importantly, compare our new function to the problems we assessed with the original. A few brief points:

• Both functions are the same exact length, being only 22 lines long with the same number of comments and an identical amount of whitespace.

• Both functions touch the same number of elements and produce the same output given the same input. Apart from a change in execution order of a base case, functionality is nearly identical.

• The new function no longer requires thinking about the scope of next iteration of recursion to determine whether or not an array element is included in the result set. The base case for exceeding the target sum now occurs prior to recursion, keeping the scope of the value comparison nearest where those values are defined.

• The new function no longer uses a third accumulator argument, reducing the number of values to be tracked and removing the issue of ambiguity with whether or not to include the third argument in top-level calls.

• The new function is now defined in terms of finding the solutions to increasingly smaller target sums, making it easier to determine functional correctness.

Considering all of the above, we can confidently state that the second function is easier to follow, easier to verify functional correctness for, and less confusing for anyone who needs to use it. Although the two functions are nearly identical, the second version is clearly and objectively better than the original. This is because despite both being functionally correct, the first function does a poor job at accurately defining the problem it's solving while the second function is clear and accurate in its definition.

Correct code isn't necessarily accurate code. Anyone can write code that works, but writing code that accurately defines a problem can mean the difference between understanding what you're looking at, and being completely bewildered at how, or even why, your code works in the first place.

Final Thoughts

Accurately defining a problem in code isn't easy. Sometimes you'll get it right, but more often than not you'll get it wrong on the first go, and it's only after you've had some distance from you original solution that you realize that you should've done things differently. Despite that, understanding the difference between functional correctness and accuracy gives you the opportunity to watch for obvious inaccuracies and keep them to a minimum.

In the end, even functionally correct, inaccurate code is worth more than no code at all. No amount of theory is a replacement for practical experience. The only way to get better is to mess up, assess why you messed up, and make things just a little bit better the next time around. Theory just makes that a little easier.