Indeed it's 10, in base 38 xd

@Lensflare

My man, he snorts chaos emeralds and gets such an high that he actually turns super Saiyan and flies!

You could also simply not have kiddo and do whatever the fuck you want XD.

Good thing I don't really care if a potential partner has kids, because at my age that would severely limit the pool, but then again, I still live like I'm 20, even if my body doesn't like it.

I dare say the description fits sonic more than Mario XD

Also Mario is secretly communist.

Haven't you realized his goal is actually overthrowing the rightful king and proudly rising the red star flag onto his castle over and over?

But will you blend?

@Lensflare

You can indeed disambiguate by fully qualifying, yeah.

Using using in an implementation file is not so bad, but doing so in a header file deserves the gallows, because you'll pollute the global namespace of whichever file includes it.

@Demolishun

But surely they can have a std:: future?

@donkulator

Global using namespace are evil.

(And defeat the whole point of namespaces)

But that's only if Json got a 201 on
POST /stress
{"disorder": "traumatic"}

I'll see myself out

Could simply be growth.

This week, I had to dust off lots of C arcane knowledge that I barely remembered.

They didn't come into use for my line of work in decades, so naturally, other knowledge takes its place in the forefront, and, the more you diversify, you end up with a broader perspective of the whole process, and naturally end in architecture/DevOps/sysadmin, etc, at the price that low level details give way.

In my experience, the problem always comes from salesmen wanting to parrot shit about being "cloud native", "high availability", "scalable", "state of the art", and other bullshit.

And they end paying absurd amounts of money and man hours for something they could easily run in a couple computers gathering dust in the corner.

@antigermanist

Not saying otherwise, but "sidra" is not exactly English, or gaelic.

@cprn

Well, I'd rather express it the other way around. Duck typing is the polymorphism of non statically typed languages.

But yeah, in the end both aim to solve the same problem, just that in one the contract (interface) is explicit, and in the other it is by convention.

Historically, non static typed languages have been interpreted, and those, by the very definition, could only have runtime dispatch anyway.

Another undercover spaniard or latinoamerican, it seems. Cheers.

45 min ago. Feliç passagem do ano para tudos!

For me, and mind you, my family ain't perfect by any means but it certainly is *big*, we have an unspoken rule that didn't really apply to me but does now, which is, "don't burden the children with the sins of the parents".

Our parents could hate each other's guts, but would always be there for the nephews/nieces, no matter what.

That's how I see family. Don't really watch TV so can't speak about portrayals, but still. Family is who you choose it to be. If the biological ones are worthy, do cherish them, otherwise, nah

@retoor

I know UUID is just a format, hence why I said "safely generated".

@kiki

urandom itself does fall back to known PRNG algorithms such as Mersenne when there's not enough entropy, but yeah, so long as entropy ain't a big fat 0, you should be set.

Also, last I checked, servers without physical sources of entropy could fall back to algorithms run on a concat of request bodies and timestamps to substitute /dev/u random.

While that certainly has more of an attack surface, it is still a decent source of entropy.

UUIDv4, despite not being guaranteed to be unique, has such a ridiculously big keyspace that for 99.999% of applications you can safely treat a well generated UUID as unique.

After all, the probability of a collision, and thus someone stealing your session, is waaaaay less likely than you being struck by lightning, or an asteroid wiping us all out, which would render your shitty web session pointless anyway.

The skin of woke people is so thin that I think it behaves like dark matter. Photons just phase through it.

Also, for an extra brainfuck. You've heard that light from very distant astronomical entities takes millions of years to reach us, and that as you get closer and closer to the speed of light, your subjective time dilates.

Well, when you are a photon and you travel at the actual speed of light, time doesn't flow at all, so technically, as far as that photon is concerned, it arrived here at the same time it was emitted.

@kiki @Lensflare

Glass has colour. Everything sufficiently macroscopic has a colour because it radiates photons based on temperature. It just so happens that on normal temperature ranges they emit in infrared (why incorrectly named night goggles work). If you were to heat them up enough, they'd go, go figure, *red hot*.

I'm willing to accept quarks too but only because of the *name* of quantum chromodynamic. (Doesn't really have anything to do with colour).

Dark matter, as we understand it today, can't have colour because it doesn't interact with the EM field in any known way.

(Some*) Black holes are actually the brightest objects in the universe. Sure, we can't see anything past the event horizon, but the accretion disk matter is accelerated to a significant fraction of the speed of light, which makes it glow like there's no tomorrow. Quasars (the brightest objects in the universe) are supermassive black holes really.

@qwwerty

It does have news and stuff like that, but never ads. And even if it did you could still hosts the fuck off their ad servers.

With enough voltage everything is a wire.

@kiki

Well, grayscale would be if you had actual photons of *every* visible wavelength mixed (since that's gray).

Things under 400 nm (which is the start of ultraviolet spectrum) do have colour, but our retinas don't have receivers for them. Some animals do, though.

Still, colours are a tricky thing.

You could ask 100 people to order a colour gradient, and you'd get 100 different results.

Even grayscale is tricky, because the way we perceive intensity is actually logarithmic, not linear. Screens do actually play math tricks on us to make us perceive it as linear by running linear RGB values to the power of (usually) 2.2. (this is the fabled gamma correction).

Also, the sun isn't yellow. It's white (and its peak of emissive power is actually green, not yellow, which is why our vision is sharpest on green wavelengths).

@Lensflare

Well, sounds exactly like std::shared_ptr baked in, but that's still runtime.

@Lensflare

Oh, I do not underestimate compilers at all. I say here all the time that the compiler does better than any of us.

My gripe is that what you described isn't really automatic, in the sense that having the compiler insert the calls to init and release is just like GCC will add a call to your constructor/destructor. You don't call them manually. You can then do ARC in them (like std::shared_ptr) or not, and while not free, it's nearly free, but doesn't dismiss you from actually having to properly destruct objects (release resources, etc).

My other gripe about compile time ARC is that the compiler can't possibly know when an object will be constructed or copied if there's no topologically unique code path through the program.

It just takes shit like reacting to a key press to invalidate that. If you create an object on each key press, the compiler can't know how many times the key will get pressed in runtime.

Like in every internet community, there's users and there's lurkers.

I know that I myself was a lurker for almost two years before engaging at all.

Platform being abandoned certainly does not help, but also, in some ways, keeps it authentic kinda like the old IRC days.

@Lensflare

To be fair I don't really know swift, but it's still an example of what I said. It doesn't matter what it is used for. Reference counting has overhead that you have to pay for.

C++ does not impose that on you, at your own risk.

And even then, I'm not at all sold at "compile time reference counting". A compiler has no idea when or why a piece of code with explicit malloc can be called.

RAII is the closest you can get to that, and it still relies on developer discipline to properly implement destructors.

And that is why, despite other languages doing a good job so far, everything performance critical will still be done in C/C++.

@Demolishun

"struct" in C++ is just syntactic sugar for "public class" with default public accessibility. There's no functional difference, and of course, no runtime penalty either from

struct A { int i; };

To

public class A {
public:
int i;
};

They are the same and compile to the same.

Zero cost abstractions are what they are.

For example, smart pointers. An abstraction for reference counted pointers, which could be used for say, garbage collection.

In C#, java, or JS, you pay for this always. Every reference is reference counted and thus you pay the price, even if seemingly negligible.

C++ doesn't impose this penalty. You have smart pointers. You don't want to use them? Fine. They will cost you no runtime performance.

Yes, you will be on your own and might have memory leaks, but believe me, when you have to deal with very hot loops with allocations, those negligible penalties, will amount to non negligible penalties.