Tech News - Programming

Embarcadero has made a significant announcement of launching the community edition for its premium products Delphi, a cross-platform IDE and C++Builder, a powerful C++ IDE. With the community edition, the developers can start using both the products without any charge and access most of the features that are part of the Professional Edition. Apart from the developers, they have the free access to the organizations with less than $5,000 in annual revenue. This announcement is getting a big welcome in the community, considering the offerings for developers, startups, freelancers who have struggled to enter the Delphi ecosystem for years. Delphi has been unpopular among the native applications developers. This may be because of the entry point pricing. As such, this move seems to ease that barrier at least for the developers, using different IDEs. Delphi's community edition is said to provide access to all the features and components from the Professional edition. This will permit developing open source projects at no cost to the developers. Apart from the normal community edition offering, Delphi and C++Builder have free trial versions of the Pro, Enterprise, and Architect version of the products available. Embarcadero did not talk about RAD Studio, one of the 3 premium tools apart from Delphi and C++Builder in its lineup. RAD Studio is a platform to write, compile, and deploy cross-platform applications. You can download the starter edition for Delphi and C++Builder from the Embarcadero’s community website. In case you want to try other offerings, you can opt for a 30 days trial. Delphi: memory management techniques for parallel programming Implementing C++ libraries in Delphi for HPC [Tutorial] Delphi Cookbook

Python 3.5 is no longer supported.  There will be no more bug fixes or security patches for the 3.5 series, and Python 3.5.10 is the last release.  The Python core development community recommends that all remaining Python 3.5 users should upgrade to the latest version.

I’m Hong Ooi, data scientist with Microsoft Azure Global, and maintainer of the checkpoint package. The checkpoint package makes it easy for you freeze R packages in time, drawing from the daily snapshots of the CRAN repository that have been archived on a daily basis at MRAN since 2014. Checkpoint has been around for nearly 6 years now, helping R users solve the reproducible research puzzle. In that time, it’s seen many changes, new features, and, inevitably, bug reports. Some of these bugs have been fixed, while others remain outstanding in the too-hard basket. Many of these issues spring from the fact that it uses only base R functions, in particular install.packages, to do its work. The problem is that install.packages is meant for interactive use, and as an API, is very limited. For starters, it doesn’t return a result to the caller—instead, checkpoint has to capture and parse the printed output to determine whether the installation succeeded. This causes a host of problems, since the printout will vary based on how R is configured. Similarly, install.packages refuses to install a package if it’s in use, which means checkpoint must unload it first—an imperfect and error-prone process at best. In addition to these, checkpoint’s age means that it has accumulated a significant amount of technical debt over the years. For example, there is still code to handle ancient versions of R that couldn’t use HTTPS, even though the MRAN site (in line with security best practice) now accepts HTTPS connections only. I’m happy to announce that checkpoint 1.0 is now in beta. This is a major refactoring/rewrite, aimed at solving these problems. The biggest change is to switch to pkgdepends for the backend, replacing the custom-written code using install.packages. This brings the following benefits: Caching of downloaded packages. Subsequent checkpoints using the same MRAN snapshot will check the package cache first, saving possible redownloads. Allow installing packages which are in use, without having to unload them first. Comprehensive reporting of all aspects of the install process: dependency resolution, creating an install plan, downloading packages, and actual installation. Reliable detection of installation outcomes (no more having to screen-scrape the R window). In addition, checkpoint 1.0 features experimental support for a checkpoint.yml manifest file, to specify packages to include or exclude from the checkpoint. You can include packages from sources other than MRAN, such as Bioconductor or Github, or from the local machine; similarly, you can exclude packages which are not publicly distributed (although you’ll still have to ensure that such packages are visible to your checkpointed session). The overall interface is still much the same. To create a checkpoint, or use an existing one, call the checkpoint() function: library(checkpoint) checkpoint("2020-01-01") This calls out to two other functions, create_checkpoint and use_checkpoint, reflecting the two main objectives of the package. You can also call these functions directly. To revert your session to the way it was before, call uncheckpoint(). One difference to be aware of is that function names and arguments now consistently use snake_case, reflecting the general style seen in the tidyverse and related frameworks. The names of ancillary functions have also been changed, to better reflect their purpose, and the package size has been significantly reduced. See the help files for more information. There are two main downsides to the change, both due to known issues in the current pkgdepends/pkgcache chain: For Windows and MacOS, creating a checkpoint fails if there are no binary packages available at the specified MRAN snapshot. This generally happens if you specify a snapshot that either predates or is too far in advance of your R version. As a workaround, you can use the r_version argument to create_checkpoint to install binaries intended for a different R version. There is no support for a local MRAN mirror (accessed via a file:// URL). You must either use the standard MRAN site, or have an actual webserver hosting a mirror of MRAN. It’s anticipated that these will both be fixed before pkgdepends is released to CRAN. You can get the checkpoint 1.0 beta from GitHub: remotes::install_github("RevolutionAnalytics/checkpoint") Any comments or feedback will be much appreciated. You can email me directly, or open an issue at the repo.

As an update to this post, here's a list of the major events in R history since its creation:  1992: R development begins as a research project in Auckland, NZ by Robert Gentleman and Ross Ihaka  1993: First binary versions of R published at Statlib 1995: R first distributed as open-source software, under GPL2 license 1997: R core group formed 1997: CRAN founded (by Kurt Hornik and Fritz Leisch) 1999: The R website, r-project.org, founded 1999: First in-person meeting of R Core team, at inaugural Directions in Statistical Computing conference, Vienna 2000: R 1.0.0 released (February 29)  2000: John Chambers, recipient of the 1998 ACM Software Systems Award for the S language, joins R Core 2001: R News founded (later to become the R Journal) 2003: R Foundation founded 2004: First UseR! conference (in Vienna) 2004: R 2.0.0 released 2009: First edition of the R Journal 2013: R 3.0.0 released 2015: R Consortium founded, with R Foundation participation 2016: New R logo adopted 2017: CRAN exceeds 10,000 published packages 2020: R 4.0.0 released The presentation below (slides available here) also covers the history of R through 2020.  

In .NET Interactive Preview 2, we announced that in addition to Jupyter Notebook and Jupyter Lab, users could use nteract as well. In this preview, users can add VS Code Insiders to that list. With the VS Code Insiders experience, users can get started with .NET notebooks without needing to install Jupyter. The VS Code experience is still a work in progress, and is only available in VS Code Insiders. We look forward to your feedback. Getting started To get started with .NET notebooks, please install the following: The latest version of VS Code Insiders. The latest .NET Core 3.1 SDK. The .NET Interactive Notebooks extension. Creating a new .NET notebook Once you have the requirements listed above installed, you are ready to start creating .NET Notebooks in VS Code Insiders. To create a new notebook, open the Command Palette(Ctrl+Shift+P), and select Create new blank notebook. You can also create a new notebook with Ctrl+Shift+Alt+N key combination. Every notebook has a default language. A new blank notebook starts with a C# cell, as noted in the lower right corner of the cell. If you click on C# (.NET Interactive), you can change the language of the cell. If you change the language of the cell, the next cell you create will continue with that language. To add a cell, hover above or below an existing cell. Buttons appear allowing you to specify the type of cell to add, +Code or +Markdown. If you select +Code, you can change the language afterward. Opening an existing .NET notebook To open an existing .NET notebook, bring up the Command Palette and select Open notebook. Now, navigate to a local .ipynb file. With .NET notebooks in VS Code, you can take advantage of rich coding experiences like IntelliSense, and you can use all of your favorite VS Code extensions. Polyglot Notebooks: Variable Sharing .NET Interactive is a multi-language kernel that allows you to create notebooks that use different languages together. You switch languages from one cell to another, as appropriate to the task at hand. Pulling values into the notebook and moving values between languages are useful capabilities, which we’ve enabled with a pair of magic commands: #!share and #!value. #!share .NET Interactive provides subkernels for three languages (C#, F#, and PowerShell) within the same process. You can share variables between the .NET subkernels using the #!share magic command. Once a variable has been declared in one of these subkernels, it can be accessed from another. And because these kernels run in the same process, if the type of a variable is a reference type, changes to its state can be observed immediately from other kernels. Example: In this GIF, I’ve declared a C# variable csharpVariable in one cell, which I then share with F# using #!share --from csharp csharpVariable. #!value Importing text into a notebook, whether from the clipboard or a JSON or CSV file or a URL, is a fairly common scenario. The #!value magic command makes it easier to get text into your notebook without having to explicitly declare a string variable and worry about correctly escaping it. When you execute a cell using #!value, the content is stored in memory. (It will also be stored in your .ipynb output, and displayed, if you use the --mime-type switch.) So how do you access the value once it’s stored? The #!value magic command actually refers to another subkernel. In the GIF above, you can see it in the IntelliSense list that’s shown when #!share is typed. Once a value has been stored using #!value, you can share it with another subkernel just like you can from C#, F#, or PowerShell. There are a few ways to use #!value to store data in a notebook session. The example below shows you how to do it from the clipboard. For examples of other ways to use it, including reading from files and URLs, please check out Direct data entry with #!value. Sharing kernel values with JavaScript .NET Interactives has APIs available that simplify the process of directly writing HTML and JavaScript in the same notebook where you write .NET code. This enables you to create custom visualizations and access the broader ecosystem of JavaScript libraries without needing .NET wrappers. In the example below, we are sharing code from the .NET kernel using JavaScript and using it to render HTML, all in a single notebook. First, I build a collection of items in C# representing fruits with prices and quantities. Next, since .NET Interactive is polyglot, I can switch to JavaScript. (While the VS Code experience has a language chooser, you can also switch languages using magic commands like #!javascript, so that you can use these features in Jupyter as well). In the JavaScript cell, I load the D3.js visualization library and when it’s loaded, I access the fruits variable from the C# kernel using interactive.csharp.getVariable("fruits"). This interactive object has properties corresponding to each of the .NET Interactive subkernels. The variable from the subkernel is serialized into JSON and then deserialized into a JavaScript object (basket) that I’ll use to render my bar chart with D3.js. Final step: Let’s render the results. We are now going to use HTML to render our chart and JavaScript to call our function. The HTML has to be rendered first because that’s where the JavaScript will build the visualization. But we don’t have to put them in separate cells. Using magic commands, we can switch languages within the same cell so that the output renders at the bottom of the notebook. #!html <svg id = "fruit_display" width = "100%"></svg> #!js renderfruits("svg#fruit_display"); And there you have it! A simple demonstration on how you can leverage .NET Interactive polyglot notebooks. To learn more about variable sharing, sub-kernels, and HTML and JavaScript in .NET Interactive, please check out the linked documentation. Documentation We are also happy to share some progress on .NET Interactive documentation. You can now learn more about .NET Interactive’s architecture, variable sharing, visualization, and other features. The documentation is still a work progress, so we look forward to hearing from you. Resources Documentation Samples Source code .NET Interactive Notebooks Extension Happy interactive programming! The post .NET Interactive Preview 3: VS Code Insiders and .NET Polyglot Notebooks appeared first on .NET Blog.

Scratch 3.0 was released yesterday. Scratch is an environment aimed to teach basic programming logic to kids with blocks and cartoon-ish characters and scenes. Yesterday, Scratch 3.0 officially became a part of the Scratch online community. Scratch 3.0 new features There are various new sprites, backgrounds, and sounds for users to play with. A new extension library lets users add new sets of blocks that connect to hardware and software components to do more tasks with Scratch A new sound editor New programming blocks Support for tablets, hence the blocks in Scratch 3.0 are bigger Users can add collections of extra blocks the developers call ‘extensions’ Among existing blocks new ones are added for sound effects, operators to make string operations easier, new pen blocks and a new glide block to move a sprite. The paint editor has a new layout that increases the visibility of tools and options, an eraser tool, more color options, better control over vector points, more controls for ordering layers, and new gradient controls. With the sound editor in Scratch 3.0, you can now record sounds, trim audio with more ease, and explore new sound effects. General reactions to Scratch Comments from Hacker news are positive for Scratch: “Scratch is pretty great, and at least 3 of my kids constantly ask if they can play Scratch.” “Scratch (and similar programming environments) is a very successful way to introduce children to programming and I hope that it continues to do so.” Any of your old projects can be found at https://scratch.mit.edu/mystuff/. You can check out Scratch at the MIT website. Ruby 2.6.0 released with a new JIT compiler Python governance vote results are here: The steering council model is the winner NumPy drops Python 2 support. Now you need Python 3.5 or later.

This Wednesday, GitHub pages were non-functional as there was some instability in their servers. A hacker claimed that he performed a DDoS attack on the website. Github was down for roughly about an hour before normal functionality was restored. A hacker that goes by the name of Hax Stroke, a part of Ghost Squad Hackers Tweeted: https://twitter.com/HaxStroke/status/1080517770222231553 Hax Stroke claims to have performed the attack using RPCBIND service DDoS amp and that it was ‘just a demo’. The Issues, PRs, Dashboard, Projects seemed to be down, enough for the website to not load at all. https://twitter.com/odraudek99/status/1080517844763377665 The outage was observed in many parts of the globe. https://twitter.com/ReportOutage/status/1080517092569423878 The same person also claims to be responsible for the YouTube outage end of last year. https://twitter.com/HaxStroke/status/1052743020435640325 The new year has just started and users observed issues in using GitHub: https://twitter.com/arungupta/status/1080518646152089601 On their status website, their official comment as of January 2, 16:32 UTC is: “Resolved - We observed elevated error rates and discovered a capacity issue in one of our databases which impacted Web, API, and Gists. A backlog was cleared and systems returned to normal.” This isn’t the first time when the crowd favorite open-source repository was malfunctional. In October last year, GitHub was down for one whole day due to a failure in its data storage system. GitHub down for a complete day due to failure in its data storage system GitHub plans to deprecate GitHub services and move to Webhooks in 2019 GitHub Octoverse: The top programming languages of 2018

The ISO C++ Committee met last week at Cologne, Germany to complete and publish the Committee Draft (CD) of the next C++ standard called C++20. This standard will bring some of the game-changing advancements to C++ including modules, concepts, coroutines, and ranges to C++. Here are some of the changes made to the draft in this meeting: Contracts moved out of C++20 A contract specifies a set of preconditions, postconditions, and assertions that a software component should adhere to. The committee unanimously decided to move contracts out of C++20 and defer it to a later standard because it has recently gone through major design changes. They were unsure of the impact or implications of these changes as they did not have much usage experience with contracts. “In short, contracts were just not ready. It's better for us to ship contracts in a form that better addresses the use cases of interest in a future standard instead of shipping something we are uncertain about in C++20. Notably, this decision was unanimous -- all of the contracts’ co-authors agreed to this approach,” wrote the committee. To continue the work on contracts a new study group is created named SG21. It will be chaired by John Spicer from Edison Design Group and includes all original authors and members who are interested to work on contracts. std::format, a new text formatting API One of the key advantages of the ‘printf’ syntax is its familiarity among developers. However, it does suffer from a few drawbacks. The format specifiers it provides like hh, h, l, and j are redundant in type-safe formatting. They can unnecessarily make specification and parsing complicated. The printf syntax also does not provide a standard way for extending the syntax for user-defined types. C++20 will come with a new text formatting API called ‘std::format’ that aims to offer a flexible, safe, and fast alternative to (s)printf and iostreams. Based on the syntax we see in Python, the .NET family of languages, and Rust, it uses ‘{‘ and ‘}’ as replacement field delimiters instead of %. The C++20 synchronization library This new standard will bring new improved synchronization and thread coordination facilities. It will support efficient ‘atomic’ waiting and semaphores, latches, barriers, atomic_flag::test, lockfree integral types, and more. The next step for the committee is to submit the draft to all the national standard bodies to gather their feedback. The committee plans to address their feedback in the next two meetings and then publish the C++20 standard at the February 2020 meeting in Prague. Developers are excited about the new features C++20 will come with. A Reddit user commented, “Wow, the C++ committee is really doing a great job. There are so many good features coming into the standard (std::format, constexpr features, better threading support, etc, etc). Thank you all for all of your hard work.” Others are not very impressed by the ‘web_view’ proposal. This introduces a facility that aims to enable natural, multimodal user interaction with the help of existing web standards and technologies. Another user added, “Very surprising, I didn't expect that because personally, I think that the proposal is not very good. If we use JS and other technologies to display stuff, why not directly use those languages? Why go through C++? But maybe I don't understand it; I'll make sure to go through the minutes.” You can read the full report posted by the ISO C++ Committee for more details. ISO C++ Committee announces that C++20 design is now feature complete GCC 9.1 releases with improved diagnostics, simpler C++ errors and much more Code completion suggestions via IntelliCode comes to C++ in Visual Studio 2019  

After releasing Elixir 1.8 in January, the team behind Elixir announced the release of Elixir 1.9 yesterday. This comes with a new ‘releases’ feature, the Config API for streamlined configuration, plus many other enhancements and bug fixes. Elixir is a functional, concurrent, general-purpose programming language that runs on the Erlang VM. Releases, a single unit for code and the runtime Releases are the most important feature that has landed in this version. A release is a “self-contained directory” that encapsulates not only your application code and its dependencies but also the whole Erlang VM and runtime. So, basically, it allows you to precompile and package your code and runtime in a single unit. You can then deploy this single unit to a target that is running on the same OS distribution and version as the machine running the ‘mix release’ command. Following are some of the benefits ‘releases’ provide: Code preloading: As releases run in embedded mode for loading code it loads all the modules beforehand. This makes your system ready for handling requests right after booting. Configuration and customization: It gives you “fine-grained control” over system configuration and the VM flags for starting the system. Multiple releases: It allows you to assemble different releases of the same application with different configurations. Management scripts: It provides management scripts to start, restart, connect to the running system remotely, execute RPC calls, run in daemon mode, run in Windows service mode, and more. Releases are also the last planned feature for Elixir and the team is not planning to add any other user-facing feature in the near future. The Elixir team shared in the announcement, “Of course, it does not mean that v1.9 is the last Elixir version. We will continue shipping new releases every 6 months with enhancements, bug fixes, and improvements.” A streamlined configuration API This version comes with a more streamlined Elixir’s configuration API in the form of a new ‘Config’ module. Previously, the ‘Mix.Config’ configuration API was part of the Mix build tool. Beginning Elixir 1.9, the runtime configuration is now taken care of by ‘releases’ and Mix is no longer included in ‘releases’, this API is now ported to Elixir. “In other words, ‘use Mix.Config’ has been soft-deprecated in favor of import Config,” the announcement reads. Another crucial change in configuration is that starting from this release the ‘mix new’ command will not generate a ‘config/config.exs’ file. The ‘mix new --umbrella’ will also not generate a configuration for each child app as the configuration is now moved from individual umbrella application to the root of the umbrella. Many developers are excited about the ‘releases’ support. One user praised the feature saying, “Even without the compilation and configuration stuff, it's easier to put the release bundle in something basic like an alpine image, rather than keep docker image versions and app in sync.” However, as many of them currently rely on the Distillery tool for deployment they have some reservations about using releases as it lacks some of the features Distillery provides. “Elixir's `mix release` is intended to replace (or remove the need for) third-party packages like Distillery. However, it's not there yet, and Distillery is strictly more powerful at the moment. Notably, Elixir's release implementation does not support hot code upgrades. I use upgrades all the time, and won't be trying out Elixir's releases until this shortcoming is addressed,” a Hacker News user commented. Public opinion on Twitter was also positive: https://twitter.com/C3rvajz/status/1140351455691444225 https://twitter.com/rrrene/status/1143443465549897733 Why Ruby developers like Elixir How Change.org uses Flow, Elixir’s library to build concurrent data pipelines that can handle a trillion messages Introducing Mint, a new HTTP client for Elixir

Yesterday, the Nim team announced the release of Nim version 0.20.0. Nim is a statically typed compiled systems programming language, which successfully combines the concepts from mature languages like Python, Ada and Modula. This is a massive release from Nim, with more than 1,000 commits. Nim version 0.20.0 is effectively Nim 1.0 RC1. The team has also mentioned that the stable release 1.0 will either be, the Nim 0.20.0 being promoted to 1.0 status or another release candidate, as there will be no more breaking changes. Also, version1.0 will be a long-term supported stable release and will only receive bug fixes and new features in the future, as long as it doesn't break backwards compatibility. New Features not is always a unary operator Stricter compile time checks for integer and float conversions Tuple unpacking for constant and for loop variables Hash sets and tables are initialized by default Better error message for case-statements The length of a table must not change during iteration Better error message for index out of bounds Changelog The Nim version 0.20.0 includes many changes affecting backwards compatibility. One of the changes is that strutils.editDistance has been deprecated, instead editdistance.editDistance or editdistance.editDistanceAscii to be used instead. One of the breaking changes in the standard library includes osproc.execProcess now also takes a workingDir parameter and std/sha1.secureHash will now accept openArray[char], and not string. There are few breaking changes in the compiler too. One of the main changes is that the compiler now implements the “generic symbol prepass” for when statements in generics. Library additions There are many new library additions in this release. Some of them are mentioned below: stdlib module std/editdistance as a replacement for the deprecated strutils.editDistance. stdlib module std/wordwrap as a replacement for the deprecated strutils.wordwrap. Added split, splitWhitespace, size, alignLeft, align, strip, repeat procs and iterators to unicode.nim. Added or for NimNode in macros Added system.typeof for more control over how type expressions can be deduced. Library changes Many changes have been made in the library. Some of them are mentioned below: The string output of macros.lispRepr proc has been tweaked slightly. The dumpLisp macro in this module now outputs an indented proper Lisp, devoid of commas. Added macros.signatureHash that returns a stable identifier derived from the signature of a symbol. In strutils empty strings now no longer match as substrings The Complex type is now a generic object and not a tuple anymore. The ospaths module is now deprecated, use os instead. Note that os is available in a NimScript environment but unsupported operations produce a compile-time error. Language additions There have been new additions to the language as well. Some of them are mentioned below: Vm support for float32<->int32 and float64<->int64 casts was added. There is a new pragma block noSideEffect that works like the gcsafe pragma block User defined pragmas are now allowed in the pragma blocks Pragma blocks are no longer eliminated from the typed AST tree to preserve pragmas for further analysis by macros. Language changes The standard extension for SCF (source code filters) files was changed from .tmpl to .nimf. Pragma syntax is now consistent. Previous syntax where type pragmas did not follow the type name is now deprecated. Also pragma before generic parameter list is deprecated to be consistent with how pragmas are used with a proc. Hash sets and tables are initialized by default. The explicit initHashSet, initTable, etc. are not needed anymore. Tool changes jsondoc now includes a moduleDescription field with the module description. jsondoc0 shows comments as its own objects as shown in the documentation. nimpretty: –backup now defaults to off instead of on and the flag was undocumented; use git instead of relying on backup files. koch now defaults to build the latest stable Nimble version unless you explicitly ask for the latest master version via --latest. Compiler changes The deprecated fmod proc is now unavailable on the VM A new --outdir option was added The compiled JavaScript file for the project produced by executing nim js will no longer be placed in the nimcache directory. The --hotCodeReloading has been implemented for the native targets. The compiler also provides a new more flexible API for handling the hot code reloading events in the code. The compiler now supports a --expandMacro:macroNameHere switch for easy introspection into what a macro expands into. The -d:release switch now does not disable runtime checks anymore. For a release build that also disables runtime checks use -d:release -d:danger or simply -d:danger. The Nim version 0.20.0 also contains many bug fixes. Most developers are quite delighted with the release of Nim version 0.20.0. A user on Hacker News states that “It's impressive. 1000 commits! Great job Nim team!” Another user comments, “I've been full steam on the Nim train for the past year. It really hits a sweet spot between semantic complexity and language power. If you've used any mainstream language and understand types, you already understand 80% of the semantics you need to be productive. But more advanced features (generics, algebraic data types, hygienic macros) are available when needed. Now that the language is approaching 1.0, the only caveat is a small ecosystem and community. Nim has completely replaced Node as my language of choice for side projects and prototyping.” While there are some users who still prefer Python, for its strong command language, a user says that “It seems to me that the benefits of Nim over Python are far smaller than the benefits of Python's library ecosystem. I'm pretty happy with Python though. It seems like Nim's benefits couldn't be that big. I consider Python "great", so the best Nim could be is "great-er", as a core language I mean. I've been rooting for Nim, but haven't actually tried it. And my use case is pretty small, I admit.” These are select few updates. More information on the Nim blog. Containers and Python are in demand, but Blockchain is all hype, says Skill Up developer survey Apple releases native SwiftUI framework with declarative syntax, live editing, and support of Xcode 11 beta Storm 2.0.0 releases with Java enabled architecture, new core and streams API, and more

The D Language front-end got finally merged into GNU Compiler Collection (GCC) 9, yesterday, as reported by Phoronix. The D language front-end is written in C++ and it supports the D 2.0 run-time and shared libraries. Iain Buclaw in his e-mail thread titled ‘Submission of D Front End’ says,  "The front-end is split into two parts. First being a standalone D language implementation that does the source file lexing, parsing and semantic analysis. Second being the binding layer that sits between GCC and the DMD front-end, doing the actual code generation.” Approval on the plan for merging D language front-end into GCC 9 According to a report by Phoronix, last year in June, the GCC Steering Committee had approved the plan of adding the D front-end. However, it took the project more than a year as a set of 13 patches of code, which is nearly 800k lines of code was worked upon and which had undergone revisions for getting the code in adequate shape for merging. Iain Buclaw from the GDC project took the initiative of posting these patches after carefully cleaning them up and also addressing the feedback he had received before. The patch series is available on GCC-patches. Updates on the future plan As per a report by Phoronix, Richard Biener of SUSE announced on 17th October that GCC's "stage 1" development will shift to "stage 3" on 11 November. It’s clear that the open feature development is over and the focus is now on bug-fixing. 6 January 2019 is the tentative date, to begin with the fixes. GCC 9.1, the initial GCC9 stable compiler release with GDC support is expected to be out around the end of the first quarter of 2019. Read more about this news on the official site of Phoronix. GCC 8.1 Standards released! What is a micro frontend? Frontend development with Bootstrap 4

Crystal is a general-purpose, object-oriented programming language with support from over 300 contributors. Last Friday, Crystal 0.27.0 was released. Language changes in Crystal 0.27.0 From Crystal 0.27.0, if the arguments of a method call need to be splitted across multiple lines, the comma must be put at the end of the line just before the line break. This is more in line with other conventional languages. Better handling of stack overflows A program entering an infinite recursion or running out of space in the stack memory is known as a stack overflow. Crystal 0.27.0 ships with a boundary check that allows a better error message on stack overflow. Concurrency and parallelism changes The next releases should start showing parallelism. There are some steps in preparation for that. The Boehm GC has API that enables support for multithreading environment in v7.6.x. From this version of Crystal, GC 7.6.8 or greater is used. As Crystal 0.26.1 was shipped with v7.4.10, the dependency needed to be updated first so that the CI can compile the compiler with the new GC API. Also, refactoring was done to separate the responsibilities of Fiber, Event, Scheduler, and EventLoop. Arithmetic symbols added In Crystal 0.27.0, arithmetic operators like &+, &-, &* were added. They are for additions, subtraction and multiplication with wrapping. In one of the next versions, the regular operators will raise on overflow. This will allow users to trust the result of the operations when reaching the limits of the representable range. Collection names changed In Indexable module and Hash, there are some breaking changes. The Indexable#at was replaced in favor of Indexable#fetch. The API between Indexable and Hash is now more aligned in the latest version. This includes ways to deal with default values in case of a missing key. If no default value is needed, the #[] method must be used. This is true even for Hash, since Hash#fetch(key) was dropped. Time changes There are breaking changes to support cleaner and more portable names. All references to “epoch” should now be replaced to “unix”. Also effectively, Time#epoch was renamed to Time#to_unix, #epoch_ms to #unix_ms, and #epoch_f to #to_unix_f. ISO calendar week numbers are now supported. Changing the time zone while maintaining the wall clock is also easy. File changes Working with temporal files and directories needed the Tempfile class. Now the creation of such files are handled by File.tempfile or File.tempname. This change also tidies up the usage of prefix, suffix and default temp path. Platform support There was an issue detected in Boehm GC regarding while running in Google Cloud because. The fix for this will be released in the next version of GC. Meanwhile, a patch is included in Crystal 0.27.0. There is some preparation for Windows support related to processes, forking, file handlers and arguments. Other fixes include fixing signals between forked processes, and dealing how IO on a TTY behaves in different environments. Networking changes HTTP::Server#bind_ssl was dropped since #bind_tls was introduced. It wasn’t removed to avoid a breaking change. The bindings for OpenSSL were updated to support v1.1.1. Compiler changes Support for annotations inside enums is added. Calling super will by default forward all the method arguments. Even if the call was expanded by macros in this version. When using splats argument the type of values can be restricted. This also goes for the whole Tuple or NamedTuple that is expected as splatted arguments. A bug was present when these restrictions were used, now fixed. For a complete list of changes, visit the Crystal changelog. WebAssembly – Trick or Treat? Mozilla shares plans to bring desktop applications, games to WebAssembly and make deeper inroads for the future web The D language front-end support finally merged into GCC 9

This Monday, Matthias Bussonnier, a core developer of the IPython and Jupyter Project team, announced the release of IPython 7.3. Along with some major bug fixes, this release comes with the %conda and %pip magics and compatibility with Python 3.8. The %conda and %pip magics IPython offers magic functions as an added enhancement on top of the Python syntax that is intended to solve common problems like data analysis using Python. The biggest update the team has introduced to this release is the implementation of the %conda and %pip magics. These magics will automatically install packages into the kernel that is currently running in an IPython or Jupyter notebook session. The %pip magic was already available, but it was limited to printing a warning and now, it will actually forward commands to pip. Users will still need to restart the interpreter or kernel for the newly installed packages to be taken into account. Though this update is great, users are recommended to use the conda/pip commands as their preferred way for installing. Bug fixes This release is compatible with Python 3.8, which comes with the addition of Assignment Expressions, better thread safety, and more. To opt out of shell variable expansion, the `@magic.no_var_expand` decorator is added to the execution magics. The behavior of the %reset magic has been changed by initializing the posix aliases `clear`, `less`, `more`, and `man` during a reset. IPython command line now will allow running *.ipynb files. To read more about the updates in IPython 7.3, check out its official announcement. IPython 7.2.0 is out! IPython 7.0 releases with AsyncIO Integration and new Async libraries PyPy 7.0 released for Python 2.7, 3.5, and 3.6 alpha

On behalf of the Python development community and the Python 3.9 release team, I’m pleased to announce the availability of Python 3.9.0. Python 3.9.0 is the newest feature release of the Python language, and it contains many new features and optimizations. You can find Python 3.9.0 here: https://www.python.org/downloads/release/python-390/ Most third-party distributors of Python should be making 3.9.0 packages available soon. See the “What’s New in Python 3.9” document for more information about features included in the 3.9 series. Detailed information about all changes made in 3.9.0 can be found in its change log. Maintenance releases for the 3.9 series will follow at regular bi-monthly intervals starting in late November of 2020. OK, boring! Where is Python 4? Not so fast! The next release after 3.9 will be 3.10. It will be an incremental improvement over 3.9, just as 3.9 was over 3.8, and so on. In fact, our newest Release Manager, Pablo Galindo Salgado, prepared the first alpha release of what will become 3.10.0 a year from now. You can check it out here: https://www.python.org/downloads/release/python-3100a1/ We hope you enjoy the new releases! Thanks to all of the many volunteers who help make Python Development and these releases possible! Please consider supporting our efforts by volunteering yourself or through organization contributions to the Python Software Foundation. https://www.python.org/psf/ More resources Online Documentation PEP 596, 3.9 Release Schedule PEP 619, 3.10 Release Schedule Report bugs at https://bugs.python.org. Help fund Python and its community. Your friendly release team, Ned Deily @nad Steve Dower @steve.dower Pablo Galindo Salgado @pablogsal Łukasz Langa @ambv  

Python 3.5.10rc1 is now available. You can download it here.