With separate write types, developers can specify types for reading and writing to properties. TypeScript will only use the “reading” type when considering how two properties with the same name relate to each other. On the other hand, “writing” types are only considered when directly writing to a property.

RELATED CONTENT: TypeScript Handbook gets a rework

Microsoft also added the ‘override’ keyword in TypeScript 4.3 to overcome the issue that arises when a user can’t make it clear whether they mean to add a new method or to override an existing one. When a method is marked with ‘override,’ TypeScript will make sure that a method with the same name exists in the base class. 

Also, with the ‘noImplicitOverride’ flag,  it becomes an error to override any method from a superclass unless one explicitly uses an ‘override’ keyword.

As part of the new template string improvements, TypeScript will now handle the work to prove whether or not each part of a template string can successfully match so that developers can now mix template strings with different substitutions while TypeScript figures out if they’re compatible. 

TypeScript 4.3 also added methods and accessors to the elements that can be given #private #names to make them truly private at run-time.

In the new version, the ‘ConstructorParameters’ type helper now works on ‘abstract’ classes and TypeScript now includes slightly smarter type-narrowing logic on generic values, which allows it to accept more patterns. 

Other updates include always-truthy promise checks, static index signatures, .tsbuildinfo size improvements, lazier calculations in ‘–incremental’ and ‘–watch’ compilations, import statement completions, editor support for @link tags and more. 

Additional details on all of the new features in TypeScript 4.3 are available here.

The post TypeScript 4.3 released with separate write types appeared first on SD Times.

Additionally, 91% of respondents would like to use Go for their next new project, and 89% find it is working well for their team. The results are based on 9,648 developer responses. “Understanding developers’ experiences and challenges helps us measure our progress and directs the future of Go,” the team wrote in a post. 

RELATED CONTENT: Why developers love Go

The language’s top features, according to respondents, include build speed, reliability, using concurrency, CPU usage and editor support. VS Code is the preferred editor with GoLand following closely. Respondents are also having success with its cloud services, debugging and modules. 

Overall, 92% of respondents say they are satisfied or somewhat satisfied with the language. Eighty-one percent of respondents find they are very or extremely productive with Go, and 93% stated it took less than one year to become productive with Go. Of that 93%, 31% found themselves more productive between one week and one month of using Go, and 33% were more productive between one month and three months. 

The report did find a downwards trend of those who stated they feel welcomed by the Go community. Only 78% of respondents reported feeling welcomed this year compared to 84% in 2017. When asked what would make them feel more welcome, respondents stated more learning resources and docs, improved contributor experience, and maintainer attitudes. 

The top use cases for Go include: API/RPC services, CLI, libraries or frameworks, and web services. 

The top reasons for not using Go include working on a project in another language, the team prefers to use another language, and Go lacks a critical feature necessary to do their work. Top challenges include lack of generics, modules/package management, and problems with the learning curve. 

The post Report finds Go is becoming more critical to a company’s success appeared first on SD Times.

Null safety strengthens the language’s type system, and will enable developers to more easily catch null errors during development. Previously, it was difficult to tell the difference between code that anticipated being passed as null versus code that didn’t work with nulls. This resulted in a lot of bugs passing through, even after rigorous code reviews, and possibly going unnoticed for years, in some cases.

Null safety is a major change to the language, and requires a few changes when coding. Developers that want to create a variable that can contain either a null or a value will need to make that explicit when declaring a variable by adding a ? to the end of the type. There is also a new “required” keyword that produces an error when a parameter is marked as “required” and the caller forgets to provide the argument.

Null safety will be offered as an incremental migration, so developers can use Dart 2.12 without taking advantage of this feature. This is because the team believes it is too big of a change to force people into.

FFI is an interoperability mechanism enabling developers to invoke existing code that is written in C. Sample use cases the team has already seen include using the open_file API to invoke operating system APIs on Windows, macOS, and Linux; calling Windows Win32 APIS; objectbox, which is a fast database that uses a C-based implementation; and tflite_flutter, which uses FFI to wrap the TensorFlow Lite API.

Now that the core platform for FFI is complete, the team will be shifting its focus to expanding the FFI feature set. It is currently investigating adding features such as ABI-specific data types, inline arrays in structs, packed structs, union types, and exposing finalizers to Dart. 

Future plans for Dart overall in the next release will mainly be focused on incremental language changes, such as type aliases, triple-shift operator, generic metadata annotations, and static meta-programming. 

The post Dart 2.12 available with sound null safety and FFI appeared first on SD Times.

While it may have been Google’s backing that gained developers’ attention, its efficiency, simplicity and tooling are the reason developers keep coming back, according to Nathan Youngman, author of Get Programming with Go. He explained that efficiency equates to fewer servers, which is good for business. Simplicity and familiarity mean it’s easy to learn. And the tooling means more uniform code, making it easier to understand. 

Last year, the Stack Overflow developer survey reported that Go was the fifth most loved programming language, moving up from the 10th spot the previous year. It is also the third most wanted language among developers who aren’t using it,  but are interested in it. 

According to the language’s 2019 annual developer survey, the reason more developers don’t use it is because they are working on a project in another language, their team prefers another language, and the lack of critical features doesn’t make it suitable for their needs. However, the number of developers that prefer a different language is decreasing every year. Eighty-nine percent of respondents indicated they want to use Go for their next project, and 86% who are using it reported it is working well for their teams. 

What makes Go special?
The beauty of Go has more to do with its lack of features than its actual features, according to Jonathan Bodner, distinguished engineer at Capital One. He explained it’s intentionally small and tries to be boring. “It’s not the prettiest language, or the one with the most features, but its focus on maintainability, testability, repeatable builds, and developer productivity gives it the right priorities for modern cloud development,” Bodner said. 

According to Steve Francia, product and strategic lead for Go at Google, Go grew out of the need for simplicity. Programming languages were starting to get more and more complex and the readability was becoming untenable. When you have hundreds of teams working on the same codebase, much like Google does, readability is crucial. “One of the big catalysts for Go was to create a language that was simple, easy to read, easy to scale up on a human basis,” said Francia. 

This is important because coding is a team sport, according to Thomas Limoncelli, SRE manager at Stack Overflow. “Devs spend more time reading existing code and updating it than writing new code from scratch. Code readability is undervalued in this industry. Google culture encourages engineers to change teams frequently (every 1.5-3 years). Therefore code readability is highly valued,” he said. 

Limoncelli explained Google’s backing also didn’t hurt the language’s rise in popularity. “As a company grows they face more and more problems that Google faced years ago. It’s nice to have a trailblazer that cleared the way,” he added. 

Go also has an advantage over older languages because decades ago when languages like Python, Java and JavaScript were developed, no one could have imagined how the world and technology would evolve. For instance, Francia explained pretty soon Moore’s Law will be coming to an end, and we will no longer have single-core machines. Go has concurrency baked in, making it easier to program on multiple cores and multiple threads. 

Starting a language from scratch enabled the programming language’s team to learn and be inspired from other languages. “Making a new language allows for a reset. For example, C++ classes support multiple inheritance, whereas Java has interfaces and single-inheritance, and Go has interfaces but no inheritance,” said Youngman. “Such a reduction takes a best practice from other languages and makes it the ‘one way to do it.’ Simplifying the language in this way may benefit other aspects of the implementation, such as improving compile times.”

Luck and the right timing also had a lot to do with Go’s success, according to Google’s Francia. “[Go] happened to hit the right set of features at the same time the cloud was emerging, and as a result a lot of cloud native stuff (Docker, Kubernetes, Istio) was written in Go,” he said. “That was the incubation moment where it proved this wasn’t a research language, that it had practical use and that allowed it to cross into the mainstream.”

Since so many cloud development tools are written in the language, as companies move to the cloud and rethink their development stacks, they are starting to investigate the language, according to Capital One’s Bodner. 

The language’s concurrency support “allows people to think about concurrency as data flowing through a system, with goroutines processing data that’s passed in and out via channels, with the data flow managed by select statements,” Bodner explained.

Other key features of the language include its fast compiler, which allows developers to get rapid feedback; its standard library and compatibility guarantee; and its implicit interfaces that enable duck typing while enforcing type safety, according to Bodner. 

Areas for improvement
With the variety of programming languages available for developers to learn, some languages are better than others for certain things, and Go is no exception. Capital One’s Bodner explained better immutability in Go would make it easier to understand how data flows through a program. “There are techniques that you can use in Go programs to mitigate this, but it’d be nice if there was a way to tag a value as immutable and have the compiler validate this,” he said.

Stack Overflow’s Limoncelli explained that while Go is very good at error handling, it can be verbose. “It would be nice to have a more concise syntax for dealing with errors,” he said. In addition, Go is aggressive about dropping support for older operating systems, and best suited for servers and systems that are updated frequently.

Youngman also noted that type parameters for generic programming “could open the floodgates for new kinds of libraries without sacrificing type safety.”

Google’s Francia added that GUI-based objects are more challenging in Go, and that Go is not a scripting language, so there may be places where developers want to script and Go isn’t the best fit. 

“The best part about Go is what it leaves out. It doesn’t try to be the end-all, be-all, language for every situation. It tries to be very good at one thing (server and back-end code).  People often complain that it is missing a feature (Generics, functional operations, etc.) but keeping the language small is good,” Stack Overflow’s Limoncelli said. 

Where is Go going?
Some of the top requests users have asked for over the last couple of years include better dependency management and generics. 

According to Google’s Francia, the introduction of modules two years ago changed the Go developer tooling landscape, and made it easier to manage dependencies. The first production-ready implementations of the Go modules were released last year with Go 1.14, and the team now encourages users to migrate to Go modules for dependency management. 

Generics would allow developers to write more reusable code than the language allowed previously. This is something Francia said the company has been trying to get right for over a decade, and now they believe they finally have a plan to allow generics that don’t introduce complexity and give users more features. “Generics can give us powerful building blocks that let us share code and build programs more easily. Generic programming means writing functions and data structures where some types are left to be specified later. For example, you can write a function that operates on a slice of some arbitrary data type, where the actual data type is only specified when the function is called. Or, you can define a data structure that stores values of any type, where the actual type to be stored is specified when you create an instance of the data structure,” Ian Lance Taylor, Go programming team member, wrote in a post. 

In the beginning of the year, the team filed a change proposal to support type parameters for types and functions, which would permit a form of generic programming. The proposal was officially accepted in February and moved to a work milestone. According to Francia, implementing this feature will be a main focus for the rest of the year, as well as better security and performance — which is something the team works on in every release. 

“The proposed implementation follows the Go philosophy. It’s just enough generics to solve developer pain points, but leaves out features that are interesting but would unnecessarily complicate the language,” said Capital One’s Bodner.

Other areas of improvement the team will be working on this year include helping users make better choices. For instance, the team provides insights to users into ecosystem packages and what packages may fit users’ needs best, as well as making users’ IDE experience better. 

The team is also working on more ARM support. The upcoming release of Go 1.16 is expected to include a new file system interface and build-time file embedding as well as support for the new Apple Silicon Macs. 

Lasty, the team has been working on what it calls “Go 2,” an ongoing effort to improve the language through incremental releases and proposal implementations. 

“A major difference between Go 1 and Go 2 is who is going to influence the design and how decisions are made,” wrote Robert Griesemer, one the language’s main developers, in a blog post. “Go 1 was a small team effort with modest outside influence; Go 2 will be much more community-driven. After almost 10 years of exposure, we have learned a lot about the language and libraries that we didn’t know in the beginning, and that was only possible through feedback from the Go community.” Current proposals for Go 2 include adding a match statement, removing init functions, type parameter declaration and instantiation segregation, function values as iterators, and allowing type-parameterized methods.

“Go is far more than just us on the Go team at Google. We are indebted to the contributors who work with us with the Go releases and tools,” Go team member Russ Cox wrote in a post. 

Go in action
Go is currently being used by a wide range of different companies and industries — from Google, Microsoft, and Facebook to American Express, Capital One, Target and Netflix, these companies are using Go to power their software and services. 

Google, which designed Go, is using the language in its core data solutions, Chrome content optimization service, and within the Firebase Hosting team. 

Microsoft has been using Go to power aspects of its cloud infrastructure such as the Azure Container Service, and has been working to help developers build apps for Azure with Go with the Azure SDK for Go. “One of the advantages of using Go with Azure, I think, is the speed at which you can develop—the speed at which Go executes,” according to Brian Ketelsen, cloud advocate at Microsoft. “It’s a really fast language. And that awesome ability to create a single static binary: you don’t have the craziness of worrying about dependencies when you build your applications with Go.” 

Financial companies like American Express and Capital One use Go in their microservices to improve speed and productivity, and serverless initiatives. 

Facebook recently decided to write a new ORM in Go with the ability to define any data model or graph structure easily. 

Lastly, Netflix is using Go for application data caching because it needed something with lower latency than Java, but more developer productivity for developers. Meanwhile, Target recommends Go for its simplified syntax, mature and well-built libraries and external community. 

“When we first released Go to the public in November 2009, we didn’t know if the language would be widely adopted or if it might influence future languages,” Rob Pike, one of the creators of Go, wrote on its website. “Looking back from 2020, Go has succeeded in both ways: it is widely used both inside and outside Google, and its approaches to network concurrency and software engineering have had a noticeable effect on other languages and their tools. 

“Go has turned out to have a much broader reach than we had ever expected. Its growth in the industry has been phenomenal, and it has powered many projects at Google.”

The post Why developers love Go appeared first on SD Times.

Last year, it broke onto the TIOBE Index Top 20 list of the most popular programming languages for the first time, and it continues to win over more developers. It has been voted the most loved programming language on the Stack Overflow Developer Survey for the last five years. Out of the developers surveyed using Rust, the report found 86% are interested in continuing to develop with it.

What is all the fuss about?
Developers who have never used Rust might be wondering what all the hype is about. According to Jake Goulding, StackOverflow’s top Rust contributor, “the short answer is that Rust solves pain points present in many other languages, providing a solid step forward with a limited number of downsides.”

Rust was first started as a personal project from Mozilla developer Graydon Hoare in 2006. In 2009, Mozilla started sponsoring the project and the first introduction to the language happened in 2010.

The initial selling point was the promise of memory safety, according to Armin Ronacher, director of engineering at Sentry, an application monitoring and error tracking company. “They didn’t compromise on the core promise of memory safety,” he said. “If you think about all the other languages developed over the last couple of years in that space, there is really no contender. There hasn’t been a language that was ever designed to be as good as C and C++. Rust didn’t compromise as being a replacement for those languages as other languages have.”

Jim Blandy, free software developer and author of the Programming Rust book, explained that while typically almost all programming is done in a high-level language like JavaScript, Java, Python or TypeScript, when developers need to program something that involves memory usage or the computer processors, high-level languages don’t work. The reason for this is because those languages use a garbage collector to attempt to reclaim memory that is no longer in use. Garbage collection can have a negative impact on resource consumption, performance and program execution.

There are other systems programming languages like C and C++ that don’t use garbage collection, but they are difficult to program with. According to Blandy, C and C++ enforce rules that make sense in theory, but don’t work in practice. “It’s possible to have rules that are easy to understand, but impossible to follow,” he explained. “It’s like if someone put a chess game in front of you and told you to win it, you know the rules and you’ll do your best, but you can’t just say okay I am going to win it. C and C++ have been putting programmers into that exact situation.”

Rust is designed to accomplish memory safety without the need of a traditional garbage collector. “We agree in this industry that memory safety is necessary because the moment you start to touch bad memory, you are implicitly opening yourself up to a bunch of vulnerabilities,” said Ronacher. “If you look into C and C++ projects, most security vulnerabilities have been a result of a program not dealing with memory properly.”

Rust is able to ensure memory safety through its ownership and borrowing system, which includes a set of rules that the compiler checks to make sure memory usage is safe, the program is free of memory errors when it is compiled, and features don’t slow down the program.

“All programs have to manage the way they use a computer’s memory while running. Some languages have garbage collection that constantly looks for no-longer-used memory as the program runs; in other languages, the programmer must explicitly allocate and free the memory. Rust uses a third approach: memory is managed through a system of ownership with a set of rules that the compiler checks at compile time,” the Rust team wrote in its documentation.

Beyond memory safety
Memory safety is why developers come to the language, but they stay for the package manager and Cargo ecosystem, according to Sentry’s Ronacher. According to the Rust team, developers love Rust’s build system and package manager because it is able to handle a lot of tasks such as building code, downloading libraries, and building libraries.

“The fact that you can build your project with all the dependencies without having to pull in another tool is what makes people happy. It comes out of the box full-featured and with a good development experience,” said Ronacher.

When free software developer Blandy looked into why people choose the languages they choose, the number one consideration is not the language itself, but the libraries and tools they connect to.

According to Ronacher, developers enjoy working with Rust over C and C++ because it’s less prone to crashes and its tooling is much stronger. He explained that while the compiler integration for C and C++ might be good, the tooling is bad and requires external dependencies. Additionally, if developers want to reuse code someone else wrote, it’s hard to do in C and C++ because of a lack of a package manager. Ronacher also explained many C++ libraries are difficult to add to large projects because of the lack of standardized strings and common types. Rust’s packaging ecosystem makes it easier to do iterative development and doesn’t require developers to reimplement everything or make everything consistent with the codebase.

“That is a huge reason why Rust is so successful, because you can actually both integrate with the existing codebases, but when you start from scratch you can put in so many dependencies much easier than you can in C and C++,” said Ronacher.

As a result of the memory safety, Rust also resolves a lot of concurrency issues, making it much easier to write concurrent programs with Rust than other languages, Blandy explained.

“Memory safety bugs and concurrency bugs often come down to code accessing data when it shouldn’t. Rust’s secret weapon is ownership, a discipline for access control that systems programmers try to follow, but that Rust’s compiler checks statically for you,” the Rust team wrote in a post. “For concurrency, this means you can choose from a wide variety of paradigms (message passing, shared state, lock-free, purely functional), and Rust will help you avoid common pitfalls.”

Helping to avoid those pitfalls actually forces developers to write good quality code, according to Maxwell Flitton, an R&D software engineer in financial tech and author of Rust Web Programming. “When you compile, you are very confident that it is going to work and you are less likely to get bugs that creep in,” he said. 

Beyond the code, Rust has a strong and welcoming community around it, according to Shane Miller, the senior engineering manager of the Rust platform at AWS, which recently announced it would sponsor the project. “Rust really focuses on providing a great experience for people. The Rust community is particularly welcoming, reaching out to those who haven’t traditionally participated in systems programming or open source.”

The limitations of Rust
Rust is both safe and manages to reach really close to what the C and C++ languages can do, but it is a more restrictive language and comes with its limitations, according to Blandy.

For instance, the way Rust is able to provide security guarantees is by restricting what developers can do. “Rust takes pointers and pointers are this functional thing in every language — in Java every object is a pointer to that object. They are ubiquitous and Rust restricts how you can use them. It basically says there are some rules. I am only going to let you use them in a certain fashion. It challenges the programmer,” said Blandy.

Blandy also mentions that the debugging support in Rust is not up to the level of C++.

In addition, while Rust is memory efficient, it takes way too long to compile programs. “It rivals C++ in how slow it is to compile the code. Once it is compiled, it runs really fast, but the compile times are really bad,” said Ronacher.

And since it is still so new, developers might run into situations or environments that no one has worked on before. For instance, if you want to develop something for Bluetooth, in JavaScript there is a rich ecosystem, but in Rust there is just a barely maintained Bluetooth module, according to Ronacher.

Web development has also been an area where Rust hasn’t been too strong, but Flitton believes that’s changing, especially as the world becomes more digital. The 2020 State of the Developer Ecosystem Report by JetBrains revealed while Rust is mostly used for systems programming, 44% of respondents are now using it for web development. “In the beginning, Rust was mostly associated with embedded systems or robotics, but it has matured and stable frameworks have started to come out. The possibilities with web development are opening up for some core services that take a lot of traffic or require a lot of processing power,” he said. 

Learning Rust has also been a problem in the community because a lot of developers feel too intimidated to take it on, according to Flitton. “Rust has this very nasty image of, it is going to be really hard to code. It’s really fast, but going to be hard to code…but not really. It is memory safe and if you focus on a few quirks initially then you can pick it up quite quickly,” he said.

The problem has been because it forces you to do good quality coding, it can be annoying for developers who picked up bad habits and don’t want to change the way they code. “There is a saying that a bad workman always blames his tools. When I first started to get Rust programs compiled, I was incredibly frustrated because it kept saying you haven’t thought about this. I am not compiling because this doesn’t seem safe. So I was quite frustrated, but when you look at it it is just forcing safety,” said Flitton.

Ronacher added that the way developers learn Rust is different from the way they learn other languages. “If you go into the mindset learning Rust the same way you approach other languages, you are going to have an uphill battle because the language will punish you in ways that you wouldn’t expect,” he said.

However, Flitton believes Rust can help developers realize all the things they’ve been doing wrong and in turn make them better for it.

Top tech companies turn to Rust
After working with and incorporating the language in many of its services, Amazon announced in 2019 that it would sponsor the Rust project. The first notable product the company wrote in Rust was Firecracker, an open-source virtual machine manager. The language is also used in Lambda, EC2 and S3 Amazon services.

“Since that launch we’ve found more opportunities to build high-performance customer experiences quickly and securely. Rust helps us deliver fast, robust services to AWS customers at scale, and our responsibility and investment in the Rust ecosystem and community of builders grows with our adoption,” said Shane Miller, the senior engineering manager of the Rust platform at AWS.

At the end of last year, Amazon revealed it started to hire Rust contributors to ensure the language got the time and resources necessary to improve. The company also started to build a team around the Rust asynchronous runtime Tokio, and invest in developer tools, infrastructure components, interoperability and verification.

“We believe Rust changes the game when it comes to writing safe systems software. Rust provides the performance and control needed to write low-level systems, while empowering software developers to write robust, secure programs,” said Miller.

In 2019, Microsoft also revealed it started to experiment with Rust after it saw a need for a safer systems programming language. “We’re using languages that, because they are quite old and come from a different era, do not provide us the ability to protect ourselves from … vulnerabilities,” Ryan Levick, cloud developer advocate at Microsoft, said in a video. “C++ is not a memory safe language and no one would really pretend that it is,” he said.

Microsoft has since been moving toward using Rust over C and C++, and rewriting low-level components of the Windows codebase in Rust.

“For C++ developers used to writing complex systems, using Rust as a developer is a breath of fresh air. The memory and data safety guarantees made by the compiler give the developer much greater confidence that compiling code will be correct beyond memory safety vulnerabilities. Less time is spent debugging trivial issues or frustrating race conditions. The compiler warning and error messages are extremely well written, allowing novice Rust programmers to quickly identify and resolve issues in their code,” Adam Burch, software engineer at Microsoft, explained in a post.

The post What’s all the fuss about Rust? appeared first on SD Times.

One shortcoming is that the Excel language only supported scalar values like numbers, strings, and Booleans. The second is that Excel doesn’t let users define new functions. With new developments from Microsoft, both of these issues are being addressed. 

The first shortcoming is addressed by Microsoft’s Calc Intelligence project, which was developed at Microsoft Research Cambridge. The project is aimed at transforming “spreadsheet formulas into a full-fledged programming language,” Andy Gordon, senior principal research manager at Microsoft, and Simon Peyton Jones, senior principal researcher at Microsoft, wrote in a post. According to Microsoft, at the 2019 ACM SIGPLAN Symposium on Principles of Programming Languages, it introduced two new developments: data types that allow cells to contain first-class records, and dynamic arrays that allow ordinary formulas to compute whole arrays that spill into adjacent cells, Microsoft explained.

The second shortcoming is addressed by the LAMBDA programming language, which was first introduced in December 2020. LAMBDA allows users to define new functions. According to Microsoft, these functions can call other LAMBDA functions, even recursively. 

“With LAMBDA, Excel has become Turing-complete. You can now, in principle, write any computation in the Excel formula language,” Gordon and Peyton Jones wrote. 

An example of what LAMBDA is capable of is the ability to recursively reverse a string using a fixed-point combinator. This is something that previously could only be accomplished with an external language like Visual Basic or JavaScript. “One of the big missing pieces in Excel formulas has been the ability to loop… to repeat over a set of logic at a dynamically defined interval. There are ways that you can manually configure the interval at which Excel recalculates to mimic this to an extent, but it’s not inherent to the formula language. That changes with LAMBDA,” Brian Jones, head of product for Excel at Microsoft, wrote in a post.   

In this example, a function called REVERSE is defined and uses functions HEAD and TAIL to compute the first character and everything but the first character. It can use this REVERSE function to give what the reverse of an entered word, number, or phrase is. It can also reverse the output of that to give back what the input originally was. 

LAMBDA is currently available to members of the Insiders: Beta program. Its current release has a few implementation restrictions that Microsoft expects to lift in the future. 

“It will be interesting to see how users continue to experiment with and apply not only LAMBDA but also data types and dynamic arrays. We believe these new functional programming features will transform how people make decisions with Excel,” Gordon and Peyton Jones wrote.

The post Microsoft’s LAMBDA language allows new functions to be written in Excel appeared first on SD Times.

In this version, rest elements can be used in more ways than before. Previously, they were only allowed at the last position of a tuple type, but they can now occur anywhere within a tuple. There is a restriction that rest elements can’t be followed by another optional element or rest element. 

The TypeScript 4.2 beta also features smarter internals. It now tracks how types were constructed and differentiates type aliases to instances of other aliases. 

Another new feature is that template literal expressions now have template literate types. Template literal types were introduced in 4.1 as a way to model specific patterns of strings, but there was inconsistency between types and expressions. Now, template string expressions will always start with template literal types. 

Other new features in 4.2 include:

• Stricter checks for the “in” operator
• Abstract construct signatures
• –explainFiles that show why certain files are included in a program
• Relaxed rules between optional properties and string index signatures
• A new way to declare new functions and methods based on the call site

There are a number of breaking changes as well, such as template literal expressions now having template literal types, noImplicityAny errors apply to loose yield expressions, and more. 

“We’re excited to hear your thoughts on TypeScript 4.2! With the beta we’re still in relatively early stages, but we’re counting on your feedback to help make this an excellent release. So try it today, and let us know if you run into anything,” Daniel Rosenwasser, program manager of TypeScript wrote in a post. 

The post TypeScript 4.2 beta now available appeared first on SD Times.

“It has been stated before: Python is popping up everywhere. It started as a competitor of Perl to write scripts for system administrators a long time ago. Nowadays it is the favorite language in fields such as data science and machine learning, but it is also used for web development and back-end programming and growing into the mobile application domain and even in (larger) embedded systems,” the Index stated in a post. 

RELATED CONTENT: 
Python has overtaken Java in the last year
Moving from Python 2 to Python 3

According to TIOBE, main factors for Python’s popularity include ease of learning and high productivity. “These two qualities are key in a world that is craving for more developers in all kinds of fields. Python already tested the second position some months ago and it will for sure swap places with Java permanently soon. Will Python also beat C? Well, C has still one trump card to play: its performance, and this will remain the case for some time to come. So I guess it will certainly take some years for Python to become the new number 1 in the TIOBE index,” TIOBE wrote. 

Other notable changes in the last year include C has once again surpassed Java at the top spot. C was also considered the programming language of 2019, according to the index. In addition, R and Groovy have made their way into the top 20 programming languages on the index. TIOBE predicts Julia, Dart and Rust will reach the top 20 this year.

The post Python named TIOBE’s programming language of 2020 appeared first on SD Times.

RBS is a language for describing types of Ruby programs, and it enables developers to document the definitions of classes and modules. According to the Ruby team, the goal is to help support commonly seen patterns in programs, as well as allowing developers to write advanced types such as union types, method overloading, and generics. 

TypeProf is a type analysis tool that reads Ruby code, analyzes what methods are defined and their uses, and creates a prototype of type signature in RBS format. Currently this feature is still experimental, so it is only supported in a subset of the language and its error detection is limited. The team is currently working to expand coverage, improve analysis performance, and make it more usable. 

Ractor is another experimental feature that provides parallel execution without any thread-safety concerns. The Ruby team explained that Ractor allows developers to create thread-safe parallel programs since ractors don’t share normal objects. To limit object sharing, Ractor puts several restrictions on Ruby’s syntax. 

Another new feature planned for Ruby 3.0.0 is Fiber Scheduler, which is for intercepting blocking operations. Fiber Scheduler will enable lightweight concurrency without the need to change existing code. 

Other new features coming in Ruby 3.0.0 are a redesign of one-line pattern matching, endless method definition, memory view, and more. 

For more information, view the release notes here. 

The post Ruby 3.0.0 RC1 now available appeared first on SD Times.

New language refinements include adding a string initializer with access to uninitialized storage, synthesized Comparable conformance for enum types, where clauses on contextually generic declarations, refined didSet semantics, and more. 

RELATED CONTENT: Swift now available for Windows

Runtime performance is also significantly improved in this release. Swift 5.3 offers improved binary code size and runtime memory usage. 

Improvements to developer experience include indentation improvements when editing code, code completion enhancements, build time improvements, compiler diagnostics, and debugging improvements. 

There are also updates to the Swift Package Manager. Packages can now contain resources like images or other data files, can contain localizable content, can vend prebuilt libraries distributed as XCFrameworks, and a package target’s dependencies can now be declared as conditional. 

The post Swift 5.3 focuses on language refinements appeared first on SD Times.