Why use RPMs (distribution packages in general) at all ?!
Distribution RPMs enables you to get signed curated content, with security updates, bug fixes, general updates, some level of testing, and known ways of reproducing the build locally. Of course, it has its cost mostly in the package size overhead and packaging infrastructure overhead (yum, dnf, apt….).
Continue reading “Basics of Go in Fedora”
A few months ago, I had to write some internal GCC passes to perform static analysis on the GNU C Library (glibc). I figured I might as well write them as plugins since they were unlikely to see the light of day outside of my little sandbox. Being a long time GCC contributor, but having no experience writing plugins I thought it’d be a good way to eat our own dog food, and perhaps write about my experience.
Continue reading “Diagnosing Function Pointer Security Flaws with a GCC plugin”
Everything around us has a name, I mean everything, otherwise, how would we be able to refer to them, particularly in programming. From our project name, directories, variables, and more, a name must be associated with every item or else we lose their meaning and use.
Continue reading “Naming Matters”
As a web developer, being able to run a Linux distro alongside your pre-existing mobile OS on your android phone is a very enticing offer. With a fully functional Linux program in your pocket at all times, you can begin to utilize your phone for various processes including powering a LAMP server and turning the device into a portable network, troubleshooting tool, and pen-testing device.
Continue reading “Installing Linux on an Android Phone”
So, my first programming job was part of the Duke Basketball IT department, while I was enrolled as an undergraduate. To be fair, it wasn’t really a programming job, mostly just churning out scouting reports and videos, but it was a lot of fun. I really liked basketball back then. I wasn’t any good at it but I enjoyed playing all the same, and I had a lot of fun watching it. And as most people know, the culmination of the college basketball season is a 68-team single elimination tournament called March Madness. And it is just that, Madness; employee productivity plummets, players, coaches, and spectators spend thousands of dollars traveling all over the country with a single day’s notice, and a lot of scouting reports get generated. Most people look forward to it, both the participants and the fans, but due to a series of mistakes and poor decisions, I have grown to dread March Madness…
Continue reading “A Post Mortem on Madness, or Why Process Matters”
In programming, documentation is not only about documenting our code, but also the steps, processes, and architecture around how things work. We are most familiar with documentation from the aspect of the code, which is something that should be encouraged. But as developers look for greener pastures and move from one job to another, the idea of documenting every aspect of programming is important so that the effect of the bus factor does not set in for any organization when a programmer decides to leave.
Continue reading “Why Software Documentation is the Next Big Thing”
I came across Linux in 2005, it was Debian. Then followed a love affair with Ubuntu, for which in March 2009 I purchased a netbook Asus EeePC 1000. In 2010, I began to contribute to ALT Linux participating in the “School Project” and even became a basic256 package maintainer.
The last few years my EeePC with Ubuntu peacefully rested deep in my cupboard. Then there was a chance to clean off the dust. There was a task to get acquainted with CentOS Linux and test examples for my webinar “Apache Ant – quick start”.
Continue reading “Preparing CentOS 6.8 for Work”
Many developers are (or should be) aware that Java processes running inside Linux containers (docker, rkt, runC, lxcfs, etc) don’t behave as expected when we let the JVM ergonomics set the default values for the garbage collector, heap size, and runtime compiler. When we execute a Java application without any tuning parameter like “java -jar mypplication-fat.jar”, the JVM will adjust by itself several parameters to have the best performance in the execution environment.
This blog post takes a straightforward approach to show developers what they should know when packaging their Java applications inside Linux containers.
Continue reading “Java inside docker: What you must know to not FAIL”
Ever wonder how you can set up and hit a basic https endpoint with camel? These directions are sure to help!
Continue reading “Basic Camel and HTTPS”
C/C++ libraries expect to be able to change the internal implementation details of opaque data types from release to release since such a change has no external ABI consequences. If an opaque data type is placed in process-shared memory (when allowed by the standard) and shared with multiple processes, each process must ensure they are using exactly the same version of the library or they could fail in unexpected ways during library upgrades. The placement of opaque data types in process-shared memory is never allowed unless otherwise stated by the library documentation. For the GNU C Library (glibc) you may place pthread_mutex_t, pthread_cond_t, and sem_t in process-shared memory as allowed by POSIX. Failures using these types occur because a process started more recently may have a newer version of the library for the type and that version may have a different understanding of the internal details of the type. The problem has always been one for the developer to solve, but without help, this problem is so intractable as to make it difficult to robustly use opaque data types in process shared memory.
We will cover opaque data types, what they are, why you would use them, and how library upgrades play into the problem, and what might be done by the application developer.
Continue reading “C/C++ library upgrades and opaque data types in process shared memory”