drewhk

Not it is not stable, it was 1.38 last year (source, from the central statistics authority: https://www.ksh.hu/stadat_files/nep/hu/nep0006.html). This year will be even worse, see top left chart: https://www.ksh.hu/heti-monitor/nepmozgalom.html (live births per month)

(edit: added translation of unit)

Grug hurt itself in its confusion!

Also, judgement alone might not be enough. Judgement can take you to "something is off", but not necessarily further. I mix music as a hobby and it takes a good amount of practice to step up from recognizing the presence of a problem to actually know where and how to fix it. If you don't know where you should look, you just aimlessly try various things, and it is not unusual to make the problem worse.

Eventually you learn to properly recognize the problems, not just their presence, but their actual nature and implications. But this takes practice.

It is also interesting to consider, that if all transcendental numbers exist physically, then it basically means that there is an experiment that yields the Nth digit of such a number (for any N assuming unlimited physical resources to realize the experiment). If such experiment does NOT exist though, then there cannot be any relevance physically of that Nth digit (otherwise the "relevance" would materialize as an observable physical effect - an experiment!). This is something Turing machines cannot do for uncomputable numbers, like Chaitin's Omega, etc. We can yield the Nth digit of _many_ transcendental numbers (PI, e, trig functions, etc), but not all of them. It is so interesting that physics, machines and the existence of all the real numbers are so intertwined!

Of course one can also ponder, even if a mathematical object is "un-physical", can it be still useful? Like negative frequencies in fourier analysis, non-real solutions to differential equations, etc. Under what conditions can "un-physical" numbers be still useful? How does this relate to physical observation?

And just for the fun of it: when you execute unit tests, you are actually performing physical experiments, trying to falsify your "theory" (program) :D

The set of all possible mapping from all possible finite strings to booleans is definitely not countable.

Just to add another perspective to this, this is one of the places where classical and constructive mathematics diverge. Do those functions that are not expressible by algorithms (algorithms are countable) even exist? Of course you can define them into existence, but what does that mean?

Another food for thought is to consider if the limits imposed on computation by the Turing machine is a law of physics? Is this an actual physical limit? If so, what does that mean about the functions not expressible by algorithms? What is so exciting about programs/algorithms that they are both a well-defined mathematical object suitable for formal analysis, but they are actually machines as well, fully realizable physically and their properties physically falsifiable.

Before anyone starting to nit-pick, I just put this comment here as a conversation starter, not a precise thought-train: this is a deep rabbit whole that I think is worth to explore for everyone interested in the computational world. I am pretty sure other commenters can add more accurate details!

This warms my heart in an otherwise bland day :)

You clearly did not read the article...

One way to think about it is to ask yourself, is your personal project actually _playtime_? Playing is not goal oriented and therefore very relaxing. There is nothing wrong with that! I am happy to "play" programming and I learned a lot of techniques that I used years later - and then actually finishing it. Do not deny yourself playtime!

But honestly, why ruin your fun projects by turning them into work.

Agreed! For fun, it is completely fine to not finish things if you enjoy the process more than the actual result. You achieved your goal of having fun and likely still learned a lot from it. Of course if it bothers you then sure, improve on your ability to close things, but first evaluate if this truly an issue coming internally from yourself, or some imagined external pressure that your work is worthless if you don't finish it (in the hobby context). Is it important to show it to others for example, or is this a solitary activity purely for yourself? In some hobbies I strive to finish, because I want to show it to others, in others, I don't care at all.

The email verification email itself does not show up properly in Fastmail for some reason. I had to switch to the text only view to get the actual link...

One more addition, there is a subtle but very important difference between how TypeScript's "erasure" works compared to Java's.

In the case of Java, an explicit cast is emitted in the bytecode, which upon execution checks the compatibility of the actual runtime type with the target type during runtime. Yes, this makes it a runtime error compared to a static bytecode verifier/compiler error, but the behavior is well defined and the error does not propagate further from the original mistake.

In comparison, Typescript does not emit "verification code" at the casting site ensuring for example that all asserted fields exist on the runtime object at that point. The result of this is that the type mismatch will be only evident at the point where for example a missing field is accessed - which can be very far from the original mistake.

If you wish, you can consider type issues caused by Java's erasure as runtime, but _defined behavior_, while in TypeScript it is kind-of undefined behavior that can lead to various error symptoms not known in advance.

The problem with generics type erasure is less of an issue though in practice because the ecosystem is generally compiled from typed code and hence the compile-time guarantees reduce the dangers of erasure. This is unfortunately not true in TypeScript where you encounter plain JS all the time (sometimes TypeScript wrappers of dubious quality) causing more havoc. So while _theoretically_ type erasure could be considered having similar problems, in _practice_ it is much more manageable in Java. I guess if the whole JS ecosystem would be TypeScript only it would be less of an issue there as well, but right now it can be messy.

the JVM has no type safety whatsoever.

This is just partially true (or completely untrue in the mathematical sense since your statement is "_no_ type safety _whatsoever_" :P ). The whole purpose of the bytecode verifier is to ensure that the bytecode accesses objects according to their known type and this is enforced at classloading time. I think you meant type erasure which is related - generic types do not exist on the bytecode level, their type parameters are treated as Object. This does not violate the bytecode verifier's static guarantees of memory safety (since those Objects will be cast and the cast will be verified at runtime), but indeed, it is not a 100% mapping of the Java types - nevertheless, it is still a mapping and it is typed, just on a reduced subset.

It is not so clear-cut though. There is a hierarchy here that the article misses a bit I think. There will be participants of various awareness level:

1. Members of the audience that do not notice anything at all 2. Members of the audience that only notice it subconsciously, affecting some overall feeling of quality (an analogy would be typography which operates mostly in this realm) 3. Members of the audience that consciously notice that something is off, somewhere 4. The conductor that exactly knows that the piano is off 5. The tuner that exactly knows what and where is wrong with the piano

Well, instead of complaining here about 1 and l, I just filed a ticket on their GH repo and it already got resolved... https://github.com/internet-development/www-server-mono/issu...

I'm concerned by the number of misunderstandings expressed in short time here.

I have a feeling you misread my comment completely, and the misunderstandings are on your part?

Nobody claims service time is constant.

Neither did I. Neither did I claimed that Little's Formula requires a constant service time.

Little's law is one of the few parts of queueing theory that remarkably does not depend on service time distribution.

I did not say otherwise either. My point is that it is way less useful and enlightening than these edutainment posts make it. Two systems with the exact same parameters and results by Little's Formula might behave completely differently, and in many cases, counterintuitively.

Many results for typical simplified M/M/c systems apply well also to any other service time distribution provided (a) arrivals are Poisson, and (b) the server uses time slicing multiprocessing. These are not very severe requirements, fortunately!

This was not my point. Or do you claim that queue size distributions DO NOT depend on service time distribution? Because that WAS my point. Averages do not tell the story you are most interested in. The whole point of queues is that service and arrival times have distributions with deviation. I personally think queues and buffers are very-very important and I am a huge proponent of predictable user-observable latencies as they improve general system health and resiliency under load.

Long-term average sounds restrictive but it really just means a period long enough to exhibit some statistical stability. Most systems I see sit mainly in those regimes.

Long-term averages do not talk about pathological transient behavior, do not help you with queue sizing - or setting ideal timeouts. Also, statistical stability is misleading, the convergence time to the given statistic might be arbitrarily slow. Also, if we talk about real-world systems (which you do), they exhibit feedback do to clients retrying, throwing off the formula and potential ergodicity.

I am a bit worried of the overuse of Little's formula, especially in these catchy educational presentations. In reality queue sizes will dictate your consumer observable latency profile, which is in turn is dictated by the actual distribution of the service time - it is not a constant.

If you think about it, if you have an ideal system that serves users like a clockwork, every X ms with no jitter, while your arrival is also completely regular, every Y ms (Y < X), then basically a queue length of 1 is sufficient. In reality, just like we all observe in real-life queues, service time is far from constant, and outliers result in queue buildup. This is why often cutting the tail of service-time latency results in better overall latency than simply reducing average service-time.

Little's formula of course holds also in the above scenario, but it handles long-time averages and does not give you any indication what extreme behavior is lurking under the mask of these averages.

But any child can look at the sun (with eye protection :) and see that it is a disc, not a point of light. The disc is about 0.5 degrees, which is not so small.

Page 11-12 explicitly discusses "sun-as-a-disk", the resulting shadow penumbra and other sources of inaccuracies.

And don't forget multi-stage programming which generalizes the concept and allows for partial evaluation at compile time and runtime as well.

The time our election comes, the Ukraine conflict will likely be mostly over, at least there would be nothing to stop serious Russian movement. We will have an election with russian toys lying around just over the border, while our foreign minister prodly wears his pledge of "Friendship", given by Lavrov himself. I really hope we will not be "liberated" once again.

Many of us are trying, trust me. Things got out of hand here, big time. If the next election is lost, I will go through half of my life (20 years!) under the rulership of one single person.

From Hungary with deep shame because of our traitor government. There are many of us that are deeply disturbed with what is happening, and our government is not representative of all of us.

I used to work on the Akka Team, mostly on streams, but I was doing different stuff elsewhere in the last years, not touching Akka much. To be honest, I am quite emotionally distanced nowadays from Akka...

That said, it still feels good reading success stories from people who used it. Thanks, you made my day!

No, you are not wrong: https://akka.io/team/ (check the Honorary Members section)

It is scary to think about one of these batteries burning inside the tunnel...

Hm, can't this be circumvented by pushing towards a correlated equilibrium (https://en.wikipedia.org/wiki/Correlated_equilibrium) instead of a Nash equilibrium?

Hm, can be related to: https://en.wikipedia.org/wiki/Ghaith_Pharaon

(last seen in Hungary, likely being involved with the prime minister; there was some scandal about it)

It depends on whether you imagine a fraction line there or not: https://wikimedia.org/api/rest_v1/media/math/render/svg/8c6e... ;)

I am not a physicist, in fact, I am a complete dilettante, but can the transition from a power law to an inverse law simply indicate that on large scale the universe has less dimensionality? I mean, if we take a suitable definition of dimension, likely along the lines of Hausdorff dimension (https://en.wikipedia.org/wiki/Hausdorff_dimension) then we can see it as a number that defines how volume/surface changes with changing diamater of an observed "sphere" (I know I oversimplify things here). In other words, as we start to measure cosmic distances on a large enough scale, volumes/surfaces covered don't grow quadratically anymore but with a lower rate. This might be even in line with the assumption of a universe curved into itself, i.e. closed. This would change the gravity power law from having a constant 2 power to having a function as the power.

I nowadays do an approach where I don't write tests first, but I write down the test titles (I use a language where the testing framework gives a nice DSL to write nicely readable test names compared to method names) and I just mark them as pending (which will report as no test failures or passes but ignored cases). I rarely end up with the same test ideas and names which I started from, but since I only start with names which do not hinder refactorings this worked out surprisingly nicely for me.