Red Hat Developer

Another great overview of Go compiler's register allocation: https://developers.redhat.com/articles/2024/09/24/go-compiler-register…

Later in the article, it mentions: Improved experimental support for C++23, including: std and std.compat modules (also supported for C++20). From https://developers.redhat.com/articles/2025/04/24/new-c-features-gcc-1… The next major version of the GNU Compiler Collection (GCC), 15.1, is expected to be released in April or May 2025. GCC 15 greatly improved the modules code. For instance, module std is now supported (even in C++20 mode).

To all those interested in podman, this book by Daniel Walsh is a gem. Highly recommended and it is free. https://developers.redhat.com/e-books/podman-action

I love the standalone kubelet/static manifests pattern. It's ideal for edge type stuff and really simple systems. Here's a talk on my CNC control software running in my shop with just the kubelet, no control plane: https://developers.redhat.com/devnation/tech-talks/kubelet-no-masters

Unfortunately, int main(){ char buffer[10]; buffer[10] = 0; } are so rare they are hardly worth bothering with. The more usual case is: int get(char* buffer) { return buffer[10]; } void test() { char buffer[10]; get(buffer); } I.e. the array bounds for buffer get lost in the function call. I have proposed a fix: https://www.digitalmars.com/articles/C-biggest-mistake.html that is compatible with existing code. And yet, nobody cares. Oh well! Instead, we have overly complex solutions like this: https://developers.redhat.com/articles/2022/09/17/gccs-new-fortificati…

The extensions can be kinda broken down into 4 levels. Basically ancient, old (SSE 4.2), reasonably new (AVX2, Haswell/Zen 1 and up), and baseline AVX512. https://developers.redhat.com/blog/2021/01/05/building-red-hat-enterpr… There is discussion of a fifth level. Someone in the Intel Clear Linux IRC said a fifth level wasn't "worth it" for Sapphire Rapids because most of the new AVX512 extensions were not autovectorized by compilers, but that a new level would be needed in the future. Perhaps they were thinking of APX, but couldn't disclose it.

> Paying Red Hat customers will still have access to the proper RHEL sources via the Red Hat Customer Portal. wonder does this include customers in the Dev Program. I got access to RHEL though https://developers.redhat.com/... Cant figure out where to download the code... might not be available though this...

This should be a fairly unsurprising result. High level languages are fundamentally more optimisable than low level ones because, as you say, the latter express unnecessary constraints, lacking information about domain-level semantics. Low-level optimisations are also known to follow a pareto distribution wrt their efficacy: 20% of the optimisations are responsible for 80% of your performance (if not more). See for example mir - https://developers.redhat.com/blog/2020/01/20/mir-a-lightweight-jit-co… That said: > It seems to me that the LLVM optimisations are only of benefit to you if you generate really bad LLVM code in the first place. Much llvm development is sponsored by large corporations for whom it really is worth it to squeeze that last 1%.

> All system time in Linux is tracked in seconds past Jan 1, 1970. > If your application is time sensitive and not looking for a literal time traveling event... One of my least-favourite facts is that these statements are misleading. Since Linux uses UTC and not TAI, it no longer tracks an absolute measurement of seconds since the unix epoch as it takes “leap seconds” in to account. As well, because of leap-seconds you can absolutely have time-travelling events. https://developers.redhat.com/blog/2015/06/01/five-different-ways-hand…

https://developers.redhat.com/products/developertoolset/ this greatly extends of what can be considered supported by RHEL 7 (unless we require - "don't install any packages")

Not docker compose, but I would like to introduce you to RedHat image streams, my least favourite feature of OpenShift: https://developers.redhat.com/blog/2019/09/20/using-red-hat-openshift-… I consider not pinning to at least a version to be a hot potato that will eventually bite you. Not least of which when you’re using an older version of an image instead of the newer one due to the caching/local repo you mention. Sadly there is no right answer - pinning to an image not under your control always means the image can disappear, which is part of the— never mind. Let’s just say there is a trade off between availability and security where for the most secure experience you have to do extra legwork that frankly isn’t immediately required if we trust the upstream image.

This is why you should never run plain-old-Kubernetes in prod (or in dev, if you want my opinion). Stock Kubernetes basically ignores security and, then, as you said, it requires a bunch of additional work to config. There are several companies that take Kubernetes and polish it up, the two biggest examples are Red Hat OpenShift[0] (which I'm most familiar with, because I manage it as my day job), and Rancher[1]. Also, note OpenShift is a paid product, but Red Hat also releases OKD[2] for free, which is OpenShift without support. OpenShift is Kubernetes with great default security policies. Storage, networking, logging, and more are all configured out of the box. I would recommend anyone who is using or looking to use Kubernetes to strongly consider OpenShift or OKD. [0] https://developers.redhat.com/products/openshift/overview [2] https://www.okd.io/ [1] https://www.rancher.com/

The term "Two pizza team" comes from Amazon and describes a team size such that it is the number of people that can be fed by two pizzas. The reality is that the term is not only a reference to team size but, rather, underscores the concept of "Accountability". https://developers.redhat.com/blog/2022/10/21/coming-terms-two-pizza-t… I think a well composed small team can have greater than linear improvement in effectiveness because of skill stretch and decreasing blindspots.

I'm plugging this amazing resource (not only containers but also virtual machines...): https://developers.redhat.com/blog/2018/10/22/introduction-to-Linux-in… It's lower lever than OP but might give ideas.

You can volume mount in the host container storage into the container using additional stores. In this article, note sections on /var/lib/shared https://developers.redhat.com/blog/2019/08/14/best-practices-for-runni…

And yet RedHat's recommended compiler flags for GCC [0], for example, do not appear to catch the wrapping assignment in the above example code. 0: https://developers.redhat.com/blog/2018/03/21/compiler-and-linker-flag…

The readme has a link to the blog post describing MIR -- it's a great read and is probably where you actually want to go: https://developers.redhat.com/blog/2020/01/20/mir-a-lightweight-jit-co…

“Full” init systems tend to need to do things that are hard to secure in a container. Many must run as root, and the reasons not to do that are discussed in the article this HN thread is discussing. Systemd is particularly tricky because it needs to be able to control the cgroups of its child processes, which means the container needs to be granted that capability. See https://developers.redhat.com/blog/2019/04/24/how-to-run-systemd-in-a-… about how to run systemd in a container via Podman, and is a follow up to https://developers.redhat.com/blog/2016/09/13/running-systemd-in-a-non… which discusses why the Docker case is even more difficult. That said, if you just want a process supervisor for a multi process container, there are several more minimal init systems that will work well, for example, supervisord.

Rust with it's Cargo package manager, unicode string handling and strong type system is really great for Python speed-ups: https://developers.redhat.com/blog/2017/11/16/speed-python-using-rust/

Reading the article hurts me. The link from RedHat [1] is much better. What is hard to understand is Quarkus. >The Quarkus project was launched in 2019 and provided that evolutionary step needed for Java developers in this new world of Kubernetes and serverless. And on its webpage >A Kubernetes Native Java stack tailored for OpenJDK HotSpot and GraalVM, crafted from the best of breed Java libraries and standards. So correct me if I am wrong. Quarkus is an umbrella term for all the "selected" Open Source project that works perfectly on tops of Mandrel / GraalVM and Kubernetes? [1] https://developers.redhat.com/blog/2020/06/05/mandrel-a-community-dist…

This must be something asked of RedHat support quite a bit because it was covered thoroughly in their UNIX sysadmin training material for Redhat 7 and there's a published solution on their site from years ago. [1] Redhat documentation is pretty decent and access is free via their developer program [2]. The program gives one free bare metal license for a system with up to 8 sockets that can host unlimited VMs. [3] I realize HN is all about open source and free software but for people looking to work in a corporate environment that uses RHEL, Redhat does try to make entry at least possible for those who can self study. [1] https://access.redhat.com/solutions/1192 [2] https://developers.redhat.com/ [3] https://developers.redhat.com/articles/faqs-no-cost-red-hat-enterprise…

Podman supports pods, hence the name. It follows the k8s approach, and it’s nowhere close to a drop-in replacement for docker-compose, but managing multiple related containers is supported as a core feature. https://developers.redhat.com/blog/2019/01/15/podman-managing-containe…

>I’ve appreciated RH putting in effort like Software Collections to bring more modern versions of tools Then you are going to love Modularity and Application Streams: https://developers.redhat.com/blog/2018/11/15/rhel8-introducing-appstr…

As far as I can see it looks like there is a possibility that a new version of ActiveMQ will be based on Apache Artemis in the future sometime, as in later on, maybe... Artemis claims to be really fast and solves some of the problems outlined in the RocketMQ motivation page you listed. It uses an append only journal file similar to Kafka and the clustering and failover story looked simple and reliable to me though I haven't tested it. Whether or not Artemis becomes the new version of ActiveMQ, RedHat have recently released a new version of their AMQ and it is based on Artemis. It supports AMQP 1.0, MQTT, STOMP, OpenWire, and HornetQ Core. https://developers.redhat.com/products/amq/overview/

Your best bet is probably to use the OpenJDK build for Windows. It's an MSI file and it doesn't have any of the Oracle crap attached to it. https://developers.redhat.com/products/openjdk/overview/

Whilst I agree with the premise, I think you are actually underselling them. Claude becomes near lobotomized at beyond 500,000 tokens. I don't believe much quality code gets outputted at such high token counts, not to mentioned drastically increased cost. 270k isn't massive, but its very usable with compaction. Not every task needs the full context history. Quantized models do have a quality / accuracy impact, although it is not as drastic as you suggest. There is some good data on this [0]. "These findings confirm that quantization offers large benefits in terms of cost, energy, and performance without sacrificing the integrity of the models. " One thing that is worth mentioning is quant models are not created equally, they are not always scaling at the same rate. [1] For example not all tensors contribute equally to model accuracy. In practice, the most sensitive parts (such as key attention projections) are often quantized less aggressively to preserve the quality of the inference. [0] - https://developers.redhat.com/articles/2024/10/17/we-ran-over-half-mil… [1]- https://medium.com/@paul.ilvez/demystifying-llm-quantization-suffixes-…

Yes, and I think we're already seeing that in the general trend of recent linux work toward atomic updates. [bootc](https://developers.redhat.com/articles/2024/09/24/bootc-getting-starte… based images are getting a ton of traction. [universal blue](https://universal-blue.org/) is probably a better brochure example of how bootc can make systems more resilient without needing to move to declarative nix for the entire system like you do in NixOS. Every "upgrade" is a container deployment, and you can roll back or forward to new images at any time. Parts of the filesystem aren't writeable (which pisses people off who don't understand the benefit) but the advantages for security (isolating more stuff to user space by necessity) and stability (wedged upgrades are almost always recoverable) are totally worth it. On the user side, I could easily see [systemd-homed](https://fedoramagazine.org/unlocking-the-future-of-user-management-wit… evolving into a system that allows snapshotting/roll forward/roll back on encrypted backups of your home dir that can be mounted using systemd-homed to interface with the system for UID/GID etc. These are just two projects that I happen to be interested in at the moment - there's a pretty big groundswell in Linux atm toward a model that resembles (and honestly even exceeds) what NixOS does in terms of recoverability on upgrade.

> ...includes support for a soft memory limit. This memory limit includes the Go heap and all other memory managed by the runtime, and excludes external memory sources such as mappings of the binary itself, memory managed in other languages, and memory held by the operating system on behalf of the Go program" Of course it’s a runtime setting, it won’t affect other factors but you can’t say it didn’t solved anything “because there’s a GitHub issue open” Then Go runtime was unpredictable because of its ideology “CPU is unlimited but not Memory” and containers are kinda of a dynamic resource allocated but it did solve vast amount of problem dealing with kernel OOM and unpredictable GC cycles > You still need to use a helper library like https://github.com/KimMachineGun/automemlimit or https://github.com/uber-go/automaxprocs. I would be surprised if the Go team implemented it into the runtime, because some devs would love to have there own way of handling such settings so I don’t see it as an issue > Forgot to add: The JVM does this for you since JDK 17 https://developers.redhat.com/articles/2022/04/19/java-17-wh... We can’t just compare added features if don’t compare how backwards compatible the language is at that time I don’t know much about Java, but I wouldn’t say the same from upgrading from Go 1.9 to Go 1.19

Is there a specific aspect of k8s that's causing friction along the learning curve? I'm assuming your referring to the developer side of the equation, not the ops/admin workflows. Before jumping straight into production k8s, something you can mess around with is using Podman to generate[0] and run[1] Kubernetes resources that you can parse through and familiarize yourself with. Paired with Podman Desktop[2] can produce a nice graphical environment. After that you could take a look at more production-simulating environments with minikube[3], OpenShift Local[4] (very much recommend if you have the resources to run it), and the no-cost OpenShift Sandbox[5]. In general, the Red Hat Developer[6] site has a lot of good resources to learn from, both passive and interactive. I highly recommend going through the courses and tutorials available if it can help your team skill up (assuming k8s is the direction you want to go in). [0] https://docs.podman.io/en/latest/markdown/podman-generate.1.html [1] https://docs.podman.io/en/latest/markdown/podman-kube.1.html [2] https://podman.io/features | https://podman-desktop.io/ [3] https://minikube.sigs.k8s.io/docs/ [4] https://developers.redhat.com/products/openshift-local/overview [5] https://developers.redhat.com/developer-sandbox [6] https://developers.redhat.com/

At this point, I'm not sure why end users who care about Red Hat stability don't just use RHEL directly. Red Hat has multiple ways to take advantage of RHEL that involve no cost (that weren't available when the original CentOS project was conceived): - Free developer licenses[0] (great if you're a home-labber, IIRC you can get up to 16, I think?) - Red Hat UBI images[1] I feel like most users of AlmaLinux won't see a huge difference between just using AlmaLinux's release cycle vs RHEL -- especially since AlmaLinux will be ABI compatible with RHEL. I.E. apps that work for RHEL should work for AlmaLinux. So, back to your original question, I don't know what end-users want more of other than as was said by mrweasel in a different comment: "that's not what some people want, they specifically want RHEL, but for free". [0] https://developers.redhat.com/blog/2021/02/10/how-to-activate-your-no-… [1] https://developers.redhat.com/products/rhel/ubi