Tech News - Languages

Oracle has announced the release of Java 10 version on March 20. While this is not an LTS version, there are few changes in this version which are worth noting. In this article we’ll look at  5 of the most important things you’ll need to watch out for, especially if you’re a Java developer. Java releases long term support versions in every 3 year. As per this scheduling, their future long term support version, Java 11 will be releasing in Fall 2018. Java 10 is a precursor to that and contains some important changes which will take a clearer shape in the next version. Java 10 is trying to emulate some of the popular features of Scala and Kotlin. One of the primary reasons can be the growing popularity of Kotlin in both web and mobile development domain and also the dynamic typing capability in Scala and Kotlin both.  The introduction of local variable type is one of them. This feature implies that variables can now be declared as “var” and when you assign a certain integer or a string to it then the compiler will automatically know what type of variable it is. Although this doesn’t make Java a dynamically typed language like Python, still this allows a lot more flexibility for the programmers and lets them avoid boilerplates in their code. There are 2 JEPs in JDK 10 that focus on improving the current Garbage Collection (GC) elements. The first one, Garbage-Collector Interface (JEP 304) will introduce a clean garbage collector interface to help improve the source code isolation of different garbage collectors. In current Java versions there are bits and pieces of GC source files scattered all over the HotSpot sources. This becomes an issue when implementing a new garbage collector, since developers have to know where to look for those source files. One of the main goals of this JEP is to introduce better modularity for HotSpot internal GC code, have a cleaner GC interface and make it easier to implement new collectors. Java 10 promises to become much faster than its previous version by making the full garbage collector parallel. This is a welcome move and change from the version 9 since this allows the developers scope to better allocate memory and use the GC (Garbage Collector) in parallel. The GC  in the previous versions didn’t have the capability to load values in parallel and that made it heavy and difficult to operate for complex applications. The present parallel GC removes that factor and makes it much more lightweight and efficient. Java 10 enables programmers to allow heap allocation on alternative memory devices. This feature lets the Java VM decide on the most important tasks and then allocate maximum memory for those priority processes with other processes are allocated to alternative memory. This helps in fastening up the overall process. This change is important for the Java developers because this will help them in better and efficient memory management and hence will increase the performance of their applications. With these changes, Java 10 has opened up the doors for a more open and flexible language which is looking towards the future. With Kotlin breathing down its neck as a worthy alternative, the stage is set for Java to work towards a more dynamic and easy to use power packed version 11 in 2018 fall. We would be waiting for that along with the Java developers for sure. What can you expect from the upcoming Java 11 JDK? Oracle reveals issues in Object Serialization. Plans to drop it from core Java. Java Multithreading: How to synchronize threads to implement critical sections and avoid race conditions  

The Java team is planning to remove the Java Serialization feature from core Java language. This is owing to some security issues with the object serialization API. What is Java’s Object Serialization feature? The Serialization API converts the message in a data communication system into a sequence of bytes which can be processed further. The sequence of bytes is made into an object and written in a Java file. This file can be read and deserialized to recreate the message in the memory. Why is Oracle calling it a mistake? Approximately one-third of all the vulnerabilities in the Java systems have serialization involved. Mark Reinhold, chief Architect from Oracle mentioned that Oracle has been receiving reports that revealed the security weakness in Java Serialization. They have found a lot of applications servers receive serialization data streams on unprotected ports of a server. The attackers can use the easy use case of the serialized object and deserialize to recreate the object. Adding to the overhaul, Reinhold called the serialization feature as a “horrible mistake” made in 1997. To counteract these vulnerabilities, Oracle has added a filtering capability in Java to provide a defense mechanism for the network using serialization and receiving untrusted data streams. Oracle also mentioned their plans to remove serialization from Java as a long-term plan under Project Amber, focussed on streamlining the release cycle of Java and to enhance the productivity of the Java language in the Java 11 release. Looking ahead To continue to support the serialization in Java language, Oracle is planning to add a Serialization feature that will enable object serialization in a safe way. The framework will also be developed to support graphs, that supports JSON or XML to provide serialization of any record. Why Oracle is losing the Database Race What Google, RedHat, Oracle, and others announced at KubeCon + CloudNativeCon 2018 What can you expect from Java 11

PyCon Conference 2018, held between May 9 -17 at Cleveland, United States, is one of the largest annual gatherings in the Python programming community. Every year features a range of important announcements and discussions, many of which could have a huge impact on the future of Python. This year featured discussions on everything from data science to cryptocurrencies. Let’s take a look at some of the highlights. Quantum Computing Quantum computers are turning into reality, 30 years after they were first theorized. Companies such as IBM, Google, Intel, and Microsoft have all jumped into the quantum computing pool by announcing their own quantum devices. Although Quantum computing is still at a very early stage, Python is slowly becoming a de facto language for programming quantum computers due to its vast ecosystem of libraries. Dr. Ravi Chityala, a Senior Engineer at Elekta Inc, gave an impressive talk on quantum computing while highlighting several caveats that distinguish a traditional and quantum computer. He also demonstrated how to program a quantum computer on stage with Python. Check out the complete presentation here. Blockchain and Cryptocurrencies Blockchain and cryptocurrencies are all the rage right now. Cryptocurrencies such as Bitcoin had attracted a lot of attention in the past one year, mostly from people who were trying to make a quick buck. But this trends seems to be settling down. People are shifting their focus to understanding the technology behind cryptocurrencies. This is where Blockchain comes into the picture. What’s important to developers and businesses is how Blockchain can be applied. The lack of knowledge about how Blockchain works is a barrier that stops many  people entering and exploring the blockchain and cryptocurrency world. The session “Getting Started with Blockchains and Cryptocurrencies in Python” at PyCon conducted by Amirali Sanatinia, aimed to solve this problem by helping them understand the nuts and bolts of Blockchain and embark their journey on this revolutionary technology. Django 2.0 Unchained Django is one of the most popular web development frameworks for Python. Last December the Django team released version 2 of the popular server-side framework. Since this was one of the major releases, it was no surprise that Django was a hot topic of discussion at PyCon 2018. Harry Percival, author of Test-Driven Development with Python, presented a couple of tutorials specifically for Python testers. His tutorial was an introduction to doing Test-Driven Development (TDD) with Django.He shed some light on how automated software testing has moved from being a niche interest to an important new way of thinking about how to optimise automation testing. Serverless Python Serverless is the latest phase in the evolution of cloud development; it has recently exploded in terms of popularity. Going serverless lets developers to focus on their core product instead of worrying about managing and operating servers or runtimes, either in the cloud or on-premises. This reduced overhead helps them to achieve the required scale without the overhead of running and managing the fleet of servers. Since Python is one of the few languages supported by AWS Lambda, developers can leverage it to build fast and cost-effective solutions. In PyCon 2018 we saw some exciting sessions which highlighted the latest developments in Serverless computing. James Saryerwinnie’s tutorial on Building serverless applications with AWS Chalice, sparked the interest of professional developers, while Michael Herman’s tutorial on Going Serverless with OpenFaaS, Kubernetes, and Python was explored how to build and deploy a full-stack application that uses Flask (client-facing app) along with OpenFaaS to handle background processes. While the list of sessions is long we can only cover so much. One of the most important reasons for the dominating success of Python’s popularity is it’s vibrant community and PyCon is a shining example of that. It truly symbolises how liked minded people come together and share the knowledge to make the software development world a better place to live. You can catch up on all the sessions, tutorials, and events at PyCon 2018 at their official website and their Youtube vlog. Should you move to Python 3? 7 Python experts’ opinions How to write high quality code in Python: 15+ tips for data scientists and researchers Why is Python so good for AI and Machine Learning? 5 Python Experts Explain    

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

TensorFlow has continued its success in 2017 well into 2018. It's quickly expanding its capabilities, and we're beginning to see it used by engineers that aren't data specialists.  We've seen that in the launch of TensorFlow.js, which allows you to bring machine learning to the browser. But Swift for TensorFlow is a slightly different proposition. In fact, it does two things. On the one hand it offers a new way of approaching TensorFlow, but it also helps to redefine Swift. Let's be honest - Swift has come a long way since it was first launched by Apple back at WWDC 2014. Back then it was a new language created to reinvigorate iOS development. It was meant to make Apple mobile developers happier and more productive. That is, of course, a noble aim - and by and large it seems to have worked. If it hadn't we probably wouldn't still be talking about it. But Swift for TensorFlow marks Swift as a powerful modern programming language that can be applied to some of the most complex engineering problems. What is Swift for TensorFlow? Swift for TensorFlow was first unveiled at the TensorFlow Dev Summit in March 2018. Now it's open source, it's going to be interesting to see how it shapes the way engineers use TensorFlow - and, of course, how the toolchain might shift. But what is it exactly? Watch the video below, recorded at TensorFlow Dev Summit, to find out more. https://www.youtube.com/watch?v=Yze693W4MaU Here's what the TensorFlow team had to say about Swift for TensorFlow in a detailed post on Medium. "Swift for TensorFlow provides a new programming model that combines the performance of graphs with the flexibility and expressivity of Eager execution, with a strong focus on improved usability at every level of the stack. This is not just a TensorFlow API wrapper written in Swift — we added compiler and language enhancements to Swift to provide a first-class user experience for machine learning developers." Why did TensorFlow choose Swift? This is perhaps the key question: why did the TensorFlow team decide to use Swift for this project? The team themselves note that they are often asked this question themselves. Considering many of the features of Swift for TensorFlow can easily be implemented in other programming languages, it's a reasonable question to ask. To properly understand why TensorFlow chose Swift you need to go back to the aims of the project. And they're actually quite simple - the team want to make TensorFlow more usable. They explain: "We quickly realized that our core static analysis-based Graph Program Extraction algorithm would not work well for Python given its highly dynamic nature. This led us down the path of having to pick another language to work with, and we wanted to approach this methodically." The post on GitHub is well worth reading. It provides a detailed insight into how to best go about evaluating the advantages and disadvantages of one programming language over another. Incidentally, The TensorFlow team say the final shortlist of languages was Swift, Rust, Julia, and C++. Swift ended up winning out - there were 'usability concerns' around C++ and Rust, and compared to Julia not only was there a larger and more active community, it is also much more similar to Python in terms of syntax.

Scala in its recent announcement suggested the roadmap for Scala 3.0 and what features developers can expect in Scala 3. Following this, the Scala community also announced the new release will be Scala 2.13 and mentioned that Scala 3 will succeed Scala 2.13. With the first official talk about Scala 3, the community also unveiled its secret project called Dotty. It announced that Dotty will become Scala 3. Dotty is a set of compiler technology for Scala. The suggested timeline for the preview release of Scala 3.0 is around early 2020. With this development, the community has suggested that Scala 2.13, expected to release in few months, will be an important release for migration to Scala 3. What can you expect in Scala 3? The community is working to fuse two big paradigms: Object-Oriented programming and functional programming together to make development more convenient in Scala ecosystem. Alongside this ongoing improvement, the community is focussing on the following aspects: With Scala 3, the community is emphasizing on 4 main features of Scala: consistency, safety, ergonomics, and performance. The community is working on adding types and operators to carry out these functionalities. In Scala 3 expect advanced programming paradigms like metaprogramming and generative programming. Currently, the macro systems are implemented at an experimental level to carry out metaprogramming. The community has suggested replacing the macro system with some other solution. Generative programming design with scala is currently under development. Improvement in Scala tools for building strong foundations for software design. Also removal of some components of the language that are rarely used to make the language lightweight. Automatic rewriting through the scalafix tool for efficient migration of code from Scala 2 to Scala 3. Updated Scala compiler, IDE plugins, REPL, Scaladoc, and build tools. The community is working on updating the Dotty plugins and its standard build tools SBT for working properly with Scala 3. Scala 3 will share the same standard library used in Scala 2. However, with the update, Scala 3 will not be binary compatible with Scala 2 because of the update in Scala compiler. The community is working on making the migration as smooth as possible which makes the release of Scala 2.14 pivotal. To get an early preview of Scala 3 features, developers can start working on the development of Dotty, available on the GitHub repository and report any issues on the issues page. Scala 2.12.5 is here!

It’s been more than 20 years since Microsoft released the first version of the C# language. Over the years C# has experienced a remarkable evolution, from being called as a Java copycat to one of the most loved and used programming languages. The current developments in C# 7 ecosystem are exciting, and grabbing the attention of developers, but what about the future? Can developers take a sneak peek into the future of C#? Well of course they can! The Microsoft language design team have been developing the language features ‘in the open’ for quite some time now. They have proposed several new features for the upcoming C# 8.0 and have released several prototypes for the developers, to try them out and provide feedback on the official Github repo. Let’s take a look at the most likely new C# 8 features: Nullable Reference Types The name of this particular feature might confuse a lot of developers wondering “Isn’t nullable reference a bad idea?” or “Shouldn’t it be called non nullable reference types?”. Sir Tony Hoare, a British computer scientist invented null references and famously called them the “Billion Dollar Mistake” as the biggest problem is, of course, the risk of getting the infamous null-reference exception. Since all reference types in C# can be null, you always run the risk of getting an exception when you try to access some member of the object. Functional languages try to deal with this problem by having a type that represents the concept of potential absent value. Instead of introducing non-nullable reference types in C#, Microsoft has chosen to consider reference types as non-nullable by default and provide mechanisms to deal with nullable types. Since the premise of a reference is often considered to be non-nullable and to be dereferenced. Asynchronous Streams Asynchronous streams provide the ability to use async/await inside an iterator. In most cases, an iterator is implemented synchronously. There are some cases, however, where it might need to await a call on every iteration to fetch the next item. In such cases, asynchronous streams can come in handy. To support this feature, a couple of things need to be taken care of: New types, the async equivalents of IEnumerable and IEnumerator Ability to specify an await on an iterator construct such as foreach. Default interface implementations: The primary use case for default interface methods is to enable the developer to safely evolve an interface. You could add new methods to it and, as long as you provide a default implementation, existing clients of the interface wouldn’t be forced to implement it. Another important value proposition of default implementation on interfaces relates to Android and iOS. Since both Java and Swift offer this feature, it’s tricky to use C# to wrap Android/iOS APIs that make use of default interface implementations. C# 8.0 will make it possible to wrap those APIs more faithfully. There are plenty of other features proposed to be implemented in C# 8 such as target-typed new expressions, covariant return types, and extension everything. All these features are in different stages of development and a lot can (and probably will) change from now until C# 8.0’s release Till then you can closely follow the official Github repo for C#.   Stay up to date with the latest features, release dates, and general discussions on key programming tools and tech by subscribing to Packt Hub. Check out other latest news: Red Programming Language for Android development! What’s new in Visual Studio 1.22 OpenCV 4.0 is on schedule for July release