Tech News - Programming

In one of the most interesting developments in tech for some time (and that's saying something), Bloomberg are reporting that Microsoft has acquired GitHub. Spokespeople from Microsoft and GitHub declined to comment when asked by Bloomberg, but the deal could be announced later today. With 24 million users on the platform, this move could well have an impact across the software world. However, while it may seem surprising, it isn't perhaps quite as shocking as it immediately appears. Microsoft has embraced open source in the last few years; the company is one of the top contributors to the site, according to The Verge. When were rumors of Microsoft's intention to buy GitHub first reported? Reports of Microsoft's intention to acquire GitHub were first made in Business Insider just a few days ago, at the beginning of June 2018. According to the website, sources 'close to both companies' said that serious talks have been happening for the past few months. Informal discussions on the issue have taken place over the last few years - it's only now that they have become more serious. With GitHub's CEO Chris Wanstrath set to leave in August, it makes sense for Microsoft to take the opportunity to make a move to acquire the company now. Why would Microsoft want to acquire GitHub? Microsoft has been playing catch up with the open source revolution. It's attitude towards open source has changed significantly in recent years. It has open sourced a growing number of its tools, including PowerShell, Visual Studio Code and .NET. Back in 2001, former Microsoft CEO Steve Ballmer called Linux a "cancer" (he did later retract his statement). Today, under Satya Nadella, it's a completely different story. For that reason, the acquisition of GitHub represents an important step in the evolution of Microsoft's relationship to the open source world. There are questions around how much Microsoft is really committed to open source. To cynics, embracing open source is as much about business than values. Billion dollar acquisitions don't exactly scream 'free and open software'. However, it is still early days. How the acquisition unfolds, how it will be received by the developer community will be interesting. Whatever you think of the Microsoft's move, GitHub isn't exactly thriving from a business perspective; GitHub lost $66 million in three quarters in 2016. Read next 10 years of GitHub Microsoft releases Windows 10 Insider build 17682! Epicor partners with Microsoft Azure to adopt Cloud ERP

Yesterday, Mozilla released the latest versions of Firefox for desktop, Android, and iOS. The latest version for desktop and Android users is Firefox 62.0 and for iOS users it is Firefox 13.2. They have made some changes for faster page loads, better scrolling performance, a newly added Dark theme for iOS users, and much more. They have also laid foundation for upcoming release, Firefox 63, by allowing users to distrust certificates issued by Symantec. In Firefox 63, all trust for Symantec-issued certificates will be removed. What’s new for desktop users? The default New Tab, Firefox Home, now can display up to 4 rows of top sites, Pocket stories, and highlights. The Reopen in Container option is added for users with Containers that lets them choose to reopen a tab in a different container. Dark theme is automatically enabled in macOS 10.14 dark mode. Improved graphics rendering for Windows users without accelerated hardware. Users opting to disconnect from Sync can now wipe their Firefox profile data, including bookmarks, passwords, history, cookies, and site data from their desktop computer. FreeBSD support is added for WebAuthn. The Description field for bookmarks is removed. Added support for CSS Shapes for richer web page layouts. Added support for CSS Variable Fonts to create beautiful typography with a single font file. What’s new for Android users? Scrolling performance is improved. Page loading is now faster over WiFi connections by loading from the network cache if disk cache is slow. Notifications settings provides a toggle button, Product and feature tips, to allow more control over which notifications are shown. What’s new for iOS users? New dark theme: Firefox for iOS now supports dark and light theme. According to your preference, you can easily switch between the two themes either manually or automatically. To enable this manually, tap Settings in the menu panel, then, tap Display, and choose either Light or Dark. To automatically turn it on you can use Automatic switch. Source: Mozilla Improved searching experience: They have made some improvements to make searching content easier. Tab settings can now be managed in a single view allowing  you to make changes easily and quickly. You will also be able to search your open tabs and seamlessly switch between normal and private browsing. Source: Mozilla To know more, read Mozilla’s official announcement and also check their release notes. Mozilla, Internet Society, and web foundation wants G20 to address “techlash” fuelled by security and privacy concerns Mozilla’s new Firefox DNS security updates spark privacy hue and cry Firefox Nightly browser: Debugging your app is now fun with Mozilla’s new ‘time travel’ feature

After releasing TypeScript 3.3 RC, two weeks ago, yesterday Microsoft announced the availability of TypeScript 3.3. TypeScript 3.3 contains no breaking changes and is a comparatively smaller release than usual. What’s new in Typescript 3.3 Better behavior when calling union types When there is a union type A | B, TypeScript now allows users to access all of the properties common to both A and B. For example, the intersection of members. You can get a property from a union type only if it’s known to be present in every union type. When every type has only one signature with identical parameters, things work. Such a restriction was too much and have errors in some areas. So, in TypeScript 3.3, the following code as shown in the blog will work: type Fruit = "apple" | "orange"; type Color = "red" | "orange"; type FruitEater = (fruit: Fruit) => number;     // eats and ranks the fruit type ColorConsumer = (color: Color) => string;  // consumes and describes the colors declare let f: FruitEater | ColorConsumer; f("orange"); // It works! Returns a 'number | string'. f("apple");  // error - Argument of type '"apple"' is not assignable to parameter of type '"orange"'. f("red");    // error - Argument of type '"red"' is not assignable to parameter of type '"orange"'. The parameters of the above signatures are ‘intersected’ to create a new signature. When the impossible intersections are gone, what remains is “orange” & “orange” which is just “orange”. That is not to say there are no restrictions. The new behavior is active only when only one type in the union has multiple overloads and a generic signature. The forEach method will now be callable, but there may be some issues under noImplicitAny. --build --watch use incremental file watching In TypeScript 3.3, --build mode’s --watch flag leverage incremental file watching. This results in significantly faster builds with a reduction of 50% to 75% in build times of the original --build --watch times. Sublime Text supports JavaScript editing The TypeScript plugin for Sublime Text now supports editing in JavaScript files. Users will now get more accurate completions, rename, go-to-definition, and more in JavaScript code that utilizes JSDoc and interoperates with TypeScript code. Typescript recently announced the ‘TypeScript Roadmap’ for January 2019- June 2019 which outlines the priorities that the team will be focussing on, over the next 6 months. Future of ESLint support in TypeScript PayPal replaces Flow with TypeScript as their type checker for every new web app npm JavaScript predictions for 2019: React, GraphQL, and TypeScript are three technologies to learn

Last week, the team behind GNU Radio announced the release of GNU Radio 3.8, a free and open-source software development toolkit. GNU Radio 3.8.0.0 comes with a few major changes and deprecations. Major changes in GNU Radio 3.8.0.0 Dependencies With this release, new dependencies have been introduced including MPIR/GMP, Qt5, codec2, gsm. The team has removed few of the dependencies including libusb, Qt4, and CppUnit Python compatibility This release is Python 2 and Python 3 compatible. Also, GNU Radio 3.8 is going to be the last Py2k-compatible release series. Gengen got replaced Gengen (GENerator GENerator) a tool that generates a text generator got replaced by templates. gnuradio-runtime The team has reworked on fractional tag time handling which is in the context of resamplers C++ generation In this release, C++ generation has been introduced as an option. gr-utils The gr_modtool has also improved now. Some deprecations in GNU Radio 3.8  Modules Modules gr-comedi, gr-fcd and gr-wxgui have been removed. Gr-comedi Gr-comedi has been removed as it had 0 active code contributions in the 3.7 lifecycle. gr-fcd Gr-fcd is getting removed as it is currently untestable by the CI and as there were no code contributions. It seems few users are excited to experiment with GNU Radio 3.8 in the near future. A user commented on HackerNews, “GNU Radio is one of those examples of free software being hyper-niche yet super successful. It's something I want to start playing with in the near future.” To know more about this news, check out the official post by GNURadio. GNU C Library version 2.30 releases with POSIX-proposed functions, support for Unicode 12.1.0, new Linux functions and more! GNU APL 1.8 releases with bug fixes, FFT, GTK, RE and more Debian 10 codenamed ‘buster’ released, along with Debian GNU/Hurd 2019 as a port    

Today, we are releasing the .NET Core October 2020 Update. These updates contains reliability and other non-security fixes. See the individual release notes for details on updated packages. Getting the Update .NET Core 3.1.9 and .NET Core SDK ( Download | Release Notes ) .NET Core 2.1.23 and .NET Core SDK ( Download | Release Notes ) See the .NET Core release notes for details on the release, including issues fixed and affected packages.  The latest .NET Core updates are available on the .NET Core download page.   Lifecycle Updates Ubuntu 20.10 and Fedora 33 have been added as a supported OS with this update of .NET Core. Docker Images .NET Docker images have been updated for today’s release. The following repos have been updated. dotnet/core/sdk: .NET Core SDK dotnet/core/aspnet: ASP.NET Core Runtime dotnet/core/runtime: .NET Core Runtime dotnet/core/runtime-deps: .NET Core Runtime Dependencies dotnet/core/samples: .NET Core Samples Note: You must pull updated .NET Core container images to get this update, with either docker pull or docker build --pull. Visual Studio This update will be included in a future update of Visual Studio. Each version of Visual studio is only supported with a given version of the .NET Core SDK. Visual Studio version information is included in the .NET Core SDK download pages and release notes.If you are not using Visual Studio, we recommend using the latest SDK release.   The post .NET Core October 2020 Updates – 2.1.23 and 3.1.9 appeared first on .NET Blog.

Two days ago, Linus Torvalds, the principal developer of the Linux kernel announced the release of Linux 5.3 on the Linux Kernel Mailing List (lkml). This major release brings new support for AMD Navi GPUs, the umwait x86 instructions, and Intel speed select. Linux 5.3 also presents a new pidfd_open(2) system call and 16 millions new IPv4 addresses in the 0.0.0.0/8 range. There are also many new drivers and improvements in this release. The previous version, Linux 5.2 was released more than two months ago. It included Sound Open Firmware project, new mount API, improved pressure stall information and more. What’s new in Linux 5.3? pidfd_open(2) system call The PID (process identification number) issue has been present in Linux, for a long time. The Linux 5.1 release had the pidfd_send_signal which allowed processes to send signals to stable ‘pidfd’ handles, even after PID reuse. Linux 5.2 added the CLONE_PIDFD to clone(2) feature which enabled users to create PIDs that were usable with pidfd_send_signal(2). However, this created problems for Android's low memory killer (LMK). Thus, Linux 5.3 has a new pidfd_open(2) syscal to complete the functionality needed to deal with the PID reuse issue. This release also has an added polling support for pidfd to allow process managers to identify when a process dies in a race-free way. Support for AMD Navi GPUs Linux 5.3 provides initial support for the AMD Navi GPUs in the amdgpu driver. The AMD Navi GPUs are the new AMD RX5700 GPUs which became available recently. This release also adds support for the core driver,(DCN2) displays, GFX and compute (GFX10), System DMA (SDMA 5), multimedia decode and encode (VCN2) and power management. Zhaoxin x86 CPU support This release also supports the Zhaoxin x86 Processors. The report states, “The architecture of the ZX family of processors is a continuation of VIA's Centaur Technology x86-64 Isaiah design.” Intel Speed Select support for easier power tuning Linux 5.3 also adds support for Intel Speed Select, which is a feature only supported on specific Xeon servers. The power management technology allows users to configure their servers for throughput and per-core performance settings. The Intel Speed Select enables prioritization of performance for certain workloads running on specific cores. 16 millions of new IPv4 addresses This release makes the 0.0.0.0/8 IPv4 range acceptable by Linux as a valid address range and available for 16 million new IPv4 addresses. The IPv4 address space includes hundreds of millions of addresses which were previously reserved for future use. The new IPv4 Cleanup Project has made the addresses usable now. Utilization clamping support in the task scheduler This release adds utilization clamping support to the task scheduler. This is a refinement of the energy-aware scheduling framework for power-asymmetric systems (like ARM big.LITTLE) added in Linux 5.0. Per-task clamping attributes can be set through sched_setattr(2). This feature intends to replace the hacks that Android had developed to achieve the same result. Improvements in Core Io_uring Added support for recvmsg() Added support for sendmsg() Added support for Submission Queue Entry links. Task scheduler New tracepoints added which will be required for energy-aware scheduling testing CONFIG_PREEMPT_RT It will help the RT patchset to be fully integrated into the mainline kernel in the future merge Improvements in Memory management Smaps: It is used to report separate components for the PSS in smaps_rollup proc file. This will help in tuning the memory manager behavior in consumer devices, particularly for the mobile devices commit. Swap: It uses rbtree for swap_extent instead of a linked list. Thus, it improves swap performance when there are lots of processes accessing the swap device concurrently. Linux developers are happy with the Linux 5.3 features, especially the new support for AMD Navi GPUs. https://twitter.com/NoraDotCodes/status/1173621317033218049 A Redditor comments, “I'm really glad to hear that Linux is catching up to the navi gpus as I just invested in all that and after building a new box in attempting to do GPU pass-through for a straight up Linux host and windows VM realized that things aren't quite there yet.” Another user says, “Looks like some people were eagerly waiting for this release. I'm glad the Linux kernel keeps evolving and improving.” These are some of the selected updates in Linux 5.3. You may go through the release notes for more details. Latest news in Linux A recap of the Linux Plumbers Conference 2019 Lilocked ransomware (Lilu) affects thousands of Linux-based servers IBM open-sources Power ISA and other chips; brings OpenPOWER foundation under the Linux Foundation

Chris Dickinson, a developer working on implementing Git in Rust shared updates on his project Git-rs. This is his second try over the same project. He writes, “I'm trying again this year after reading more of "Programming Rust" (Blandy, Orendorff).” Dickinson has maintained a ‘To Do’ list wherein he has written the steps right from reading the objects from loose store to creating a packfile and publishing it to crates. You can checkout his full project for his day-by-day updates. It is also quite interesting to see how developers are sharing their projects on Git and learning something new on a daily basis based on their experience. Users are overall happy to see Dickinson’s contribution. A user commented on Reddit, “Maybe everybody is happy just to use this as a personal learning experience for now, but I think there will be a lot of interest in a shared project eventually.” Users are also sharing their experiences from their own projects. A user commented on HackerNews, “I love to see people reimplementing existing tools on their own, because I find that to be a great way to learn more about those tools. I started on a Git implementation in Rust as well, though I haven't worked on it in a while.” Why work with Rust? Rust has been gaining tremendous popularity in recent times. Steve Klabnik, a popular blogger/developer shares his experiences working with Rust and how the language has outgrown him. He writes in his blog post, “I’m the only person who has been to every Rust conference in existence so far. I went to RustCamp, all three RustConfs, all five RustFests so far, all three Rust Belt Rusts. One RustRush. Am I forgetting any? Thirteen Rust conferences in the past four years.” He further adds, “ I’m starting to get used to hearing “oh yeah our team has been using Rust in production for a while now, it’s great.” The first time that happened, it felt very strange. Exciting, but strange. I wonder what the next stage of Rust’s growth will feel like.” Rust is also in the top fifteen (by the number of pull requests) as of 2018 in the GitHub Octoverse report. Moreover, according to the Go User Survey 2018, 19% of the respondents ranked it as a top preferred language which indicates a high level of interest in Rust among this audience. Last month, the team at Rust announced the stable release, Rust 1.33.0. This release brought improvements to const fns, compiler, and libraries. Last week, the Rust community organized the Rust Latam 2019 Conference at Montevideo for the Rust community. It involved 200+ Rust developers and enthusiasts from the world. https://twitter.com/Sunjay03/status/1112095011951308800 ‘Developers’ lives matter’: Chinese developers protest over the “996 work schedule” on GitHub Sublime Text 3.2 released with Git integration, improved themes, editor control and much more! Microsoft open sources the Windows Calculator code on GitHub  

Update: On July 23rd, the Enhancements Lead of Kubernetes 1.15 at VMware, Kenny Coleman,  published a “What's New in Kubernetes 1.15” video with Cloud Native Computing Foundation (CNCF). In the video, he explains in detail about the three new major features in Kubernetes 1.15, which include Dynamic HA Clusters with Kubeadm, Volume Cloning and CustomResourceDefinition (CRDs). Coleman also highlights each feature and explains its importance to users.  Watch the video below to know in detail about Kenny Coleman’s talk about Kubernetes 1.15. https://www.youtube.com/watch?v=eq7dgHjPpzc On June 19th, the Kubernetes team announced the release of Kubernetes 1.15, which consists of 25 enhancements, including 2 moving to stable, 13 in beta, and 10 in alpha. The key features of this release include extensibility around core Kubernetes APIs, cluster lifecycle stability, and usability improvements. This is Kubernetes’ second release this year. The previous version Kubernetes 1.14, released three months ago, had 10 stable enhancements--the most amount of stable features revealed in a release. In an interview to the New Stack, Claire Laurence, the team lead at Kubernetes said that in this release, “We’ve had a fair amount of features progress to beta. I think what we’ve been seeing a lot with these alpha and beta features as they progress is a lot of continued focus on stability and overall improvement before indicating that those features are stable.” Let’s have a brief look at all the new features and updates. #1 Extensibility around core Kubernetes APIs The theme of the new developments around CustomResourceDefinitions is data consistency and native behavior. The Kubernetes team wants that a user should not notice whether the interaction is with a CustomResource or with a Golang-native resource. Hence, from v1.15 onwards, Kubernetes will check each schema against a restriction called “structural schema”. This enforces non-polymorphic and complete typing of each field in a CustomResource. Out of the five enhancements, the ‘CustomResourceDefinition Defaulting’ is an alpha release. It is specified using the default keyword in the OpenAPI validation schema. Defaulting will be available as alpha in Kubernetes 1.15 for structural schemas. The other four enhancements are in beta which include: CustomResourceDefinition Webhook Conversion In Kubernetes, CustomResourceDefinitions gain the ability to convert between different versions on-the-fly, just like users are used to from native resources for the long term. CustomResourceDefinition OpenAPI Publishing OpenAPI publishing for CRDs will be available with Kubernetes 1.15 as beta, but only for structural schemas. CustomResourceDefinitions Pruning Pruning is the automatic removal of unknown fields in objects sent to a Kubernetes API. A field is unknown if it is not specified in the OpenAPI validation schema. It enforces that only data structures specified by the CRD developer are persisted to etcd. This is the behaviour of native resources, and will be available for CRDs as well, starting as beta in Kubernetes 1.15. Admission Webhook Reinvocation & Improvements In the earlier versions, mutating webhooks were only called once, in alphabetical order. An earlier run webhook cannot react on the output of webhooks, called later in the chain. With Kubernetes 1.15, mutating webhooks can opt-in into at least one re-invocation by specifying reinvocationPolicy: IfNeeded. If a later mutating webhook modifies the object, the earlier webhook will get a second chance. #2 Cluster Lifecycle Stability and Usability Improvements The cluster lifecycle building block, kubeadm, continues to receive features and stability work, which is needed for bootstrapping production clusters efficiently. kubeadm has promoted high availability (HA) capability to beta, allowing users to use the familiar kubeadm init and kubeadm join commands to configure and deploy an HA control plane. With kubeadm, certificate management has become more robust in 1.15, as it seamlessly rotates all the certificates before expiry. The kubeadm configuration file API is moving from v1beta1 to v1beta2 in 1.15. kubeadm now has its own new logo. Continued Improvement of CSI In Kubernetes 1.15, the Special Interests Groups (SIG) Storage enables migration of in-tree volume plugins to Container Storage Interface (CSI). SIG Storage worked on bringing CSI to feature parity with in-tree functionality, including functionality like resizing and inline volumes. SIG Storage introduces new alpha functionality in CSI that doesn’t exist in the Kubernetes Storage subsystem yet, like volume cloning. Volume cloning enables users to specify another PVC as a “DataSource” when provisioning a new volume. If the underlying storage system supports this functionality and implements the “CLONE_VOLUME” capability in its CSI driver, then the new volume becomes a clone of the source volume. Additional feature updates Support for go modules in Kubernetes Core Continued preparation on cloud provider extraction and code organization. The cloud provider code has been moved to kubernetes/legacy-cloud-providers for easier removal later and external consumption. Kubectl get and describe now work with extensions. Nodes now support third party monitoring plugins. A new Scheduling Framework for schedule plugins is now Alpha ExecutionHook API designed to trigger hook commands in the containers for different use cases is now Alpha. These extensions/v1beta1, apps/v1beta1, and apps/v1beta2 APIs will continue to depreciate and eventually will be retired in the next version 1.16. To know about the additional features in detail check out the release notes. https://twitter.com/markdeneve/status/1141135440336039936 https://twitter.com/IanColdwater/status/1141485648412651520 For more details on Kubernetes 1.15, check out Kubernetes blog. HAProxy 2.0 released with Kubernetes Ingress controller, layer 7 retries, polyglot extensibility, gRPC support and more Red Hat releases OpenShift 4 with adaptability, Enterprise Kubernetes and more! Linkerd 2.3 introduces Zero-Trust Networking for Kubernetes

On Tuesday, Gnome announced that they are planning on retiring the app menus from its next release, which is GNOME 3.32. Application menus or app menus are the menus that you see in the GNOME 3 top bar, with the name and icon for the current app. Why application menus are being removed in GNOME? The following are the reasons GNOME is bidding adieu to the application menus: Poor user engagement: Since their introduction, application menus have been a source of usability issues. The app menus haven’t been performing well over the years, despite efforts to improve them. Users don’t really engage with them. Two different locations for menu items: Another reason for the application menus not doing well could be the split between app menus and the menus in application windows. With two different locations for menu items, it becomes easy to look in the wrong place, particularly when one menu is more frequently visited than the other. Limited adoption by third-party applications: Application menus have seen limited adoption by third-party applications. They are often kept empty, other than the default quit item, and people have learned to ignore them. What guidelines developers must follow? All GNOME applications will have to move the items from its app menu to a menu inside the application window. Here are the guidelines that developers need to follow: Remove the app menu and move its menu items to the primary menu If required, split the primary menus into primary and secondary menus The about menu item should be renamed from "About" to "About application-name" Guidelines for the primary menu Primary menu is the menu you see in the header bar and has the icon with three stacked lines, also referred to as the hamburger menu. In addition to app menu items, primary menus can also contain other menu items. 2. Quit menu item is not required so it is recommended to remove it from all locations. 3. Move other app menu items to the bottom of the primary menu. 4. A typical arrangement of app menu items in a primary menu is a single group of items: Preferences Keyboard Shortcuts Help About application-name 5. Applications that use a menu bar should remove their app menu and move any items to the menu bar menus. If an application fails to remove the application menu by the release of GNOME 3.32, it will be shown in the app’s header bar, using the fallback UI that is already provided by GTK. Read the full announcement on GNOME’s official website. Fedora 29 beta brings Modularity, GNOME 3.30 support and other changes GNOME 3.30 released with improved Desktop performance, Screen Sharing, and more GIMP gets $100K of the $400K donation made to GNOME

TypeScript 3.2 was released yesterday. It is a language that brings static type-checking to JavaScript which enables developers to catch issues even before the code is run. TypeScript 3.2 includes the latest JavaScript features from ECMAScript standard. In addition to type-checking, it provides tooling in editors to jump to variable definitions, find the user of a function, and automate refactorings. You can install TypeScript 3.2 via NuGet or install via npm as follows: npm install -g typescript Now let’s look at the new features in TypeScript 3.2. strictBindCallApply TypeScript 3.2 comes with stricter checking for bind, call, and apply. In JavaScript, bind, call, and apply are methods on functions that allow actions like bind this and partially apply arguments. They also allow you to call functions with a different value for this, and call functions with an array for their arguments. Earlier, TypeScript didn’t have the power to model these functions. Demand to model these patterns in a type-safe way led the TypeScript developers to revisit this problem. There were two features that opened up the right abstractions to accurately type bind, call, and apply without any hard-coding: this parameter types from TypeScript 2.0 Modeling the parameter lists with tuple types from TypeScript 3.0 The combination of these two can ensure that the uses of bind, call, and apply are more strictly checked when we use a new flag called strictBindCallApply. When this new flag is used, the methods on callable objects are described by a new global type—CallableFunction. It declares stricter versions of the signatures for bind, call, and apply. Similarly, any methods on constructable (which are not callable) objects are described by a new global type called NewableFunction. A caveat of this new functionality is that bind, call, and apply can’t yet fully model generic functions or functions having overloads. Object spread on generic types JavaScript has a handy way of copying existing properties from an existing object into a new object called “spreads”. To spread an existing object into a new object, an element with three consecutive periods (...) can be defined. TypeScript does well in this area when it has enough information about the type. But it wouldn’t work with generics at all until now. A new concept in the type system called an “object spread type” could have been used. This would be a new type operator that looks like this: { ...T, ...U } to reflect the syntax of an object spread. If T and U are known, that type would flatten to some new object type. This approach was complex and required adding new rules to type relationships and inference. After exploring several different avenues, two conclusions arrived: Users were fine modeling the behavior with intersection types for most uses of spreads in JavaScript. For example, Foo & Bar. Object.assign: This a function that exhibits most of the behavior of spreading objects. It is already modeled using intersection types. There has been very little negative feedback around that. Intersections model the common cases and they’re relatively easy to reason about for both users and the type system. So now TypeScript 3.2 allows object spreads on generics and models them using intersections. Object rest on generic types Object rest patterns are kind of a dual to object spreads. It creates a new object that lacks some specified properties instead of creating a new object with some extra or overridden properties. Configuration inheritance via node_modules packages TypeScript has supported extending tsconfig.json files by using the extends field for a long time. This feature is useful to avoid duplicating configuration which can easily fall out of sync. It really works best when multiple projects are co-located in the same repository. This way each project can reference a common “base” tsconfig.json. But some projects are written and published as fully independent packages. Such projects don’t have a common file they can reference. So as a workaround, users could create a separate package and reference that. TypeScript 3.2 resolves tsconfig.jsons from node_modules. TypeScript will dive into node_modules packages when a bare path for the "extends" field in tsconfig.json is used. Diagnosing tsconfig.json with --showConfig The TypeScript compiler, tsc, now supports a new flag called --showConfig. On running tsc --showConfig, TypeScript will calculate the effective tsconfig.json and print it out. BigInt BigInts are a part of an upcoming ECMAScript proposal that allow modeling theoretically arbitrarily large integers. TypeScript 3.2 comes with type-checking for BigInts along with support for emitting BigInt literals when targeting esnext. Support for BigInt in TypeScript introduces a new primitive type called bigint. BigInt support is only available for the esnext target. Object.defineProperty declarations in JavaScript When writing in JavaScript files using allowJs, TypeScript 3.2 recognizes declarations that use Object.defineProperty. This means better completions, and stronger type-checking when enabling type-checking in JavaScript files. Improvements in error messages A few things have been added in TypeScript 3.2 that will make the language easier to use. Better missing property errors Better error spans in arrays and arrow functions Error on most-overlapping types in unions or “pick most overlappy type” Related spans on a typed this being shadowed A new warning message that says Did you forget a semicolon? on parenthesized expressions on the next line is added More specific messages are displayed when assigning to const/readonly bindings When extending complex types, more accurate messages are shown Relative module names are used in error messages Improved narrowing for tagged unions TypeScript now makes narrowing easier by relaxing rules for a discriminant property. The common properties of unions are now considered discriminants as long as they contain some singleton type and contain no generics. For example, a string literal, null, or undefined. Editing improvements The TypeScript project doesn’t have a compiler/type-checker. The core components of the compiler provide a cross-platform open-source language service that can power smart editor features. These features include go-to-definition, find-all-references, and a number of quick fixes and refactorings. Implicit any suggestions and “infer from usage” fixes noImplicitAny is a strict checking mode, and it helps ensure the code is as fully typed as possible. This also leads to a better editing experience. TypeScript 3.2 produces suggestions for most of the variables and parameters that would have been reported as having implicit any types. TypeScript provides a quick fix to automatically infer the types when an editor reports these suggestions. Other fixes There are two smaller quick fixes: A missing new is added when a constructor is called accidentally. An intermediate assertion is added to unknown when types are sufficiently unrelated. Improved formatting TypeScript 3.2 is smarter in formatting several different constructs. Breaking changes and deprecations TypeScript has moved more to generating DOM declarations in lib.d.ts by leveraging IDL files. Certain parameters no longer accept null or accept more specific types. Certain WebKit-specific properties have been deprecated. wheelDelta and friends have been removed as they are deprecated properties on WheelEvents. JSX resolution changes The logic for resolving JSX invocations has been unified with the logic for resolving function calls. This action has simplified the compiler codebase and improved certain use-cases. The further TypeScript releases will need Visual Studio 2017 or higher. For more details, visit the Microsoft Blog. Introducing ReX.js v1.0.0 a companion library for RegEx written in TypeScript Vue.js 3.0 is ditching JavaScript for TypeScript. What else is new? Babel 7 released with Typescript and JSX fragment support

Yesterday, Diane Hosfelt, a Research Engineer at Mozilla, shared what she and her team experienced when rewriting Firefox internals in Rust. Taking Quantum CSS as a case study, she touched upon the potential security vulnerabilities that could have been prevented if it was written in Rust from the very beginning. Why Mozilla decided to rewrite Firefox internal in Rust? Quantum CSS is a part of Mozilla’s Project Quantum, under which it is rewriting Firefox internals to make it faster. One of the major parts of this project is Servo, an engine designed to provide better concurrency and parallelism. To achieve these goals Mozilla decided to rewrite Servo in Rust, replacing C++. Rust is very similar to C++ in some ways while being different in terms of the abstractions and data structures it uses. It was created by Mozilla keeping concurrency safety in mind. Its type and memory-safe property make programs written in Rust thread-safe. What type of bugs does Rust prevent? Overall Rust prevents bugs related to memory, bounds, null/uninitialized variables, or integer by default. Hosfelt mentioned in her blog post, “Due to the overlap between memory safety violations and security-related bugs, we can say that Rust code should result in fewer critical CVEs (Common Vulnerabilities and Exposures).” However, there are some types of bugs that Rust does not address like correctness bugs. According to Hosfelt, Rust is a good option in the following cases: When your program involves processing of untrusted input safely When you want to use parallelism for better performance When you are integrating isolated components into an existing codebase You can go through the blog post by Diane Hosfelt on Mozilla’s website. Mozilla shares key takeaways from the Design Tools survey Mozilla partners with Scroll to understand consumer attitudes for an ad-free experience on the web Mozilla partners with Ubisoft to Clever-Commit its code, an artificial intelligence assisted assistant

Researchers Paul Emmerich et al have developed a new simple user space network driver called ixy. According to the researchers, ixy is an educational user space network driver for the Intel ixgbe family of 10 Gbit/s NICs. Its goal is to show that writing a super-fast network driver can be surprisingly simple in high-level languages like Rust, Go, Java and C# among others. Ixy has no dependencies, high speed, and a simple-to-use interface for applications to be built on it. The researchers have published their findings in a paper titled The Case for Writing Network Drivers in High-Level Programming Languages. Initially, the researchers implemented ixy in C and then successfully implemented the same driver in other high-level languages such as Rust, Go, C#, Java, OCaml, Haskell, Swift, Javascript, and Python. The researchers have found that the Rust driver executes 63% more instructions per packet but is only 4% slower than a reference C implementation. Go’s garbage collector keeps latencies below 100 µs even under heavy load. Network drivers written in C are vulnerable to security issues Drivers written in C are usually implemented in production-grade server, desktop, and mobile operating systems. Though C has features required for low-level systems programming and fine-grained control over the hardware, they have vulnerabilities for security as “they are exposed to the external world or serve as a barrier isolating untrusted virtual machines”. The paper states that the C code “accounts for 66% of the code in Linux, but 39 out of 40 security bugs related to memory safety found in Linux in 2017 are located in drivers. These bugs could have been prevented by using high-level languages for drivers.” Implementing Rust, Go and other high level languages in ixy network driver Rust: A lightweight Rust struct is allocated for each packet that contains metadata and owns the raw memory. The compiler enforces that the object has a single owner and only the owner can access the object. This prevents use-after-free bugs despite using a completely custom allocator. Rust is the only language evaluated in the case study that protects against use-after-free bugs and data races in memory buffers. Go: It has an external memory that is wrapped in slices to provide bounds checks. The atomic package in Go also indirectly provides memory barriers and volatile semantics thus offering stronger guarantees. C#: The researchers have implemented two external memories out of the many available. It offers a more direct way to work with raw memory by offering full support for pointers with no bounds checks and volatile memory access semantics. Java: The researchers have targeted OpenJDK 12 which offers a non-standard way to handle external memory via the sun.misc.Unsafe object that provides functions to read and write memory with volatile access semantics. OCaml: OCaml Bigarrays backed by external memory is used for DMA buffers and PCIe resources, the allocation is done via C helper functions. The Cstruct library from the OCaml allowed researchers to access data in the arrays in a structured way by parsing definitions similar to C struct definitions and generating code for the necessary accessor functions. Haskell: It is a compiled functional language with garbage collection. The necessary low-level memory access functions are available via the Foreign package. Memory allocation and mapping is available via System.Posix.Memory. Swift: Its memory is managed via automatic reference counting, i.e., the runtime keeps a reference count for each object and frees the object once it is no longer in use. It also offers all the features necessary to implement drivers. JavaScript: ArrayBuffers is used to wrap external memory in a safe way, these arrays can then be accessed as different integer types using TypedArrays, circumventing JavaScript’s restriction to floating-point numbers. Memory allocation and physical address translation is handled via a Node.js module in C. Python: For this driver, the implementation was not explicitly optimized for performance and meant as a simple prototyping environment for PCIe drivers and as an educational tool. The researchers have provided primitives for PCIe driver development in Python. Rust is found to be the prime candidate for safer network drivers After implementing the network driver ixy in all high-level languages, the researchers conclude that Rust is the prime candidate for safer drivers. The paper states, “Rust’s ownership based memory management provides more safety features than languages based on garbage collection here and it does so without affecting latency.” Other languages like Go and C# are also a suitable language if the system can cope with sub-millisecond latency spikes due to garbage collection. Other languages like Haskell and OCaml will also be more useful if their performance is less critical than having a safe and correct system. Though Rust performs better than C, it is 4% slower than the C driver. The reason behind is that Rust applies bounds checks while C does not. Another reason is that C does not require a wrapper object for DMA buffers. Image Source: Research paper Users have found the result of this high-level language implementation of network drivers quite interesting. https://twitter.com/matthewwarren/status/1172094036297048068 A Redditor comments, “Wow, Rust and Go performed quite well. Maybe writing drivers in them isn't that crazy” Many developers are also surprised to see the results of this case study, especially the performance of Go and Swift. A comment on Hacker News says, “The fact that Go is slower than C# really amazes me! Not long ago I switched from C# to Go on a project for performance reasons, but maybe I need to go back.” Another Redditor says, “Surprise me a bit that Swift implementation is well below expected. Being Swift a compiled native ARC language, I consider the code must be revised.” Interested readers can watch a video presentation by Paul Emmerich on ‘How to write PCIe drivers in Rust, go, C#, Swift, Haskell, and OCaml’. Also, you can find more implementation details in the research paper. Other News in Tech New memory usage optimizations implemented in V8 Lite can also benefit V8 Google releases Flutter 1.9 at GDD (Google Developer Days) conference Intel’s DDIO and RDMA enabled microprocessors vulnerable to new NetCAT attack

Yesterday, at the ongoing Worldwide Developers Conference (WWDC) 2019, Apple announced a new framework called SwiftUI for building user interfaces across all Apple platforms. With an aim to decrease the line of codes, SwiftUI supports declarative syntax, design tools, and live editing. SwiftUI has an incredible native performance, thus allowing developers to feel fully integrated by taking advantage of the features from the previous technologies and developer experiences of Apple platforms. It's also automatically supported for dynamic type, dark mode, localization, and accessibility. The tools for SwiftUI development are only available when running on macOS 10.15 beta. Declarative syntax SwiftUI enables a developer to simply state the requirements of a user interface and it will be done directly. For example, if a developer wants a list of items consisting of text fields, then the developer will have to just describe the alignment, font, and color for each field. This makes the code simpler and easier to read, thus saving time and maintenance. SwiftUI also makes complex concepts like animation, much simpler. It enables developers to add animation to almost any control and choose a collection of ready-to-use effects with only a few lines of code. Design tools During the WWDC, Xcode 11 beta release notes were also released. Xcode 11 beta includes SDKs for iOS 13, macOS 10.15, watchOS 6, and tvOS 13.  Xcode 11 beta also supports development with SwiftUI. It supports uploading apps from the Organizer window and its editors can now be added to any window without needing an Assistant Editor. Also the LaunchServices on macOS, now respects the selected Xcode when launching Instruments, Simulator, and other developer tools embedded within Xcode. Thus using these intuitive new design tools of Xcode11, SwiftUI can be used to build interfaces like dragging and dropping, dynamic replacement, and previews. Drag and drop A developer can arrange components within the user interface by simply dragging controls on the canvas. It can be done by opening an inspector to select font, color, alignment, and other design options, and easily rearrange controls with the cursor. Many of these visual editors are also available within the code editor. It is also possible to drag controls from the library and drop them on the design canvas or directly on the code. Dynamic replacement When working in a design canvas, every edit by the developer will be completely in sync with the code in the adjoining editor. Xcode will recompile the changes instantly such that a developer can constantly build an app and run it at the same time, like a ‘live app’. With this feature, Xcode can also swap the edited code directly in the live app. Previews It is now possible to create one or many previews of any SwiftUI views to get sample data and configure almost anything the users can see, such as large fonts, localizations, or dark mode. The users' code will be instantly visible as a preview, and if any change is made in the preview, it will immediately appear in the code. Previews can also display a UI, in any device and any orientation. Native on all Apple platforms SwiftUI has been created in such a way that all controls and platform-specific experiences are included in the code. It allows an app to directly access the features from the previous technologies of each platform, with a small amount of code and an interactive design canvas. It can be used to build user interfaces for any Apple device, including iPhone, iPad, iPod touch, Apple Watch, and Apple TV. SwiftUI’s striking features have made developers very excited to try out the framework. https://twitter.com/stroughtonsmith/status/1135647926439632899 https://twitter.com/fjeronimo/status/1135626395168563201 https://twitter.com/sascha_p/status/1135626257884782592 https://twitter.com/cocoawithlove/status/1135626052678574080 For more details on SwiftUI framework, head over to the Apple Developers website. Apple promotes app store principles & practices as good for developers and consumers following rising antitrust worthy allegations Apple proposes a “privacy-focused” ad click attribution model for counting conversions without tracking users Apple Pay will soon support NFC tags to trigger payments

Last week, the Python team released NumPy version 1.17.0. This version has many new features, improvements and changes to increase the performance of NumPy. The major highlight of this release includes a new extensible numpy.random module, new radix sort & timsort sorting methods and a NumPy pocketfft FFT implementation for accurate transforms and better handling of datasets of prime length. Overriding of numpy functions has also been made possible by default. NumPy 1.17.0 will support Python versions 3.5 - 3.7. Python 3.8b2 will work with the new release source packages, but may not find support in future releases. The Python team had previously updated users that Python 2.7 maintenance will stop on January 1, 2020. NumPy 1.17.0 officially dropping Python 2.7 is a step towards the adoption of Python 3. Developers who want to port their Python 2 code in Python 3, can check out the official porting guide, released by Python. Read More: NumPy drops Python 2 support. Now you need Python 3.5 or later. What’s new in NumPy 1.17.0? New extensible numpy.random module with selectable random number generators NumPy 1.17.0 has a new extensible numpy.random module. It also includes four selectable random number generators and improved seeding designed for use in parallel processes. PCG64 is the new default numpy.random module while MT19937 is retained for backwards compatibility. Timsort and radix sort have replaced mergesort for stable sorting Both the radix sort and timsort have been implemented and can be used instead of mergesort. The sorting kind options ‘stable’ and ‘mergesort’ have been made aliases of each other with the actual sort implementation for maintaining backward compatibility. Radix sort is used for small integer types of 16 bits or less and timsort is used for all the remaining types of bits. empty_like and related functions now accept a shape argument Functions like empty_like, full_like, ones_like and zeros_like will now accept a shape keyword argument, which can be used to create a new array as the prototype and overriding its shape also. These functions become extremely useful when combined with the __array_function__ protocol, as it allows the creation of new arbitrary-shape arrays from NumPy-like libraries. User-defined LAPACK detection order numpy.distutils now uses an environment variable, comma-separated and case insensitive detection order to determine the detection order for LAPACK libraries. This aims to help users with MKL installation to try different implementations. .npy files support unicode field names A new format version of .npy files has been introduced. This enables structured types with non-latin1 field names. It can be used automatically when needed. New mode “empty” for pad The new mode “empty” pads an array to a desired shape without initializing any new entries. New Deprications in NumPy 1.17.0 numpy.polynomial functions warn when passed float in place of int Previously, functions in numpy.polynomial module used to accept float values. With the latest NumPy version 1.17.0, using float values is deprecated for consistency with the rest of NumPy. In future releases, it will cause a TypeError. Deprecate numpy.distutils.exec_command and temp_file_name The internal use of these functions has been refactored for better alternatives such as replace exec_command with subprocess. Also, replace Popen and temp_file_name <numpy.distutils.exec_command> with tempfile.mkstemp. Writeable flag of C-API wrapped arrays When an array is created from the C-API to wrap a pointer to data, the writeable flag set during creation indicates the read-write nature of the data. In the future releases, it will not be possible to convert the writeable flag to True from python as it is considered dangerous. Other improvements and changes Replacement of the fftpack based fft module by the pocketfft library pocketfft library contains additional modifications compared to fftpack which helps in improving accuracy and performance. If FFT lengths has large prime factors then pocketfft uses Bluestein's algorithm, which maintains O(N log N) run time complexity instead of deteriorating towards O(N*N) for prime lengths. Array comparison assertions include maximum differences Error messages from array comparison tests such as testing.assert_allclos now include “max absolute difference” and “max relative difference” along with previous “mismatch” percentage. This makes it easier to update absolute and relative error tolerances. median and percentile family of functions no longer warn about nan Functions like numpy.median, numpy.percentile, and numpy.quantile are used to emit a RuntimeWarning when encountering a nan. Since these functions return the nan value, the warning is redundant and hence has been removed. timedelta64 % 0 behavior adjusted to return NaT The modulus operation with two np.timedelta64 operands now returns NaT in case of division by zero, rather than returning zero. Though users are happy with NumPy 1.17.0 features, some are upset over the Python version 2.7 being officially dropped. https://twitter.com/antocuni/status/1156236201625624576 For the complete list of updates, head over to NumPy 1.17.0 release notes. Plotly 4.0, popular python data visualization framework, releases with Offline Only, Express first, Displayable anywhere features Python 3.8 new features: the walrus operator, positional-only parameters, and much more Azure DevOps report: How a bug caused ‘sqlite3 for Python’ to go missing from Linux images

Yesterday, the ReactOS team announced the release of ReactOS 0.4.11. This release comes with improvements in the kernel for better overall system stability, support for manifests, and more. Following are some of the updates ReactOS 0.4.11 comes with: Kernel improvements ReactOS 0.4.11 comes with substantial updates in the interface that allow operating systems to talk with storage devices. Nowadays, computers generally use SATA connections and the corresponding AHCI interface. To support this interface, ReactOS relies on the UniATA driver. But, this driver was not supported by the 6th generation of Intel’s Core processors (Skylake). The team has now resolved this incompatibility enabling users to test ReactOS on more modern platforms. Support for manifests Applications often depend on other libraries in the form of dynamic link libraries (DLLs), which are loaded by the loader (LDR). One way these dependencies are specified is with the help of manifests. In the previous versions of ReactOS, manifests were not properly supported. ReactOS 0.4.11 comes with sufficient support for manifests, which has also widened the range of applications that can run in ReactOS. With this support added, ReactOS can now run applications like Blender 2.57b, Bumptop, Evernote 5.8.3, Quicktime Player 7.7.9, and many others. USETUP improvements ReactOS 0.4.11 comes with major improvements in the USETUP module. The goal behind these improvements was to enable users to upgrade an existing installation of ReactOS. This is also a step forward towards making ReactOS an actual system OS with the ability to update without the loss of any data and configuration. Testing In this release, the team has restructured the test results page to better encapsulate the relevant information. In addition to the overall conclusion of the test, users will now also be able to see details such as tracking what drove a particular conclusion and the workarounds that they might themselves attempt. Support for network debugging and diagnosis programs ReactOS 0.4.11 now supports various network debugging and diagnosis programs as a result of work done in TCP and UDP connection enumeration. With this update, the ReactOS team aims to make the platform useful for not just running applications, but also to debug them. To read the full list of updates in ReactOS 0.4.11, check out the official announcement. Btrfs now boots ReactOS, a free and open source alternative for Windows NT ReactOS version 0.4.9 released with Self-hosting and FastFAT crash fixes You can now install Windows 10 on a Raspberry Pi 3