Stackify Blog

They are 100% doing it. A lot of really bright people work on the engines/compilers.

The problem is telling individuals to focus on optimization.

Let's use javascript as an example. Say you need to transform an array. You can use `.map` or a `for` loop in javascript.

You see a lot of articles like this https://dev.to/henryjw/array-map-much-slower-than-for-loop-57if that say a `for` loop is faster. And sometimes it's true.

By the logic of the original article, you should hyperoptimize your code. The problem is. If everyone writes `for` loops instead of using `map`. When map eventually becomes more efficient there's all that garbage code out there that has to be refactored.

Ignoring the problems associated with benchmarking - this for example claims map now being faster than for loops. https://leanylabs.com/blog/js-forEach-map-reduce-vs-for-for_of/

It comes down to return on effort. We only have so much effort to put at solving this problem. You maximize your return on effort by having a clear separation of responsibility. In this case the individual's responsibility is to write code to the latest spec. The institution's responsibility is to make the code written as efficient as possible.

A single website saving .000000001 ppm of carbon (exaggerating) is just never going to be worth the effort. But a compiler improvement on all websites running javascript. Now that's totally worth it.

Further reading behind this…

I agree, New Relic's pricing model is almost too "enterprise". Per host pricing seems high, and difficult to scale. It's too bad, because I love everything else they offer. I'm even considering the new Insights service. I think they need to introduce a mid-tier pricing level between Free and Pro.

They've got a good foothold in the market as a all-in-one solution. I've attempted to find a drop-in replacement, without much luck. It's difficult to find a one-for-one service, but here's some similar services with entry-level pricing:

DataDog (https://www.datadoghq.com/pricing/): $15/host/month up to 100 hosts.

Scout (https://scoutapp.com/subscriptions): $10/host/month

CopperEgg (http://copperegg.com/pricing/): A la carte depending on service

Stackify (http://www.stackify.com/pricing/): $15/host/month

The biggest feature that I need is application level monitoring for PHP. There's plenty of great server monitoring tools, but not many services that track application performance like New Relic does.

I know there's plenty of ways to replicate New Relic, but who has the time?

Of course, I could be completely wrong, and missing a great alternative service.

Ugh, I started reading this before I realized it's the same person who thinks C#'s under the hood improvements in the last decade can be handwaved away.

Yeah, 10% of Java's market share is not larger than C#

https://stackify.com/popular-programming-languages-2018/

If it was, those languages would be showing up on Github's survey above C# as well, they all consider Java independently not as a combination of all JVM languages.

-

You've contorted this conversation so ridiculously out of shape then beating the horse you laid on it.

My original comment was a rebuttal to this comment:

> While Java's slow and cautious evolution frustrates developers, it still arguably demonstrates longer-term thinking than the constant accrual of features in its contemporaries such as JavaScript and C#.

If you read the whole comment, it was not about the JVM, it was not about confusing this issue with "oh yeah well the language sucks but that's so you can run Python on it's runtime".

No idea why you are so insistent on making it about anything but the actual language called Java, not Clojure or Kotlin or Js or Python.

https://www.androidpolice.com/2018/03/22/google-warning-developers-include-prominent-crash-reporting-disclosures-apps-face-removal/

https://www.reddit.com/r/androiddev/comments/868ie7/google_play_violation_about_disclosure_of_crash/

https://docs.instabug.com/docs/gdpr

https://stackify.com/about/gdpr/

https://raygun.com/gdpr

https://www.loggly.com/about/privacy-policy/

https://www.sumologic.com/compliance/what-is-gdpr/

https://logsentinel.com/gdpr-practical-guide-developers/

https://help.papertrailapp.com/kb/how-it-works/security-compliance/

https://www.landoop.com/blog/2017/12/apache-kafka-gdpr-compliance/

https://www.splunk.com/en_us/solutions/solution-areas/security-and-fraud/compliance/gdpr-compliance.html

https://www.elastic.co/gdpr

https://www.google.com/intl/en/cloud/security/gdpr/

There are nuances with multi-threading in C#.

I don't agree with OP about I/O-bound ops, I think if you're looking to green threading, you've taken a wrong approach.

> [0] the Task.Runmethod offloads the provided action to the thread pool, and the await keyword yields control back to the caller until the task completes.

All async code must be in an async call stack, virtual threads are 100% transparent because its the runtime scheduling them so you get a but more control than relying on the yeild of dotnet at least as I see it.

Again I don't see the huge demand for it personally, but I barely touch dotnet too often so take this with a grain of salt.

[0] https://stackify.com/c-threading-and-multithreading-a-guide-with-examples/

Found it here: https://stackify.com/whats-new-in-java-10/

——— start quote ———

This feature has been a long time coming. It was suggested as far back as 2001, and was closed at that time with the following comment by Gilad Bracha:

Humans benefit from the redundancy of the type declaration in two ways. First, the redundant type serves as valuable documentation – readers do not have to search for the declaration of getMap() to find out what type it returns. Second, the redundancy allows the programmer to declare the intended type, and thereby benefit from a cross-check performed by the compiler.

——— end quote ———

Link to original RFE and quote source: https://bugs.java.com/bugdatabase/view_bug.do?bug_id=4459053