.NET Core Magic: Develop on one OS, run on another

I recently attempted to write a blog post about Angular and .NET Core 2.0 [Note: It will be posted as soon as the .NET Core 2.0 RPMs are released], using my Red Hat Enterprise Linux (RHEL) VM as the operating system. Even though the .NET Core 2.0 bits are not available yet from Red Hat, I gave it a shot by using a daily build. When I tried to run the code, however, I got an error related to the Roslyn compiler. Sometimes, when you play with fire — i.e. a daily build — you get burned.

And that’s when the creative juices, combined with the knowledge of .NET Core’s Self-contained deployment technology (you might also see it referred to as a “Standalone app”) came to the rescue.

Continue reading “.NET Core Magic: Develop on one OS, run on another”


Red Hat at the ISO C++ Standards Meeting (March 2017): Parallelism and Concurrency

Several Red Hat engineers attended the JTC1/SC22/WG21 C++ Standards Committee meetings in March 2017. This post focuses on the sessions of SG1, the study group on parallelism and concurrency. The major topics of work of the week were (1) further polishing of the parallel algorithms in the C++17 draft, (2) making progress on the executors proposal (which provides mechanisms to control how parallel work is executed, for example on which resources), and (3) continuing work on proposals targeting the Concurrency Technical Specification version 2. We also discussed an important aspect of enabling standard C++ code to execute on GPUs, which is a topic that several people in SG1 have a lot of interest in — I certainly do, for example.

Continue reading “Red Hat at the ISO C++ Standards Meeting (March 2017): Parallelism and Concurrency”


From Java to .NET Core, Part 2: Types

In my previous post in the series, I discussed some fairly surface-level differences between C#/.NET and Java. These can be important for Java developers transitioning to .NET Core, to create code that looks and feels “native” to the new ecosystem. In this post, we dig beneath the surface, to understand .NET’s type system. It is my belief that, with Java in the rear view mirror, the .NET type system is more effective and enjoyable to write on. But you be the judge.

Continue reading “From Java to .NET Core, Part 2: Types”


Running HPC workloads across multiple architectures with Red Hat Enterprise Linux

In this article, I want to provide some background details about our recently developed demonstration video – “Running Game of Life across multiple architectures with Red Hat Enterprise Linux“.

This video shows the Game of Life running in a heterogeneous environment using three 64-bit hardware architectures: aarch64 (ARM v8-A), ppc64le (IBM Power little endian) and x86_64 (Intel Xeon). If you are not familiar with the rules of this cellular automaton, they are worth checking out via the reference above.

Continue reading “Running HPC workloads across multiple architectures with Red Hat Enterprise Linux”


Working with peer, scoped and private npm dependencies in RHMAP

RHMAP Environments

An RHMAP Environment provides a Node.js runtime for Mobile Backends. There are 2 environment types: Dynofarm & OpenShift. The former is an LXC based PaaS, written in Node.js & bash. It is superseded by OpenShift environments. However, there are still many Dynofarm environments in use in the RHMAP SaaS offering.

Continue reading “Working with peer, scoped and private npm dependencies in RHMAP”