Language Selection

English French German Italian Portuguese Spanish


General Programming Leftovers

Filed under
  • Develop a Kubernetes controller in Java

    Java is no doubt one of the most popular programming languages in the world but it?s been difficult for a period time for those non-Golang developers to build up their customized controller/operator due to the lack of library resources in the community. In the world of Golang, there?re already some excellent controller frameworks, for example, controller runtime, operator SDK. These existing Golang frameworks are relying on the various utilities from the Kubernetes Golang SDK proven to be stable over years. Driven by the emerging need of further integration into the platform of Kubernetes, we not only ported many essential toolings from the Golang SDK into the kubernetes Java SDK including informers, work-queues, leader-elections, etc. but also developed a controller-builder SDK which wires up everything into a runnable controller without hiccups.

  • Make Lua development easy with Luarocks

    You should try Lua, a lightweight, efficient, and embeddable scripting language supporting procedural programming, object-oriented programming, functional programming, data-driven programming, and data description. And best of all, it uses explicit syntax for scoping!

    Lua is also small. Lua's source code is just 24,000 lines of C, the Lua interpreter (on 64-bit Linux) built with all standard Lua libraries is 247K, and the Lua library is 421K.

    You might think that such a small language must be too simplistic to do any real work, but in fact Lua has a vast collection of third-party libraries (including GUI toolkits), it's used extensively in video game and film production for 3D shaders, and is a common scripting language for video game engines. To make it easy to get started with Lua, there's even a package manager called Luarocks.

  • Multi-cluster Management with GitOps

    In this blog post we are going to introduce Multi-cluster Management patterns with GitOps and how you can implement these patterns on OpenShift.
    If you’re interested in diving into an interactive tutorial, try this link.

    In the introductory blog post to GitOps we described some of the use cases that we can solve with GitOps on OpenShift. In
    today’s blog post we are going to describe how we can leverage GitOps patterns to perform tasks on multiple clusters.

  • Excellent Free Tutorials to Learn C

    C is a general-purpose, procedural, portable, high-level programming language that is one of the most popular and influential languages. It was designed to be compiled using a straightforward compiler, to provide low-level access to memory, to provide language constructs that map efficiently to machine instructions, and to require minimal run-time support. Many programming languages owe a considerable debt to C. It has become something of the lingua franca in the programming world.

    C is fairly simple to understand. It allows the programmer to organize programs in a clear, easy, logical way. It is a very flexible, practical and compact language combined with an easy to read syntax. Code written in C runs quickly, with easy access to the low level facilities in the computer. Compiler directives make it possible to produce a single version of a program compiled for different architectures.

  • LibreOffice Macro Team: progress report

    So, what has happened in the meantime? This article is a collection of the work done by the LibreOffice Macro Team in the past few months, as well as any other macro-related things in the project. If you are interested in contributing to the macro team (development, testing or documentation), we’d love to hear from you – please send an email to and we’ll get in touch.

  • Your Debugger Sucks

    If you don't use an interactive debugger then you probably debug by adding logging code and rebuilding/rerunning the program. That gives you a view of what happens over time, but it's slow, can take many iterations, and you're limited to dumping some easily accessible state at certain program points. That sucks.

    If you use a traditional interactive debugger, it sucks in different ways. You spend a lot of time trying to reproduce bugs locally so you can attach your debugger, even though in many cases those bugs have already been reproduced by other people or in CI test suites. You have to reproduce the problem many times as you iteratively narrow down the cause. Often the debugger interferes with the code under test so the problem doesn't show up, or not the way you expect. The debugger lets you inspect the current state of the program and stop at selected program points, but doesn't track data or control flow or remember much about what happened in the past. You're pretty much stuck debugging on your own; there's no real support for collaboration or recording what you've discovered.

  • Motorola m68k Support Improved Upon In GCC - Saved From Being Removed In GCC 11

    While the Motorola 68000 32-bit processors are from the 80's and early 90's, there still is a loyal following of hobbyists who managed to save the "m68k" compiler back-end from being removed in GCC 11.

    The m68k back-end in GCC was at risk of being removed due to plans for GCC 11 to drop the CC0 representation code and the back-ends still depending upon it. M68k was the most notable user relying upon the deprecated CC0 representation but there are also other back-ends like AVR (AVR micro-controller), CRIS (the Axis Communications' ETRAX CRIS embedded processors), H8300 (the Renesas H8 microcontrollers), VAX (DEC VAX), and CR16 (National Semi CompactRISC). But now at least m68k is safe.

  • 2019.47 Late Again Or

    If you intended to write a blog post for this years Raku Advent Calendar, you’re too late! Well, sort of. You can still add yourself as a fallback should one of the other participants not be able to write a blog post after all!

  • g_clear_{s,}list() in GLib 2.63.3

Python Programming Leftovers

Filed under
  • Using SQLAlchemy to access MySQL without frustrating library installation issues

    I’ve often struggled with accessing MySQL from Python, as the ‘default’ MySQL library for Python is MySQLdb. This library has a number of problems: 1) it is Python 2 only, and 2) it requires compiling against the MySQL C library and header files, and so can’t be simply installed using pip.

    There is a Python 3 version of MySQLdb called mysqlclient, but this also requires compiling against the MySQL libraries and header files, so can be complicated to install.

  • Two Books About the Kivy GUI Framework

    The Kivy Python GUI framework is intriguing.

    Not only it’s cross-platform but also supports Android. Java is too verbose and low level for me and Kivy is an opportunity for developing native Android apps without leaving Python.

    Outside of the Kivy project documentation, there are few third-party advanced tutorials that go in more depth than the official tutorials. So, before diving into the code of the Kivy demos, I wanted some books to explore more features and get a broader picture of the framework and what it can do.

  • Revisiting Building Android Apps in Python Using Kivy with Android Studio

    One of the books I read on Kivy, a Python cross-platform GUI framework, is Building Android Apps in Python Using Kivy with Android Studio: With Pyjnius, Plyer, and Buildozer by Ahmed Fawzy Mohamed Gad (Apress, 2019). My comments on the book, which focused on it not being a good match for my learning needs, sounded negative. Perhaps unnecessarily so.

  • Insertion Sort in Python

    If you're majoring in Computer Science, Insertion Sort is most likely one of the first sorting algorithms you have heard of. It is intuitive and easy to implement, but it's very slow on large arrays and is almost never used to sort them.

    Insertion sort is often illustrated by comparing it to sorting a hand of cards while playing rummy. For those of you unfamiliar with the game, most players want the cards in their hand sorted in ascending order so they can quickly see which combinations they have at their disposal.

  • How our Open Studio team hacked together a project tracker with Python and a Raspberry Pi

    Yet another marketing piece was late, and what we had published was underperforming.

    In October 2018, Red Hat marketers recognized that our existing project management process, which relied on manual data entry and email updates, was unsustainable given an exploding demand for datasheets, whitepapers, e-books, and other marketing collateral.

    Purchasing an existing system didn’t make sense. Our project management tool, CA Agile Central (previously known as Rally), does not allow content requesters to kick off projects through a form.

    To initiate a project, requesters had to fill out a template file. The project manager would then manually create a project and pass the template file back and forth as it was edited, designed, and published. When requesters wanted to know the status of a project, they would email their project manager, who would check CA Agile Central.

  • Python KeyError Exceptions and How to Handle Them

    Python’s KeyError exception is a common exception encountered by beginners. Knowing why a KeyError can be raised and some solutions to prevent it from stopping your program are essential steps to improving as a Python programmer.

  • PyCoder’s Weekly: Issue #396 (Nov. 26, 2019)
  • Tips for Selecting Columns in a DataFrame

    This article will discuss several tips and shortcuts for using iloc to work with a data set that has a large number of columns. Even if you have some experience with using iloc you should learn a couple of helpful tricks to speed up your own analysis and avoid typing lots of column names in your code.

Programming: Rust, Java, C and More

Filed under
  • Federico Mena-Quintero: Moving gnome-shell's styles to Rust

    Gnome-shell uses CSS processing code that dates from HippoCanvas, a CSS-aware canvas from around 2006. It uses libcroco to parse CSS, and implements selector matching by hand in C.

    This code is getting rather dated, and libcroco is unmaintained.

    I've been reading the code for StTheme and StThemeNode, and it looks very feasible to port it gradually to Rust, by using the same crates that librsvg uses, and eventually removing libcroco altogether: gnome-shell is the last module that uses libcroco in distro packages.

  • Develop a Kubernetes controller in Java

    The official Kubernetes Java SDK project recently released their latest work on providing the Java Kubernetes developers a handy Kubernetes controller-builder SDK which is helpful for easily developing advanced workloads or systems.


    If you notice, the new Java controller framework learnt a lot from the design of controller-runtime which successfully encapsulates the complex components inside controller into several clean interfaces. With the help of Java Generics, we even move on a bit and simply the encapsulation in a better way.

    As for more advanced usage, we can wrap multiple controllers into a controller-manager or a leader-electing controller which helps deploying in HA setup. In a word, we can basically find most of the equivalence implementations here from Golang SDK and more advanced features are under active development by us.

  • p2k19 Hackathon Report: Stefan Sperling on iwm(4) wifi progress, more

    My main goal for the p2k19 hackathon was 9260 device support in iwm(4). Firmware updates for previous device generation were an important prerequisite step. One day before p2k19, the oldest generation of hardware supported by the iwm(4) driver was switched to latest available firmware images.

  • Extreme C book extract: Exploring structures and user-defined types in C

    In his new book, Extreme C (left), Kamran Amini outlines the essential features of the language before moving onto encapsulation and composition, synchronisation, as well as advanced programming – with code samples – and integration with other languages, including C++, Java, and Python.

    This extract, exclusive to Developer, explores structures within C, as well as touching on the reasons behind the almost 50-year-old language’s continued longevity.

  • HTTP/3 Support Added to cURL in Gentoo

    HTTP/3 may still be in the draft state but that isn’t stopping software from adding support for it. As a Gentoo developer, I decided to maintain Gentoo’s reputation for not being one to shy away from the bleeding edge by adding (optional) support for HTTP/3 to cURL. I believe that this makes Gentoo the first Linux distribution to ship support for this new protocol outside of the Firefox and Chrome/Chromium browsers.

    cURL is a command line tool as well a library (libcurl) that is used by a wide variety of software. It’s commonly used by applications written in php, it’s used by the Kodi media center, and it’s at least an optional dependency of everything from git to systemd to cmake and dovecot. By adding support for HTTP/3 to cURL, potentially everything that uses cURL will also instantly also start supporting HTTP/3.

    cURL added HTTP/3 support in version 7.66.0. Rather than writing the entirety of large, complex, and evolving HTTP/3 protocol implementation again (and having to maintain that forever), cURL instead leverages libraries. The two options it currently supports for this purpose are quiche and the combination of ngtcp2 and nghttp3.

Shaping the Future of KDE Frameworks

Filed under

Already during this year’s Akademy we started discussing our strategies for a Qt 6 transition and created a giant work board of tasks for our next major release of Frameworks. Overall our goal is to keep API breakages to a minimum while still cleaning up some cruft that might have built up over the years. We kicked off the sprint Friday morning with discussions mostly around policies and guidelines.

First of all, we acknowledged that our current release model with monthly feature updates works well but found that we need to be more conscious about merging large changes too close to a release. Furthermore, the fact that there’s actually a “string freeze” before each release to give translators a chance to catch up seems not widely known. In general, the categorization of Frameworks into 3-4 tiers worked but we realized a more fine-grained set of tiers might be necessary.

When Frameworks 5 came out QML was still relatively new and its future unclear; now that it has proven itself, a key goal of Frameworks 6 is making its features more easily used in a widget-less environment. This means for instance removing and splitting out widget dependencies. Moreover, we want to apply a hacksaw to KDeclarative which has a lot of declarative wrappers for other Frameworks which are better supplied by the individual Frameworks themselves. Also, we want to have better separation between API classes and runtime services, so external users of an API don’t have to pay a build dependency price for something they then just talk to at runtime.

Read more

Programming Leftovers

Filed under
  • Python Community Interview With Brian Okken

    This week, it’s my pleasure to interview Brian Okken. Brian is perhaps best known as the author of Python Testing with pytest, as well as being the host of two podcasts. Read on to find out more about the man behind the voice, his new meetup in Portland, and the advice he has for anyone new to testing software.

  • Creating Dashboard to Visualise Data In Python

    During one of my university project modules which require us to present our data from the sample dataset of the Scottish Referendum 2014.

    There I was exposed to terms like Data Wrangling and the use of D3 to create an interactive dashboard.

    Which the process to do data-wrangling was a tedious process and creating the dashboard using D3 was quite bad as well.

  • How to Create and Manage Python Virtual Environments

    It is pretty common to see Python developers installing and upgrading packages from standard and non-standard sources to develop applications. Reasons could range from using a newer version of a module to using a specific version in case there is a regression.

    These requirements and use cases can be a pain to manage when different applications require different versions of the same library. Thankfully, Python provides a robust solution to isolate development environments using virtual environments.

  • Best Cloud Based IDEs for Python

    Development environments are increasingly moving in the cloud in part or full, allowing programmers to access and collaborate on their projects on the go. Numerous such services have been launched in the past few years, especially for web developers writing code in Node.js, HTML, JavaScript and CSS. However there are very few such options available for Python, despite being one of the most popular and fastest growing programming languages.
    This article will list various IDEs and text editors available in the cloud for creating Python programs.

  • Keep These Portable Python Builds for Linux Always With You

    Most Linux distributions come with pre-installed Python packages. These packages are deeply integrated into the OS and they depend on shared libraries. If you want to keep Python projects isolated, using virtual environments is an excellent option. Another realistic option would be to use Python installed on an external drive as a portable package that you can carry it at your convenience (useful for teaching for example).
    Unfortunately, as far as portability of Python is concerned, Linux users don’t have much choice. While compiling Python with shared libraries is easy, building Python with statically linked libraries takes more than a few tweaks, patches and changing lines in source code.

    This article will list the few portable Python options available for Linux. Note that any of the methods mentioned below will work on external drives formatted in NTFS or EXT3/EXT4 file systems only. FAT32 file system doesn’t support symlinks which is a requirement for these packages to work.

  • Linux System Call Tutorial with C

    While it’s inevitable you’ll use a system call at some point in your C development career, unless you are targeting high performance or a particular type functionality, the glibc library and other basic libraries included in major Linux distributions will take care of the majority of your needs.

    The glibc standard library provides a cross-platform, well-tested framework to execute functions that would otherwise require system-specific system calls. For example, you can read a file with fscanf(), fread(), getc(), etc., or you can use the read() Linux system call. The glibc functions provide more features (i.e. better error handling, formatted IO, etc.) and will work on any system glibc supports.

    On the other hand, there are times where uncompromising performance and exact execution are critical. The wrapper that fread() provides is going to add overhead, and although minor, isn’t entirely transparent. Additionally, you may not want or need the extra features the wrapper provides. In that case, you’re best served with a system call.

    You can also use system calls to perform functions not yet supported by glibc. If your copy of glibc is up to date, this will hardly be an issue, but developing on older distributions with newer kernels might require this technique.

    Now that you’ve read the disclaimers, warnings, and potential detours, now let’s dig into some practical examples.

  • subdirmk - ergonomic preprocessing assistant for non-recursive make

    Peter Miller's 1997 essay Recursive Make Considered Harmful persuasively argues that it is better to arrange to have a single make invocation with the project's complete dependency tree, rather than the currently conventional $(MAKE) -C subdirectory approach.

    These problems are not theoretical for me. In the Xen Project we use recursive make and sadly suffer from occasional concurrency bugs. In my work on secnet (the currently rather unproductised vpn program) I have been frustrated by unreliability of the build system (which is developing fairly rapidly, as I overhaul secnet) .

    However, actually writing a project's build system in a non-recursive style is not very ergonomic. I was complaining about this in the pub a week or two ago. Accepting my challenge, Mark Wooding demonstrated a proof of concept showing that it was possible to do better. I thought I had a better approach so I took his code and I ran with it.

Programming Leftovers

Filed under
  • Updating PyOpenGL Sample Code References

    Continuing to prepare for a PyOpenGL 3.1.4 release.
    I've worked through getting the auto-generated reference documentation updated. We now use the upstream git repository for the docbook base files (gl, glu and glx) while still using the legacy files for glut and gle.
    I've had to disable the sample-source projects still using SourceForge CVS, as SourceForge doesn't provide web-based viewing of the CVS repositories any more. If you know of projects that should be added to the set of sample-code projects, let me know.

  • PyDev of the Week: Miguel Grinberg

    This week we welcome Miguel Grinberg (@miguelgrinberg) as our PyDev of the Week! Miguel is the author of Flask Web Development and the very popular Flask Mega-Tutorial. You can find out more about Miguel by checking out his blog or his Github profile. Let’s spend some time getting to know Miguel better!


    The open source project that takes most of my time these days is my Socket.IO client and server, which is split in two repositories, python-socketio and python-engineio. Socket.IO is a standard communication protocol built on top of HTTP and WebSocket that allows clients and servers to establish long lived bi-directional connections, avoiding some of the limitations of HTTP, and also with very low latency. My project allows Python to act as a client or as a server and connect to Socket.IO applications built in other languages, or of course, you can also use Python on both ends if that’s what you like. My Socket.IO server is commonly paired with the JavaScript client running on web browsers to build highly dynamic applications that are an alternative to the more traditional option of building the server as a REST or HTTP API.

  • “Microservices require a high-level vision to shape the direction of the system in the long term,” says Jaime Buelta

    Looking back 4-5 years ago, the sentiment around microservices architecture has changed quite a bit. First, it was in the hype phase when after seeing the success stories of companies like Netflix, Amazon, and developers thought that microservices are the de facto of application development. Cut to now, we have realized that microservices is yet another architectural style which when applied to the right problem in the right way works amazingly well but comes with its own pros and cons.

    To get an understanding of what exactly microservices are, when we should use them, when not to use them, we sat with Jaime Buelta, the author of Hands-On Docker for Microservices with Python. Along with explaining microservices and their benefits, Buelta shared some best practices developers should keep in mind if they decide to migrate their monoliths to microservices.

  • Perl Weekly Challenge - 036

    With great pleasure, we announce Steven Wilson as the winner of “Perl Weekly Challenge - 035”. Congratulations Steven, you should soon hear from Perl Careers about your reward. For rest of the participants, I would say Good Luck for next time. Keep sending in your solutions and share your knowledge with each other.

  • Laurent Rosenfeld Weekly Review: Challenge - 034

    This is derived in part from my blog post made in answer to the Week 34 of the Perl Weekly Challenge organized by Mohammad S. Anwar as well as answers made by others to the same challenge.

  • Kian-Meng Ang Weekly Review: Challenge - 034

    Continues from previous week.

  • RECAP - Perl Weekly Challenge - 035

    Today, Monday 25th Nov, 2019, we have completed 8 months of successfull run of The Weekly Challenge. Over the period, I came across many smart hackers. I have lots of personal favourites that I always look forward to their solutions. It always brings a big smile on my face every time I look at their solutions. Sometimes, I find it difficult to grasp in first reading. But then once it settles down, the feeling is out of this world.

Programming: Debian, Raspberry Pi, Haskell and Awk

Filed under
  • Cross Distribution Developer Camp 2019 Fall

    I had attend to Cross Distribution Developer Camp 2019 Fall at Manazuru-machi, Kanagawa at 16th Nov. 2019.
    There was 8 developers from openSUSE, Ubuntu, LibreOffice and Debian. We had talked about some problem between such distributions, upstream software, especially Japanese (or CJK) specific things.

  • Videomass

    There is a new tool available for Sparkers: Videomass

    What is Videomass?

    Videomass provides a graphical interface for audio and video conversions through FFmpeg.

  • Raspberry Pi Cooling – Finally Passive Good Enough

    Over time folks tend to fix things that are obviously an issue. The Raspberry Pi Foundation has made a firmware update that reduces the heating (by about 12 C more or less) and some other vendors have come out with aluminium cases that are heat sinks (or heat sinks big enough to act like a case) so now there ARE effective passive cooling solutions.

    Temperatures down around 53 C at full load are quite acceptable. Heat throttling tends to kick in at over 80 C and heat damage to silicon is up about 100 C. So half that is quite fine.

    Will I be buying one? Well, not any time soon. I’m still “over supplied” with computes via the Odroid N2, XU4, C2, Rock64 and RockPro64. Yes, I’m working on some “software issues” in finding a release I like for all of them, but even there I’ve got quite enough. IF Devuan makes a Pi M4 port I might get one. But it’s a very low priority thing for me due to what all kit I’ve got already.

  • Statistics (the making-of)

    Did you like the graph and the stats that I produced? Just for completeness, I am including the various scripts I used. Nothing super exciting to see here, but maybe someone finds this useful.

  • Faster Winter 7: The Zipper

    The last bit of performance could be considered a domain-specific optimization, as one might describe it as “introducing a control stack to the interpreter”. But in a different light, one could consider it the introduction of a more appropriate data structure, by applying a “zipper”-like transformation to the existing data structure.

  • How to use loops in awk

    Awk scripts have three main sections: the optional BEGIN and END functions and the functions you write that are executed on each record. In a way, the main body of an awk script is a loop, because the commands in the functions run for each record. However, sometimes you want to run commands on a record more than once, and for that to happen, you must write a loop.

    There are several kinds of loops, each serving a unique purpose.

  • The many faces of awk

    If you only use awk when you need to select a specific field from lines of text, you might be missing out on a lot of other services that the command can provide. In this post, we'll look at this simple use along with some of the other things that awk can do for you and provide some examples.

Programming Leftovers

Filed under
  • Preps for the Developers Conference 2020...

    Preparations for the Developers Conference 2020 have begun. The date, location and theme have been announced.

    The next Developers Conference, simply dubbed DevCon 2020, will be held on 2 - 4 April at the Caudan Arts Centre in Port-Louis, Mauritius. This time the conference theme is Comics, which I am pretty sure requires no further explanation as to what to expect.

  • Faster Winter 6: Simpler Code

    The Wasm reference interpreter has a function step that performs one single one step of evaluation, by taking the state before (in a type called code), and returning the state after the step. The function eval calls step, checks if the result is “done” (no instructions left to do), and if it is not done, recursively calls eval again. This way, evaluation progresses step by step until it is done.

  • Weekly Python StackOverflow Report: (cciv) stackoverflow python report
  • LLVM Developers Have Been Reviewing Work To Offset The Performance Hit From Intel JCC

    With the Jump Conditional Code (JCC) Erratum that was made public earlier this month and ushered in new Intel microcode to mitigate this Skylake to Cascade Lake design defect, compiler/toolchain patches have been in the works to help offset the performance cost incurred from the updated microcode. Besides the GNU Assembler work we've talked about several times since JCC came to light, the LLVM folks have also been reviewing their comparable changes.

25 Raspberry Pi Project Ideas to Put Your Pi to Some Good Use

Filed under

It won’t be an exaggeration if I call Raspberry Pi a revolutionary gadget. When it was first launched in the year 2011-12, people just couldn’t believe that a computer can be available in just $25.

If you bought a Pi and wondering what should do with my Raspberry Pi, I have got your back. I am going to list some cool Raspberry Pi projects that you can start following in your free time.

These Raspberry Pi project ideas are not limited to Pi. You can use them with other Raspberry Pi like devices such as Orange Pi, Khadas etc.

25 Cool Raspberry Pi Projects

I have listed several these project ideas by categorizing them in terms of the level of complexity (beginner, intermediate, and advanced). Some projects need additional equipment and sensors as well.

Of course, it is worth noting that it will be subjective to what expertise you have. So, let us take a look at the project ideas.

Read more

Programming: Debian, Python and LibreOffice

Filed under
  • Dirk Eddelbuettel: digest 0.6.23: More sha1 refinements

    Another new version of digest got onto CRAN earlier today, and was also uploaded to Debian.

    digest creates hash digests of arbitrary R objects (using the md5, sha-1, sha-256, sha-512, crc32, xxhash32, xxhash64, murmur32, and spookyhash algorithms) permitting easy comparison of R language objects. It is a fairly widely-used package (currently listed at 868k monthly downloads) as many tasks may involve caching of objects for which it provides convenient general-purpose hash key generation.

    This release comes again one month after the previous release and contains further refinements for sha1 digests, thanks once more to Bill Denney and Thierry Onkelinx who added more support for formulae and better support for object attributes. I added some refinement for the encoding / utf8 filename tests from the previous to round things off.

  • Zsh prompt with asynchronous Git status

    Zsh ships vcs_info, a function fetching information about the VCS state for the current directory and populating a variable that can be used in a shell prompt.

  • Talk Python to Me: #239 Bayesian foundations

    In this episode, we'll dive into one of the foundations of modern data science, Bayesian algorithms, and thinking. Join me along with guest Max Sklar as we look at the algorithmic side of data science.

  • Support windows bar calendar

    Like any large suite of applications, Open edX software (my day job) depends on a number of underpinnings: Django, Python, Ubuntu, MySQL, and so on. We want to stay up-to-date on those dependencies, or at least ensure we are using supported versions of each.

    To help with that, I wanted to make a chart of the support windows for different versions of each dependency. I figured the simplest way to draw a chart like that was to make a spreadsheet. Google Sheets is enough for something like this, and makes it easy to share the result with others who need to refer to it.

    To create the spreadsheet programmatically, I used the JavaScript scripting support. My program went through a few other iterations before landing on this technique, so it’s in kind of a strange form now: it’s a Python program that writes JavaScript, which you then paste into a spreadsheet and run.

  • LibreOffice coverity scan

    When we make C++17 a requirement for LibreOffice at the end of 2018 the version of coverity provided by no longer worked for us. In July 2019 a newer version of the coverity tooling was available which supported C++17 and analysis resumed.

    Prior to losing coverity support we had a defect density (i.e. defects per 1,000 line of code) of 0, on its return this had inflated to 0.06 due to both new defects introduced during the down period and old defects newly detected due to additional checks introduced in the new version.

Syndicate content

More in Tux Machines

Type Title Author Replies Last Postsort icon
Story Vim 8.2 is available! Roy Schestowitz 13/12/2019 - 2:33am
Story Deepin Linux Review: Stylish Distro or Spyware? Roy Schestowitz 13/12/2019 - 2:10am
Story today's howtos Roy Schestowitz 13/12/2019 - 2:08am
Story Games: Game Awards, Unity (Mono) and Hive Time Roy Schestowitz 13/12/2019 - 1:57am
Story Android Leftovers Rianne Schestowitz 12/12/2019 - 9:57pm
Story Nvidia Linux/BSD Graphics Driver Adds Support for Quadro T2000 with Max-Q Design Rianne Schestowitz 12/12/2019 - 9:44pm
Story Why secure web-based applications with Kali Linux? Rianne Schestowitz 12/12/2019 - 9:40pm
Story today's leftovers Roy Schestowitz 12/12/2019 - 6:39pm
Story Latte bug fix release v0.9.5 Roy Schestowitz 12/12/2019 - 4:43pm
Story KDE's December 2019 Apps Update Rianne Schestowitz 2 12/12/2019 - 4:39pm