Language Selection

English French German Italian Portuguese Spanish

About Tux Machines

Tuesday, 19 Nov 19 - Tux Machines is a community-driven public service/news site which has been around for over a decade and a half and primarily focuses on GNU/LinuxSubscribe now Syndicate content

Search This Site

Fedora and Red Hat: release-monitoring, Command Line Heroes, OpenShift Hive, Red Hat Software Collections

Filed under
Red Hat
  • Stories from the amazing world of release-monitoring.org #8

    The evening wind was cold, but I protected myself by the fire spell. It was nice to sit outside and look at the whole release-monitoring.org realm in the sunset. One could see the beauty behind all this hard work and it’s ignites a nice feeling inside one’s heart. Lately I didn’t have much time to appreciate this beauty. To be honest I didn’t have much time to work on this realm in the last few months. But still some work was done even here.

    I heard the footsteps behind me. “Traveler, it’s nice to see you again. Do you want to join me?” Footsteps stopped beside me and my companion was looking at the sunset with me. “I suppose you are here to hear about the news from this world. I assure you there are many things I want to share with you. Just listen…”

  • Command Line Heroes takes Bash from script to screen

    Creating visuals for stories about programming language isn’t always straightforward. The artwork for the first few episodes of this season was inspired by origins and functions. But for Episode 6, Heroes in a Bash Shell, we decided to take a more abstract approach.

    Shells, particularly the Bash shell, are widely used large-scale IT environments. Shell scripting allows us to automate repetitive tasks and do much more with standalone utilities. Our graphic designer, Karen Crowson, and animator, Drew Carrow, share how that reality, mixed in with some pun-related imagery, provided the frame for the Heroes in a Bash Shell artwork.

  • OpenShift Hive: Cluster-as-a-Service

    Red Hat OpenShift has enabled enterprise developers to utilize a fast feedback loop during the development phase of platforms and applications. The idea of ‘as-a-service’ has arisen from the ability of cloud providers to offer an on demand capability to consume services and products. This increased flexibility for organisations can further ease the development path to production.

    Kubernetes and Red Hat OpenShift unlocks organisations to achieve freedom with platforms of choice on a number of cloud providers without lock-in as workloads are abstracted from vendor specific constructs. Kubernetes, and Red Hat OpenShift Container Platform, provide the ability to run operators, where operators can act as an organisation’s very own consumable on demand service whilst providing a unique user experience to its intended audience.

    As a developer having a personal on demand environment was once one of the reasons for the rise of “shadow IT”. Organisations have since moved from the days of having to build servers for additional workloads through the use of new models of IT services thanks to virtualisation, PaaS and public/private cloud in an effort to adopt the on-demand/as-a-service utopia and enable their consumers to have the freedom to develop and produce strong value proposition products in today’s competitive market.

    OpenShift has become the platform of choice for many organisations. However, this can mean developers are somewhat restricted in consuming PaaS environment, due to greater process and management surrounding the environment, in accordance with internal IT regulations. OpenShift Hive is an operator which enables operations teams to easily provision new PaaS environments for developers improving productivity and reducing process burden due to internal IT regulations. Hive can do this in a true DevOps fashion while still adhering to an organization’s regulations and security standards.

  • Red Hat Software Collections 3.4 and Red Hat Developer Toolset 9 Beta now available

    The latest versions of Red Hat Software Collections and Red Hat Developer Toolset are available now in beta. Red Hat Software Collections 3.4 delivers the latest stable versions of many popular open source runtime languages and databases natively to the world’s leading enterprise Linux platform. These components are supported for up to five years, helping to enable a more consistent, efficient, and reliable developer experience.

  • What is a community of practice in an open organization?

    In other words, people in open organizations often define their roles, responsibilities, and affiliations through shared interests and passions—not title, role, or position on an organizational chart.

    That means organizational leaders will find themselves invested in building communities inside their organizations, connecting like-minded people with one another to accelerate business objectives.

    For this reason, communities of practice can be a useful component of open organizations. In this three-part series, I'll explain what communities of practice are, why they are beneficial to an organization, and how you can start a community of practice.

SUSE: Unified Patents, SC19 and Iguazio

Filed under
SUSE
  • SUSE welcomes cooperation of Open Invention Network, Linux Foundation, IBM and Microsoft in co-funding Unified Patent’s new Open Source Zone

    An eternal truth is that everything has its opposite for good and evil. Patents are no exception. In fact, even the simple word ‘Patent’ evokes much positive and negative emotion in today’s software world – particularly as news continues to circulate around baseless patent lawsuits by non-practicing entities (NPEs).
    But in news this week there is a bit of positive for a change. The positive news is the announcement of the efforts by Unified Patents to reduce NPE assertion of invalid patents in the open source software zone.

  • SC19: Empowering SUSE HPC customers with expanded options

    SC19, the International Conference for High Performance Computing, Networking, Storage and Analysis is just around the corner. For SUSE, it’s a great opportunity to reconnect with customers and partners working in one of the sectors of our industry driving significant innovation in all aspects of computing.

    If I tried to succinctly define SUSE’s message at SC19, it would be: “As with any journey, who you travel with is more important than the destination”. In SUSE’s instance, customers and partners make up our travel companions. In this journey, the customer is in the driver’s seat and elects the destination. Our role at SUSE is to empower HPC customers with choice across processor and GPU platforms as well as delivery options (on-premise, cloud, or hybrid).

  • SUSE and Iguazio Break the Mold by Providing an Open Source Solution for Enterprise Data Science Teams

    The notions of collaborative innovation, openness and portability are driving enterprises to embrace open source technologies. Anyone can download and install Kubernetes, Jupyter, Spark, TensorFlow and Pytorch to run machine learning applications, but making these applications enterprise grade is a whole different story. Delivering enterprise grade applications involves scalability, high-performance, tuning, monitoring, security and automation of infrastructure tasks. It can take months and typically requires a large team of developers, data scientists and data engineers.

Programming Lesson 101, Bash and Java Books/Tutorials

Filed under
Development
  • Lesson 101: Everything You Need To Learn About Programming Guidance

    This era has witnessed how far technology can go, and at present, it seems to be ruling all. Technology plays a significant role when it comes to innovations and a remarkable portion of such creations deal with software.
    Software development is mainly based on programming, and thus, it has become an exciting topic. Since a significant portion of technology revolves around programming, every student should at least have a basic concept regarding the same. However, many are willing to gain in-depth knowledge. Either way, there are some essential aspects everyone should be aware of before proceeding with the subject.

  • Generate random passwords with this Bash script
  • Excellent Free Tutorials to Learn Java

Linux Events: Linux Plumbers Conference and Audio Miniconf

Filed under
Linux
  • Linux Plumbers Conference: Linux Plumbers Conference 2019 videos are now available

    Following up on our previous post, and as many of you have already noticed, the LPC 2019 videos have now been uploaded to our YouTube channel.

    Over the coming days the LPC committee will be updating the 2019 site to incorporate links to the videos. At the same time, we will be getting ready to launch the 2020 site as well.

  • Audio Miniconf 2019 Report

    Daniel Baluta then started some discussion of topics related to Sound Open Firmware (slides). The first was issues with loading firmware before the filesystems are ready, we agreed that this can be resolved through the use of the _nowait() APIs. More difficult was resolving how to deal with card initialization. Currently the only complete in-tree users are x86 based so have to deal with the problems with the incomplete firmware descriptions provided by ACPI, there’s nothing standards based like we have for device tree systems, and assumptions about that have crept into how the code works. It’s going to take a bunch of work to implement but we came to a reasonable understanding of how this should work, with the DSP represented as a device in the device tree and bound to the card like any other component.

    Continuing on the DSP theme Patrick Lai then lead a discussion of gapless playback with format switches, we agreed that allowing set_params() to be called multiple times on a single stream when the driver could support it was the most sensible approach. The topic of associating controls with PCM streams was also discussed, there are some old APIs for this but so little hardware has implemented them that we agreed that a convention for control names based on the stream names was probably easier to support with current userspace software.

Devices: Centaur, Espruino and Orange Pi

Filed under
GNU
Linux
Hardware

Security: Overhyped 'NextCry', Wi-Fi Issues and Windows TCO

Filed under
Security
  • NextCry Ransomware Encrypts Files On NextCloud Linux Servers

    The ransomware gets its name from the extension it uses to append the file names of encrypted files. There is no free decryption tool available for NextCry victims at the moment and it remains undetected by the majority of antivirus engines on public scanning platforms.

  • Russian programmer claims he hacked Wi-Fi on popular high-speed train in 20 minutes, gaining access to passenger data

    On the technology-oriented social site Habr, an individual writing under the username keklick1337 has claimed that he was able to hack into the public Wi-Fi network provided on a popular high-speed Russian rail route, gaining access to a database of passenger data. The user boarded a Sapsan train from St. Petersburg to Moscow and subsequently decided to try hacking its wireless network out of boredom, he wrote.

  • Nokia WiFi Beacon 3 review: high-speed mesh networking

    The Beacon 3 units are considerably larger than either Eero or Nest Wifi routers; they are roughly the size of an Amazon Echo speaker. That makes them a bit less discreet than other routers, but the advantage is that each node includes four gigabit Ethernet ports, which is two more than either Google or Eero gives you. More Ethernet ports on the nodes give you more flexibility with what you can do with them, whether that’s running a wired backhaul between them with Ethernet that’s built into your home or plugging devices like a desktop computer, smart home hub, or gaming system directly into the Wi-Fi node to minimize wireless traffic.

  • Louisiana Target of Attempted Ransomware Hack, Governor Says [iophk: Windows TCO]

    The state was attacked as election officials canvass the results of a tightly contested Nov. 16 gubernatorial election won by Edwards by about 40,000 votes. The tally is unlikely to be affected as the state did not suffer any data loss, nor has it paid a ransom, Edwards said. A spokesman for the Louisiana Secretary of State’s Office couldn’t be reached for comment.

Programming Leftovers

Filed under
Development
  • Mike Hommey: Five years of git-cinnabar

    On this very day five years ago, I committed the initial code of what later became git-cinnabar. It is kind of an artificial anniversary, because I didn’t actually publish anything until 3 weeks later, and I also had some prototypes months earlier.

    The earlier prototypes of what I’ll call “pre-git-cinnabar” could handle doing git clone hg::https://hg.mozilla.org/mozilla-central (that is, creating a git clone of a Mercurial repository), but they couldn’t git pull later. That pre-git-cinnabar initial commit, however, was the first version that did.

    The state of the art back then was similar git helpers, the most popular choice being Felipec’s git-remote-hg, or the opposite tool: hg-git, a mercurial plugin that allows to push to a git repository.

    They both had the same caveats: they were slow to handle a repository the size of mozilla-central back then, and both required a local mercurial repository (hidden in the .git directory in the case of Felipec’s git-remote-hg).

  • Top 10 Vim plugins for programming in multiple languages

    Recently, when I was redoing my setup (as I do every so often), I decided it was a good opportunity to identify the best Vim plugins for programming in multiple languages and a way to combine those plugins for each language I program in.

    I do use certain plugins for specific languages and profiles (e.g., I only install Rocannon in my Ansible profile), and I won't go into those here—that would be a long list. But the 10 Vim plugins described below are my favorites, the ones I use in virtually every profile I have, no matter what programming language I'm using.

  • teach your kids to build their own game with Python - 1

    I used to be a coding trainer few months ago. Our students were former street kids coming from under-privileged societies. You can imagine the lack of education they had. As a teacher there, I had to make my lessons fun and easy for them to grasp, so I would often use games to do so. I was going through my old files and I found this lesson plan I wrote to teach the kids how to build the famous game Space Invaders. At the beginning it seemed an impossible mission, but they actually loved it and got to love coding because of it!

    Anywho, with no further details, I am going to share this lesson in three posts here. today is the first, hoping that any beginner or parent would find it helpful.

  • p2k19 Hackathon Report: Jeremy Evans on PostgreSQL and Ruby

    I started off by preparing an update to PostgreSQL 12. This involved updating a bunch of ports that depend on PostgreSQL. Thankfully, the PostgreSQL 12 update was a little easier than the PostgreSQL 11 update, and didn't take as much time. Now that PostgreSQL 12.1 has been released, this update should hopefully be committed to the ports tree soon.

  • Book review – Supercharged Python, by Brian Overland and John Bennet

    If you have been following beginner or even intermediate guides on Python and are starting to feel the need for more advanced learning, this book may be the one you have been looking for.

    According to the authors, this book was written for those who already know the basics of Python, but want to deepen their knowledge and skills. While being targeted to people who already know the fundamentals of Python, it still includes a quick review in the first chapter. It goes briefly through the usual stuff, like variables, operators, data types, basic I/O, if/else, while, for, function definitions and arguments, lists, tuples, dictionaries, sets, and the distinction between global and local variables. This initial chapter is presented as being an optional reading, as its contents are pretty basic, but the authors recommend that the reader takes a minute or so on the last to pages, which cover the global statement.

  • New book: Retro Gaming with Raspberry Pi

    Raspberry Pi Press is delighted to announce the release of the latest addition to your bookshelf: Retro Gaming with Raspberry Pi!

  • 2019.46 Guidance

    Naoum Hankache has taken the famous perl6intro.com website, which currently provides the same introduction in 13 different languages, to the Raku era at https://raku.guide (/r/rakulang comments). So if your native language is Bulgarian, Chinese, Dutch, French, German, Indonesian, Italian, Japanese, Portuguese, Spanish, Russian or Turkish, you can learn the basics about the Raku Programming Language in your native language!

Games: Counter-Strike: Global Offensive, Avorion, SamRewritten and 7 Days to Die

Filed under
Gaming
  • Counter-Strike: Global Offensive's mission system in Operation Shattered Web is pretty good

    I will admit, after dropping an update last night with a big new Operation for Counter-Strike: Global Offensive I was a little sceptical with the Battle Pass system. However, it's surprisingly good. This update shows what Valve can do when they experiment a little further.

    There's not many of these missions in yet, but Operation Shattered Web goes on for at least 16 weeks so there will no doubt be more coming. Let's talk about the new co-op Virus Outbreak mission for example, which uses the Danger Zone map Sirocco. Valve has actually expanded the map, with a big underground complex and some new voice-over from your leader and the enemy leader.

    They've taken all the additions to CS:GO over the last year or so and done something quite fun with it. Since this new mission requires co-op, this is also the first time I've made use of the Looking to Play system added in May this year and it works well. Within a few seconds of turning it on, I had invites ready to begin.

  • The fantastic co-op space sandbox Avorion should now be easier to get going

    Avorion already had a lot of things truly nailed down, from the freedom to build and explore to the excellent presentation but one thing it lacked was a good experience for newer users. Now it should be much improved.

    It starts off as your typical space adventure, with you beginning with nothing but the most basic possible ship. Taking elements from games like the X series, Freelancer, Eve Online and others it blends things together giving you the chance to explore space and do whatever you want. The most interesting part of it though, is that you build you ships block by block and you can make some fun designs.

    Currently in Early Access, elements of it were a little rough for newcomers. However, they've been gradually improving that a lot recently. Last month they introduced several new tutorial missions, helping you get to grips with the basics and some long-terms quests to guide you through the galaxy a bit more.

  • SamRewritten is an open source Steam Achievements Manager for Linux

    Want an easy way to view, lock and unlock Steam Achievements on Linux? SamRewritten seems like a very handy application to do all of that and more.

    The developer just announced a brand new release with a bunch of new features. Messing with achievements by manually unlocking them or locking them should be reliable, all your games should show up, it dynamically finds your Steam folders, a bunch of UI improvements and more.

  • 7 Days To Die Is Another Game Seeing A Big Bump From Mesa OpenGL Threading

    For those that are fans of the 7 Days to Die open-world shooter / horror game, the performance on Linux is now as much as 30% higher as a result of Mesa GL threading.

    With Mesa 20.0-devel (and presumably for back-porting too) is whitelisting mesa_glthread for the 7 Days to Die game on Linux.

    This is the few years old functionality around better CPU multi-threading within Mesa where some games are as much as 60~76% faster thanks to punting some of the OpenGL driver work off to a separate CPU thread.

today's leftovers

Filed under
Misc
  • Vulkan 1.1.128 Released With Performance Query Extension

    Vulkan 1.1.128 is out with various corrections and clarifications to this graphics/compute API specification but it also comes with one exciting new extension.

    The new extension that is quite notable for Vulkan 1.1.128 is VK_KHR_performance_query. This KHR-ratified extension is the first cross-vendor extension in Vulkan for the querying of any performance counters on the hardware. We are used to seeing various performance counter extensions within Vulkan (and other APIs like OpenGL) but they tend to be vendor-specific extensions tailored towards their own individual needs.

  • Calligra Plan version 3.2.0 released

    We are pleased to announce the release of Calligra Plan 3.2.0.

  • The Linux who command tells who’s logged in and a lot more
  • Prague launches mobile app to make its budget more transparent

    CityVizor was developed by the Ministry of Finance of the Czech Republic and published as an open-source under the GNU GPL license - free to use. The operation for non-Prague town halls is provided by the Open Cities Association and the Czech.digital community.

  • Photoshop for free? The best free alternatives

    We’re starting off with a big dog here. GIMP, which stands for Gnu Image Manipulation Program is the most fully formed and arguably most well-known Photoshop alternative there is. GIMP is like an open source Photoshop developed by a global team of volunteer developers to work on Microsoft Windows, Linux, and Apple Mac. It has an extensive set of features to rival what even Photoshop has to offer and can edit a wide range of file formats including RAW files. This means GIMP is a pro-friendly alternative to Photoshop with features like layer masks and filters enabling photographers and graphic designers to get their work done. GIMP is also a customizable photo editing software as users can download add-on packs to add the extra features they need.

  • Security updates for Monday

    Security updates have been issued by Debian (angular.js, libapache2-mod-auth-openidc, mosquitto, postgresql-common, and thunderbird), Fedora (chromium, djvulibre, freetds, ghostscript, java-1.8.0-openjdk-aarch32, samba, thunderbird-enigmail, wpa_supplicant, and xen), openSUSE (go1.12, ImageMagick, and ucode-intel), Oracle (ghostscript and kernel), Red Hat (libcomps and sudo), Slackware (kernel), SUSE (microcode_ctl, slurm, and ucode-intel), and Ubuntu (mysql-5.7, mysql-8.0 and python-ecdsa).

  • Linux, Windows Users Targeted With New ACBackdoor Malware [Ed: Microsoft has back doors, Linux hasn't.]

    Windows version is being pushed through malvertising with the help of the Fallout Exploit Kit while the Linux payload is dropped via a yet unknown delivery system.

Events: Linux and LibreOffice Microconferences

Filed under
LibO
Linux
OSS
  • Summaries of Some Microconferences Released

    We know everyone is still waiting for the videos. Unfortunately, we?re
    having a small production glitch, so until we can release them, several
    MC leads have now sent us written summaries of their MCs which you can
    see here:

    Tracing microconference
    You, Me and IoT microconference
    Live Patching microconference
    Open Printing microconference
    Databases microconference
    Scheduler microconference
    VFIO/IOMMU/PCI microconference
    Power Management and Thermal Control microconference

  • LibreOffice localisation sprint (and other events) in Albania

    The Albanian LibreOffice community has been super active in recent years, organising the LibreOffice Conference 2018 in Tirana, and regularly contributing with translation and marketing efforts.

Servers: Kubernetes, Red Hat, USENET and Solaris

Filed under
Server
  • HPE launches container platform, aims to be 100% open source Kubernetes

    Hewlett Packard Enterprise launched its HPE Container Platform, a Kubernetes container system designed to run both cloud and on-premises applications.

    On the surface, HPE Container Platform will face an uphill climb as all the top cloud providers have Kubernetes management tools and instances and IBM with Red Hat has a big foothold for hybrid cloud deployments and the container management that goes with it.

    HPE, which recently outlined a plan to make everything a service, is betting that the HPE Container Platform can differentiate itself based on two themes. First, HPE is pledging that its container platform will be 100% open source Kubernetes compared to other systems that have altered Kubernetes. In addition, HPE Container Platform will be able to run across multiple environments and provide one management layer.

  • Virtio-networking: first series finale and plans for 2020

    Let's take a short recap of the Virtio-networking series that we've been running the past few months. We've covered a lot of ground! Looking at this series from a high level, let's revisit some of the topics we covered:

    [...]

    For those who didn't crack and made it all the way here, we hope this series helped you clarify the dark magic of virtio and low-level networking both in the Linux kernel and in DPDK.

  • Inside the Book of Red Hat

    Shared stories are the cornerstone of community. And in open organizations like Red Hat—where community is paramount—shared stories are especially important to the collective identity that binds participants together.

    At Red Hat, we're quite fond of the stories that inform our shared history, purpose, and culture. We've just collected some of them in a new version of the Book of Red Hat, which is available now.

    Here are just three of the community-defining moments the book recounts.

  • The Early History of Usenet, Part III: File Format

    When we set out to design the over-the-wire file format, we were certain of one thing: we wouldn't get it perfectly right. That led to our first decision: the very first character of the transmitted file would be the letter "A" for the version. Why not a number on the first line, including perhaps a decimal point? If we ever considered that, I have no recollection of it.
    A more interesting question is why we didn't use email-style headers, a style later adopted for HTTP. The answer, I think, is that few, if any, of us had any experience with those protocols at that time. My own personal awareness of them started when I requested and received a copy of the Internet Protocol Transition Workbook a couple of years later — but I was only aware of it because of Usenet. (A few years earlier, I gained a fair amount of knowledge of the ARPANET from the user level, but I concentrated more on learning Multics.)

    Instead, we opted for the minimalist style epitomized by 7th Edition Unix. In fact, even if we had known of the Internet (in those days, ARPANET) style, we may have eschewed it anyway. Per a later discussion of implementation, the very first version of our code was a shell script. Dealing with entire lines as single units, and not trying to parse headers that allowed arbitrary case, optional white space, and continuation lines was certainly simpler!

    [...]

    Sending a date and an article title were obvious enough that these didn't even merit much discussion. The date and time line used the format generated by the ctime() or asctime() library routines. I do not recall if we normalized the date and time to UTC or just ignored the question; clearly, the former would have been the proper choice. (There is an interesting discrepancy here. A reproduction of the original announcement clearly shows a time zone. Neither the RFC nor the ctime() routine had one. I suspect that announcement was correct.) The most interesting question, though, was about what came to be called newsgroups.

    We decided, from the beginning, that we needed multiple categories of articles — newsgroups. For local use, there might be one for academic matters ("Doctoral orals start two weeks from tomorrow"), social activities ("Reminder: the spring picnic is Sunday!"), and more. But what about remote sites? The original design had one relayed newsgroup: NET. That is, there would be no distinction between different categories of non-local articles.

  • From humble Unix sysadmin to brutal separatist suppressor to president of Sri Lanka

    A former Unix sysadmin has been elected the new president of Sri Lanka, giving hope to all those IT workers who fear they are trapped in a role where the smallest of decisions can have catastrophic consequences if it goes wrong.

    Gotabaya Rajapaksa, younger brother of former president Mahindra, won the popular vote in an election held on Saturday (16 November). He is notable to The Register's readership for his stint working in America as a Solaris system integrator and later as a Unix sysadmin for a Los Angeles university.

Ubuntu and Debian Picks

Filed under
Debian
Ubuntu
  • Ubuntu Weekly Newsletter 605

    Welcome to the Ubuntu Weekly Newsletter, Issue 605 for the week of November 10 – 16, 2019. The full version of this issue is available here.

  • Russell Coker: 4K Monitors

    I like having lots of terminal windows on my desktop. For common tasks I might need a few terminals open at a time and if I get interrupted in a task I like to leave the terminal windows for it open so I can easily go back to it. Having more 80*25 terminal windows on screen increases my productivity. My previous monitor was 2560*1440 which for years had allowed me to have a 4*4 array of non-overlapping terminal windows as well as another 8 or 9 overlapping ones if I needed more. 16 terminals allows me to ssh to lots of systems and edit lots of files in vi. Earlier this year I had found it difficult to read the font size that previously worked well for me so I had to use a larger font that meant that only 3*3 terminals would fit on my screen. Going from 16 non-overlapping windows and an optional 8 overlapping to 9 non-overlapping and an optional 6 overlapping is a significant difference. I could get a second monitor, and I won’t rule out doing so at some future time. But it’s not ideal.

  • SCP Foundation needs you!

    SCP is a mind-blowing, diverse, high-quality collection of writings and illustrations, all released under the CC-BY-SA free license.
    If you never read horror stories written with scientific style -- have a try Smile

    [obviously this has nothing to do with OpenSSH Secure CoPy ;)]

Proprietary: CrossOver 19, ycrash and SUSE Pushing HANA

Filed under
Software
  • CROSSOVER 19 IS PROGRESSING WELL AND IS NOW IN BETA!

    It's been two weeks; we feel we owe everyone an update on our efforts to support 32 bit Windows applications on macOS Catalina, despite Apple's decision to terminate support for 32 bit applications.

    I'm happy to announce that we have released the first beta version of CrossOver 19 on Friday, November 15, 2019 to our community of advocates and beta testers. Further, our alpha testing and other internal testing has gone well, so I am confident that we will have a final product ready before the end of the year.

  • CrossOver 19 Enters Beta With Better Microsoft Office Support On Linux

    CodeWeavers' Jeremy White has announced that CrossOver 19 is now in beta for existing customers of this Wine-based software for running Windows programs on Linux and macOS.

    The biggest benefactor of CrossOver 19 is Apple macOS users with there being initial support for macOS Catalina. CrossOver/Wine needed a lot of changes to enable support for this newest version of macOS particularly for 32-bit Windows programs with Apple aiming to end 32-bit application support on their operating system.

  • Overview of ycrash – finding the source of your problem

    Take a tour of ycrash in this article by Ram Lakshmanan. ycrash helps capture critical artifacts, including garbage collection logs, thread dumps, core dumps, heap dumps, disk usage, and more when the problem happens. It applies machine learning algorithms and generates a report which gives you a complete view of the problem, down to the lines of code that caused it.
    The industry has seen cutting edge application performance monitoring tools (AppDynamics, NewRelic, Dynatrace…), log analysis tools (DataDog, Splunk,…). These are great tools for detecting problems. i.e. they can detect CPU spiked by x%, memory degraded by y%, response time shot up by z seconds. But they don’t answer the question: Why has the CPU spiked up? Why has memory degraded? Why has the response time increased? You still need to engage developers/architects/vendors to troubleshoot the problem and identify the root cause of the problem.

    ycrash captures critical artifacts (GC logs, thread dumps, core dumps, heap dumps, netstat, vmstat, lsof, iostat, top, disk usage….) when the problem happens, applies machine learning algorithms, and generates one unified root cause analysis report. This report gives you a 360-degree view of the problem. The report points out the exact class, method, and line of code that caused the problem.

  • SAP HANA is now supported on SUSE Linux Enterprise Server for SAP Applications 15 SP1

Mozilla: Firefox 71 Beta 12 Testday and Privacy Debate

Filed under
Moz/FF
  • Firefox 71 Beta 12 Testday – November 22nd

    We are happy to let you know that Friday, November 22nd, we are organizing Firefox 71 Beta 12 Testday. We’ll be focusing our testing on: Inactive CSS.

    Check out the detailed instructions via this gdoc.

    *Note that this events are no longer held on etherpad docs since public.etherpad-mozilla.org was disabled.

  • Mozilla Privacy Blog: Mozilla Mornings on the future of openness and data access in the EU

    On 10 December, Mozilla will host the next installment of our Mozilla Mornings series – regular breakfast meetings where we bring together policy experts, policymakers and practitioners for insight and discussion on the latest EU digital policy developments.

    The next installment will focus on openness and data access in the European Union. We’re bringing together an expert panel to discuss how the European Commission should approach a potential framework on data access, sharing and re-use.

Programming Leftovers

Filed under
Development
  • Quicksort in Python

    Quicksort is a popular sorting algorithm and is often used, right alongside Merge Sort. It's a good example of an efficient sorting algorithm, with an average complexity of O(n logn). Part of its popularity also derives from the ease of implementation.

    We will use simple integers in the first part of this article, but we'll give an example of how to change this algorithm to sort objects of a custom class.

    Quicksort is a representative of three types of sorting algorithms: divide and conquer, in-place, and unstable.

  • GCC 10.0 Status Report (2019-11-18), Stage 3 in effect now
  • GCC 10 Feature Development Is Over - Now The Focus Turns To Bug Fixing

    GCC 10 has moved to its next stage of development that shifts away from feature work to instead general bug fixing with hopes of shipping the GNU Compiler Collection 10 release in the months ahead.

    GCC 10 release manager Richard Biener of SUSE announced this Monday morning that "stage three" development phase.

  • ttdo 0.0.4: Extension

    A first update release to the still very new (and still very small) ttdo package arrived on CRAN today. Introduced about two months ago in September, the ttdo package extends the most excellent (and very minimal / zero depends) unit testing package tinytest by Mark van der Loo with the very clever and well-done diffobj package by Brodie Gaslam.

  • Adventures optimizing a bytecode based scripting language
  • Keeping a simple markdown work-log, via emacs

    For the past few years I've been keeping a work-log of everything I do. I don't often share these, though it is sometimes interesting to be able to paste into a chat-channel "Oh on the 17th March I changed that .."

  • Implement C++ coroutines.
    This patch series is an initial implementation of a coroutine feature,
    expected to be standardised in C++20.
    
    Standardisation status (and potential impact on this implementation):
    ----------------------
    
    The facility was accepted into the working draft for C++20 by WG21 in
    February 2019.  During two following WG21 meetings, design and national
    body comments have been reviewed, with no significant change resulting.
    
    Mature implementations (several years) of this exist in MSVC, clang and
    EDG with some experience using the clang one in production - so that the
    underlying principles are thought to be sound.
    
    At this stage, the remaining potential for change comes from two areas of
    national body comments that were not resolved during the last WG21 meeting:
    (a) handling of the situation where aligned allocation is available.
    (b) handling of the situation where a user wants coroutines, but does not
        want exceptions (e.g. a GPU).
    
    It is not expected that the resolution to either of these will produce any
    major change.
    
    The current GCC implementation is against n4835 [1].
    
    ABI
    ---
    
    The various compiler developers have discussed a minimal ABI to allow one
    implementation to call coroutines compiled by another; this amounts to:
    
    1. The layout of a public portion of the coroutine frame.
    2. A number of compiler builtins that the standard library might use.
    
    The eventual home for the ABI is not decided yet, I will put a draft onto
    the wiki this week.
    
    The ABI has currently no target-specific content (a given psABI might elect
    to mandate alignment, but the common ABI does not do this).
    
    There is not need to add any new mangling, since the components of this are
    regular functions with manipulation of the coroutine via a type-erased handle.
    
    Standard Library impact
    -----------------------
    
    The current implementations require addition of only a single header to
    the standard library (no change to the runtime).  This header is part of
    the patch series.
    
    GCC Implementation outline
    --------------------------
    
    The standard's design for coroutines does not decorate the definition of
    a coroutine in any way, so that a function is only known to be a coroutine
    when one of the keywords (co_await, co_yield, co_return) is encountered.
    
    This means that we cannot special-case such functions from the outset, but
    must process them differently when they are finalised - which we do from
    "finish_function ()".
    
    At a high level, this design of coroutine produces four pieces from the
    original user's function:
    
      1. A coroutine state frame (taking the logical place of the activation
         record for a regular function).  One item stored in that state is the
         index of the current suspend point.
      2. A "ramp" function
         This is what the user calls to construct the coroutine frame and start
         the coroutine execution.  This will return some object representing the
         coroutine's eventual return value (or means to continue it when it it
         suspended).
      3. A "resume" function.
         This is what gets called when a the coroutine is resumed when suspended.
      4. A "destroy" function.
         This is what gets called when the coroutine state should be destroyed
         and its memory returned.
    
    The standard's coroutines involve cooperation of the user's authored function
    with a provided "promise" class, which includes mandatory methods for
    handling the state transitions and providing output values.  Most realistic
    coroutines will also have one or more 'awaiter' classes that implement the
    user's actions for each suspend point.  As we parse (or during template
    expansion) the types of the promise and awaiter classes become known, and can
    then be verified against the signatures expected by the standard.
    
    Once the function is parsed (and templates expanded) we are able to make the
    transformation into the four pieces noted above.
    
    The implementation here takes the approach of a series of AST transforms.
    The state machine suspend points are encoded in three internal functions
    (one of which represents an exit from scope without cleanups).  These three 
    IFNs are lowered early in the middle end, such that the majority of GCC's
    optimisers can be run on the resulting output.
    
    As a design choice, we have carried out the outlining of the user's function
    in the front end, and taken advantage of the existing middle end's abilities
    to inline and DCE where that is profitable.
    
    Since the state machine is actually common to both resumer and destroyer
    functions, we make only a single function "actor" that contains both the
    resume and destroy paths.  The destroy function is represented by a small
    stub that sets a value to signal the use of the destroy path and calls the
    actor.  The idea is that optimisation of the state machine need only be done
    once - and then the resume and destroy paths can be identified allowing the
    middle end's inline and DCE machinery to optimise as profitable as noted above.
    
    The middle end components for this implementation are:
     1. Lower the coroutine builtins that allow the standard library header to
        interact with the coroutine frame (these fairly simple logical or
        numerical substitution of values given a coroutine frame pointer).
     2. Lower the IFN that represents the exit from state without cleanup.
        Essentially, this becomes a gimple goto.
     3. Lower the IFNs that represent the state machine paths for the resume and
        destroy cases.
     4. A very late pass that is able to re-size the coroutine frame when there
        are unused entries and therefore choose the minimum allocation for it.
    
    There are no back-end implications to this current design.
    
    GCC Implementation Status
    -------------------------
    
    The current implementation should be considered somewhat experimental and is
    guarded by a "-fcoroutines" flag.  I have set out to minimise impact on the
    compiler (such that with the switch off, coroutines should be a NOP).
    
    The branch has been feature-complete for a few weeks and published on Compiler
    Explorer since late September.  I have been keeping a copy of the branch on
    my github page, and some bug reports have been filed there (and dealt with).
    
    The only common resource taken is a single bit in the function decl to flag
    that this function is determined to be a coroutine.
    
    Patch Series
    ------------
    
    The patch series is against r278049 (Mon 11th Nov).
    
    There are 6 pieces to try an localise the reviewer interest areas.  However
    it would not make sense to commit except as possibly two (main and testsuite).
    I have not tested that the compiler would even build part-way through this
    series.
    
    1) Common code and base definitions.
    
    This is the background content, defining the gating flag, keywords etc.
    
    2) Builtins and internal functions.
    
    Definitions of the builtins used by the standard library header and the
    internal functions used to implement the state machine.
    
    3)  Front end parsing and AST transforms.
    
    This is the largest part of the code, and has essentially two phases
     1. parse (and template expansion)
     2. analysis and transformation, which does the code generation for the
        state machine.
    
    4) Middle end expanders and transforms
    
     As per the description above.
    
    5) Standard library header.
    
    This is mostly mandated by the standard, although (of course) the decision
    to implement the interaction with the coroutine frame by inline builtin
    calls is pertinent.
    
    There is no runtime addition for this (the builtins are expanded directly).
    
    6) Testsuite.
    
    There are two chunks of tests.
     1. those that check for correct error handling
     2. those that check for the correct lowering of the state machine
     
    Since the second set are checking code-gen, they are run as 'torture' tests
    with the default options list.
    
    ======
    
    I will put this patch series onto a git branch for those that would prefer
    to view it in that form.
    
    thanks
    Iain
    
  • Initial Patches Wire In C++20 Coroutines For The GCC Compiler

    The GNU Compiler Collection continues picking up new features aligned for the upcoming C++20 standard. The latest are patches pending on the mailing list for implementing coroutines in C++.

    C++20 is expected to have coroutines per the pending technical specification. Coroutines allow a function to have its execution stopped/suspended and then to be resumed later.

  • Faster Winter 1: Vectors
  • Faster Winter 2: SPECIALIZE
  • Attention! Attention! Tutorial Proposal Deadline Approaching
  • Python Software Foundation Fellow Members for Q3 2019

    Congratulations! Thank you for your continued contributions. We have added you to our Fellow roster online.

    The above members have contributed to the Python ecosystem by teaching Python, maintaining popular libraries/tools such as cryptography and pytest, helping document on packaging.python.org, organizing Python events, starting Python communities in their home countries, and overall being great mentors in our community. Each of them continues to help make Python more accessible around the world. To learn more about the new Fellow members, check out their links above.

  • Why Sponsor PyCon 2020?

    Sponsors help keep PyCon affordable and accessible to the widest possible audience. Sponsors are what make this conference possible. From low ticket prices to financial aid, to video recording, the organizations who step forward to support PyCon, in turn, support the entire Python community. They make it possible for so many to attend, for so many to be presenters, and for the people at home to watch along.

  • Pandas GroupBy: Your Guide to Grouping Data in Python

    Whether you’ve just started working with Pandas and want to master one of its core facilities, or you’re looking to fill in some gaps in your understanding about .groupby(), this tutorial will help you to break down and visualize a Pandas GroupBy operation from start to finish.

    This tutorial is meant to complement the official documentation, where you’ll see self-contained, bite-sized examples. Here, however, you’ll focus on three more involved walk-throughs that use real-world datasets.

  • Solving CAPTCHA with Web automation

    CAPTCHA is no longer an alien term to the users. An acronym for Completely Automated Public Turing test to tell Computers and Humans Apart. CAPTCHA is basically a computer program built to distinguish between the human and machine to prevent any type of spam or data extraction from websites. The entire concept of CAPTCHA is based on the assumption that only a human would pass this test and bot or automated scripts would fail.

Syndicate content