Tech News - Programming

With JDK 11 reaching general availability next week, there is also a proposed schedule released for JDK 12. The proposed schedule indicates a final release in March 2019 along with two JDK Enhancement Proposals (JEPs) proposed for JDK 12. Mark Reinhold, Chief Architect of the Java Platform Group at Oracle, made an announcement in a mail posted to the OpenJDK mailing list. Per the mail, JDK 12 should be out to the public on March 19, 2019. The proposed schedule for JDK 12 will be as follows: 13th December 2018 Rampdown Phase One 17th January 2019 Rampdown Phase Two 31st January 2019 Release-Candidate Phase 19th March 2019 General Availability JDK 11 had a total of 17 JEPs contributed out of which three were from the community, the highest number in any JDK release. The other 14 were from Oracle according to a tweet by @bellsoftware. For JDK 12, there are two JEPs integrated which will be available as a preview language feature and four candidate JEPs. JDK 12 preview features JEP 325: Switch Expressions (Preview) This JEP is going to allow the switch statement to be used as both statements and as an expression. Both forms can use either a “traditional” or “simplified” scoping and control flow behavior. The changes to the switch statement will simplify everyday coding. It will also pave the way for the use of pattern matching in switch. JEP 326: Raw String Literals (Preview) This JEP adds raw string literals to Java. A raw string literal can span many source code lines. It does not interpret escape sequences, such as \n, or Unicode escapes, of the form \uXXXX. This does not introduce any new String operators. There will be no change in the interpretation of traditional string literals. JDK 12 JEP candidates JEP 343: Packaging Tool To create a new tool based on the JavaFX javapackager tool for packaging self-contained Java applications. JEP 342: Limit Speculative Execution To help both developers and deployers to defend against speculative-execution vulnerabilities. This is to be done by providing a means to limit speculative execution and not a complete defense against all forms of speculative execution. JEP 340: One AArch64 Port, Not Two Remove all arm64 port related sources while retaining the 32-bit ARM port and the 64-bit AArch64 port. This will help focus on a single 64-bit ARM implementation and eliminate duplicate work to maintain two ports. JEP 341: Default CDS Archives Enhance the JDK build process to generate a class data-sharing (CDS) archive by using the default class list, on 64-bit platforms. The goal is to improve out-of-the-box startup time and eliminating the need for users to run -Xshare:dump to benefit from CDS. To know more details on the proposed schedule for JDK 12, visit the OpenJDK website. JEP 325: Revamped switch statements that can also be expressions proposed for Java 12 Mark Reinhold on the evolution of Java platform and OpenJDK No more free Java SE 8 updates for commercial use after January 2019

Earlier this month, Uber open-sourced Pelton, a unified resource scheduler that manages resources across distinct workloads. Pelton, first introduced in November last year, is built on top of Mesos. “By allowing others in the cluster management community to leverage unified schedulers and workload co-location, Peloton will open the door for more efficient resource utilization and management across the community”, states the Uber team. Peloton is designed for web-scale companies such as Uber that consist of millions of containers and tens of thousands of nodes. Peloton comes with advanced resource management capabilities such as elastic resource sharing, hierarchical max-min fairness, resource overcommits, and workload preemption. Peloton uses Mesos to aggregate resources from different hosts and then further launch tasks as Docker containers. Peloton also makes use of hierarchical resource pools to manage elastic and cluster-wide resources more efficiently. Before Peloton was released, each workload at Uber comprised its own cluster which resulted in various inefficiencies. However, with Peloton, mixed workloads can be colocated in shared clusters for better resource utilization. Peloton feature highlights Elastic Resource Sharing: Peloton supports hierarchical resource pools that help elastically share resources among different teams. Resource Overcommit and Task Preemption: Peloton helps with improving cluster utilization by scheduling workloads that use slack resources. Optimized for Big Data Workloads:  Support has been provided for advanced Apache Spark features such as dynamic resource allocation. Optimized for Machine Learning: There is support provided for GPU and Gang scheduling for TensorFlow and Horovod. High Scalability: Users can scale to millions of containers and tens of thousands of nodes. “Open sourcing Peloton will enable greater industry collaboration and open up the software to feedback and contributions from industry engineers, independent developers, and academics across the world”, states the Uber team. Uber and Lyft drivers strike in Los Angeles Uber and GM Cruise are open sourcing their Automation Visualization Systems Uber releases Ludwig, an open source AI toolkit that simplifies training deep learning models for non-experts

Saturday was the ninth anniversary of the day when the Go team open-sourced the initial sketch of Golang. On each anniversary they list what has happened over the past year for Go. Golang adoption indicated in surveys In 2018 Go users expressed in multiple surveys about their happiness with using Go. Many developers who do not use Golang currently also indicated their intent to learn Go before any other language. In the Stack Overflow 2018 Developer Survey, Golang was in the top 5 most loved and top 3 most wanted languages. This indicated that developers using Go like it, and developers not using Go want to. ActiveState’s 2018 Developer Survey had Go topping the charts with 36% of users responding with “Extremely Satisfied” using Go and 61% of the users responded with “Very Satisfied” or better. While the JetBrains’s 2018 Developer Survey awarded Go the “Most promising language” with 12% of respondents using Go today and 16% with the intention to use Go in the future. Also in the HackerRank 2018 Developer Survey, 38% developer responses indicated that were intending to learn Go next. The evolution of the Golang community The first Go conferences and Go meetups were held five years ago. Since then, there has been major growth in community leadership. Now there are more than 20 Go conferences and over 300 Go-related meetups across the world. There have also been hundreds of great talks in 2018. The Go code of conduct has been revised to better support inclusivity in the Go community. Go 2 After five years since Go 1, the Go core team is looking into changes to support the language at scale. A draft design for Go modules was published in August, which included ideas to better support error values, error handling, and generic programming. And the most recent release, Golang 1.11, included preliminary support for modules. Golang contributors There has been an increasing number of contributors for Go through the years. In Q2 2018, a milestone was hit when for the first time, the contributions from the community were more than that of the Go team. For more details, visit the Go Blog. Go 2 design drafts include plans for better error handling and generics Why Golang is the fastest growing language on GitHub Golang 1.11 is here with modules and experimental WebAssembly port among other updates

Last week, Wednesday marked the first major milestone for Fyne, which is a cross-platform GUI written in Go. Fyne 1.0 uses OpenGL to provide cross-platform graphics and the entire toolkit is developed using scalable graphics. The Fyne toolkit communicates with operating system graphics using OpenGL, which is supported on almost all desktop and laptop systems. To do this, it relies on the built-in functionality of Cgo, the C language bridge for Go. For packaging, it uses fyne package command to generate and package all the required metadata for an application to distribute on macOS, Linux, or Windows. By default, it will build an application bundle for the current platform, which can be used in part of a cross-compilation workflow. What’s new in Fyne 1.0? Canvas API (rect, line, circle, text, image) Widget API (box, button, check, entry, form, group, hyperlink, icon, label, progress bar, radio, scroller, tabs, and toolbar) Light and dark themes Pointer, key and shortcut APIs (generic and desktop extension) OpenGL driver for Linux, macOS, and Windows Tools for embedding data and packaging releases Currently, the release only supports desktop applications. For more info, read Fyne’s blog. You may also check out Hands-On GUI Application Development in Go to learn more about Go programming. Introducing Web High-Level Shading Language (WHLSL): A graphics shading language for WebGPU State of Go February 2019 – Golang developments report for this month released Golang just celebrated its ninth anniversary

On August 22, the JetBrains team announced the release of Kotlin 1.3.50. Some of the major improvements in this Kotlin version include a preview of the new Duration and Time Measurement API in the standard library, using Dukat for the experimental generation of external declarations for npm dependencies in Gradle Kotlin/JS projects, a separate plugin for debugging Kotlin/Native code in IntelliJ IDEA Ultimate, and much more. The team has also worked on improving Java-to-Kotlin converter and on Java compilation support in multi-platform projects. Let us have a look at these improvements in brief. Major improvements in Kotlin 1.3.50 Changes in the standard library Experimental preview of duration and time measurement API A new duration and time measurement API is available for preview. The researchers say that if the API expects the duration stored as primitive value like Long, one can erroneously pass the value in the wrong unit, and unfortunately, the type system doesn’t help prevent that. Hence, the team created a regular class to store duration solves this problem. However, this brings another problem, i.e., additional allocations. Now the API can use the Duration type, and all the clients will need to specify the time in the desired units explicitly. This release brings support for MonoClock which represents the monotonic clock, which doesn’t depend on the system time. The monotonic clock can only measure the time difference between given time points, but doesn’t know the “current time.” The Clock interface provides a general API for measuring time intervals. MonoClock is an object implementing Clock; it provides the default source of monotonic time on different platforms. When using the Clock interface, the user explicitly marks the time of action start, and later the time elapsed from the start point. It is especially convenient if one wants to start and finish measuring time from different functions. To know more about this feature in detail, read Kotlin/KEEP on GitHub. Experimental API for bit manipulation The standard library now contains an experimental API for bit manipulation. Similar extension functions for Int, Long, Short, Byte, and their unsigned counterparts have also been added. IntelliJ IDEA support in Kotlin 1.3.50 Improvements in Java to Kotlin converter This release includes a preview of Java to Kotlin converter to minimize the amount of “red code” one has to fix manually after the conversion. This improved version of the converter tries to infer nullability more correctly based on the Java type usages in the code. The goal is to decrease the number of compilation errors and to make the produced Kotlin code more convenient to use. The new converter fixes many other known bugs, too; for instance, it now correctly handles implicit Java type casts. This new converter may become the default one in the future. To turn it on, specify the Use New J2K (experimental) flag in settings. Debugging improvements In Kotlin 1.3.50, the team has improved how the Kotlin “Variables” view chooses variables to display. As there’s a lot of additional technical information in the bytecode, the Kotlin “Variables” view highlights only the relevant variables. Local variables inside the lambda, as well as captured variables from the outer context and parameters of the outer function, are correctly displayed: Source: jetbrains.com Kotlin 1.3.50 also adds improved support for the “Evaluate expression” functionality in the debugger for many non-trivial language features, such as local extension functions or accessors of member extension properties. Users can now modify variables via “Evaluate expression”: Source: jetbrains.com Added new intentions and inspections This release includes the addition of new intentions and inspections. One of the goals of intentions is to help users learn how to write idiomatic Kotlin code. The following intention, for instance, suggests using the indices property rather than building a range of indices manually: Source: jetbrains.com Updates to Kotlin/JS Kotlin 1.3.50 adds support for building and running Kotlin/JS Gradle projects using the org.jetbrains.kotlin.js plugin on Windows. Users can now build and run projects using Gradle tasks, dependencies from NPM required in the Gradle configuration are resolved and included. Users can also try out their applications using webpack-dev-server and much more. The team has also added performance improvements for Kotlin/JS by improving the incremental compilation time for projects. With this users expect speedups of up to 30% when compared to 1.3.41. This version also shows an improved integration with NPM, which means that projects are now resolved lazily and in parallel, and support for projects with transitive dependencies between compilations in the same project has been added. Kotlin 1.3.50 also brings changes in the structure and naming of generated artifacts. Generated artifacts are now bundled in the distributions folder, and they include the version number of the project and archiveBaseName (which defaults to the project name), e.g. projectName-1.0-SNAPSHOT.js. Using Dukat for automatic conversion of TypeScript declaration files Dukat allows the automatic conversion of TypeScript declaration files (.d.ts) into Kotlin external declarations. This makes it more comfortable to use libraries from the JavaScript ecosystem in a type-safe manner in Kotlin, thus, reducing the need for manually writing wrappers for JS libraries. Kotlin/JS now ships with experimental support for Dukat integration for Gradle projects. With this integration, by running the build task in Gradle, typesafe wrappers are automatically generated for npm dependencies and can be used from Kotlin. As Dukat is still in a very early stage, its integration is disabled by default. The team has prepared an example project, which demonstrates the use of dukat in Kotlin/JS projects. Updates to Kotlin/ Native Previously, the version of Kotlin/Native differed from the version of Kotlin. However, in this version, schemes for Kotlin and Kotlin/Native are now aligned. This release uses version 1.3.50 for both Kotlin and Kotlin/Native binaries, reducing the complexity. This release brings more pre-imported Apple frameworks for all platforms, including macOS and iOS. The Kotlin/Native compiler now includes actual bitcode in produced frameworks. Several performance improvements have also made in the interop tool. The team has also announced that Null-check optimizations have been planned for Kotlin 1.4. Starting from Kotlin 1.4, "all runtime null checks will throw a java.lang.NullPointerException instead of a KotlinNullPointerException, IllegalStateException, IllegalArgumentException, and TypeCastException. This applies to: the !! operator, parameter null checks in the method preamble, platform-typed expression null checks, and the as operator with a non-null type. This doesn’t apply to lateinit null checks and explicit library function calls like checkNotNull or requireNotNull." Apart from the changes mentioned, Java compilation can now be included in Kotlin/JVM targets of a multiplatform project by calling the newly added withJava() function of the DSL. This release also adds multiple features and improvements in scripting and REPL support. To know more about these changes and other changes in detail, read Kotlin 1.3.50 official blog post. Introducing Coil, an open-source Android image loading library backed by Kotlin Coroutines Introducing Kweb: A Kotlin library for building rich web applications How to avoid NullPointerExceptions in Kotlin [Video]

Yesterday, the team at Kubernetes released Kubernetes 1.14, a new update to the popular open-source container orchestration system. Kubernetes 1.14 comes with support for Windows nodes, kubectl plugin mechanism, Kustomize integration, and much more. https://twitter.com/spiffxp/status/1110319044249309184 What’s new in Kubernetes 1.14? Support for Windows Nodes This release comes with added support for Windows nodes as worker nodes. Kubernetes now schedules Windows containers and enables a vast ecosystem of Windows applications. With this release, enterprises with investments can easily manage their workloads and operational efficiencies across their deployments, regardless of the operating systems. Kustomize integration With this release, the declarative resource config authoring capabilities of kustomize are now available in kubectl through the -k flag. Kustomize helps the users in authoring and reusing resource config using Kubernetes native concepts. kubectl plugin mechanism This release comes with kubectl plugin mechanism that allows developers to publish their own custom kubectl subcommands in the form of standalone binaries. PID Administrators can now provide pod-to-pod PID (Process IDs) isolation by defaulting the number of PIDs per pod. Pod priority and preemption in this release enables Kubernetes scheduler to schedule important pods first and remove the less important pods to create room for more important ones. Users are generally happy and excited about this release. https://twitter.com/fabriziopandini/status/1110284805411872768 A user commented on HackerNews, “The inclusion of Kustomize[1] into kubectl is a big step forward for the K8s ecosystem as it provides a native solution for application configuration. Once you really grok the pattern of using overlays and patches, it starts to feel like a pattern that you'll want to use everywhere” To know more about this release in detail, check out Kubernetes’ official announcement. RedHat’s OperatorHub.io makes it easier for Kuberenetes developers and admins to find pre-tested ‘Operators’ for applications Microsoft open sources ‘Accessibility Insights for Web’, a chrome extension to help web developers fix their accessibility issues Microsoft open sources the Windows Calculator code on GitHub  

The Qt team released Qt Design Studio 1.0 yesterday. Qt Design Studio 1.0 explores features such as Qt photoshop bridge, timeline-based animations, and Qt live preview among other features. Qt Design Studio is a UI design and development environment which allows designers and developers around the world to rapidly prototype as well as develop complex and scalable UIs. Let’s discuss the features of Qt Design Studio 1.0 in detail. Qt Photoshop Bridge Qt Design Studio 1.0 comes with Qt photoshop bridge that allows users to import their graphics design from photoshop. Users can also create re-usable components directly via Photoshop. Moreover, exporting directly to specific QML types is also allowed. Other than that, Qt photoshop Bridge comes with an enhanced import dialog as well as basic merging capabilities. Timeline-based animations Timeline-based animations in Qt Design Studio 1.0 come with a timeline-/keyframe-based editor. This editor allows designers to easily create pixel-perfect animations without having to write a single line of code. You can also map and organize the relationship between timelines and states to create smooth transitions from state to state. Moreover, selecting multiple keyframes is also enabled. Qt Live Preview Qt Live Preview lets you run and preview your application or UI directly on the desktop, Android devices, as well as the Boot2Qt devices. You can also see how your changes affect the UI live on your target device. Moreover, it also comprises a zoom in and out functionality. Other Features You can insert a 3D studio element to preview it on the end target dice with the Qt Live Preview. There’s a Qt Safe Renderer integration that uses Safe Renderer items and also map them in your UI. You can use states and timeline for the creation of screen flows and transitions. Qt Design Studio is free, however, you will need a commercial Qt developer license to distribute the UIs created with Qt Design Studio. For more information, check out the official Qt Design Studio blog. Qt 3D Studio 2.1 released with new sub-presentations, scene preview, and runtime improvements Qt creator 4.8 beta released, adds language server protocol Qt Creator 4.7.0 releases!

Flask is a Python microframework that has been around for a while. It was first released in April 2010; 8 years on, it finally reaches its first stable release. While this is perhaps the first major release, the framework is the most popular Python web framework on GitHub. Not bad for a framework that started life as an April fool's joke. In truth, Flask has been 'stable' for some time, even if it wasn't officially. However, the announcement of Flask 1.0 is important, as it brings with it a few key changes that might be instrumental in growing the community. What's new in Flask 1.0? More flexible CLI. In the release notes, the team explains: "FLASK_APP can point to an app factory, optionally with arguments. It understands import names in more cases where filenames were previously used. It automatically detects common filenames, app names, and factory names. FLASK_ENV describes the environment the app is running in, like development, and replaces FLASK_DEBUG in most cases." Flask can now handle concurrent requests in development. You can test an application's CLI commands with test_cli_runner. Improvements to documentation. In what is sure to improve the number of Flask users, the team have made changes to the documentation available. This represents a step towards more structure and control within the project. The team have app.logger. They write that it "has been greatly simplified and should be much easier to customize. The logger is always named flask.app, it only adds a handler if none are registered, and it never removes existing handlers." There many more updates and improvements. You can read about them in detail here. As you'll see many of the updates are around simplicity, and making Flask more accessible to new users. As Python continues to grow in popularity, it wouldn't be surprising to see Flask do the same with this new release. It might mark a new chapter in the development of the project, but it's a necessary step that will be important in maintaining the project for the future. Read more on Flask Python Web Development Frameworks: Django or Flask? Read here.

After the release of Java Development Kit 10 in March this year, Oracle is all set to release JDK 11. Expected in September 2018 as part of Oracle’s new six-month release cadence for the standard edition of Java, Version 11 has just a handful of features announced so far. JDK 11 is set to be a long-term support unlike JDK 10, hence it will be a reference implementation of Java Platform, Standard Edition (Java SE) 11. JDK 11 is set to receive premier-level support from Oracle until September 2023 and extended support, featuring patches and security alerts, until 2026. Java 11 is also set to lose some capabilities as the support for CORBA, Java EE, and JavaFX will be removed. For now, JDK 11 is set to have four new features, although more are expected later. This post summarizes some details about each of the four JEPs (JDK Enhancement Proposal) currently targeted for JDK 11. Epsilon: An Arbitrarily Low-Overhead Garbage Collector The Epsilon garbage collector, billed as a “no-op” collector, will handle memory allocation without implementing any actual memory reclamation mechanisms. Epsilon’s use cases include testing for performance, memory pressure, and the virtual machine interface. It also could be used for short-lived jobs. Local-Variable Syntax for Lambda Parameters A local-variable syntax for lambda parameters aims to achieve one goal which is to allow var reserved word to be used to declare the formal parameters of an implicitly typed lambda expression. Dynamic Class-File Constants The Java class-file format will be extended to support a new constant pool form, CONSTANT_Dynamic. The goal is to reduce the cost and disruption of developing new forms of materializable class-file constraints. Remove the Java EE and CORBA Modules The Java EE and CORBA modules were deprecated in Java SE 9, with the intent to remove them in a later release—that is now set to be JDK 11. Changes under consideration for Java JDK 11 The builders of Java 11 are also looking at several proposed changes or additions to JDK 11: Adding raw string literals to Java This would make it easier to express character sequences in a readable form, with no Java indicators. It also would make it simpler to supply strings targeted for grammar syntaxes other than Java, as well as supply strings spanning several lines of source code without supplying special indicators. Extending the switch statement This functionality can be used as either a statement or an expression. This also would improve how switch handles nulls. These changes would simplify coding and prepare for pattern matching in switch. Nest-based access control This is a context that aligns with the current notion of nested types in Java. Nests allow classes that are logically part of the same code entity but compiled to distinct class files to access each other’s private members without needing compilers to insert accessibility-broadening bridge methods. To know more about Java 11 JDK read Oracle’s official blog. Read Next 26 new Java 9 enhancements you will love How to recognize Patterns with Neural Networks in Java How to create a standard Java HTTP Client in ElasticSearch

Adding to the list of Python-like programming languages is Coconut that allows developers write simple and elegant functional code, while using the familiar Python environment and libraries. It is basically a superset of Python that adds on top of Python syntax and is inspired by programming languages like Haskell, CoffeeScript, F#, and patterns.py. The language is written by Evan Hubinger, an undergraduate student studying mathematics and computer science at Harvey Mudd College. Why Coconut was developed? Writing functional programs in Python can be challenging at times. While Python does allow developers to write high-order functions, it lacks concise syntax for lambdas, boilerplate-less pattern matching, etc. One Hacker News user mentioned, “It's capable of functional programming in the sense that functions are first class values that you can pass around, but it is infamously hostile to functional programming. For example, Python still doesn't have multiline lambdas, and the justifications for why always boil down to it being "unpythonic".” This is what Coconut tries to solve by bringing tools of modern functional programming. It provides a clean -> operator replacing Python’s lambda statements. It supports pipeline-style programming, partial application, pattern-matching, destructuring assignment, parallel programming, and more. To provide optional static type-checking you can integrate Coconut with MyPy, which is an optional static type checker for Python. But, it is not purely functional that allows programmers to choose whatever programming style they are comfortable with. As it is a variant of Python, developers who have experience in working on Python will not have much difficulty in learning it. Coconut code are compiled to Python code. Developers can access the Coconut compiler through its command-line utility, which also comes with an interpreter to enable real-time compilation. Additionally, it also supports the use of IPython/Jupyter notebooks. What are the Python version it supports? It supports these Python versions: >= 2.6 on the 2.x branch or >= 3.2 on the 3.x branch. To make Coconut built-ins universal across Python versions, it automatically overwrites Python 2 built-ins with their Python 3 counterparts. It also overwrites some Python 3 built-ins for optimization and enhancement purposes. If developers want to access the original Python versions of any overwritten built-ins, they can retrieve the old built-in by prefixing them with py_. pandas will drop support for Python 2 this month with pandas 0.24 Qt for Python 5.12 released with PySide2, Qt GUI and more Google researchers introduce JAX: A TensorFlow-like framework for generating high-performance code from Python and NumPy machine learning programs

Mastodon 2.5 is here, a social network often viewed as an alternative to Twitter. The 100th version of the social network has a variety of software improvements in UI, media and a bunch of fixes including security and performance fixes. UI changes in Mastodon 2.5 The web interface in Mastodon 2.5 has been redesigned for public areas. The design and color scheme is now more consistent when logged in to your account. A better use of space is made with a new profile layout with prominent follow buttons for new users. The public pages now display reply, favorite and boost buttons. The actions can open a remote interaction dialogue. You can interact with the dialogue from your home server and interact with the toot from your account. This is a simpler approach than the previous approach where users had to copy paste permalink to the server’s search bar. You can also choose to feature specific people you follow, on your profile. They can be displayed randomly or as a recommendation to your profile visitors. The count of replies to toots is now displayed enabling you to know if a question has been already answered or if a discussion is happening. Mastodon 2.5 now also accepts MOV video files from iOS, and other large video files. It also has better image resizing. Admin and deployment changes For admins who moderate Mastodon servers, a new dashboard is available providing an overview of important information like weekly sign-up and activity numbers. The e-mail notifications generated from reports have been cut down and report notifications can be disabled for your account now. Suspending users now has a confirmation screen where you can type the name of the account you want to suspend. The temporary lock-out is now reversible and works as an alternative to suspensions. For admins who run Mastodon servers, the database schema has been changed to reduce disk write operations and CPU load of PostgreSQL. For scaling, there is support for red-replicas baked into the software, you only need to change the configuration. There is also a new command-line interface for making it easy Terminal easy to use These were a select few updates. For a full list of changes, take a look at the changelog. PrimeTek releases PrimeReact 2.0.0 Beta 3 version Babel 7 released with Typescript and JSX fragment support Node.js announces security updates for all their active release lines for August 2018

Dart 2.1, an increment over Dart 2 is released with changes for performance and usability. New features in Dart 2.1 include smaller code size, faster type checks, better usability for type errors, and new language features to improve productivity. Support for int-to-double conversion in Dart 2.1 Developers new to Flutter often face obstacles in the form of analysis errors when specifying padding, setting font sizes, etc. These errors make sense from a system point of view. For example, the API expects a type say, a double, and the developer specifies the value in a different type say, an int. From a usability point of view, it seems foolish as there is a trivial conversion from int to double. So, Dart 2.1 now infers the line where applicable and silently evaluates an int as a double. Language support for mixins in Dart 2.1 Dart 2.1 comes with a new syntax for mixins. It features a new mixin keyword that can be used to define classes which can exclusively be used as mixins. Support is also added so that mixins can extend other classes and invoke methods in their superclass. Previously, mixins could only extend Object. An example of extending non-Object classes is from Flutter’s animation APIs. The SingleTickerProviderStateMixin which is a framework class that provides a ticker for advancing an animation by a single frame declares a mixin that implements the general TickerProvider interface. The animations are applicable only to stateful widgets since the position in the animation is considered state. The new mixin support in Dart 2.1 allows expressing this by declaring that only classes that extend the Flutter State class can use the mixin. Compile-time type checks The type system in Dart 2 protects users during development, indicating violations of the contract specified by the types. Such checks at edit time were added in Dart 2 powered by the Dart Analyzer. There is another place where developers might expect type checks. Like compile time, when performing a Flutter release build. Such checks were incomplete in Dart 2, which potentially leading to usability issues where bad source code could compile without errors. In Dart 2.1, these checks are complete. Now, the Analyzer and Dart compiler both contain the same checks. Performance improvements for Flutter developers In a few cases, though, the comprehensive checks in Dart 2 caused undesirable overheads of 20–40%. Dart 2.1 has greatly reduced cost of type checks. This is applicable to both, AOT-compiled code and code run in the VM with JIT compilation. The developer tools which run using the VM, benefit from this. Performing code analysis of one large benchmark app used to take about 41 seconds, it now takes only around 25 seconds. Performance improvements for web developers The code size and compile time is also improved for Dart code running on the web. The output size of dart2js were in focus. This yielded good results, such as a 17% reduction in minified output size and a 15% improvement in compilation time in one of the tested samples. Other changes There are also some changes made outside the core Dart SDK. One is protocol buffers (protobuf) which are a platform-neutral mechanism for serializing structured data. Dart is now an officially protobuf supported language. They have created a small sample for knative—a platform based on Kubernetes for building, deploying, and managing serverless workloads. For more details, visit the Dart Blog post. Google’s Dart hits version 2.0 with major changes for developers C# 8.0 to have async streams, recursive patterns and more Golang just celebrated its ninth anniversary

Michael Thomsen, the Project Manager for Dart announced the stable release of the general purpose programming language, Dart 2.2. This version, which is an incremental update to v2, offers improved performance of ahead-of-time (AOT) compiled native code and a new set literal language feature. Improvements in Dart 2.2 Improved AOT performance Developers have worked on improving the AOT performance by 11–16% on microbenchmarks (at the cost of a ~1% increase in code size). Prior to this optimization, developers had to make several lookups to an object pool to determine the destination address. However, the optimized AOT code is now able to call the destination directly using a PC-relative call. Extended Literals to support sets Dart supported the literal syntax only for Lists and Maps, which caused difficulties in initializing Sets as it had to be initialized via a list as follows: Set<String> currencies = Set.of(['EUR', 'USD', 'JPY']); This code proved to be inefficient due to the lack of literal support and also made currencies a compile-time constant. With Dart 2.2’s extension of literals to support sets, users can initialize a set and make it const using a convenient new syntax: const Set<String> currencies = {'EUR', 'USD', 'JPY'}; Updated Dart language Specification Dart 2.2 includes the up-to-date ‘Dart language specification’ with the spec source moved to a new language repository. Developers have also added continuous integration to ensure a rolling draft specification is generated in PDF format as and when the specification for future versions of the Dart language evolves. Both the 2.2 version and rolling Dart 2.x specifications are available on the Dart specification page. To know more about this announcement in detail, visit Michael Thomsen’s blog on Medium. Google Dart 2.1 released with improved performance and usability Google’s Dart hits version 2.0 with major changes for developers Is Dart programming dead already?  

Yesterday, the team behind Rust announced the release of Rust 1.36.0. This release brings a stabilized 'Future' trait, NLL for Rust 2015, stabilized Alloc crate as the core allocation and collections library, a new --offline flag for Cargo, and more. Following are some of the updates in Rust 1.36.0: The stabilized 'Future' trait A ‘Future’ in Rust represents an asynchronous value that allows a thread to continue doing useful work while it waits for the value to become available. This trait has been long-awaited by Rust developers and with this release, it has been finally stabilized. “With this stabilization, we hope to give important crates, libraries, and the ecosystem time to prepare for async / .await, which we'll tell you more about in the future,” the Rust release team added. The alloc crate is stable The ‘std’ crate of the standard library provides types like Box<T> and OS functionality. But, the problem is it requires a global allocator and other OS capabilities. Beginning with Rust 1.36.0, the parts of std that are dependent on a global allocator will now be available in the ‘alloc’ crate and std will re-export these parts later. Use MaybeUninit<T> instead of mem::uninitialized Previously, the ‘mem::uninitialized’ function allowed you to bypass Rust’s memory-initialization checks by pretending to generate a value of type T without doing anything. Though the function has proven handy while lazily allocating arrays, it can be dangerous in many other scenarios as the Rust compiler just assumes that values are properly initialized. In Rust 1.36.0, the MaybeUninit<T> type has been stabilized to solve this problem. Now, the Rust compiler will understand that it should not assume that a MaybeUninit<T> is a properly initialized T. This will enable you to do gradual initialization more safely and eventually use ‘.assume_init()’. Non-lexical lifetimes (NLL) for Rust 2015 The Rust team introduced NLL in December last year when announcing Rust 1.31.0. It is an improvement to Rust’s static model of lifetimes to make the borrow checker smarter and more user-friendly. When it was first announced, it was only stabilized for Rust 2018. Now the team has backported it to Rust 2015 as well. In the future, we can expect all Rust editions to use NLL. --offline support in Cargo Previously, the Rust package manager, Cargo used to exit with an error if it needed to access the network and the network was not available. Rust 1.36.0 comes with a new flag called ‘--offline’ that makes the dependency resolution algorithm to only use locally cached dependencies, even if there might be a newer version. These were some of the updates in Rust 1.36.0. Read the official announcement to know more in detail. Introducing Vector, a high-performance data router, written in Rust Brave ad-blocker gives 69x better performance with its new engine written in Rust Introducing PyOxidizer, an open source utility for producing standalone Python applications, written in Rust

On Tuesday, the GitHub team announced that they will be making life easy for developers by getting Git right into our editor. The insights on this extension will be announced on Day 2 (17th October, 2019) of the two-day GitHub Universe conference. GitHub, in collaboration with the Visual Studio Code Team at Microsoft will brief users about this update during their talk Cross Company Collaboration: Extending GitHub to a New IDE. Sarah Guthals, the Engineering Manager at GitHub in her post mentions, “We’ve been working since 2015 to provide a GitHub experience that meets you where you spend the majority of your time: in your editor.” What’s in store for developers from different communities? For .NET developers In 2015, GitHub brought all Visual Studio developers an extension that supports GitHub.com and GitHub Enterprise engagements within the editor. Sarah says, “today you can complete an entire pull request review without ever leaving Visual Studio.” For the Atom community GitHub also support a first class Git and GitHub experience for Atom developers. Users can now access basic Git operations like staging, commiting, and syncing, alongside more complex collaboration with the recently-released pull request experience. For game developers Unity game developers can now use Git within Unity for the first time to clone and sync with GitHub.com and lock files. The Conflux : GitHub and Visual Studio Code In the talk which will be presented in the coming week, Visual Studio Code team at Microsoft and the editor tools team at GitHub will share their experience on how both these teams began exploring the possibility of an integration between their two products. The team at Microsoft started to design a pull request experience within Visual Studio Code, while the GitHub team prototyped one modeled after the same experience in the Visual Studio IDE. This brought users an integrated GitHub experience in Visual Studio Code supported by the Visual Studio Code API. This new extension gives developers the ability to: Authenticate with GitHub within VS Code (for GitHub.com and GitHub Enterprise) List pull requests associated with your current repository, view their description, and browse the diffs of changed files Validate pull requests by checking them out and testing them without having to leave VS Code GitHub applies machine intelligence to its GitHub security alerts Github also announced that it has built a machine learning model that can scan text associated with public commits (the commit message and linked issues or pull requests) to filter out those related to possible security upgrades. With such smaller batch of commits, the model uses the diff to understand how required version ranges have changed. Further, it aggregates across a specific timeframe to get a holistic view of all dependencies that a security release might affect. Finally, the model outputs a list of packages and version ranges it thinks require an alert and currently aren’t covered by any known CVE in their system. To know more about these updates, visit the GitHub blog. Also know more about GitHub and Visual Studio Code integration in Sarah Guthals’ GitHub post. GitHub’s new integration for Jira Software Cloud aims to provide teams a seamless project management experience 4 myths about Git and GitHub you should know about 7 tips for using Git and GitHub the right way