Stackify Blog

stackify.com · Company blog · on HN since 2012

Stackify's company blog covers Java and .NET development, logging, performance, and application monitoring topics.

What HN saysHN links it for Java and .NET explainers, such as Java 10 features and logging, while commenters mostly discuss monitoring tools.
42HN people shared it
14linked it in comments
134stories submitted
451story points
2 years agolast shared
2012people per year2026

Most-shared posts

  1. 1
  2. 2
    Why Premature Optimization Is the Root of All Evil
    3 people · 1 points · first shared 2017 · discussion on HN
  3. 3
    Lessons Learned while Converting from ASP.NET to .NET Core
    2 people · 167 points · first shared 2016 · 78 comments on HN
  4. 4
  5. 5
  6. 6
  7. 7
  8. 8
    REST API Tutorial
    2 people · 3 points · first shared 2018 · discussion on HN
  9. 9
    Java Logging Frameworks: log4j vs. logback vs. log4j2
    2 people · 3 points · first shared 2018 · 1 comments on HN
  10. 10
  11. 11
    C# Threading and Multithreading: A Guide with Examples
    2 people · 1 points · first shared 2023 · discussion on HN
  12. 12
  13. 13
    Errors log management
    2 people · first shared 2015
  14. 14
    Ways to Tail a Log File on Windows and Linux
    1 people · 28 points · first shared 2013 · 28 comments on HN
  15. 15
    The Golden Rule of Programming
    1 people · 14 points · first shared 2013 · 18 comments on HN

What HN people wrote when they linked it

spo81rty · 2014-07-12
Monitoring background services can be difficult due to changing process ids. If anyone is looking for a commercial product that does this, I would recommend checking out Stackify. We do server monitoring, app monitoring, errors, logs, metrics, etc all in one app. http://www.stackify.com
dmitriid · 2019-01-22
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
scarface74 · 2018-07-11
Using only files for logging is the last thing I would do in 2018. I use Serilog for structured logging. Depending on the log destination, your logs are either stored in an RDMS (I wouldn’t recommend it) or created as JSON with name value pairs that can be sent directly to a JSON data store like ElasticSearch or Mongo where you can do adhoc queries. https://stackify.com/what-is-structured-logging-and-why-developers-nee…
jefflombardjr · 2021-12-08
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…
ericcholis · 2014-10-08
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.
AndrewDucker · 2024-10-30
Kestrel does ASP.Net very quickly, because that's all it does. If you want a full web server, that does things like static files, SSL, Reverse Proxying, etc. then you want IIS at the very least sitting in front of it. See https://stackify.com/kestrel-web-server-asp-net-core-kestrel-vs-iis/ - comparison table 3/4 of the way down.
bilekas · 2024-08-22
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-examp…
cccc4all · 2021-01-27
Premature optimization is root of all evil - Donald Knuth https://stackify.com/premature-optimization-evil/ Don't be evil.
Koshkin · 2018-12-24
On the other hand, "there are languages everyone complains about, and there are languages nobody uses." See, for instance, https://stackify.com/popular-programming-languages-2018/.
sharemywin · 2017-12-28
I live in ohio and it's 6 degrees outside I'm aloud to be mean in the morning: https://stackify.com/popular-programming-languages-2018/
MichaelGG · 2015-04-27
I always have to Google it. http://stackify.com/errors-log-management/ Dunno why it's not more discoverable. Maybe they're doing tests, because it's underpriced IMO. I've not found any service like them - maybe New Relic but that's 10x the price, last I checked. Azure has something they're pushing in their UI, too, but a brief look made it seem nontrivial to implement. Apart from that, Stackify is $15/server/mo for the server monitoring and app metrics, IIRC.
BoorishBears · 2019-12-07
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.

Keyboard shortcuts

/Search
j kNext / previous blog
EnterOpen selected blog
vVisit the blog site
fFollow / unfollow
lSwitch grid / list view
dSwitch dark mode
g hHome
g pTop posts
g tTopics
g fFollowing
g lLiked
g yHistory
g qFAQ
EscBack / close