Language Selection

English French German Italian Portuguese Spanish

Development

Programming: GCC, C++, Python and PHP

Filed under
Development
  • AMD GCN GPU Target Continuing To Improve For The GCC 10 Compiler

    With the recent release of the GCC 9 stable compiler there is the initial "AMD GCN" GPU target/back-end merged. However, for this GNU Compiler Collection release the AMD GCN target isn't all that useful but continued work on it gives us hope of seeing it in good shape for next year's GCC 10 release.

    With the GCC 9.1 release, the AMD GCN back-end can only handle running basic single-threaded programs... Not exactly useful for graphics cards. The GCC 9 code supports targeting the Fiji and Vega 10 GCN instruction set architecture.

  • IBM Begins Plumbing "Future" Processor Into GCC Compiler - POWER10?

    IBM engineers have landed initial support for "-mcpu=future" into the GCC compiler... As they say in the commit message, "a future architecture level, as yet unnamed."

    This IBM "future" processor is being added to the POWER architecture code succeeding POWER9. More than likely, its the early enablement work for POWER10.

  • Little Trouble in Big Data – Part 1

    A few months ago, we received a phone call from a bioinformatics group at a European university. The problem they were having appeared very simple. They wanted to know how to usemmap() to be able to load a large data set into RAM at once. OK I thought, no problem, I can handle that one. Turns out this has grown into a complex and interesting exercise in profiling and threading.

    The background is that they are performing Markov-Chain Monte Carlo simulations by sampling at random from data sets containing SNP (pronounced “snips”) genetic markers for a selection of people. It boils down to a large 2D matrix of floats where each column corresponds to an SNP and each row to a person. They provided some small and medium sized data sets for me to test with, but their full data set consists of 500,000 people with 38 million SNP genetic markers!

  • Why precompiled headers do (not) improve C++ compile times

    Would you like your C++ code to compile twice as fast (or more)?

    Yeah, so would I. Who wouldn't. C++ is notorious for taking its sweet time to get compiled. I never really cared about PCHs when I worked on KDE, I think I might have tried them once for something and it didn't seem to do a thing. In 2012, while working on LibreOffice, I noticed its build system used to have PCH support, but it had been nuked, with the usual poor OOo/LO style of a commit message stating the obvious (what) without bothering to state the useful (why). For whatever reason, that caught my attention, reportedly PCHs saved a lot of build time with MSVC, so I tried it and it did. And me having brought the PCH support back from the graveyard means that e.g. the Calc module does not take 5:30m to build on a (very) powerful machine, but only 1:45m. That's only one third of the time.

    In line with my previous experience, on Linux that did nothing. I made the build system support also PCH with GCC and Clang, because it was there and it was simple to support it too, but there was no point. I don't think anybody has ever used that for real.

    Then, about a year ago, I happened to be working on a relatively small C++ project that used some kind of an obscure build system called Premake I had never heard of before. While fixing something in it I noticed it also had PCH support, so guess what, I of course enabled it for the project. It again made the project build faster on Windows. And, on Linux, it did too. Color me surprised.

  • KDAB at CppCon 2019

    CppCon is the annual, week-long face-to-face gathering for the entire C++ community – the biggest C++ event in the world. This year, for the first time, CppCon takes place in the stunning Gaylord Rockies Hotel and Convention Center in Aurora, Colorado, very near Denver International Airport.

  • Clear Linux Discovers Another AVX2/AVX512 Fix/Optimization To Yield Better Performance

    For those running a system with AVX-512 support, Clear Linux builds as of this week should be yielding even better performance on top of their existing AVX2 and AVX-512 optimizations.

    The Intel developers working on Clear Linux uncovered an issue how the new GCC 9 compiler has been building the important libm math library poorly in AVX2/AVX-512 mode. This poor code compilation yielded slowdowns in various math functions since the switch to the GCC 9 compiler.

  • Building Machine Learning Data Pipeline using Apache Spark
  • It is easier to gather package meta-data from PyPI package ecosystem, once know the right way
  • Python 2.7 vs Python 3.4 ─ What should Python Beginners choose?
  • Be Quick or Eat Potatoes: A Newbie’s Guide to PyCon
  • Remote Development with Wing Pro

    In this issue of Wing Tips we take a quick look at Wing Pro's remote development capabilities.

  • Data School: Data science best practices with pandas (video tutorial)
  • PHP extensions status with upcoming PHP 7.4

Announcing Rust 1.35.0

Filed under
Development
Moz/FF

The Rust team is happy to announce a new version of Rust, 1.35.0. Rust is a programming language that is empowering everyone to build reliable and efficient software.

Read more

Also: Rust 1.35 Released With Support For Empty Debug Macro, ~4x Faster ASCII Case Conversions

GNU Guile 2.9.2 (beta) released

Filed under
Development
GNU

We are delighted to announce GNU Guile 2.9.2, the second beta release in preparation for the upcoming 3.0 stable series. See the release announcement for full details and a download link.

This release extends just-in-time (JIT) native code generation support to the ia32, ARMv7, and AArch64 architectures. Under the hood, we swapped out GNU Lightning for a related fork called Lightening, which was better adapted to Guile's needs.

Read more

Programming: Kyma, Microsoft Entryism, Python, Go, and Fedora Summer Coding interns

Filed under
Development
  • Kyma - extend and build on Kubernetes with ease

    According to this recently completed CNCF Survey, the adoption rate of Cloud Native technologies in production is growing rapidly. Kubernetes is at the heart of this technological revolution. Naturally, the growth of cloud native technologies has been accompanied by the growth of the ecosystem that surrounds it. Of course, the complexity of cloud native technologies have increased as well. Just google for the phrase “Kubernetes is hard”, and you’ll get plenty of articles that explain this complexity problem. The best thing about the CNCF community is that problems like this can be solved by smart people building new tools to enable Kubernetes users: Projects like Knative and its Build resource extension, for example, serve to reduce complexity across a range of scenarios. Even though increasing complexity might seem like the most important issue to tackle, it is not the only challenge you face when transitioning to Cloud Native.

  • A panel with the new Python steering council [Ed: Microsoft bought PyCon and and now it's stuffing/stacking Python panels to push proprietary software with back doors (or its 'free bait')]

    Brett Cannon is a development manager for the Python extension to Visual Studio Code at Microsoft.

    [...]

    [I would like to thank LWN's travel sponsor, the Linux Foundation, for travel assistance to Cleveland for PyCon.]

  • Run your blog on GitHub Pages with Python [Ed: Why does Red Hat's site help Microsoft devour blogs with its  surveillance and lock-in machine?]
  • Testing a Go-based S2I builder image
  • EuroPython 2019: Monday and Tuesday activities for main conference attendees

    Although the main conference starts on Wednesday, July 10th, there’s already so much to do for attendees with the main conference ticket on Monday 8th and Tuesday 9th.

  • Test and Code: 75: Modern Testing Principles - Alan Page
  • Shaily and Zubin: Building CI pipelines and helping testers

    This post is the third introduction to the Fedora Summer Coding interns Class of Summer 2019. In this interview, we’ll meet Shaily Sangwan and Zubin Choudhary, who are both working on projects to improve quality assurance processes in the Fedora community.

Crazy Compiler Optimizations

Filed under
Development
GNU
Linux

Kernel development is always strange. Andrea Parri recently posted a patch to change the order of memory reads during multithreaded operation, such that if one read depended upon the next, the second could not actually occur before the first.

The problem with this was that the bug never could actually occur, and the fix made the kernel's behavior less intuitive for developers. Peter Zijlstra, in particular, voted nay to this patch, saying it was impossible to construct a physical system capable of triggering the bug in question.

And although Andrea agreed with this, he still felt the bug was worth fixing, if only for its theoretical value. Andrea figured, a bug is a bug is a bug, and they should be fixed. But Peter objected to having the kernel do extra work to handle conditions that could never arise. He said, "what I do object to is a model that's weaker than any possible sane hardware."

Will Deacon sided with Peter on this point, saying that the underlying hardware behaved a certain way, and the kernel's current behavior mirrored that way. He remarked, "the majority of developers are writing code with the underlying hardware in mind and so allowing behaviours in the memory model which are counter to how a real machine operates is likely to make things more confusing, rather than simplifying them!"

Still, there were some developers who supported Andrea's patch. Alan Stern, in particular, felt that it made sense to fix bugs when they were found, but that it also made sense to include a comment in the code, explaining the default behavior and the rationale behind the fix, even while acknowledging the bug never could be triggered.

But, Andrea wasn't interested in forcing his patch through the outstretched hands of objecting developers. He was happy enough to back down, having made his point.

It was actually Paul McKenney, who had initially favored Andrea's patch and had considered sending it up to Linus Torvalds for inclusion in the kernel, who identified some of the deeper and more disturbing issues surrounding this whole debate. Apparently, it cuts to the core of the way kernel code is actually compiled into machine language.

Read more

Programming Leftovers

Filed under
Development
  • Intel Icelake Brings New Top-Down Performance Counters

    Back to the Sandy Bridge days there have been "Top-Down" metrics for exposing CPU pipeline statistics around bottlenecks in the processor front-end, back-end, bad speculation, or retiring. Those metrics have been done using generic counters but with Icelake and Intel CPUs moving forward, there are in-hardware fixed performance counters for these metrics.

  • Intel Open-Source 19.19.12968 Compute Runtime Released

    For those making use of Intel's OpenCL "NEO" Compute Runtime, a new tagged release is now available.

    The Intel 19.19.12968 Compute Runtime is this latest release consisting of the latest code around their OpenCL LLVM/Clang components with the graphics compiler, GMM Library, and related bits. With today's release, they pulled in the Intel Graphics Compiler 1.0.4 update.

  • Running Python in the Browser

    Running Python in the web browser has been getting a lot of attention lately. Shaun Taylor-Morgan knows what he’s talking about here – he works for Anvil, a full-featured application platform for writing full-stack web apps with nothing but Python. So I invited him to give us an overview and comparison of the open-source solutions for running Python code in your web browser.

  • Python Logging: A Stroll Through the Source Code

    The Python logging package is a a lightweight but extensible package for keeping better track of what your own code does. Using it gives you much more flexibility than just littering your code with superfluous print() calls.

    However, Python’s logging package can be complicated in certain spots. Handlers, loggers, levels, namespaces, filters: it’s not easy to keep track of all of these pieces and how they interact.

    One way to tie up the loose ends in your understanding of logging is to peek under the hood to its CPython source code. The Python code behind logging is concise and modular, and reading through it can help you get that aha moment.

    This article is meant to complement the logging HOWTO document as well as Logging in Python, which is a walkthrough on how to use the package.

  • Enhance your AI superpowers with Geospatial Visualization
  • Kushal's Colourful Adafruit Adventures

    Friend of Mu, community hero, Tor core team member, Python core developer and programmer extraordinaire Kushal Das, has blogged about the fun he’s been having with Adafruit’s Circuit Playground Express board, CircuitPython and Mu.

today's howtos and programming

Filed under
Development
HowTos

Programming: KubeCon, PHP, Python, GitLab, and Rust

Filed under
Development
  • Team OpenCensus or OpenTracing? It'll be neither and both now: Hello, OpenTelemetry

    Something odd happened at KubeCon 2019. Rather than snipe at each other from the safety of Twitter, two very similar open-source projects opted to pool their ideas into one: OpenTelemetry.

    The project is geared towards solving the problem of working out just what the heck is happening in today's microservices or container-based apps. Logging without incurring a chunky overhead both in terms of generating useful telemetry and actually collating the output.

    Distributed tracing is a bit more than fancy logging, as one commentator put it. Think more a transaction log over all the containers, services and components used in an application.

    Two projects emerged to deal with the challenge – OpenCensus from Google and OpenTracing, co-created by Ben Sigelman of Lightstep.

  • PHP 7.4 as Software Collection.

    Version 7.4.0-alpha1 will be soon released. It's now enter the stabilization phase for the developers, and the test phase for the users.

    RPM of this upcoming version of PHP 7.4, are available in remi repository for Fedora 29, 30 and Enterprise Linux 7, 8 (RHEL, CentOS, ...) in a fresh new Software Collection (php74) allowing its installation beside the system version.

    As I strongly believe in SCL potential to provide a simple way to allow installation of various versions simultaneously, and as I think it is useful to offer this feature to allow developers to test their applications, to allow sysadmin to prepare a migration or simply to use this version for some specific application, I decide to create this new SCL.

  • HEIC / HEIF images support

    The HEIF image format (High Efficiency Image File Format) is now widely used, especially since iOS 11, so it make sense to be able to process these images.

  • EuroPython 2019: First batch of accepted sessions
  • Hello CodeGrades!

    This is a blog about CodeGrades, an experiment to help folks learn about programming (initially in Python). We’ll use it to celebrate the successes, learn from the failures and reflect upon the feedback of participants. We’ll also share project news here too.

  • Setting Up GitLab CI for a Python Application

    This blog post describes how to configure a Continuous Integration (CI) process on GitLab for a python application.

  • How OpenTracing & OpenCensus Merger Helps Users Like GitLab

    In this episode of Let’s Talk, Andrew Newdigate – Staff Site Reliability Engineer at GitLab talks about OpenTracing, OpenCensus, and the newly announced OpenTelemetry project.

  • This Week In Rust: This Week in Rust 287
  • Kushal Das: Game of guessing colors using CircuitPython

OpenJDK 8 and 11: Still in safe hands

Filed under
Development

In 2018, Oracle announced that it would only provide free public updates and auto-updates of Java SE 8 for commercial users until the end of January 2019. Java 8 is a very important platform, used by millions of programmers, so this was a big deal. The Java community needed to fill the gap.

In February of this year, I was appointed as the new Lead of the OpenJDK 8 Update Releases Project. A couple of weeks later, I was appointed the new Lead of the OpenJDK 11 Updates Project. This is an important milestone in the history of OpenJDK and of Java SE because it’s the first time that a non-Oracle employee has led the current long-term OpenJDK release project. JDK 8 is still a much-used Java release in industry, and JDK 11 is the current long-term maintenance release.

It’s now a couple of weeks after the first releases of JDK8u and JDK11u on my watch. I think the process went pretty well, although it was not entirely smooth sailing for the developers. Having said that, we got our releases out on the day, as planned, and so far we’ve seen no major problems.

Read more

Spyder 4.0 takes a big step closer with the release of Beta 2!

Filed under
Development
Software

It has been almost two months since I joined Quansight in April, to start working on Spyder maintenance and development. So far, it has been a very exciting and rewarding journey under the guidance of long time Spyder maintainer Carlos Córdoba. This is the first of a series of blog posts we will be writing to showcase updates on the development of Spyder, new planned features and news on the road to Spyder 4.0 and beyond.

First off, I would like to give a warm welcome to Edgar Margffoy, who recently joined Quansight and will be working with the Spyder team to take its development even further. Edgar has been a core Spyder developer for more than two years now, and we are very excited to have his (almost) full-time commitment to the project.

Read more

Syndicate content

More in Tux Machines

Android Leftovers

Stable kernels 5.1.10, 4.19.51, and 4.14.126

  • Linux 5.1.10
    I'm announcing the release of the 5.1.10 kernel. All users of the 5.1 kernel series must upgrade. The updated 5.1.y git tree can be found at: git://git.kernel.org/pub/scm/linux/kernel/git/stable/linux-stable.git linux-5.1.y and can be browsed at the normal kernel.org git web browser: https://git.kernel.org/?p=linux/kernel/git/stable/linux-s...
  • Linux 4.19.51
  • Linux 4.14.126

Android Leftovers

My personal journey from MIT to GPL

As I got started writing open source software, I generally preferred the MIT license. I actually made fun of the “copyleft” GPL licenses, on the grounds that they are less free. I still hold this opinion today: the GPL license is less free than the MIT license - but today, I believe this in a good way.

[...]

I don’t plan on relicensing my historical projects, but my new projects have used the GPL family of licenses for a while now. I think you should seriously consider it as well.

Read more