Are those handheld or on a tripod. I’d imagine you would need an extremely steady hand or super fast shutter speeds to get those.

I wouldn’t say I’ve mastered it but recently I’ve experimented with backlighting and I’m relly happy with the results.

• https://social.helios42.de/system/media_attachments/files/113/458/706/194/633/403/original/72958197e45ba2db.jpg
• https://social.helios42.de/system/media_attachments/files/113/458/708/605/004/740/original/a0ad4ae7d82c221e.jpg

Edit: I use two remote controlled flashes with mini softboxes. The whole thing started out of necessity because at the club, when you have your flash on your camera or behind you, the fog just results in a mostly white photo.

Actually, isn’t this the optimal outcome? The new “security” features are now optional for those who want them. Everyone else can choose developer mode, has all the old features and is responsible for securing their network. We could argue if opt-in or opt-out is better but I see the argument for having “security” features enabled by default.

Are we sure this is MK8 and not some MK9?

So? Just because it isn’t useful for you that doesn’t mean it isn’t useful for others.

• posted from my Framework 13 running Windows

Well, quite literally. The park lies on that exact border.

Guter Knecht. Schnapspraline?

Here in Germany, we celebrate mostly on Christmas Eve. I have a couple of hours left to get ready before my stepdad picks me up. We’ll visit my grandma who sadly has to spend the holidays in hospital because she fell and hurt her knee. After that, Christmas dinner at my mom’s and stepdad’s house with most of the family, gifts and a relaxed evening. I’ll stay over night, have breakfast and then go home to finish packing everything I need for my winter vacation which starts on the 26th.

It’s been an exhausting year and I can really use the downtime.

Ich persönlich lasse einfach für jeden (bzw. jedes Paar) einen Kalender mit Fotos, die ich im Lauf des Jahres geschossen hab, drucken. Manche kriegen noch was oben drauf, aber so hat jeder zumindest eine Kleinigkeit.

With the trend to make ever larger but thinner phones, we’ll eventually end up with an A3 sheet of paper. I just want the 5/5S/SE1 or Mini form factor back. I don’t care about thin phones, only about being able to use the whole screen with one hand.

I have a wishlist that I share with my family and close friends. People follow that list unless they have an idea that they’re 100% sure about. I think the only times I got an unwanted gift was things I already had. Either because something went wrong coordinating between people (rare, everyone knows they can contact my partner to ask what’s still available) or because they accidentally bought the wrong thing (like the first book of a series instead the second one).

The only exception ever was during a single https://givin.gifts/ secret santa exchange where someone at the same time a) completely ignored my profile, b) gifted something below the stated minimum value, c) didn’t wrap my gift, d) didn’t include a card and e) didn’t include any packing material. They just threw a random 5€ item from the supermarket into an unpadded box and called it a day.

German here, we have the same thing (du vs. sie). Our rules may be slightly different than dutch but probably similar enough.

Police: definitely formal unless the officer is someone you know privately.

Shop: usually formal though some hobby-related shops (think GameStop or board games) might prefer informal.

Campsite: probably informal

As a general rule of thumb: informal is used with first names, formal is used with last names. Think about which name you would use in English and go with that. If in doubt, use the formal version or ask.

One important addendum: complexity classes always consider how hard a problem is depending on the input size. Sorting is in P (usually O(n*log(n)), so one of the easiest problems overall) but given a few trillion inputs, it would be pretty much impossible to solve on consumer hardware. On the other hand, problems like 3-sat, the knapsack problem or travelling salesman are all NP-hard but with small enough inputs (up to a few dozen or so), they are easy to solve, even with pen and paper and are even regularly included in puzzle books.

The diagram is pretty good but your interpretation is not quite right, especially for NP-complete and NP-hard.

NP-hard means “at least as hard as all problems in NP”, proven by the fact that any single NP-hard problem can be used to solve the entire class of all NP problems.

NP-complete means “at least as hard as all problems in NP and itself also in NP”, so the intersection between NP and NP-hard.

The thing about P = NP or P != NP is something different. We don’t know if P and NP are the same thing or not, we don’t have a proof in either direction. We only know that P is at least a subset of NP. If we could find a P solution for any NP-hard problem, we would know that P = NP. That would have massive consequences for cryptography and cyber-security because modern encryption relies on the assumption that encrypting something with a key (P) is easier than guessing the key (NP).

On the other hand, at some point we might find a mathematical proof that we can never find a P solution to an NP-hard problem which would make P != NP. Proving that something doesn’t exist is usually extremely hard and there is the option that even though P != NP we will never be able to prove it and are left to wonder for all eternity.

Done.

Alright, part 2, let’s get to NP.

Knowing that P means “in polynomial time”, you might be tempted to think that NP means “in non-polynomial time” and while that kind of goes in the right direction, it means “in non-deterministic polynomial time”. Explaining what non-deterministic calculations are would be a bit too complicated for an ELI5, so let’s simplify a bit. A regular computer must make all decisions (for example which way to turn when calculating a shortest route between two points) based on the problem input alone. A non-deterministic computer can randomly guess. For judging complexity, we look at the case where it just happens to always guess right. Even when guessing right, such a computer doesn’t solve a problem immediately because it needs to make a number of guesses that depends on the input (for example the number of road junctions between our points). NP is the class of problems that a non-deterministic computer can solve in polynomial Time (O(n^a) for any a).

Obviously, we don’t really have computers that always guess right, though quantum computers can get us a bit closer. But there are three important properties that let us understand NP problems in terms of regular computers:

1. a non-deterministic computer can do everything a regular computer can do (and more), so every problem that’s part of P is also part of NP.
2. every problem that takes n guesses with x options for each guess can be simulated on a regular computer in O(x^n) steps by just trying all combinations of options and picking the best one. With some math, we can show that this is also true if we don’t have n but O(n^a) guesses. Our base x might be different, but we can always find something with n in the exponent.
3. While finding a solution on a regular computer may need exponential time, we can always check if a solution is correct in polynomial time.

One important example for a problem in NP is finding the prime factors of a number which is why that is an important basic operation in cryptography. It’s also an intuitive example for checking the result being easy. To check the result, we just need to multiply the factors together and see if we get our original number. Okay, technically we also need to check if each of the factors we get is really prime but as mentioned above, that’s also doable in polynomial time.

Now for the important thing: we don’t know if there is some shortcut that lets us simulate NP problems on a regular computer in polynomial time (even with a very high exponent) which would make NP equal to P.

What we do know is that there are some special problems (either from NP or even more complex) where every single problem from NP can be rephrased as a combination of that special problem (let’s call it L) plus some extra work that’s in P (for example converting our inputs and outputs to/from a format that fits L). Doing this rephrasing is absolutely mind-bending but there are clever computer scientists who have found a whole group of such problems. We call them NP-hard.

Why does this help us? Because finding a polynomial-time solution for just a single NP-hard problem would mean that by definition we can solve every single problem from NP by solving this polynomial-time NP-hard problem plus some polynomial-time extra work, so polynomial-time work overall. This would instantly make NP equal to P.

This leaves us with the definition of NP-complete. This is simply the class of problems that are both NP-hard and themselves in NP. This definition is useful for finding out if a problem is NP-hard but I think I’ve done enough damage to your 5-year-old brain.

Yes, it’s pretty intuitive. A formal proof is still a bit more work than what I can fit in an ELI5 but at the same time simple enough that it can be given to a 2nd semester computer science student as an exercise.

They are classes that describe how hard a problem is.

Imagine trying to explain to someone how fast you can do something, for example sorting a list. The simplest way would be saying “I can do that in two seconds” but that’s not very helpful because it depends on how fast your computer is. A better way would be to express it as a number of steps: “I can do that in 10000 steps”. For this ELI5 explanation the exact definition of what a step is doesn’t matter that much, it could be a single CPU instruction or a comparison between two items in the list.

That gets you a bit closer but obviously, how complex sorting a list is, depends on the list: how long is it and how scrambled is it? Short lists are faster to sort than long ones and lists that are already (almost) sorted are usually fasterto sort than ones in reverse or completely random order. For that you can say “In the worst case, I can sort a list in three times the number of items squared, no matter the initial order”. When writing that down, we call the number of items n, so the total work is 3 * n^2. The bigger n gets, the less the constant factor matters, so we can leave it out and instead write O(n^2). This is, what people call “Big O notation” and it’s the reason why I said the exact definition of a step doesn’t matter that much. As long as you don’t get it too wrong, different step definitions just change the constant that we’re ignoring anyway. Oh and by the way, O(n^2) for sorting lists isn’t that great, good algorithms can reach O(n*log(n)) but I didn’t want to throw logarithms at you right away.

Now we get close to understanding what P is. It’s the class of all problems that can be solved in “polynomial” time, so O(n^a) for any number a. Note that only the highest exponent is relevant. With some work we could prove that for example O(n^3 + n^2 + n) is equivalent to O(n^3). Examples of problems in P are sorting, route planning and finding out if a number is prime.

I’m running out of time because I have some errands to run, maybe someone else can explain NP (nondeterministic polynomial time). If not, I’ll add a follow up later today.

Die Trends bzw. großen Gesprächsthemen der letzten Jahre, nehme ich an.

Sadly, the site is completely broken for me. It automatically redirects me to https://svgmix.com/de (presumably a localized German version) which gives a 404. Same problem if I select a different language from the dropdown.