Tech News - Programming

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)  

“Security, customizability, flexibility and cost are a few of the benefits of open-source software for developers. They’ll get all these and more from NVIDIA’s Material Definition Language software development kit.” —NVIDIA Blog. The material definition language (MDL) is a programming language used to define and render physical materials. This includes the creation of a wide range of physical materials such as woods, fabrics, translucent plastics and more. It is a set of tools integrating the precise look and feel of real-world materials into rendering applications. It gives users the freedom to share these materials between applications that support them. Now users can move a library of these materials between applications without worrying about them losing their appearance. This will allow developers to focus on building their applications. Allegorithmic had already built an entire MDL authoring tool, but with NVIDIA making the MDL SDK open source, developers get a deeper unrestricted access to the entire spec. The Blog states that Unreal Studio 4.20 now offers native support for MDL. “Being able to use a single material definition, like NVIDIA’s MDL, across multiple applications and render engines is a huge benefit to the end-user,” said Ken Pimentel, senior product manager of the Enterprise team at Epic Games. “Now that we’ve added MDL support to Unreal Studio, our enterprise customers can see their material representations converted to real time in Unreal Engine without baking every parameter. This means their creative intent can be carried to new forms of expression.” The MDL SDK API is C++ based and used for integration and customization tasks. It can be loaded dynamically and linked to visualization applications. The API also allows applications to load MDL modules, and analyze and understand the structure of a material. Therefore it can build a UI for editing materials then rendering the results. Some of the features in MDL SDK include: Can be used on GPU as well as CPU Database view on the imported MDL package space MDL editing C++ component-based API, and plugin architecture for extensibility MDL SDK supports Windows (only 64-bit), Linux, and macOS. To know more, visit the NVIDIA website and to get started here is the GitHub repository. Nvidia unveils a new Turing architecture: “The world’s first ray tracing GPU” Nvidia and AI researchers create AI agent Noise2Noise that can denoise images Nvidia GPUs offer Kubernetes for accelerated deployments of Artificial Intelligence workloads

The July 2018 release of Visual Studio code 1.26 version is now available. This version includes new features for navigation, how to apply a quick fix to any problem, managing extensions and much more. What’s new in the Visual Studio code 1.26? Breadcrumbs The Visual studio editor now has a navigation bar above its contents called Breadcrumbs. It displays the current location and allows quick navigation between symbols and files. Breadcrumb navigation allows one to jump to symbols and files in their workspace. Quick Fixes from Problems panel Now one can apply Quick code fixes from the Problems panel while reviewing warning and errors. When a problem entry is hovered or selected, the respective Quick Fixes are shown via a light bulb indicator. Quick Fixes can be applied either by clicking on the light bulb or by opening the context menu for the problem entry. User setup on Windows The user setup package for Windows, announced in the previous release, is now available. This setup does not require Administrator privileges while installation. It also provides a smoother background update experience. Current users of the system-wide Windows setup will be prompted to switch to the user setup. New users will be directed towards using it by default via Visual Studio code Download page. Terminal column selection Column selection is now supported within the Integrated Terminal via Alt+click. Add all missing imports with a single quick fix The Add missing import Quick Fix can now be applied to all missing imports in a JavaScript/TypeScript file. This Quick Fix requires only a single action to add all missing imports in a JavaScript/TypeScript file. JSX tag completion Now one can work with JSX tags in JavaScript/TypeScript similar to that in HTML. The JSX tags are now closed automatically when you type ‘>’ in a JavaScript or TypeScript file. Auto closing of tags can be disabled by setting "javascript.autoClosingTags": false and "typescript.autoClosingTags": false. Better JS/TS error reporting The TypeScript team has done a lot of work to make JavaScript and TypeScript error messages smarter and clearer. Some error messages now include links to relevant locations in the source code. Improved extension search This release has added an IntelliSense autocompletion to the extension searchfield making it easier. This will help in refining extension searches to filter results based on things like category and install state; or sort results by name, rating, or install count. Extension Pack management Extension Pack management has been improved in this release. An Extension Pack is installed, uninstalled, enabled or disabled always as a single pack. One can now uninstall or disable an extension belonging to an Extension Pack without requiring to uninstall or disable the entire Extension Pack. One can easily manage Extension Packs as a single unit or by individual extension. There is also a new Extension Pack tab which displays which extensions are bundled in the Extension Pack. Preview: Settings editor This version includes a preview of GUI for editing settings. To try it out, one can go to Preferences: Open Settings (Preview) command. It contains rich settings description display, "Table of Contents" tracks scrolling, and much more. Read more about these features in detail on the Visual Studio Code July 2018 version 1.26 release notes. Microsoft releases the Python Language Server in Visual Studio Debugging Xamarin Application on Visual Studio [Tutorial] Visual Studio 2019: New features you should expect to see

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

Qml.Net is a C# library for cross-platform GUI development with native dependency. It exposes the required object types to host a QML engine. In Qml.NET, Qml and JavaScript together form the UI layer. It can be thought of as the view in MVC. Qml.Net features The PInvoke code in this .NET library is hand-crafted by developer Paul Knopf to ensure appropriate memory management and pointer ownership semantics. He is pretty confident about the library and mentions in his blog “I’d bet you couldn’t generate a segfault, even if you wanted to.” In Qml.Net C# objects can be registered to be treated as QML components. You can then interoperate with them as you would with regular JavaScript objects. The registered C# objects serve as a portal through which the QML world can interact with your .NET objects. This has an added benefit of keeping your business/UI concerns separate cleanly. There will also be no chatty PInvoke calls for rendering. It is a great match. A pre-compiled portable installation of Qt and the native C wrapper is available for Windows, OSX, and Linux. Developers wouldn’t have to bother with C/C++. All you need to know is QML, C#, and JavaScript; QML if fairly simple. QML can’t really be classified as a language, in the semantic sense. More appropriately it can be considered as a combination of JSON and JavaScript. Qml.Net support and working Qml.Net will work with any .NET language including popular C# and functional languages like F#. Your libraries will reference the pure .NET NuGet package, Qml.Net. The host process (Program.Main) references the native NuGet packages. This is dependent on the OS you are on: Qml.Net.WindowsBinaries Qml.Net.OSXBinaries Qml.Net.LinuxBinaries Paul currently only tests his own models that are C# objects registered with the QML engine. They are specific to each control/page. Since Microsoft's announcement of .NET Core, there hasn’t been any clear idea on cross-platform GUI development. Although Microsoft plans to support WPF in .NET Core 3.0, it will be limited to Windows machines. With community involvement and support, Qml.net can be a potential game changer. You can head to the GitHub repository and also view some hosted examples to get a better idea. Read next Exciting New Features in C# 8.0 .NET Core completes move to the new compiler – RyuJIT Microsoft Azure's new governance DApp: An enterprise blockchain without mining

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 Free and Open source Software Developers' European Meeting (FOSDEM) is no longer the home of OpenJDK committers and other regular contributors. Traditionally the OpenJDK community used to meet at FOSDEM every February in Brussels, but since the OpenJDK team is now shipping a release every six months they agreed that it was time to meet more frequently. To fill this need the team decided to hold a Committer's workshop on the first two days of August at Oracle’s campus in Santa Clara, California, USA. Mark Reinhold, the Chief Architect of the Java Platform Group at Oracle was the conductor of the orchestra here. He shed some light on the recent developments to the OpenJDK ecosystem and shared some future plans in yesterday’s sessions. OpenJDK’s new release model is a blessing in disguise It’s probably old news for developers who have been tracking the Java release cycle for some time now, but nonetheless, it’s very important for how things are going to change for OpenJDK. 2018 marked a new dawn for the Java platform. After endless discussions in the community about the new release being a repeat telecast of the same old Java 9 movie—a historic feature driven update to the platform with no head or tail on the release date—Mark put all the rumors to bed. He suggested to replace this feature driven update to a strict, time-based model with a new feature release every six months, update releases every quarter, and a long-term support release every three years. Image Source: OpenJDK Community Update For example, JDK 10 which was a new feature release was made available in March this year. The next release in six months would be JDK 11, which automatically becomes a candidate for a Long term support which would last till 2021, i.e three years as mentioned above. The biggest advantage of this release schedule is the simplified release process; takes off the pressure of adhering to strict deadlines from the developers. It also means that every feature would have to be completed before it makes the final cut, this way there are no multiple minor versions of the same release which confuses the users and developers alike. To what extent will Oracle contribute to the OpenJDK community? In the Committer's workshop Mark Reinhold cleared some questions about Oracle’s contribution to the OpenJDK ecosystem. He mentioned that Oracle engineers would be leading and be contributing only to the current feature releases and first two updates on the quarterly release. The non-Oracle folks can have the opportunity of taking the ownership of long-term release projects. This decision is taken mainly due to the fact that Oracle developers and engineers can focus on the future releases and their functionalities rather than working on support for long-term releases. An important clause which was discussed during this session was Oracle’s smooth transition of leadership whenever the engineers feel that they need to dial down their contribution to a particular release line they would hand over the leadership of that project with relative ease. Oracle finally embraces the Open Source Culture Now the biggest announcement that came in this workshop was Oracle open sourcing the elements of it proprietary JDK. Now before discussing this, it is important for us to understand what exactly is the difference between OpenJDK and Oracle’s proprietary JDK. Sun Microsystems, who originally created Java, announced in the JavaOne conference of 2006, that Java is going to be open sourced. OpenJDK was a result of a free implementation of the Standard Edition (SE) of the Java Platform. When Oracle bought Sun in 2009, they created their own proprietary version of the JDK which catered to the enterprise users who valued stability; and unlike OpenJDK, it has releases planned every three years. Now coming back to the point of open sourcing Oracle’s proprietary JDK, for a long time developers questioned Oracle’s intentions on how they plan to shape the future of Java, especially after their feud with Google over Android that began back in 2010. The open source community felt largely alienated from Oracle as they believed that Oracle was wrong in going after an open source friendly company like Google. Fast forward to 2018 and in this day and age, companies are embracing more and more open source technologies. Oracle has finally decided to open source their JDK which includes elements like Java flight recorder, Java Mission Control, and ZGC which is Oracle’s very own garbage collector. There will still be an Oracle JDK for the purposes of offering commercial support, but it will have the same functionalities as OpenJDK. Finally, Oracle is going to release all the builds for the current releases under the GPL license for developers who prefer non-commercial licensing. To know more about the different sessions that took place at the Committer's Workshop you can visit their Official webpage. Mark Reinhold on the evolution of Java platform and OpenJDK Oracle announces a new pricing structure for Java The top 5 reasons why Node.js could topple Java

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

After Kotlin had released 1.2 nearly six months ago, the official language for Android finally announced the first release candidate of their next major version: ‘1.3 M1’. This new release comes with plenty of features most notably coroutines, new experimental unsigned arithmetic, and much more. Coroutines are no longer a pipe dream Coroutines have been in the experimental stage since they were first introduced in Kotlin 1.1. Kotlin 1.3 brings Coroutines to limelight as JetBrains’ Ilya Gorbunov explained in his blog post announcing Kotlin 1.3-M1. Coroutines simplify asynchronous programming by putting the complications into libraries. With coroutines, developers can express the logic of the program sequentially and the library will take care of the asynchrony. What’s more interesting is that with Kotlin coroutines developers can call asynchronous mechanisms from different programming languages into their own program as libraries. For example  async/await from C# and ECMAScript, channels and select from Go, and generators/yield from C# and Python. The Kotlin team has significantly improved the features surrounding coroutines since they were first introduced, some notable features include support callable references to suspending functions and serializability of all coroutine-related classes. But that’s not it, the Kotlin team plan to add a multiplatform version of the coroutine API which will support iOS through Kotlin/Native. Experimental New Features The technique of introducing experimental features in a release version helps the development team to gather valuable feedback from the community and implement their suggestions in the future releases, and that is exactly what the the Kotlin team has been doing. We saw a similar implementation with Coroutines in the previous version, and now the team is introducing a plethora of new experimental features such as inline classes, unsigned integer types, and annotations for marking an experimental API and opting-in for it. In order to use these experimental features in projects, developers would have to explicitly choose an opt-in flag. Without an opt-in, usage of a feature will be marked as warnings or errors. Other small features in Kotlin 1.3 While the bigger new features have been released as experimental there are numerous small features which have been released in this new version. Capturing when subject in a variable Capturing the subject of when expression in a variable is now supported in Kotlin language. This feature was one of the most popular feature request in Kotlin team’s issue tracker. This addition makes the response variable properly scoped within when expression, and makes the logic flow in a more expression-like fashion. @JvmStatic and @JvmField in companions of interfaces Kotlin interfaces can now expose static members (fields and methods) to Java clients. However, to use @JvmField on interface companion properties, all of them must be public final vals and all of them must be annotated. Also, the -jvm-target compiler option must be at least 1.8. Nested declarations in annotation classes Before 1.3, annotation classes could not have bodies in Kotlin. This release relaxes this limitation, allowing them to have nested classes, interfaces, and objects including a companion object. These are just a select set of features that make up for the entire release announcement of Kotlin 1.3. If you are interested in checking out the entire feature-set including the new APIs that are available in the standard library and the breaking changes, you can refer to JetBrain’s official blog. Kotlin/Native 0.8 recently released with safer concurrent programming 4 operator overloading techniques in Kotlin you need to know Building RESTful web services with Kotlin

Google Summer of Code (GSoC), a global program focused on introducing students to open source software development is nearing the end of its competition for this year. A student developer named Victor Perevertkin has been successful in his GSoC 2018 project on Btrfs file-system support for ReactOS. He has been able to boot the Windows API/ABI compatible OS off Btrfs. [box type="shadow" align="" class="" width=""]ReactOS is a free and open Source operating system and is compatible with applications and drivers written for the Microsoft Windows NT family of operating systems (NT4, 2000, XP, 2003, Vista, Seven). [/box] For his GSoC 2018 project, Perevertkin has been working on Btrfs support within the ReactOS boot-loader as well as other fixes needed to allow for ReactOS to be installed on and boot from a Btrfs file-system. BTRFS is case-sensitive file system, so paths like /ReactOS/System32, /reactos/system32, /ReactOS/system32 are different here. However, Windows is written assuming that case does not matter during path lookup. This issue is solved in WinBtrfs driver, but for Freeloader it can be a bit tricky. After Perevertkin was done with the Freeloader development and had fixed the VirtualBox bug, he was able to get to first error message from btrfs-booted ReactOS. He later found out that this was due to a bug in WinBtrfs driver. A pull-request to the upstream repository with a bugfix is provided on GitHub repository. At present, ReactOS is able to boot from BTRFS partition and also is in quite stable state. However, some problems are yet to be addressed. Read about this news in detail on ReactOS Blog. ReactOS version 0.4.9 released with Self-hosting and FastFAT crash fixes Google’s App Maker, a low-code tool for building business apps, is now generally available 5 reasons you should learn to code

The Apache NetBeans team has announced the latest release of the Java IDE Apache NetBeans 9.0 (incubating). This release focuses on two main objectives, the IP clearance of the Oracle code donation and Java 9 and 10 Support. It also adds other new features, such as support for local variable type inference and the Jigsaw module system, a new Java Modular Application project type, and Java Shell support. The ASF Incubator is the official entry path for projects and codebases that want to become a part of the ASF. This is the process through which those projects are screened to make sure they comply with the ASF legal standards and their support communities adhere to the ASF's guiding principles. The primary focus of this release is IP clearance of the code Oracle donated to the ASF. Local Variable Type Inference support Apache NetBeans (incubating) 9.0 adds support for Java 10 with new hints, error handlers, and refactorings for transforming to the new JDK 10 var type. New hint to convert explicit variable type to var. New hint to Convert var type back to explicit type. Var is not supported in a compound variable declaration. This hint helps correct compilation error by splitting the declaration into separate statements. New Error Hint for var Array declaration. This hint helps correct compilation errors by converting to an explicit type by inferring the type of data in an array. Support for the Jigsaw model Apache NetBeans 9.0 adds support for the Java Platform Module System (JPMS) which a central component of Project Jigsaw. NetBeans 9 adds ModulePath as a paradigm to NetBeans in addition to Classpath. Project Jigsaw was established with the goal to improve the security and maintainability of Java SE Platform Implementations and the JDK. It was made with the purpose to make it easy for developers to construct and maintain libraries and large applications. Java Modular Application project type Apache Netbeans 9.0 also adds a new Java Modular project type, which enables the development of several JDK 9 modules in one NetBeans project. The advantage of this type over other Java SE projects is that dependencies are managed by declaring the appropriate exports and requires, and all modules and the project are compiled at the same time. Java Shell support Apache Netbeans 9.0 also adds an integrated console-like UI to the Java Shell to leverage NetBeans editor capabilities. Java Shell introduces REPL (read-eval-print-loop) capabilities to Java and is included in JDK9 and defined in JEP 222. NetBeans also extends the capabilities of the command line tool, allowing developers to execute the shell as an agent on the debugged or run application. The Snippets written in JShell can be redefined and tested, even against a running code. Apache NetBeans 9.0 is available for download from your closest Apache mirror. For this release no installers are provided, you need to just download the binaries and unzip them. Source: incubating-netbeans-java-9.0-source.zip ( PGP ASC, SHA-1) Binaries: incubating-netbeans-java-9.0-bin.zip ( PGP ASC, SHA-1) More information about this release is available on the Apache NetBeans blog post. Apache NetBeans 9.0 RC1 released! What can you expect from the upcoming Java 11 JDK? The NetBeans Developer’s Life Cycle