Tech News - Languages

In 2016, Apache decided to start integrating GitHub’s repository and tooling with their own services. After working on the integration over the years, they made a move towards simplifying how they work and move all Git projects to GitHub. By February, this year, Apache completed the migration to GitHub and enabled all the projects with a simple platform to host and review code, collaborate on projects, and build software alongside developers around the world. Greg Stein, ASF Infrastructure Administrator, said, "In 2016, the Foundation started integrating GitHub's repository and tooling, with our own services. This enabled selected projects to use GitHub's excellent tools. Over time, we improved, debugged, and solidified this integration. In late 2018, we asked all projects to move away from our internal git service, to that provided by GitHub. This shift brought all of their tooling to our projects, while we maintain a backup mirror on our infrastructure." Yesterday, Apache Software Foundation (ASF) finally joined the GitHub open source community. Apache Software Foundation has about 200M+ lines of code that are managed by an all-volunteer community of 730 individuals. Nat Friedman, Chief Executive Officer of GitHub, said on this announcement, "We're proud to have such a long standing member of the Open Source community migrate to GitHub. Whether we're working with individual Open Source maintainers and contributors or some of the world's largest Open Source foundations like Apache, GitHub's mission is to be the home for all developers by supporting Open Source communities, addressing their unique needs, and helping Open Source projects thrive." Initially, Apache projects had two version control services, Apache Subversion and Git. As the number of projects increased, ASF communities wanted to see their source code available on GitHub because the codes were read-only mirrors. Also, the ability to use the GitHub tools around those repositories was very limited. This made Apache take the decision to join GitHub. Greg Stein further added, "We continue to experiment and expand the set of services that GitHub can provide to our communities, given our own needs and requirements. The Foundation has started working closely with GitHub management to explore ways to make this happen, and what will be possible in the future." Many users think that the reason for Apache to migrate to GitHub was the increasing cost of managing the code and infrastructure. A user commented on HackerNews, “Apparently, one of the big motivating reasons for this was "cost". The foundation’s 2018 five-year strategic plan noted that infrastructure services account for more than 80 percent of the total ASF expense budget, adding: Increasingly, project communities have infrastructure requirements that strain the capabilities of the ASF. The report noted that, given burgeoning costs, encouraging the use of more externally provided services was its best option.” Another comment reads, “Holy shit, they're spending $800k a year on infrastructure! Honestly, it's difficult to understand why they haven't sooner moved to GitHub, or even GitLab or the like - it feels reckless. That money could be put to far greater use - as an Apache supporter who hasn't ever felt the need to look at their costs, I have to say that I'm very disappointed.” To know more about this news, check out Apache’s blog post. Microsoft and GitHub employees come together to stand with the 996.ICU repository ‘Developers’ lives matter’: Chinese developers protest over the “996 work schedule” on GitHub GitHub releases Vulcanizer, a new Golang Library for operating Elasticsearch    

In a blog post, the ESLint team talks about the future of ESLint on TypeScript. Earlier, the TypeScript team talked about their future and including ESLint into their repository to improve compatibility between the two. Based on the feedback from the TypeScript community, it was discovered that the linting experience was not that good in TypeScript. They then announced support for both ESLint and TSLint. The former worked well with TypeScript while TSLint would cause duplicate work and induce some breaking changes. Also, some lint rules were not present in TSLint. Hence the focus has been on incorporating ESLint. Many members from the ESLint team have been working to improve its compatibility with TypeScript. The focus of this earlier work was on the TypeScript parser and typescript-eslint-parser. Other than that there were efforts also on eslint-plugin-typescript which was maintained by individual team members. The Typescript parser will become an important part in the integration of the two and the ESLint teams want to ensure its proper maintenance. The typescript-eslint project A key contributor working on ESLint compatibility in TypeScript, James Henry started the typescript-eslint project as a centralized repository. It contains all things pertaining to TypeScript ESLint compatibility and will be housing TypeScript parser, eslint-plugin-typescript, and other utilities that aid in the TypeScript ESLint integration. However, the ESLint team itself won’t be formally a part of this project but seem to be supportive of Henry’s efforts. ESLint’s future in TypeScript The ESLint official team will no longer maintain the typescript-eslint-parser. The repository is now archived and there will be no future released of typescript-eslint-parser in npm. Users who are using typescript-eslint-parser are advised to switch to @typescript-eslint/parser. The typescript-eslint repository will be updated for any new developments on ESLint support in TypeScript. Announcing ‘TypeScript Roadmap’ for January 2019- June 2019 TypeScript 3.2 released with configuration inheritance and more Introducing ReX.js v1.0.0 a companion library for RegEx written in TypeScript

On Friday, Libc++ version 9 was released; libc++ is an implementation of the C++ standard library, targeting C++11, C++14 and above. Libc++ 9 is a part of the LLVM Compiler Infrastructure, release 9.0.0 which was made available in September. Libc++ 9 adds explicit support for WebAssembly System Interface (WASI) along with major improvements from the previous release and new feature work. Libc++ has also dropped support for GCC 4.9; they now support GCC 5.1 and above. WASI is a system interface for the WebAssembly platform. Currently, it supports sandboxed access to the filesystem via a POSIX-like API, as well as other basic interfaces like argv, environment variables, random numbers, and timers. There are three popular implementations of WASI: wasmtime, Mozilla’s WebAssembly runtime, Lucet, Fastly’s WebAssembly runtime, and a browser polyfill. Improvements in Libc ++ 9 Minor fixes to std::chrono operators. libc++ now correctly handles Objective-C++ ARC qualifiers in std::is_pointer. Front and back methods are added to std::span std::to_chars now adds leading zeros. Ensure std::tuple is trivially constructible. std::aligned_union now works in C++03. Output of nullptr to std::basic_ostream is formatted properly. P0608 is now implemented as a sane variant converting constructor. std::is_unbounded_array and std::is_bounded_array added to type traits. std::atomic now includes many new features and specialization Added std::midpoint and std::lerp math functions and std::is_constant_evaluated function Erase-like algorithms now return size type. Added contains method to container types. std::swap is now a constant expression. std::move and std::forward now both work in C++03 mode. People on Twitter were quite happy with WASI support in libc ++ https://twitter.com/Stephen_d2005/status/1178489876070535168 https://twitter.com/iwillrunoutofsp/status/1182702301062008832 You can also see the release notes for additional information. Introducing Weld, a runtime written in Rust and LLVM for cross-library optimizations LLVM 9 releases with official RISC-V target support, asm goto, Clang 9, and more LLVM’s Clang 9.0 to ship with experimental support for OpenCL C++17, asm goto initial support and more. LLVMs Arm stack protection feature turns ineffective when the stack is re-allocated

After releasing Python 3.8.0 alpha 1 earlier this month, Python team released the second alpha version of the four planned alpha releases of Python 3.8, called Python 3.8.0a2, last week. Alpha releases make it easier for the developers to test the current state of new features, bug fixes, and the release process. Python team states that many new features for Python 3.8 are still being planned and written. Here is a list of some of the major new features and changes so far, however, these features are currently raw and not meant for production use: PEP 572 i.e. Assignment expressions have been accepted. Now, users can assign to variables within an expression with the help of the notation NAME := expr. A new exception, TargetScopeError has also been added with one change to the evaluation order. Typed_ast, a fork of the ast module (in C) used by mypy, pytype, and (IIRC) has been merged back to CPython. Typed_ast helps preserve certain comments. Multiprocessing is now allowed and users can use shared memory segments to avoid pickling costs and the need for serialization between processes. The next pre-release for Python 3.8 will be Python 3.8.0a3 and has been scheduled for 25th March 2019. For more information, check out the official Python 3.8.0a2 announcement. PyPy 7.0 released for Python 2.7, 3.5, and 3.6 alpha 5 blog posts that could make you a better Python programmer Python Software foundation and JetBrains’ Python Developers Survey 2018

The team behind Swift shared a new blog post yesterday detailing their new diagnostic architecture which is being implemented as a part of the upcoming Swift 5.2 release (expected early November). This new architecture aims to improve the diagnostics from the compiler. It will make it easier to improve/port existing diagnostics to be used by new feature implementors. The Swift compiler uses type checker to ensure the correctness of a program. Type checker enforces rules about how types are used in source code and show when those rules are violated. However, it guesses the exact location of an error which is not helpful in certain scenarios because it is not specific or actionable. With the new diagnostic infrastructure, the team is trying to implement a new type checker that attempts to “fix” problems right at the point where they occur while remembering the fixes it has applied. This way, type checker can pinpoint errors in more kinds of programs. New constraint fix resolves inconsistent situations The type checker converts the source code into a constraint system, which represents relationships among the types in the code. The Constraint System first generates the constraint and then solves them. The process of constraint generation produces a constraint system that relates the types of various subexpressions within an expression. The constraint solver takes a given set of constraints and determines the most specific type binding for each of the type variables in the constraint system. To improve the constraint solving mechanism, the new diagnostic infrastructure employs a constraint fix that tries to resolve inconsistent situations where the solver gets stuck with no other types to attempt. This fix captures all useful information about the error location from the solver and uses that later for diagnostics. While the former approach guesses where the error is located, the new approach has a symbiotic relationship with the solver which provides all of the error locations to it. How constraint fix works A constraint fix is created whenever a constraint failure is detected. The constraint fix captures three crucial pieces of information about a failure: kind of failure that occurred, location in the source code where the failure came from, and types and declarations involved in the failure. The constraint solver then accumulates these fixes. Once it arrives at a solution, it looks at the fixes that were part of a solution and produces actionable errors or warnings. The Swift team has shared examples of improved diagnostics and SwiftUI examples to better demonstrate the workings of this new diagnostic infrastructure. People are quite excited about these error improvements in Swift and shared their views on the associated thread in Swift Forums. “Omg better error messages! That's so awesome! Right now error messages are the worst part of swift, I'm excited. I hope it will be the end of types called _ in error messages” “Awesome work @xedin! The blog post is highly informative and I thoroughly enjoyed reading it. I very much look forward to seeing the new diagnostic architecture in action.” Developers from the Swift for TensorFlow project propose adding first-class differentiable programming to Swift Apple releases the native SwiftUI framework with declarative syntax, live editing, and support of Xcode and more. Swift is improving the UI of its generics model with the “reverse generics” system

After releasing Rust 1.37 last month, the Rust team announced the release of Rust 1.38 yesterday. This version supports pipelined rustc compilation, an extended #[deprecated] attribute for macros, the std::any::type_name function to know the type name, and more. Key updates in Rust 1.38 Pipelined compilation to increase parallelism Rust’s dependency manager and project compiler, Cargo create a directed acyclic graph  (DAG) of crates whenever a cargo build command is fired. Cargo waits till all of the dependencies for that compilation is completed, only then it proceeds to execute rustc.  Starting with 1.38, this wait is minimized by introducing pipelined compilation. Cargo will now take advantage of the metadata produced by the compiler to start the next compilation. Read also: Rust 1.29 is out with improvements to its package manager, Cargo The team shared in the announcement that though this update doesn’t have much effect on builds for a single crate, it has shown up to 10-20% improvement in compilation speed during testing. “Other ones did not improve much, and the speedup depends on the hardware running the build, so your mileage might vary. No code changes are needed to benefit from this,” the team adds. Linting incorrect uses of mem::{uninitialized, zeroed} Previously, the ‘mem::uninitialized’ function allowed developers to sidestep Rust’s initialization checks. This operation can be “incredibly dangerous” as it makes the Rust compiler assume that values are properly initialized. This was addressed in Rust 1.36 by stabilizing the ‘MaybeUninit<T>’ type. The Rust team explained in a previous announcement, “The Rust compiler will understand that it should not assume that a MaybeUninit<T> is a properly initialized T. Therefore, you can do gradual initialization more safely and eventually use .assume_init() once you are certain that maybe_t: MaybeUninit<T> contains an initialized T.” The ‘mem::uninitialized’ function is planned to deprecate in Rust 1.39. Starting with Rust 1.38, the compiler has a few checks to identify incorrect initializations using ‘mem::uninitialized’ or ‘mem::zeroed’. However, these checks do not cover all cases of unsound use of these methods. The #[deprecated] attribute for macros Rust 1.9 introduced the  #[deprecated] attribute that allows crate authors to notify their users an item of their crate is deprecated and will be removed in a future release. In Rust 1.38, this attribute can also be applied to indicate the deprecation of macros. The std::any::type_name function Rust 1.38 introduces a new function called ‘std::any::type_name’ that gives you the type name. Since this is a standard library function for debugging, the exact content and format of the string are not guaranteed. The team explains, “The value returned is only a best-effort description of the type; multiple types may share the same type_name value, and the value may change in future compiler releases.” Some users have already upgraded to Rust 1.38 and shared their feedback on Twitter. https://twitter.com/gilescope/status/1177229413320134661 While others are eagerly waiting for the release that will have the stabilized async-await. https://twitter.com/shirshak55/status/1177247635285000192 These were some of the updates in Rust 1.38. Check out the official announcement for more. Introducing Weld, a runtime written in Rust and LLVM for cross-library optimizations Mozilla introduces Neqo, Rust implementation for QUIC, new http protocol Introducing Nushell: A Rust-based shell Oracle releases JDK 13 with switch expressions and text blocks preview features, and more! Darklang available in private beta

Yesterday, Julia team announced the alpha release of v1.3.0, which is an early preview of Julia version 1.3.0, expected to be out in a couple of months. The alpha release includes a preview of a new threading interface for Julia programs called multi-threaded task parallelism. The task parallelism model allows many programs to be marked in parallel for execution, where a ‘task’ will run all the codes simultaneously on the available thread. This functionality works similar to a GC model (garbage collection) as users can freely release millions of tasks and not worry about how the libraries are implemented. This portable model has been included over all the Julia packages. Read Also: Getting started with Z Garbage Collector (ZGC) in Java 11 [Tutorial] Jeff Bezanson and Jameson Nash from Julia Computing, and Kiran Pamnany from Intel say the Julia task parallelism is “inspired by parallel programming systems like Cilk, Intel Threading Building Blocks(TBB) and Go”. With multi-threaded task parallelism, Julia model can schedule many parallel tasks that call library functions. This works smoothly as the CPUs are not overcrowded with threads. This acts as an important feature for high-level languages as they require library functions frequently. How to resolve challenges while implementing task parallelism Allocating and switching task stacks Each task requires its own execution stack distinct from the usual process or thread stacks provided by Unix operating systems. Julia has an alternate implementation of stack switching which trades time for memory when a task switches. However, it may not be compatible with foreign code that uses cfunction. This implementation is used when stacks consume large address space. Event loop thread issues an async signal If a thread needs an event loop thread to wake up, it issues an async signal. This may be due to another thread scheduling new work, or a thread which is beginning to run garbage collection, or a thread which wants to take the I/O lock to perform I/O. Task migration across system threads In general, a task may start running on one thread, block for a while, and then restart on another thread. Julia uses thread-local variables every time a memory is allocated internally. Currently, a task always runs on the thread it started running on initially. To support this, Julia is using the concept of a sticky task where a task must run on a given thread and per-thread queues for running tasks associated with each thread. Sleeping idle threads To avoid 100% usage of CPUs all the time, some tasks are made to sleep. This can lead to a synchronization problem as some threads might be scheduled for new work while others have been kept on sleep. Dedicated scheduler task cause overhead problem When a task is blocked, the scheduler is called to pick another task to run. But, on what stack does the code run? It is possible to have a dedicated scheduler task; however, it may cause less overhead if the scheduler code runs in the context of the recently-blocked task. One suggested measure is to pull a task out of the scheduler queue to avoid switch away. Classic bugs The Julia team faced many difficult bugs while implementing multi-threaded functionality. One of the many bug was a mysterious one on Windows which got fixed by flipping a single bit. Future goals for Julia version 1.3.0 increase performance work on task switch and the I/O latency allow task migration use multiple threads in the compiler improved debugging tools provide alternate schedulers Developers are impressed with the new multithreaded parallelism functionality. A user on Hacker News comments “Great to see this finally land - thanks for all the team's work. Looking forward to giving it a whirl. Threading is something of a prerequisite for acceptance as a serious language among many folks. So great to not just check that box, but to stick the pen right through it. The devil is always in the details, but from the doc the interface looks pretty nice.” Another user says, “This is huge! I was testing out the master branch a few days ago and the parallelism improvements were amazing.” Many users are expecting Julia to challenge Python in the future. A comment on Hacker News reads “Not only is this huge for Julia, but they've just thrown down the gauntlet. The status quo has been upset. I expect Julia to start eating everyone's lunch starting with Python. Every language can use good concurrency & parallelism support and this is the biggest news for all dynamic languages.” Another user says, “I worked in a computational biophysics department with lots of python/bash/R and I was the only one who wrote lots of high-performance code in Julia. People were curious about the language but it was still very much unknown. Hope we will see a broader adoption of Julia in the future - it's just that it is much better for the stuff we do on a daily basis.” To learn how to implement Julia using task parallelism, head over to Julia blog. Mozilla is funding a project for bringing Julia to Firefox and the general browser environment Announcing Julia v1.1 with better exception handling and other improvements Julia for machine learning. Will the new language pick up pace?

OpenSSH 7.8 base source code was released on August 24, 2018. It includes many new features such as a fix for the username enumeration vulnerability, changes to the default format for the private key file, and many more. Additionally, support for running ssh setuid root has been removed, and a couple of new signature algorithms have been added. The base source code is designed specifically for OpenBSD. The aim was to make the code simple, clean, minimal, and auditable. This release will be available from the mirrors listed at http://www.openssh.com/ shortly. Let’s take a look at the features that developers can expect in this new version of OpenSSH Changes that may affect existing configurations ssh-keygen(1): Write OpenSSH format private keys by default instead of using OpenSSL's PEM format. This offers better protection against offline password guessing and supports key comments in private keys. sshd(8): Internal support for S/Key multiple factor authentication is removed. S/Key may still be used via PAM or BSD auth. ssh(1): Vestigal support for running ssh(1) as setuid is removed. sshd(8): The semantics of PubkeyAcceptedKeyTypes and HostbasedAcceptedKeyTypes now specify signature algorithms that are accepted for their respective authentication mechanism. This matters when using the RSA/SHA2 signature algorithms "rsa-sha2-256", "rsa-sha2-512" and their certificate counterparts. Configurations that override these options but do not use these algorithm names may cause unexpected authentication failures. sshd(8): The precedence of session environment variables has changed. ~/.ssh/environment and environment="..." options in authorized_keys files can no longer override SSH_* variables set implicitly by sshd. ssh(1)/sshd(8): The default IPQoS used by ssh/sshd has changed.Interactive traffic will use  DSCP AF21and CS1 will be used  for bulk. For a detailed understanding, head over to the commit message: https://cvsweb.openbsd.org/src/usr.bin/ssh/readconf.c#rev1.28 What's new in OpenSSH 7.8 This  bugfix release has a couple of New Features in store for developers. Let’s take a look at some of the important ones. New signature algorithms "rsa-sha2-256-cert- v01@openssh.com" and "rsa-sha2-512-cert-v01@openssh.com" to  explicitly force use of RSA/SHA2 signatures in authentication. Read more at  ssh(1)/sshd(8). Some countermeasures are added against timing attacks used for account validation/enumeration. sshd will impart a minimum time or each failed authentication attempt consisting of a global 5ms minimum plus an additional per-user 0-4ms delay derived from a host secret. Fine more information at sshd(8). In sshd(8), you can add a SetEnv directive to explicitly specify environment variables in sshd_config by an administrator. Variables set by SetEnv override the default and client-specified Environment. In ssh(1), you can add a SetEnv directive to request that the server sets an environment variable in the session. Similar to the existing SendEnv option, these variables are set subject to server Configuration. Clear environment variables previously marked for sending to the server by "SendEnv -PATTERN" Bug Fixes introduced in this new version In the sshd(8), users can avoid observable differences in request parsing that could be used to determine whether a target user is valid. They can also fix failures to read authorized_keys caused by faulty supplemental group caching. Failures can be fixed to read authorized_keys caused by faulty supplemental group caching. The relax checking of authorized_keys environment="..." options to allow underscores in variable names  (regression introduced in 7.7) Some memory leaks in the ssh(1)/sshd(8) have been fixed. The SSH2_MSG_DEBUG messages for Twisted Conch clients in the ssh(1)/sshd(8) have also been disabled. Tunnel forwarding has also been fixed. In ssh(1), you can now fix a pwent clobber (introduced in openssh-7.7) that could occur during key loading, manifesting as crash on some platforms. To get a detailed overview of the features and changes introduced in portability and checksums in this new release, head over to the official release notes. JavaFX 11 to release soon, announces the Gluon team Gitlab 11.2 releases with preview changes in Web IDE, Android Project Import and more Bodhi Linux 5.0.0 released with updated Ubuntu core 18.04 and a modern look

Last week, the early access builds for OpenJDK Project Valhalla's LW2 phase was released, which was first proposed in October last year. LW2 is the next iteration of the L-World series that brings further language and JDK API support for inline types. https://twitter.com/SimmsUpNorth/status/1147087960212422658 Proposed in 2014, Project Valhalla is an experimental OpenJDK project under which the team is working on major new language features and enhancements for Java 10 and beyond. The new features and enhancements are being done in the following focus areas: Value Types Generic Specialization Reified Generics Improved 'volatile' support The LW2 specifications Javac source support Starting from LW2, the prototype is based on mainline JDK (currently version 14). That is why it requires source-level >= JDK14. To make a class declaration of inline type it uses the “inline class’ modifier or ‘@__inline__’ annotation. Interfaces, annotation types, or enums cannot be declared as inline types. The top-level, inner, or local classes may be inline types. As inline types are implicitly final, they cannot be abstract. Also, all instance fields of an inline class are implicitly final. Inline types implicitly extend ‘java.lang.Object’ similar to enums, annotation types, and interfaces. Supports "Indirect" projections of inline types via the "?" operator. javac now allows using ‘==’ and ‘!=’ operators to compare inline type. Java APIs Among the new or modified APIs include ‘isInlineClass()’, ‘asPrimaryType()’, ‘asIndirectType()’, ‘isIndirectType()’, ‘asNullableType()’, and ‘isNullableType()’. Now the ‘getName()’ method reflects the Q or L type signatures for arrays of inline types. Using ‘newInstance()’ on an inline type will throw ‘NoSuchMethodException’ and ‘setAccessible()’ will throw ‘InaccessibleObjectException’. With LW2, initial core Reflection and VarHandles support are in place. Runtime When attempting to synchronize or call wait(*) or notify*() on an inline type IllegalMonitorException will be thrown. ‘ClassCircularityError’ is thrown if loading an instance field of an inline type which declares its own type either directly ‘NotSerializableException’ will be thrown if you are attempting to serialize an inline type. If you are casting from indirect type to inline type, it may result in ‘NullPointerException’. Download the early access binaries to test this prototype. These were some of the specifications of LW2 iteration. Check out the full list of specification at OpenJDK’s official website. Also, stay tuned with the current happenings in Project Valhalla. Getting started with Z Garbage Collector(ZGC) in Java 11 [Tutorial] Storm 2.0.0 releases with Java enabled architecture, new core and streams API, and more Firefox 67 will come with faster and reliable JavaScript debugging tools

Yesterday, the team at TensorFlow introduced TensorFlow Graphics. A computer graphics pipeline requires 3D objects and their positioning in the scene, and a description of the material they are made of, lights and a camera. This scene description then gets interpreted by a renderer for generating a synthetic rendering. In contrast, a computer vision system starts from an image and then tries to infer the parameters of the scene. This also allows the prediction of which objects are in the scene, what materials they are made of, and their three-dimensional position and orientation. Developers usually require large quantities of data to train machine learning systems that are capable of solving these complex 3D vision tasks.  As labelling data is a bit expensive and complex process, so it is better to have mechanisms to design machine learning models. They can easily comprehend the three dimensional world while being trained without much supervision. By combining computer vision and computer graphics techniques we get to leverage the vast amounts of unlabelled data. For instance, this can be achieved with the help of analysis by synthesis where the vision system extracts the scene parameters and the graphics system then renders back an image based on them. In this case, if the rendering matches the original image, which means the vision system has accurately extracted the scene parameters. Also, we can see that in this particular setup, computer vision and computer graphics go hand-in-hand. This also forms a single machine learning system which is similar to an autoencoder that can be trained in a self-supervised manner. Image source: TensorFlow We will now explore some of the functionalities of TensorFlow Graphics. Object transformations Object transformations are responsible for controlling the position of objects in space. The axis-angle formalism is used for rotating a cube and the rotation axis points up to form a positive which leads the cube to rotate counterclockwise. This task is also at the core of many applications that include robots that focus on interacting with their environment. Modelling cameras Camera models play a crucial role in computer vision as they influence the appearance of three-dimensional objects projected onto the image plane. For more details about camera models and a concrete example of how to use them in TensorFlow, check out the Colab example. Material models Material models are used to define how light interacts with objects to give them their unique appearance. Some materials like plaster and mirrors usually reflect light uniformly in all directions. Users can now play with the parameters of the material and the light to develop a good sense of how they interact. TensorBoard 3d TensorFlow Graphics features a TensorBoard plugin to interactively visualize 3d meshes and point clouds. Through which visual debugging is also possible that helps to assess whether an experiment is going in the right direction. To know more about this news, check out the post on Medium. TensorFlow 1.13.0-rc2 releases! TensorFlow 1.13.0-rc0 releases! TensorFlow.js: Architecture and applications  

Programming languages are the foundations of all the existing technology that we are surrounded with. Developers, tech enthusiasts, and others keep themselves updated with the latest programming languages to be abreast with the advancements happening within each of it. Popular survey websites such as TIOBE, Redmonk, StackOverflow, IEEE spectrum, etc. help people to know about the trending top programming languages and where their favorite language stands. Out of these, the IEEE spectrum and StackOverflow showcase their ranking surveys annually. Whereas TIOBE does it every month and Redmonk does it semi-annually. From the two annual survey providers, Stack Overflow takes in surveys from 56,033 coders in 173 countries  whereas IEEE spectrum’s survey synthesizes rankings from 10 sources including Google search of “X programming” Google Trends Twitter GitHub StackOverflow Reddit Hacker News CareerBuilder Dice IEEE Xplore Digital Library The IEEE spectrum aggregates different kinds of statistical data with a view to generate the most reliable ranking. It also gives the most personalized ranking. The interactive interface allows readers to filter by search trends, job trends, or open source community trends. You can even modify the weighting of each dimension, enabling an extremely personalized ranking. Of the five popular language ranking surveys and our own Packt’s Skill Up survey 2018, the top 10 programming languages for this year include, Top 10 languages across popular surveys     Stack Overflow Redmonk TIOBE IEEE Spectrum Packt Skill Up Survey JavaScript JavaScript Java Python Java HTML Java C C++ JavaScript CSS Python C++ C Python SQL PHP Python Java C# Java C# Visual Basic C# SQL Bash/Shell C++ C# PHP C++ Python CSS PHP R C C# Ruby JavaScript JavaScript PHP PHP C SQL Go Swift C++ Swift Assembly Assembly Go Our Takeaways from IEEE survey What was obvious Python in the top 3: Python has been bagging the top position at the IEEE spectrum for two years in continuation now. It is the easiest programming language of all with an easy-going syntax. However, IEEE mentions the reason for Python to be at the zenith is because it is now listed as an embedded language. Go in the top 10 list: Google’s Go has risen from the 7th position last year to the 5th this year. Its speed, simplicity, reliability, cross-platform ability, native concurrency, easy deployment makes it the go-to cloud-native language for developers. Thus, making it the fastest growing programming language. Java, C++, C, C# in the top 5: These legendary languages are still in the top 5 due to its large scale industry-wide adoption and an established community. Also, many professional developers have been working on these languages since years and find it difficult to migrate to any new programming language making these stay at the top. R language drops down a notch: The language for statistics and big data, R has stepped down from its 6th position to a 7th position. R’s decline could be due to the popularity of Python due to the high-quality Python libraries for both statistics and machine learning. This makes statistics and big data more flexible to turn to Python than the more specialized R. What was surprising? Kotlin language not included in the list: The recently popular programming language for Android development is missing from IEEE’s survey list. Many developers use Kotlin instead of Python and Java for internal app development (console apps, OpenGL-apps, threaded socket servers, etc). Kotlin also eases porting of code from Python to Kotlin. Many promising languages missing from the IEEE list: Languages such as Typescript, Dart are missing. Typescript is the superset of JavaScript, which lacks a type system. The introduction of Typescript adds optional static typing to Javascript. Similarly, Dart is the also a useful language and can be used to program front-end applications. It is easy to use with a non-existent learning curve. Matlab and Assembly languages maintain their positions: Matlab is used for scientific computing and mathematical processing. First released in 1984, it is one of the oldest languages after Assembly still maintaining the 11th position in this list. It is widely used in Academics and research and hence is never outdated. Similarly, Assembly, the oldest form of programming, at the 10th position is still relevant to many developers. This is because it supports fast code with the absence of a compiler and is the best bet for machine level programming. Javascript not in the top 5: Being one of the dominant languages on the web front-end development, JavaScript is at the 8th position in IEEE’s list. This must be because other languages such as TypeScript and WebAssembly are providing an easy way to C/C++ developers What we are skeptical about/don’t agree with PHP might not be in the top 10: PHP is one of the most popular languages for server-side programming. Other programming languages such as Python and Ruby on Rails are competing with PHP by providing a much more simple, useful and powerful coding syntax and tools in the same domain as PHP. Ruby might drop down a few more notches: Although Ruby was the first full-stack language to be used on front and back-end development, it is difficult to learn. Integrating third-party libraries on ruby is also difficult which makes it non-flexible. As there are several options in the market today, I am skeptical Ruby will maintain its current position. Is Swift dropping from its position: Swift programming language was built by Apple Inc. for iOS, macOS, watchOS, and tvOS. Being an Apple-only development environment, developers are moving to multi-platform mobile apps such as Microsoft’s Xamarin, Apache Cordova, and Ionic. This may affect Swift’s user community. Limitations of the IEEE survey The IEEE Spectrum 2018 survey included 47 programming languages ranging from the most widely adopted to the least. However, not all the programming languages were a part of this list. Current popular languages such as Kotlin, Dart, TypeScript, WebAssembly and some others were missing from the list. As per some comments on the IEEE blog, IEEE uses the languages listed in Github. On Github, Visual basic is the common name used for both vb.net and Visual Basic. Also, some languages present in the other surveys are not present in the IEEE survey. For instance, the TIOBE index has PL/SQL at the 20th position. However, the IEEE survey has not mentioned about it. One more limitation it had was, it showed completely different results on different browsers, which Stephen Cass from IEEE spectrum said, “ I'd say it's due to variations in how JQuery/JavaScript is implemented in the different browsers: under the hood, the TPL uses a lot of floating point math, so what you are seeing could be due to differences in precision/rounding, et cetera. Ultimately, I suspect the solution will be to calculate the rankings completely server-side: the underlying code for the TPL is five years old, so we were thinking of overhauling it anyway, and this certainly puts some weight behind that.” Stephen further added, “I should add that we built the TPL primarily using Chrome, so our canonical version of the rankings is the one you see in that browser.” Read more about the other programming languages by IEEE Spectrum in the IEEE blog post Rust 1.28 is here with global allocators, nonZero types and more Racket v7.0 is out with overhauled internals, updates to DrRacket, TypedRacket among others Grain: A new functional programming language that compiles to Webassembly

Yesterday, Kent C. Dodds, a JavaScript engineer at PayPal, shared in a post that now every app created at PayPal uses TypeScript by default replacing its previous type checker, Flow.  He also shared why it took them so much time to migrate to TypeScript and what are the drawbacks of using Flow which TypeScript solves. Dodds works on a toolkit called paypal-scripts, which is a package of all the tools common to PayPal applications and published modules. It was created to replace the huge list of devDependencies in the package.json and all the config files with a single entry in the devDependencies. Keeping all the tools and config in a single package, also made updating very easier. Now, this paypal-scripts module is also merged with their base GitHub repo named “sample-app”, to ensure that every new application will get their start with modern technology and tools. These applications will also be statically typed with TypeScript and tested with Jest. It took Dodds so long to adopt TypeScript because he was hesitant towards leaving Babel and ESLint. He was using these tools for several years and enjoyed building custom plugins for both. Also, earlier, TypeScript users faced some challenges when using Babel and ESLint. A common theme was that Babel users found it difficult to set up TypeScript. The linting experience also needed some improvement, so the TypeScript team started working on improving TypeScript’s compatibility for ESLint. This meant for Dodds that he did not have to give up these tools to adopt TypeScript, and that is why he decided to replace Flow with TypeScript. Dodds mentions that the regular unreliability of Flow made him take this decision. Explaining the challenges, he wrote, “The editor plugins only sometimes worked (full disclosure, I never tried Nuclide and maybe my life would’ve been different if I had, but I tried Flow in Atom and VSCode) and I would get issues like the one all the time. It was incredibly frustrating because I could never trust my type checker. There were other issues as well.” Read more in detail on Kent C. Dodds’ post: Why every new web app at PayPal starts with TypeScript. Future of ESLint support in TypeScript The Angular 7.2.1 CLI release fixes a webpack-dev-server vulnerability, supports TypeScript 3.2 and Angular 7.2.0-rc.0 Announcing ‘TypeScript Roadmap’ for January 2019- June 2019

Last month, Facebook announced that it’s going to launch its own cryptocurrency, Libra and Calibra, a payment platform that sits on top of the cryptocurrency, unveiling its plans to develop an entirely new ecosystem for digital transactions. It also developed a new programming language, “Move” for implementing custom transaction logic and “smart contracts” on the Libra Blockchain. The Move language is written entirely in Rust. Although Facebook’s media garnered a massive media attention and had investors and partners from the likes of PayPal, loan platform Kiva, Uber, and Lyft, it had its own share of concerns. The US administration is worried about a non-governmental currency in the hands of big tech companies. Early July, the US congress asked Facebook to suspend the implementation of Libra until the ramifications were investigated. Last week, at the U.S. House Committee on Financial Services hearing, investigating Libra’s security related challenges, Congressman Denver Riggleman posed an important question to David Marcus, head of Calibra, asking why the Rust language was chosen for Libra. Riggleman: I was really surprised about the Rust language. So my first question is, why was the Rust language chosen as the implementation language for Libra? Do you believe it's mature enough to handle the security challenges that will affect these large cryptocurrency transactions? Marcus: The Libra association will own the repository for the code. While there are many flavors and branches being developed by third parties, only safe and verified code will actually be committed to the actual Libra code base which is going to be under the governance of the Libra association. Riggleman: It looks like Libra was built on the nightly build of the Rust programming language. It's interesting because that's not how we did releases at the DoD. What features of Rust are only available in the nightly build that aren't in the official releases of Rust? Does Facebook see it as a concern that they are dependent on unofficially released features of the Rust programming language? Why the nightly releases? Do you see this as a function of the prototyping phase of this? Marcus: Congressman, I don’t have the answers to your very technical questions but I commit that we will get back to you with more details on your questions. Marcus appeared before two US congressional hearing sessions last week where he was constantly grilled by legislators. The grilling led to a dramatic alteration in the strategy of Libra. Marcus has clarified that Facebook won't move forward with Libra until all concerns are addressed. The original vision of Facebook with Libra was to be an open and largely decentralized network which would be beyond the reach of regulators. Instead, regulatory compliance would be the responsibility of exchanges, wallets, and other services called the Libra association. Post the hearing Marcus has stated that the Libra Association would have a deliberately limited role in regulatory matters. Per ArsTechnica, Calibra, would follow US regulations on consumer protection, money laundering, sanctions, and so forth. But Facebook didn't seem to have plans for the Libra Association, Facebook, or any associated entity to police illegal activity on the Libra network as a whole. This video clipping sparked quite the discussion on Hacker News and Reddit with people applauding the QnA session. Some appreciated that legislators are now asking tough questions like these. “It's cool to see a congressman who has this level of software dev knowledge and is asking valid questions.” “Denver Riggleman was an Air Force intelligence officer for 11 years, then he became an NSA contractor. I'm not surprised he's asking reasonable questions.” “I don't think I've ever heard of a Congressman going to GitHub, poking around in some open source code, and then asking very cogent and relevant questions about it. This video is incredible if only because of that.” Others commented on why Congress may have trust issues with using a young programming language like Rust for something like Libra, which requires layers of privacy and security measures. “Traditionally, government people have trust issues with programming languages as the compiler is, itself, an attack vector. If you are using a nightly release of the compiler, it may be assumed by some that the compiler is not vetted for security and could inject unstable or malicious code into another critical codebase. Also, Rust is considered very young for security type work, people rightly assume there are unfound weaknesses due to the newness of the language and related libraries”, reads one comment from Hacker News. Another adds, “Governments have issues with non-stable code because it changes rapidly, is untested and a security risk. Facebook moves fast and break things.” Rust was declared as the most loved programming language by developers in the Stack Overflow survey 2019. This year more or less most major platforms have  jumped on the bandwagon of writing or rewriting its components in the Rust programming language. Last month, post the release of Libra, Calibra tech lead Ben Maurer took to Reddit to explain why Facebook chose the programming language Rust. Per Maurer, “As a project where security is a primary focus, the type-safety and memory-safety of Rust were extremely appealing. Over the past year, we've found that even though Rust has a high learning curve, it's an investment that has paid off. Rust has helped us build a clean, principled blockchain implementation. Part of our decision to choose Rust was based on the incredible momentum this community has achieved. We'll need to work together on challenges like tooling, build times, and strengthening the ecosystem of 3rd-party crates needed by security-sensitive projects like ours.” Not just Facebook, last week, Microsoft announced plans to replace their C and C++ code with Rust calling it a “modern safer system programming language” with great memory safety features. In June, Brave ad-blocker also released a new engine written in Rust which gives 69x better performance. Airbnb has introduced PyOxidizer, a Python application packaging and distribution tool written in Rust. “I’m concerned about Libra’s model for decentralization”, says co-founder of Chainspace, Facebook’s blockchain acquisition Facebook launches Libra and Calibra in a move to seriously disrupt the financial sector Facebook releases Pythia, a deep learning framework for vision and language multimodal research

Day 2 of the Kotlin Conference 2018 just ended yesterday and announcements were made regarding the programming language. There is one more day of the conference which will be streamed live at the Kotlin website. We will look at some of the announcements made in the conference so far. Kotlin 1.3 is now RC Kotlin 1.3 RC is here and brings a lot of new features. Some of them are the following. Contracts The Kotlin compiler now does extensive static analysis to show warnings and reduce boilerplate. ‘Contracts’ in Kotlin 1.3 allow functions to explicitly describe its own behavior in a way which is understood by the compiler. Coroutines Kotlin Coroutines are no longer experimental and will be supported like other features starting from Kotlin version 1.3. Coroutines delegate most of the functionality to libraries and helps in providing a fluid experience that is scalable when needed. Multiplatform projects The multiplatform projects model has been reworked to improve expressiveness and flexibility. It is in line with the language’s goal to function on all platforms. Currently Kotlin supports JVM, Android, JavaScript, iOS, Linux, Windows, Mac and embedded systems like STM32. This is beneficial for reusing code. Kotlin/Native is now in beta Kotlin/Native is designed to enable compilation in platforms where virtual machines do not work. An example would be embedded devices or iOS. Kotlin/Native is a solution to situations when developers need to produce a self-contained program where an additional runtime or virtual machine is not required. After several years of development, Kotlin/Native is now beta. The Kotlin foundation The Kotlin Foundation is a nonprofit nonstock corporation created in 2018. It has backing from JetBrains and Google. The Kotlin Foundation aims to protect, promote and advance the development of Kotlin. New revamped playground The online environment for trying and learning Kotlin has a new look, functionality, and a new section called Learn Kotline by Example. All this is available directly in your web browser via the Kotlin Playground website. The first day can be watched on YouTube. You can watch the Kotlin Conference live at their website. Kotlin 1.3 RC1 is here with compiler and IDE improvements How to implement immutability functions in Kotlin [Tutorial] Forget C and Java. Learn Kotlin: the next universal programming language

New programming languages keep popping up every now and then, but here’s something that’s out of the box - jukebox to be precise! If you’ve ever dressed up (or at least thought of it) in leather tights, a leather jacket, with an axe strung around your neck, belting out your favourite numbers, you’re probably going to love this! Somebody...no not Nickelback, created a language that is designed for creating computer programs using song lyrics! The language is called...hold your breath...Rockstar! Say, what?? Are you kidding me? Is this some kind of joke/’fake news’? No, it’s not. It’s as real as Kurt writing those songs she sang in Hole! ;) Rockstar is heavily influenced by the lyrical conventions of 1980’s hard rock and power ballads. And the somebody who created it is Dylan Beattie, a Microsoft MVP for Visual Studio and Development Technologies. Unsurprisingly, Dylan’s a musician himself. Rockstar is already growing in popularity! Will you take a look at the growth on Github and the discussions going on on Reddit? You ask why would Dylan do such a thing? Cos, as Van Halen would say, “Everybody Wants Some”! Well, he thought it would be cool to have such a language, where you can use your favourite lyrics to drive your computer and HR recruiters nuts! It’s mainly part of a movement to force recruiters from using the term, “Rockstar Programmers”. Did I say movement? Rockstar supports a unique feature known as poetic literals, which allow programmers to simultaneously initialize a variable and express their innermost angst. I’m sure Billie Joe Armstrong and Axl Rose will surely appreciate this! This is what sample Rockstar code looks like, solving the fizzbuzz problem: Let’s start with the minimalistic version: Modulus takes Number and Divisor While Number is as high as Divisor Put Number minus Divisor into Number (blank line ending While block) Give back Number (blank line ending function declaration) Limit is 100 Counter is 0 Fizz is 3 Buzz is 5 Until Counter is Limit Build Counter up If Modulus taking Counter, Fizz is 0 and Modulus taking Counter, Buzz is 0 Say "FizzBuzz!" Continue (blank line ending 'If' Block) If Modulus taking Counter and Fizz is 0 Say "Fizz!" Continue (blank line ending 'If' Block) If Modulus taking Counter and Buzz is 0 Say "Buzz!" Continue (blank line ending 'If' Block) Say Counter (EOL ending Until block) And now, the same thing in idiomatic Rockstar code: Midnight takes your heart and your soul While your heart is as high as your soul Put your heart without your soul into your heart Give back your heart Desire is a lovestruck ladykiller My world is nothing Fire is ice Hate is water Until my world is Desire, Build my world up If Midnight taking my world, Fire is nothing and Midnight taking my world, Hate is nothing Shout "FizzBuzz!" Take it to the top If Midnight taking my world, Fire is nothing Shout "Fizz!" Take it to the top If Midnight taking my world, Hate is nothing Say "Buzz!" Take it to the top Whisper my world Oh yeah, did I mention that Rockstar doesn’t care two hoots about indentation. Also, it discourages the use of comments. Why? Cos this is Rock ‘n’ Roll, baby! Let whoever wants to know the meaning, discover it on their own! Now that’s hardcore! To declare a variable in Rockstar, you simply use a common word like "a, an, the, my or your" as a preface and any unique name (e.g. "Suzanne"). For types, you can use words like "mysterious", meaning no value is assigned, or "nothing/ nowhere/nobody", for null. You could name your variable “em” so to increment it, you’d use "build em up" and to decrement it, you’d use "knock em down". Now if that’s not cool, you tell me what is! Like in Ruby or Python, variables are dynamically typed and you don't need to declare them before use. That’s not all! For I/O, you’re at the liberty of using words like "listen to" or "shout," "whisper" or "scream". Someone actually happened to test out the error handling capabilities of Rockstar, a couple of days ago: If you accidentally typed “!love” as a property, it will return “you give !love a bad name”. I wonder what it would do, if we just typed in the lyrics to Sweet Child o’ Mine. Nevertheless, the Github (Shooting) Stars are growing like a weed (pun intended) ;) I suggest you Don’t Stop Believin’ in it and go check this language out! And don’t forget to tell us in the comments, about how it Rock(ed) You Like a Hurricane or better yet, Shook Me You All Night Long! ;) Will Rust Replace C++? Why Guido van Rossum quit as the Python chief (BDFL) Apollo 11 source code: A small step for a woman, and a huge leap for ‘software engineering’