Tech News - Languages

The Mozilla team announced Rust 2018 Edition Preview 2 today, the final release cycle before Rust 2018 goes into beta. The new release explores features such as the cargo fix command, NLL, along with other changes and improvements. Rust is a systems programming language by Mozilla. It is a "safe, concurrent, practical language", which supports functional and imperative-procedural paradigms. Rust provides better memory safety while still maintaining the performance. Let’s have a look at major features in Rust’s 2018 edition preview 2. The cargo fix command now comes as a built-in feature in Rust. This command is used during migration and addition of this new feature in Rust now further streamlines the migration process. Speaking of migration, extensive efforts have gone into improving and polishing the lints which help you migrate smoothly. Apart from that, the module system changes are now broken into several smaller features that help with independent tracking issues. There is no need of mod.rs anymore for parent modules Also, the extern crate is not needed anymore for including dependencies. Support has been provided for crate as a visibility modifier.   Another new addition in the Rust 2018 edition preview 2 is that NLL or Non-lexical lifetimes has been enabled by default, in migration mode. NLL improves the Rust compiler's ability to reason about lifetimes. It removes most of the remaining cases where people commonly experience the borrow checker rejecting valid programs. As per the Rust team, “If your code is accepted by NLL, then we accept it -- if your code is rejected by both NLL and the old borrow checker, then we reject it-- If your code is rejected by NLL but accepted by the old borrow checker, then we emit the new NLL errors as warnings”. In-band lifetimes have been split up in the latest release. Both rustfmt and the RLS have reached 1.0 “release candidate” status. For more information, check out the official release notes. Multithreading in Rust using Crates [Tutorial] Rust and Web Assembly announce ‘wasm-bindgen 0.2.16’ and the first release of ‘wasm-bindgen-futures’ Warp: Rust’s new web framework for implementing WAI (Web Application Interface)  

Yesterday, the Rust and Web Assembly community made two announcements. Firstly, it released the ‘wasm-bindgen’ 0.2.16 version and second, it published the first release of ‘wasm-bindgen-futures’. wasm-bindgen facilitates high-level communication between JavaScript and Rust compiled to WebAssembly. It allows one to speak in terms of Rust structs, JavaScript classes, strings, etc.,instead of only the integers and floats supported by WebAssembly’s raw calling convention. The wasm-bindgen is designed to support the upcoming “Host Bindings” proposal, which will eliminate the need for any kind of JavaScript shim functions between WebAssembly functions and native DOM functions. What’s new in wasm-bindgen 0.2.16 Added features Added the wasm_bindgen::JsCast trait, as described in RFC #2. Added support for receiving Option<&T> parameters from JavaScript in exported Rust functions and methods and for receiving Option<u32> and other option-wrapped scalars. Added reference documentation to the guide for every #[wasm_bindgen] attribute and how it affects the generated bindings. Changes in this version 0.2.16 Restructured the guide's documentation on passing JS closures to Rust, and Rust closures to JS. Also improved  the guide's documentation on using serde to serialize complex data to JsValue and deserialize JsValues back into complex data. Static methods are now always bound to their JS class, as is required for Promise's static methods. The newly released wasm-bindgen-futures The wasm-bindgen-futures is a crate that bridges the gap between a Rust Future and a JavaScript Promise. It provides two conversions: From a JavaScript Promise into a Rust Future. From a Rust Future into a JavaScript Promise. The two main interfaces in this crate are: JsFuture The JsFuture is constructed with a Promise and can then be used as a Future<Item = JsValue, Error = JsValue>. This Rust future will resolve or reject with the value coming out of the Promise Future_to_promise Future_to_promise interface converts a Rust Future<Item = JsValue, Error = JsValue> into a JavaScript Promise. The future's result will translate to either a rejected or resolved Promise in JavaScript. These two items provide enough of a bridge to interoperate the two systems and make sure that Rust/JavaScript can work together with asynchronous and I/O work. To know more about wasm-bindgen version 0.2.16 and wasm-bindgen-futures visit its GitHub page. Warp: Rust’s new web framework for implementing WAI (Web Application Interface) Rust 1.28 is here with global allocators, nonZero types and more Say hello to Sequoia: a new Rust based OpenPGP library to secure your apps

After the release of Boost 1.67.0 in April earlier this year, Boost 1.68.0 is now out with a new library named YAP and few updates in the libraries such as, Beast, Fusion, and GIL to name a few. Boost provides peer-reviewed portable C++ source libraries for generic programming, concurrency programming, metaprogramming, data structures, testing, and many more tasks and structures. YAP: The new expression template library YAP is an expression template library that aims to help developers in writing optimized and maintainable code. Some of its features include: Member and non-member functions on ExpressionTemplates and Expressions can be added with compact macros. A reference template that models ExpressionTemplate exists for prototyping or experimentation. The evaluation done by Boost.YAP closely matches the semantics of built-in C++ expressions, enabling clearer understanding of the semantics of expression evaluation. Expressions can be transformed explicitly in a user-defined way with the help of overloaded call operators in a transform class. The evaluate(transform(expr)) idiom is expected to be one of the most common ways of using YAP to manipulate and evaluate expressions. Boost.YAP provides functions that manipulate expressions or their subexpressions. Updated libraries in Boost 1.68.0 Beast: An executor work guard is added in all composed operations used in the implementation. To avoid crashes related to asynchronous completion handlers, users are encouraged to upgrade. Fusion: A workaround is added for ambiguous call of fusion::deque constructor on GCC 4.4/c++0x. A bug with C-style array is now fixed. Fixed a fusion::for_each signature to take functor by value. This may break existing code with non-copyable (non-movable) functor. Unintentional MPL placeholder substitution bug on fusion::transform is now fixed. GIL: C++11-compliant compiler is now required by the library. Its I/O extensions have been entirely rewritten. Math: Added support for arbitrary precision complex valued quadrature and hence contour integration. Added support for contour integrals. Performance of polynomial addition is improved. Multi-index Containers: Containers of moveable but non-copyable elements can now be serialized. The default constructor of multi_index_container is no longer explicit. Test: The master_test_suite_t object is no more copyable. Dataset test case can now use command line parameters. Uuid: Breaking change: sha1 detail namespace header redirection for backwards compatibility was removed. Added support for std::hash. Added support for move semantics on random generators. Properly handle EINTR when acquiring entropy. Use getrandom(2) instead of getentropy(3) on linux. These were some of the updates in Boost 1.68.0. To know more, head over to their official site. Working with shaders in C++ to create 3D games Understanding the Dependencies of a C++ Application Getting Inside a C++ Multithreaded Application

The release of Julia 1.0 has been eagerly anticipated - but it's finally here. At JuliaCon2018 in London the team got together to mark the project's landmark step. Take a look at the video below: It's taken more than six years for Julia to hit this milestone. The language was first launched in February 2012, and since then it has grown slowly to become a popular high-level dynamic programming language. The projects aims for Julia have been hugely ambitious since the start. As the team said in this post back in 2012: "We want a language that’s open source, with a liberal license. We want the speed of C with the dynamism of Ruby. We want a language that’s homoiconic, with true macros like Lisp, but with obvious, familiar mathematical notation like Matlab. We want something as usable for general programming as Python, as easy for statistics as R, as natural for string processing as Perl, as powerful for linear algebra as Matlab, as good at gluing programs together as the shell. Something that is dirt simple to learn, yet keeps the most serious hackers happy. We want it interactive and we want it compiled." However, despite the level of ambition it hasn't quite yet managed to expand beyond its core strength: numerical computing. However, that could change with version 1.0. What new features are in Julia 1.0? The team behind Julia are keen to stress that Julia 1.0 offers greater stability than the language ever has. They explain in a blog post announcing the new release: "The single most significant new feature in Julia 1.0, of course, is a commitment to language API stability: code you write for Julia 1.0 will continue to work in Julia 1.1, 1.2, etc. The language is “fully baked.” The core language devs and community alike can focus on packages, tools, and new features built upon this solid foundation." There are also many other new features, including: A new built in package manager Simplified scope rules Improved consistency in all of Julia's APIs A new canonical representation for missing values You can find out more about the new features here. Hang on... wasn't Julia 0.7 just released? Yes, Julia 0.7 has been released alongside version 1.0. This was done "to provide an upgrade path for packages and code that predates the 1.0 release." Version 0.7 simply includes deprecation warnings that aren't included in version 1.0. How to get started with Julia 1.0 If you're ready to get started on Julia 1.0 you can download it here. It's advised that if you're currently using Julia 0.6 or earlier, you should start with the 0.7 release - the deprecation warnings in Julia 0.7 act as a guide through the upgrade process.

We recently asked whether Dart programming was dead, but news of its death might well have been exaggerated. Version 2 of the programming language has just been released, with a range of updates and changes that should cement its popularity with admirers and win new users too. With Dart playing a big part in Google's much-anticipated Flutter and Fuchsia projects, there's a possibility that version 2.0 represents a brand new chapter in Dart's life. News of a Dart 'reboot' first emerged in February 2018. Anders Thorhauge Sandholm said at the time that “with Dart 2, we’ve dramatically strengthened and streamlined the type system, cleaned up the syntax, and rebuilt much of the developer tool chain from the ground up to make mobile and web development more enjoyable and productive.” It would appear that six months later the team have finally delivered on their promise. They'll be hoping it makes a positive impact on the language's wider adoption. What's new in Dart 2.0? There's a whole host of changes that Dart developers will love, all of which can be found in the changelog on GitHub. Most notable is a stronger typed system, which includes runtime checks that will capture errors more effectively, and, for those developers working on Flutter, you can now create an instance of a class without using the "new" keyword. Among other updates, other key changes to Dart include: "Functions marked async now run synchronously until the first await statement. Previously, they would return to the event loop once at the top of the function body before any code runs." "Constants in the core libraries have been renamed from SCREAMING_CAPS to lowerCamelCase." "...New methods have been added to core library classes. If you implement the interfaces of these classes, you will need to implement the new methods." All the changes you'll find in Dart 2.0 amount to the same thing: improving the developer experience and making the code more readable. The obvious context to all this 'reboot' is that Google is betting on the growth of Flutter and Fuchsia over the next few years. With these improvements, it's possible that we'll begin to see Dart's fortunes changing. CodeMentor may have called Dart the 'worst programming language to learn in 2018' at the start of the year, but it will be interesting to see if it's popularity has grown by the time we hit 2019. You can download Dart 2.0.0 for Windows, Mac, and Linux here.

Perlin Networks, a scalable DAG-based distributed ledger protocol, introduced a new cross-platform WebAssembly VM named Life. This WebAssembly VM is secure, fast, written in Go and is built specifically for decentralized applications. WebAssembly is a high-level instruction set which enables developers to easily design computationally heavy programs that can securely run on web browsers at an improved speed. Apart from designing programs for the browsers, this instruction set can also be used to train ML models, host databases, or even host blogs/online retail stores 24/7. This is the reason why Perlin networks used it in their project, Life. Projects can easily run WebAssembly code anywhere by simply integrating the Life tool into their applications. Features of Life Life is Fast It uses a wide range of optimization techniques and is faster than all other WebAssembly implementations tested (go-interpreter/wagon, paritytech/wasmi). Life is Correct It implements WebAssembly execution semantics and passes most of the official test suite. Life is Secure User code executed is fully sandboxed. A WebAssembly module's access to resources (instruction cycles, memory usage) may easily be controlled to the very finest detail. Life is Pure This VM does not rely on any native dependencies, and may easily be cross-compiled for running WebAssembly modules on practically any platform such as Windows, Linux, Mac, Android, iOS, and so on. Life is Practical One can make full use of the minimal nature of WebAssembly to write code once and run anywhere. With Life, one can completely customize how WebAssembly module imports are resolved and integrated. A complete control over the execution lifecycle of the WebAssembly modules is also possible. To know more about the WebAssembly based Life VM, visit its GitHub page. Grain: A new functional programming language that compiles to Webassembly WebAssembly comes to Qt. Now you can deploy your next Qt app in browser

The Rust team has announced a new version of their popular programming language. Mozilla's Rust system programming language has always been focused on safety, speed, and concurrency. This release adds more power to these features. Rust 1.28 provides more flexibility and ease to memory allocation with global allocators and NonZero types. Global allocators Global allocators allow a developer to define the memory allocation system used by a Rust program.  Previously, Rust did not allow changing the way memory is obtained, which prevented some use cases. With Rust 1.28, the #[global_allocator] attribute is stable. This attribute will allow Rust programs to set their allocator to the system allocator, as well as define new allocators by implementing the GlobalAlloc trait. Better error message formatting Rust’s compiler has traditionally provided verbose and explicit error messages, along with suggestions for how to fix the problem.  Rust 1.28 introduces more detailed notes about why some error conditions arise. The entire list of formatting changes is available on Github. Library stabilizations NonZero types are now a stable addition to the language. NonZero number types are wrappers around the standard unsigned integer types: NonZeroU8, NonZeroU16, NonZeroU32, NonZeroU64, NonZeroU128, and NonZeroUsize. This provides easier to anticipate memory allocations and optimize program data placement. A number of other libraries have also been stabilized; you can see the more detailed release notes for full details. Cargo features Rust’s cargo utility no longer lets users publish crates with build scripts that modify the src directory for an application. This eliminates bugs during the compilation process. For more detailed release notes along with code snippets, you can read the Rust Language blog. Will Rust Replace C++? Say hello to Sequoia: a new Rust based OpenPGP library to secure your apps Eclipse IDE’s Photon release will support Rust

Grain is a strongly-typed functional programming language built for the modern web by leveraging the brilliant work done by the WebAssembly project. Unlike other languages used on the web today (like TypeScript or Elm), that compile into JavaScript, Grain doesn’t compile into JavaScript but compiles all the way down to WebAssembly, supported by a tiny JavaScript runtime to give it access to web features that WebAssembly doesn’t support yet. It was designed with the purpose to specifically serve web developers. Following are the language features: No runtime type errors Grain does not need any kind of type annotations. All the pieces of Grain code that developers write is thoroughly sifted for type errors. Developers do not have to deal with runtime exceptions and thus achieving full type safety with none of the fuss. Being functional, but flexible Grain is geared towards functional programming, but understands the web isn't as pure as we would like it to be. It enables one to easily write what's appropriate for the scenario. Embracing new web standards Grain is built on top of WebAssembly, a brand-new technology that represents a paradigm shift in web development. WebAssembly is nothing but a bytecode format which is executed in a web browser. This allows an application to be deployed to a device with a compliant web browser having to go through any explicit installation steps. TypeScript 3.0 is finally released with ‘improved errors’, editor productivity and more Elm and TypeScript – Static typing on the Frontend Tools in TypeScript

Racket programming language has a new version update, Racket 7.0. Users might not see huge differences between the previous version of Racket, v6.12 released in January 2018. However, v7.0 differs in the internals significantly. Racket or Racket lang is a multi-paradigm programming language--with an emphasis on functional programming--in the Lisp-Scheme family. Though not a popular one, Racket is considered as one of the easiest programming language. Languages such as Python, C#, Assembly, and so on are often talked about in the easy-categories; however, Racket lang is also a great choice as a starter language. What’s new in Racket 7.0? Updated Runtime This version includes a substantial change in its current runtime system and supports multiple runtime systems. New macro expander Version 7.0 replaces about ⅛ of the core v6.12 implementation with a new macro expander that bootstraps itself. The expander turns out to be about 40% of the new code needed to replace Racket’s core with Chez Scheme. Most of the other 60% is also implemented, but it is not included in this release. However, Racket-on-Chez will be ready for production use later in the v7.x series. Updates to DrRacket, the programming environment for Racket DrRacket’s “Create Executable” option for the teaching language (Beginner Student, etc.) uses --embed-dlls to create single-file, standalone ".exe"s on Windows. Improved supports within TypedRacket TypedRacket is Racket’s gradually-typed sister language which allows the incremental addition of statically-checked type annotations. TypedRacket’s support for prefab structs is significantly improved. This supports using prefab structs more polymorphically and fixes significant bugs in the current implementation. Programs which currently use predicates for prefab structs on unknown data may need to be revised since previous versions of Typed Racket allowed potentially buggy programs to type check. Check out Typed Racket RFC 1 and prefab Changes doc for more details on this change and on how to fix programs affected by it. Typed Racket also supports #:rest-star in the ->* type constructor, which allows function types to specify rest arguments with more complex patterns of types, such as the hash function. Other features in the Racket 7.0 include: The syntax (#') form supports new template subforms: ~@ for splicing and ~? for choosing between subtemplates based on whether pattern variables have “absent” value (from an ~optional pattern in syntax-parse, for example). The syntax/parse/experimental/templatelibrary, where these features originated, re-exports the new forms under old names for compatibility. On Windows, an --embed-dlls flag for raco exe creates a truly standalone, single-file ".exe" that embeds Racket’s DLLs. Interactive overlays can be added to plots produced by plot-snip. This allows constructing interactive plots or displaying additional information when the mouse hovers over the plot area. Examples of how to use this feature can be found on Alex Harsanyi’s blog racket/plot provides procedures for displaying candlestick charts for use in financial time series analysis. Added contract-equivalent?, a way to check whether two contracts are mutually stronger than each other without the exponential slowdown that two calls to contract-stronger? brings. Lazy Racket supports functions with keyword arguments. Read more about Racket 7.0 on the Racket official blog. What is the difference between functional and object-oriented programming? Putting the Function in Functional Programming Elixir Basics – Foundational Steps toward Functional Programming

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’

Elixir 1.7 has been released. Elixir builds on top of Erlang designed for building scalable and maintainable applications. This release is focused on improving error handling, logger reporting, and documentation. It also brings improvements to ExUnit, Elixir’s testing library. ExUnit improvements ExUnit is Elixir’s unit testing library. ExUnit uses Elixir macros to provide error reports when a failure happens using the assert macro. The assert macro can look at the code, extract the current line, extract the operands and show a difference between the data structures alongside the stacktrace when the assertion fails. However, for certain ‘bare’ assertions, ExUnit usually re-runs the tests, debugging or printing the values. In Elixir 1.7, now, whenever a “bare” assertion will fail, it will print the value of each argument individually. E.g, For a simple example such as assert some_vars(1 + 2, 3 + 4), users will get this report: Their build tool Mix has also received new updates. There is a new --failed flag that runs all tests that failed the last time they ran. The coverage reports generated with mix test --cover includes a summary out of the box. Updates to the ExDoc tool ExDoc is a tool to generate documentation for user Elixir projects. It leverages metadata to provide better documentation for developers. These are the updates to ExDoc. Deprecated modules, functions, callbacks, and types now have a warning automatically attached to them. Functions, macros, callbacks, and types now include the version in which they were added. Future Elixir versions will include their own section for guards in the documentation and in the sidebar. They are currently exploring ways to generalize this feature in ExDoc itself. Erlang/OTP logger integration improvements Elixir 1.7 fully integrates with the new :logger module available in Erlang/OTP 21. The Logger.Translator mechanism has also been improved to export metadata, allowing custom Logger backends to leverage information such as: :crash_reason, a two-element tuple with the throw/error/exit reason as the first argument and the stacktrace as the second. :initial_call, the initial call that started the process. :registered_name, the process’ registered name as an atom. Updates to Logger configuration system From Elixir 1.7 the Logger macros such as debug, info, will evaluate their arguments only when the message is logged. The Logger configuration system also accepts a new option: compile_time_purge_matching that allows users to remove log calls with specific compile-time metadata. There are also certain developments in areas not directly related to the Elixir codebase. A new Development section has been added to the website, that outlines the Elixir team structure and goals. It also now has its own mini-documentary. Read the Elixir-lang blog for the full list of Elixir 1.7 updates. You can also check the Install section to get Elixir installed and read the Getting Started guide to learn more. Elixir Basics – Foundational Steps toward Functional Programming 5 Reasons to learn programming

Team Gradle has released a new version of their tool and that’s Gradle 4.9. Gradle is a build tool for build automation with multi-language development. It offers excellent flexibility to the complete development lifecycle. As per the team, one of the quickest ways to update one’s build to use the new version is by updating the build wrapper properties as follows: ./gradlew wrapper --gradle-version=4.9 However, the standalone downloads are available at gradle.org/install What’s new in the Gradle 4.9 Command line arguments are now supported by JavaExec One can now pass command line arguments to JavaExec using --args. This means if one wants to launch their application using the command line arguments foo --bar, hardcoding it into the build script is not required. One just has to simply run gradle run --args 'foo --bar. An improved dependency insight report This version features an improved dependency insight report including build scans.  The report helps in easy diagnosis of dependency management problems, locally. Some improvements in this report include: All participants of conflict resolution are shown All custom reasons for a component selection are shown Modules rejected by a rule are displayed Modules which didn't match the version selector but were considered in the selection are shown This report also solves the readability resolution failures by restricting the report to one path with each dependency. Native ecosystem continues The Gradle Native project stays steady in order to improve and evolve the native ecosystem support for Gradle. Checkout builds are now fast and clean This version now stores more states in the Gradle user home instead of the project directory. This results in clean and faster checkout builds on CI as long as the user home is preserved. Java and Groovy compilers are now leak-proof file descriptors By default, the Java and Groovy compilers both leak file descriptors during the run in-process. This, in turn, can lead to "cannot delete file" exceptions on Windows and "too many open file descriptors" on Unix. In the Gradle 4.9, these leaks have been fixed. Users who had switched to forking mode because of this problem, can now safely switch back to in-process compilation. Experimental new task API Gradle 4.9 includes a new task API which allows builds to avoid the cost of creating and configuring tasks for the ones that will never be executed. By upgrading to this new API, one can experience slightly faster configuration times. The benefits will keep improving as more plugins adopt this API. Note that this API is in incubation and may change before Gradle 5.0. The promoted features are now stable This version includes some promoted features which were in incubation during the previous release. The promoted features which include a stable dependency insight report and the tooling API types and methods are now supported and stable. These two features are also subject to backward compatibility. Potential breaking changes in Gradle 4.9 EclipseProject tasks defined for gradle eclipse are allowed to run in Buildship. Two tasks from the EclipseProject, namely the EclipseClasspath and EclipseProject are now executed by the gradle. Use of Groovy GPath expression with the method, tasks.withType() would get a runtime exception. The easiest fix is to explicitly use the spread operator. As per my past research on Gradle and observing its past release trends, it looks like we can expect Gradle 5.0 in August or September. Read more about the other fixed issues and deprecations in the Gradle 4.9 release notes. Gradle with the Java Plugin Speeding up Gradle builds for Android Working with Gradle  

Jetbrains have released a new version of their Kotlin/Native technology. With Kotlin/Native, you can compile Kotlin to native binaries that run without any virtual machine. It can also be used when a developer needs to produce a reasonably-sized self-contained program not requiring an additional runtime. Kotlin/Native is now available in version 0.8 with the focus on safer concurrent programming, extending the stdlib functionality, and better iOS development support. The version also hosts numerous bug-fixes and performance optimizations. Let us take a look into each one in detail: Better concurrency support The version 0.8 improves concurrency support with the addition of shared immutable state and improved atomic values and references. Previously, Kotlin/Native applications kept the singleton object state local to a particular thread of execution. This helped in keeping the state of singleton objects on different threads non-synchronized. Now, the version 0.8 allows freezing on singleton objects. With this, developers now have a shared immutable state. A file will be read once per process execution, and is available to any thread or worker. Once published, the object is frozen, and cannot be modified anymore. Library improvements in Kotlin/Native Kotlin/Native has added performance improvements to the existing libraries. The standard library (kotlin.*) is standardized with other platforms using expect/actual mechanism and mostly matches other Kotlin flavors. The standard random number generator and collection shuffling functions are now available, eliminating the need of platform-specific APIs to obtain random numbers. Other JetBrains-provided libraries, like kotlinx.coroutines, kotlinx.serialization, and Ktor HTTP client will get experimental Kotlin/Native support. Developers can now write an iOS app and Android application sharing the same REST API-related logic. iOS support improvements The version 0.8 fixes bugs that prevent publishing iOS apps to AppStore and solves framework initialization problems. It also adds support for 32-bit ARM iOS, so that older devices can be used with Kotlin/Native as well. Binaries can be downloaded for macOS, Linux, and Windows. Visit the GitHub release page for additional information. Forget C and Java. Learn Kotlin: the next universal programming language Getting started with Kotlin programming 4 operator overloading techniques in Kotlin you need to know

Oracle has announced a major shift in the pricing structure for various offerings of Java. Currently, there are many offerings for the core Java language in terms of Java binaries, Java for desktops, commercial offering, among others. Java binaries are offered free for developers under the General Public License 2 (GPL 2). Java SE is offered, at an entry-level support, for $2.50/desktop for a month, or $25/CPU for a month. Under the free offering for developers, Oracle will provide OpenJDK builds (the backend that keeps Java running on any system) under the GPL + CPE license. To make the offering more flexible, Oracle is working on Oracle JDK which would support Java SE 11 (the LTS release) set to launch in September 2018. With Oracle JDK, Oracle is trying to make the offering of Java binaries simpler for the developers as it would be royalty-free for open-source development, testing, etc. For the commercial license, Oracle will be offering the Java SE Subscriptions combined with the technical support and access to all the updates that will follow the Java SE release cycle. Apart from the commercial offering, Oracle also has varied pricing for offerings through Oracle Academy. With the new Java SE Subscription, comes with a feature called Java Advanced Management Console. This feature will enable the license holders to identify, manage, and tune Java SE use in systems used across the enterprise. It also includes Oracle Premier Support, to enable support for Java across current and previous versions. Oracle, in their press release, mentioned the update in the subscription model is inspired by how Linux provides support for updates in the platform. It mentions "the subscription model for updates and support has been long established in the Linux ecosystem". By this new subscription model, Oracle ensures that anyone requiring the additional level of support for Oracle products can receive it with flexible pricing and still keep a balance between its open source and commercial offerings. For all the details on these subscriptions, you can visit the Java SE subscription FAQs. Oracle reveals issues in Object Serialization. Plans to drop it from core Java. 5 Things you need to know about Java 10 Oracle Apex 18.1 is here!

Julia 0.7  announced by the Julia developer team was speculated for a long time after v0.6 was released last year. This sets the gate open for Julia v1.0 since we had seen discussions and forecast about the v1.0 after v0.6 was out. Most features included in Julia v0.7 are the feature set for Julia v1.0 with few improvements and bug-fixes. Nothing is confirmed by the Julia team yet but the community is predicting Julia v1.0 to be next after Julia 0.7. Important features in Julia 0.7 are as follows: New macros defined for testing the local variable. Destructuring in function arguments so that the variable in a function expression gets unpacked into the local variable. Keyword argument containers will be named tuples. Keyword arguments will be required in the declaration to avoid the exceptions. To know the whole list of specifications, check out the release notes page here at Julia’s GitHub repository. Julia 0.7 will be released with exceptions in compatibility for functionalities of Julia 0.6. These exceptions will, however, discontinue in Julia 1.0. Apart from this, Julia 1.0 will add some functionality that will be prevented in Julia v0.7. It seems to be a bit complicated compatibility planning by Julia community, which is expected to get sorted with Julia 1.0. The community hinted Julia 0.7 and 1.0 to be identical. This means programs that are running on Julia 0.7, will work exactly the same on 1.0 without any warnings. The release time for Julia 1.0 is expected to be short after Julia 0.7. Julia 0.7 is said to be stable and production ready, but the community advised to keep the deprecations of features in mind. Additionally, when developers upgrade to Julia 1.0, they will have to run the tests and use cases all over again. Basics of Programming in Julia Computer vision is expanding quickly. Here’s why. Visual Studio 2019: New features you should expect to see