Language Selection

English French German Italian Portuguese Spanish

Development

Programming: Bugs, Mistakes, and Python

Filed under
Development
  • Living on the command line: Why mistakes are a good thing
  • Getting started with functional programming in Python using the toolz library

    In the second of a two-part series, we continue to explore how we can import ideas from functional programming methodology into Python to have the best of both worlds.

    In the previous post, we covered immutable data structures. Those allow us to write "pure" functions, or functions that have no side effects, merely accepting some arguments and returning a result while maintaining decent performance.

  • The code's crashed again, but why? Tell us your war stories of bugs found – and bugs fixed

    Even the best software goes wrong from time to time. So, what exactly happens when it throws a wobbly, especially when it's a key component in a production environment?

    Whether it's a total crash, a transaction failure, or the mangling of important data, there's going to be some kind of business impact. And the more the problem persists, the greater the level of pain, loss, and disruption.

    Everyone wants faults identified, diagnosed, and fixed ASAP. Identification is not normally a challenge – user complaints, curses, screams, and threats usually provide a pretty good clue. But before anyone can prioritize and schedule a fix, someone needs to diagnose the problem.

Programming: BASIC, LLVM's Clang C++17, and Mozilla

Filed under
Development
  • So I wrote a basic BASIC

    So back in June I challenged myself to write a BASIC interpreter in a weekend. The next time I mentioned it was to admit defeat. I didn't really explain in any detail, because I thought I'd wait a few days and try again and I was distracted at the time I wrote my post.

  • LLVM C++14/C++17 BoF
  • LLVM's Codebase Will Likely Move To C++17 Next Year

    While LLVM's Clang compiler already supports C++17, what this change is about is the LLVM code itself and for sub-projects like Clang can begin making use of C++17 code itself. This in turn ups the requirements for being able to compile the code-base. 

    As it stands now LLVM requires C++11 for being able to build the compiler stack, but at this week's LLVM Developers' Meeting in San Jose they discussed upping that requirement. While they could move to C++14, the unofficial consensus is they should just move directly to C++17. This enables LLVM developers to take advantage of all these modern C++ features.

  • Don't rely on the shape of (Native)Error.prototype.message
  • The Rust Programming Language Blog: Update on the October 15, 2018 incident on crates.io

    A user called cratesio was created on crates.io and proceeded to upload packages using common, short names. These packages contained nothing beyond a Cargo.toml file and a README.md instructing users that if they wanted to use the name, they should open an issue on the crates.io issue tracker.

    The rate at which this user uploaded packages eventually resulted in our servers being throttled by GitHub, causing a slowdown in all package uploads or yanks. Endpoints which did not involve updating the index were unaffected.

Programming: Thorntail 2.2 General Availability, OpenJDK, LLVM 7, wlc 0.9, Pango Development

Filed under
Development
  • Announcing: Thorntail 2.2 General Availability

    Today Red Hat is making Thorntail 2.2 generally available to Red Hat customers through a subscription to Red Hat OpenShift Application Runtimes (RHOAR). RHOAR provides application developers with a variety of application runtimes running on the OpenShift Container Platform.

    Thorntail is the new name for WildFly Swarm, and bundles everything you need to develop and run Thorntail and MicroProfile applications by packaging server runtime libraries with your application code and running it with java -jar. It speeds up the transition from monoliths to microservices and takes advantage of your existing industry standard Java EE technology experience.

  • The history and future of OpenJDK

    In the second half of 2017, a number of major changes were announced in the Java ecosystem that have the potential to force a reassessment of Java roadmaps and vendor selection for enterprise Java users. Some of the changes are happening in the upstream OpenJDK (Open Java Development Kit) community, and some of the changes are happening in proprietary commercial distributions of Java. Red Hat anticipates that many of our customers will need to review their current Java plans and we want to take this opportunity to review the history of our relationship with the OpenJDK community, discuss the changes in the Java ecosystem, and describe Red Hat’s Java offerings. Subsequent posts will cover the ecosystem changes and Red Hat’s plans going forward.

  • LLVM 7 improves performance analysis, linking

    The developers behind LLVM, the open-source framework for building cross-platform compilers, have unveiled LLVM 7. The new release arrives right on schedule as part of the project’s cadence of major releases every six months.

    LLVM underpins several modern language compilers including Apple’s Swift, the Rust language, and the Clang C/C++ compiler. LLVM 7 introduces revisions to both its native features and to companion tools that make it easier to build, debug, and analyze LLVM-generated software.

  • wlc 0.9

    wlc 0.9, a command line utility for Weblate, has been just released. There are several new commands like translation file upload or repository cleanup. The codebase has been also migrated to use requests instead of urllib.

  • A pango update

    Pango development has been slow in the last few years, while most of the work on the text rendering stack has moved to harfbuzz. But recently, Behdad and I got together for a pango work day, and made some plans, which we want to share. The underlying goal of these changes is to ensure that GTK+ and GNOME continue to have a competitive text rendering stack, and to avoid pango becoming a roadblock for this.

  • GNOME Developers Are Looking At Sprucing Up Pango

    GNOME developers want to make sure they have a competitive text rendering stack with other platforms and as such are looking to make some modernization improvements to Pango.

    Pango as a refresher is the text layout library used by GTK+ as well as other applications and works in hand with the HarfBuzz shaping engine for the display/placement of text.

GNU: GCC 9 Feature Development Is Ending Next Month, GCC's Test Suite To Begin Testing C++17 By Default

Filed under
Development
GNU
  • GCC 9 Feature Development Is Ending Next Month

    There is just three weeks left for GNU toolchain developers to finish landing new feature material in GCC 9.0 ahead of next year's GCC 9.1 stable release.

    Richard Biener of SUSE announced today that GCC's "stage 1" development will shift to "stage 3" on 11 November. This marks the point at which open feature development is over and will then focus on bug-fixing... No new features are generally allowed in during this stage. On 6 January 2019 is when they intend to begin their final period of only working on regression fixes and documentation updates.

  • GCC's Test Suite To Begin Testing C++17 By Default

    GCC's test suite will soon begin testing the C++17 standard as part of its C++98/11/14 standard tests by default... This doesn't affect the default C++ standard used by the GCC G++ compiler at this point, but at least will help eliminate any lingering C++17 bugs as well as helping to stop regressions in the future.

    With the GCC test suite's test cases having cleared through the last of the C++17 issues, Marek Polacek of Red Hat sent out the patch today to begin testing C++17 by default when running its test suite. C++17 is tested in addition to the earlier C++98, C++11, and C++14 standards.

Programming: Version Control With Git, 5 Things Your Team Should Do to Make Pull Requests Less Painful and More GitHub Workflow Automation

Filed under
Development
  • How to Use Git Version Control System in Linux [Comprehensive Guide]

    Version Control (revision control or source control) is a way of recording changes to a file or collection of files over time so that you can recall specific versions later. A version control system (or VCS in short) is a tool that records changes to files on a filesystem.

    There are many version control systems out there, but Git is currently the most popular and frequently used, especially for source code management. Version control can actually be used for nearly any type of file on a computer, not only source code.

  • 5 Things Your Team Should Do to Make Pull Requests Less Painful

    A user story is a short description of a unit of work that needs doing. It’s normally told from the perspective of the user, hence the name. The journey towards a good pull request starts with a well-written user story. It should be scoped to a single thing that a user can do in the system being built.

  • More GitHub workflow automation

    The more you use computers, the more you see the potentials for automating everything. Who doesn't love that? By building Mergify those last months, we've decided it was time bring more automation to the development workflow.

Programming/Development: uTidylib, From Python to Rust, Programming Experiences and Go Tips

Filed under
Development
  • uTidylib 0.4

    Two years ago, I've taken over uTidylib maintainership. Two years has passed without any bigger contribution, but today there is a new version with support for recent html-tidy and Python 3.

  • Rewrote summain from Python to Rust

    I've been learning Rust lately. As part of that, I rewrote my summain program from Python to Rust (see summainrs). It's not quite a 1:1 rewrite: the Python version outputs RFC822-style records, the Rust one uses YAML. The Rust version is my first attempt at using multithreading, something I never added to the Python version.

  • Which programming language for work? For the weekend?

    Our writer community grows each month as new, interesting folks write for us and join in on the fun of sharing their expertise and experiences in open source technology. So, it's no surprise that they are brimming with fascinating information. It's just asking the right question to release it.

    Recently, I asked: What programming languages do you use at work, and which ones do you use on the weekend?

  • Go command and packages cheat sheet

    Of the many things the go executable can do, most people know only go run and go build. And, of the many packages in the standard Go library, most people know only the fmt package. This cheat sheet will list many uses of the go executable and the most important packages in the Go standard library.

Mozilla: Pocket, Rust and MDN Updates

Filed under
Development
Moz/FF
  • Pocket’s Updated Listening Feature Effectively Turns Web Pages into Podcasts

    The read-it-later service has been focused on convenience and entertainment since Mozilla acquired it last year. Previous updates to the app introduced sponsored and recommended content based on a user’s interest. The new “listen” feature mimics the button layout and usability of podcast and music apps, encouraging users to treat Pocket like a source of entertainment, rather than a glorified bookmark app.

  • Announcing Rust 1.29.2

    The Rust team is happy to announce a new version of Rust, 1.29.2. Rust is a systems programming language focused on safety, speed, and concurrency.

  • Payments, accessibility, and dead macros: MDN Changelog for September 2018

    We’ve been thinking about the direction and growth of MDN. We’d like a more direct connection with developers, and to provide them with valuable features and benefits they need to be successful in their web projects. We’ve researched several promising ideas, and decided that direct payments would be the first experiment. Logged-in users and 1% of anonymous visitors see the banner that asks them to directly support MDN. See Ali Spivak’s and Kadir Topal’s post, A New Way to Support MDN, for more information.

GCC 6.5 Status Report

Filed under
Development
GNU
  • GCC 6.5 Status Report (2018-10-12)

    It is now time to release GCC 6.5 and close the 6.x branch. If you have regression bugfixes or documentation fixes that should be still backported to the branch, please test them and check them in before Friday, October 19th, when I'd like to create a Release Candidate of 6.5.

  • GCC 6.5 Is Being Prepared As The Last GCC6 Compiler Release

    Version 6.5 of the GNU Compiler Collection will soon be released to end out the GCC6 series.

    GCC8 remains the latest stable series and GCC9 is in development for release in early 2019. For those still relying upon the two-year-old GCC6 stable series, GCC 6.5 is being prepared with a last serving of bug/regression fixes before closing off that branch.

Programs and Programming: DICOM Viwers, Turtl, Weblate, Rust and Python

Filed under
Development
Software
  • Excellent Free DICOM Viewers – Medical Imaging Software

    DICOM (an acronym for Digital Imaging and Communications in Medicine) is a worldwide standard in Health IT and is provided by the National Electrical Manufacturers Assocation (NEMA). It’s the standard open image format used to handle, store, print and transmit information in medical imaging. This standard specifies the way medical images and metadata like study or patient related data are stored and communicated over different digital medias.

    DICOM is a binary protocol and data format. The binary protocol specifies a set of networking protocols, the syntax and specification of commands that can be exchanged with these protocols, and a set of media storage services. It’s an entire specification of the elements required to achieve a practical level of automatic interoperability between biomedical imaging computer systems—from application layer to bit-stream encoding.

    DICOM files can be exchanged between two entities that are capable of receiving image and patient data in DICOM format.

  • Encrypted Evernote Alternative Turtl v0.7 Includes Rewritten Server, New Spaces Feature

    Turtl was updated to version 0.7 yesterday, the new release shipping with a rewritten server, among other changes. I'll cover the new version in the second part of this article, after an introduction to Turtl.

    Turtl is a "secure, encrypted Evernote alternative". The free and open source tool, which is considered beta software, can be used to take notes, save bookmarks, store documents and images, and anything else you may need, in a safe place.

    There are Turtl applications available for Linux, Windows, macOS and Android, while an iOS application should also be available in the future. Chrome and Firefox extensions are available to easily bookmark the page you're on, great for quickly saving sites for later.

    The Turtl developers offer the service (hosted server) for free, but a premium service is planned for the future. However, the Turtl server is free and open source software, so you can install and use your own instance.

  • Weblate 3.2.1

    Weblate 3.2.1 has been released today. It's a bugfix release for 3.2 fixing several minor issues which appeared in the release.

  • This Week in Rust 255
  • Code Quality & Formatting for Python

    black, the uncompromising Python code formatter, has arrived in Debian unstable and testing.

    black is being adopted by the LAVA Software Community Project in a gradual way and the new CI will be checking that files which have been formatted by black stay formatted by black in merge requests.

    There are endless ways to format Python code and pycodestyle and pylint are often too noisy to use without long lists of ignored errors and warnings.

GCC: Optimizing Linux, the Internet, and Everything

Filed under
Development
GNU

Software is useless if computers can't run it. Even the most talented developer is at the mercy of the compiler when it comes to run-time performance - if you don’t have a reliable compiler toolchain you can’t build anything serious. The GNU Compiler Collection (GCC) provides a robust, mature and high performance partner to help you get the most out of your software. With decades of development by thousands of people GCC is one of the most respected compilers in the world. If you are building applications and not using GCC, you are missing out on the best possible solution.

GCC is the “de facto-standard open source compiler today” [1] according to LLVM.org and the foundation used to build complete systems - from the kernel upwards. GCC supports over 60 hardware platforms, including ARM, Intel, AMD, IBM POWER, SPARC, HP PA-RISC, and IBM Z, as well as a variety of operating environments, including GNU, Linux, Windows, macOS, FreeBSD, NetBSD, OpenBSD, DragonFly BSD, Solaris, AIX, HP-UX, and RTEMS. It offers highly compliant C/C++ compilers and support for popular C libraries, such as GNU C Library (glibc), Newlib, musl, and the C libraries included with various BSD operating systems, as well as front-ends for Fortran, Ada, and GO languages. GCC also functions as a cross compiler, creating executable code for a platform other than the one on which the compiler is running. GCC is the core component of the tightly integrated GNU toolchain, produced by the GNU Project, that includes glibc, Binutils, and the GNU Debugger (GDB).

Read more

Also: AMDGPU Developer Proposes Array Register Files For LLVM - Would Help Performance

Syndicate content