Frappe makes defining DocTypes easier without the need for code to be used everywhere, since everything in Frappe is a DocType. The framework also includes a single-page application with forms, lists, and search navigation built in.

Additionally, users have the ability to define customer roles and permissions that are applied out of the box on every interaction, and they can create their own applications that can be extended by other apps with Frappe’s modular architecture. 

The framework allows for integrations and comes with REST API and Webhooks on all models based on authentication. It also allows users to configure background workers as well as run periodic tasks that are powered by Python RQ.

Soket.io support based on NodeJS is also included, along with the ability to send, receive, view, and manage emails using SMTP and IMAP based email accounts.

Lastly, Frappe enables customers to host several sites on one server, with its database driven multi-tenant architecture. 

The post SD Times Open-Source Project of the Week: Frappe appeared first on SD Times.

According to Microsoft, TypeScript 5.0 is not a particularly disruptive release, which means the upgrade process should be relatively simple. 

This release includes a number of new features and improvements that make the language smaller, simpler, and faster. 

Among the updates is that the new decorators standard has been implemented. Decorators enable developers to customize classes and their members so that they can be easily reused. TypeScript had for a long time supported an experimental version of decorators which are now considered legacy technology, though Microsoft intends to continue supporting them for a while still. They required you to use an opt-in compiler flag in order to make use of them, whereas the new decorators can be used without. 

Also new in TypeScript 5.0 is that developers can add a “const” modifier to a type parameter declaration. The “const” modifier makes a variable constant, whereas by default TypeScript will infer and choose a type that is meant to be general.

Developers will now be able to more easily support multiple configuration files using the “extends” field, which copies fields from “compilerOptions.” TypeScript 5.0 enables “extends” to take multiple fields. 

There are also new features that better support EcmaScript module (ESM) projects in Node and in bundlers, such as the “–ModuleResolution bundler.” 

Other new features in this release include union enums, resolution customization flags, and support for the export type *. 

The post TypeScript 5.0 implements new ECMAScript “decorators” standard appeared first on SD Times.

With 5.0, Microsoft is working to make the language smaller, simpler, and faster. For example, the 5.0 beta takes 81% of the time to build VS Code that would take TypeScript 4.9 to do so. 

These performance improvements were possible because TypeScript was recently migrated to modules from namespaces. This allows it to leverage more modern build tooling. 

In TypeScript 5.0, Microsoft is implementing the upcoming ECMAScript (a JavaScript standard) feature Decorators. This new feature allows developers to customize classes and members and reuse them. They can be used on methods, properties/fields, getters, setters, and auto-accessors. 

According to Microsoft, there has been support for “experimental” decorators for years, and while those have been useful to developers, they were modeled after an old version of the decorators proposal and required an opt-in compiler flag: – -experimentalDecorators. This flag will still be supported for now, but the change is that decorators will now work even without that flag. 

The company also noted that the new Decorators feature won’t be compatible with — emitDecoratorMetadata, but there may be future ECMAScript proposals that bridge the gap in code that uses this. 

Another thing to note about ECMAScript’s Decorator proposal is that it requires a class decorator following any “export” keyword that is present. TypeScript will enforce this in JavaScript files, but not in TypeScript files.  The reason for this is that it provides an easier migration path between original “experimental” decorators and the new standard decorators.   

Other updates in this release include: 

• The “extends” field has been updated to enable configuration from multiple config files. 
• A “const” modifier can be added to type parameter declarations.
• All enums will now be considered union enums. This is achieved by creating a unique type for each computer member. The result of this is that all enums 
• New options for enabling or disabling features based on configuration
• Support for “export type *” 

A full list of updates can be found here.

The post TypeScript 5.0 beta adds support for Decorators appeared first on SD Times.

In TypeScript 4.5, Microsoft added nightly-only support for ESM in Node.js to get some feedback from users and let library authors ready themselves for broader support. TypeScript 4.7 expands this functionality with two new ‘module’ settings: ‘node12’ and ‘nodenext’.

The new setting controls whether ‘.js’ files are interpreted as ES modules or CommonJS modules, and defaults to CommonJS when not set.

Also, TypeScript 4.7 beta introduces a new option called ‘moduleDetection’. ‘moduleDetection’ can take on 3 values: “auto” (the default), “legacy” (the same behavior as 4.6 and prior), and “force” to alleviate the ambiguity between existing “script” code and module code. 

The “auto” detection will look for ‘import’ and ‘export’ statements and whether the “type” field in ‘package.json’ is set to “module” when running under ‘–module nodenext/–module node12’, and whether the current file is a JSX file when running under ‘–jsx react-jsx’. 

TypeScript 4.7 also now analyzes the type of computed properties and narrows them correctly, whereas previously, it would not consider any type guards on ‘obj[key]’, and would have no idea that ‘obj[key]’ was really a ‘string’.

Other new features in TypeScript 4.7 beta include improved function interference in objects and methods, instantiation expressions, and much more. Additional details are available here.

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

Since the Release Candidate, the team at Microsoft has also worked to do some internal refactoring which has fixed certain issues, corrected a few error messages, and improved type-checking performance by 3% in some instances. 

Prior to this release, it was an error to contain any code at the beginning of a constructor if its containing class had any property initializers. TypeScript 4.6 makes it more lenient and permits other code to run before super(), while still making sure that super() occurs at the top-level before any references to this.

Additionally, with this release a signature can be declared with a rest parameter whose type is a discriminated union of tuples. This means that when the first argument is the string “str”, then the second argument must be a string or when the first argument is the string “num”, the second has to be a number. Also, in cases where TypeScript infers the type of a function from a certain kind of signature, it can now narrow parameters that depend on each other.

A few other noteworthy changes include that object rests drop unspreadable members from generic objects and that JavaScript files always receive grammar and binding errors. To learn more about these features, see the first and second implementing pull requests. 

For more information on this release, see here. If you’re interested in learning more about what is on track for TypeScript’s next release, visit the issue tracker and read the iteration plan for TypeScript 4.7.

The post Microsoft releases TypeScript 4.6 appeared first on SD Times.

This release is geared towards making the lives of developers easier, bringing them:

• Increased speed and agility with on-demand access to z/OS
• Accelerated DevOps practices with consumption-based pricing 
• A reduction in the need for specialized skills with a consistent cloud-native development experience 

“By leveraging both IBM Z and IBM Cloud, clients can benefit from a hybrid cloud approach that allows them to capitalize on the innovations, technical advancements, security, resiliency of each platform. With hybrid cloud, you keep your workloads where they need to be—in the cloud, on premises, and at the edge—to help reduce risk and improve time to market,” said Tarun Chopra, VP of IBM Z hybrid cloud.

Updated testing guidance on Android

The Android development team recently announced that it has upgraded two testing sections on d.android.com. This revamp comes in response to user feedback that Android’s tools and libraries can sometimes overlap, as well as to accommodate for Compose and new architecture guidelines.

This update starts with the new Testing training, which brings users the fundamentals of testing in Android with two additional articles: What to test, a guide for beginners, and a detailed guide on Test doubles. 

Additionally, the team has updated the Testing section of the Tools documentation that places a focus on tools that work to assist developers in creating and running tests, from Android Studio to testing from the command line. 

TypeScript 4.6 RC announced

Microsoft said that there are not expected to be any new updates or changes between this Release Candidate and the stable release of TypeScript 4.6, aside from any critical bug fixes. To get started using this RC, see here or use npm with the command “npm install typescript@rc”. 

This RC brings several new features, including:

• Allowing Code in Constructors Before super ()
• Control Flow Analysis for Deconstructed Discriminated Unions
• Improved Recursion Depth Checks
• Indexed Access Inference Improvements 
• Control Flow Analysis for Dependent Parameters
• –target es2022
• More Syntax and Binding Errors in JavaScript
• TypeScript Trace Analyzer

For more information, see here. 

The post SD Times news digest: IBM Wazi aaS announced; Updated testing guidance on Android; TypeScript 4.6 RC announced appeared first on SD Times.

What is TypeScript?

While the number of programs written in JavaScript has grown exponentially, the programming language’s ability to express the relationships between different units of code and mitigate coding errors early on hasn’t kept pace. Along with JavaScript’s inconsistent semantics, this makes JavaScript-driven app development difficult to manage at scale.

Released in 2012, TypeScript was created to address JavaScript’s deficiencies in developing large-scale apps. It’s an open source, strongly typed programming language that builds on JavaScript by adding optional static typing. Types enable structuring and validating code before it’s executed, which is beneficial in developing large apps. They also provide additional information about code, which serves as better documentation for other developers and facilitates collaboration.

TypeScript is a superset of JavaScript, which means any JS code is also valid TS code ─ provided the TS configuration is set to be compatible with it. It outputs code in pure JavaScript and allows developers to liberally use JS libraries, tools, and frameworks. It runs on Node.js or any browser that supports ECMAScript 3 or higher. It also supports object-oriented programming features. 

JavaScript Drawbacks

JavaScript is one of the world’s most popular programming languages and works extremely well for small projects. However, its disadvantages ─ many of which affect projects costs and code delivery time ─ make a strong case for considering alternatives such as TypeScript, particularly for larger projects.

Much of it has to do with the lack of types and compile-time error checks, making JavaScript less than desirable for server-side code in enterprises and large codebases. The following are just a few of its disadvantages:

• JavaScript employs dynamic typing, which means scripts can compile even if they contain errors that can prevent them from properly running.
• Because JavaScript is dynamically typed, it allows one variable to have multiple properties assigned to it. It doesn’t instantly let developers know what a variable can contain. That makes it easy to assign the wrong properties.
• Since JavaScript is an interpreted language, errors can only be found during run-time. Code needs to run first to be tested and validated, so it can take considerable time to find bugs and errors in the code.
• To eliminate inaccuracies, it’s necessary to manually verify types and the syntactic correctness of the code. This lengthens development time and extends the delivery cycle to production, increasing development costs.
• JavaScript code is executed on the client-side, so it’s viewable to the user. As a result, bugs and oversights have the potential to be exploited for malicious purposes. 
• Lengthy onboarding of new developers can result because developers must figure out the properties of the structures they’re working with, as well as the data types. While JSDoc can be used for documenting code and annotating types, there’s still the need to synchronize the actual code and documentation. The lack of synchronization, in turn, can mislead developers and complicate the introduction of new, business-requested features.
• JavaScript is prototype-based, not class-based. It’s not considered a pure object-oriented programming language, although it can follow some object-oriented programming principles.

The TypeScript Advantage

TypeScript is a superset of JavaScript. If a developer knows JavaScript, there’s not much of a learning curve to take advantage of the features TypeScript offers that make up for many JavaScript’s deficiencies ─ and offer additional benefits.

For example, with JavaScript, variables can start as one property, and then change into an object or a string. These inconsistencies can generate problems that are difficult to resolve in large apps. TypeScript, on the other hand, analyzes the code and tries to determine proper variable types prior to runtime. Once a variable type is assigned, it stays unchanged. TypeScript’s compiler also helps shorten the QA and testing process in later stages of development.

TypeScript also helps developers quickly figure out the purpose of a variable within the code. It can also suggest available properties in functions, classes, or components. Being able to quickly lookup a variable is important because it reduces the likelihood of calling the wrong function or accidentally skipping a variable declaration. Any reduction in bugs and errors reduces the time required for fixing those issues and in overall development time. That gives developers more time to work on app logic and fix errors that can be detrimental to in-app performance and usability. According to a postmortem analysis by Airbnb, 38% of bugs were preventable with TypeScript after the company adopted it throughout the organization. 

As a static language, TypeScript performs type checks upon compilation, flagging type errors and helping developers spot mistakes early on in development. Reducing errors when working with large codebases can save hours of development time.

Clear and readable code is easy to maintain, even for newly onboarded developers. Because TypeScript calls for assigning types, the code instantly becomes easier to work with and understand. In essence, TypeScript code is self-documenting, allowing distributed teams to work much more efficiently. They don’t have to spend inordinate amounts of time familiarizing themselves with a project.

TypeScript’s integration with editors also makes it much easier to validate the code thanks to context-aware suggestions. TypeScript can determine what methods and properties can be assigned to specific objects, and these suggestions tend to increase developer productivity.

TypeScript is widely used to automate the deployment of infrastructure and CICD pipelines for backend and web applications. Moreover, the client part (for example, when using Angular) and the backend can be written in the same language – TypeScript. This flexibility allows an engineer who knows one programming language to cover all parts of the system.

Because TypeScript essentially transpiles to JavaScript, migrating existing code to TypeScript is easy and fast. It can typically be accomplished simply by running the compiler and adding typing where it’s not recognized by the language. There’s no need to make changes to the code.

The benefits of TypeScript have been noticed by developers. TypeScript was used by 78% of the 2020 State of JS respondents, with 93% saying they would use it again. Typescript continues to grow in popularity. It was voted the second most loved programming language in the Stack Overflow 2020 Developer survey. 

TypeScript & AWS: Better Together 

There’s another compelling reason to consider TypeScript for large-scale app development projects. It’s fully supported by AWS, the leading cloud platform for modern app design and development as noted in Gartner’s Magic Quadrant for Cloud Infrastructure and Platform Services.

The following services and tools have seamless integration out-of-the-box with TypeScript, enabling you to use this language for a vast number of tasks:

• AWS CDK provides Infrastructure as code (IaC) to deploy the entire infrastructure in one click in an automatic mode. You can also automate the creation of CI/CD pipelines for the future launch of specific jobs on demand.
• AWS Lambda allows you to run computation tasks in serverless mode using automatic scaling and an efficient pricing scheme.
• Amazon EC2, ECS, and EKS can cover any of your tasks and provide a wide range of solutions for running apps written in TypeScript – from bare metal servers to complex clusters of hundreds of Docker containers.

Optimize Your Application Development Projects

All decisions made during an application development project can impact overall costs and time to market. That includes going with the right programming language and using the most appropriate cloud platform and resources. 

When approaching an app dev project, a one-size-fits-all approach rarely works. Take the time to define your needs and priorities and select the best resources to deliver the best results.

The post For reduced development cost and accelerated code delivery, try TypeScript appeared first on SD Times.

TypeScript 4.5 comes just three weeks after the release candidate and since then, TypeScript 4.5 has undergone several changes. The most notable of these is that ECMAScript module support for Node.js has been deferred to a future release, and is now available exclusively as an experimental flag in nightly releases. 

TypeScript 4.5 also addresses a performance regression in –build mode due to excessive realpath calls for package.json files. This change was made for TypeScript 4.5, but was also back-ported to TypeScript 4.4.4.  

Mabl raised $40 million in Series C

Mabl, an intelligent test automation company, today announced $40 million in Series C funding. The financing round was led by Vista Equity Partners (Vista) with participation from existing investors such as Amplify Partners, GV, Presidio Ventures, and CRV.

Mabl’s low-code test automation solution enables software teams to reduce the effort needed to create, run, and manage reliable end-to-end user interface and API tests in a unified platform. This funding brings Mabl’s total raised to date to $77 million. In addition, Shivan Patel, senior VP at Vista, will join Mabl’s board of directors.

OutSystems partnerships to expand tech education

OutSystems, a low-code solution provider, today announced new partnerships in order to accelerate its commitment to education and building a diversified generation of developers.

A leading component of OutSystems’ push to accelerate its education efforts is a focus on marginalized communities in tech. In pursuit of this, Outsystems is partnering with Women who Code (WWCode), Blacks in Technology, and the Australian Computer Society (ACS) in order to launch new programs and sponsorships. 

With this, OutSystems expanded its Developer Education Program to close the skills gap in the development and technology community. OutSystems has donated software licenses valued at over $10 million, partnering with over 2,300 universities and training more than 58,000 students.

Sumo Logic announced new integrations 

Sumo Logic, the continuous intelligence company, today introduced new integrations with CircleCI and GitLab in order to help development teams build, run, and measure the health of the entire software delivery lifecycle. 

The Sumo Logic Software Development Optimization solution simplifies the way users democratize and unify fragmented data generated by tools used to build and deliver software. With these integrations, CircleCI and GitLab users gain access to the visibility they need to measure and manage the software development and delivery process.

These integrations allow software teams to collaborate better and gain insights to make better data-driven decisions that bring improved performance in order to optimize builds and deployments, balance resources, and identify bottlenecks.

Interas Labs joins Ortelius open-source project

The Ortelius Open-Source community recently added Interas Labs as a new corporate contributor to its open-source team. Ortelius is an open-source microservice catalog that integrates into the CD pipeline. Once integrated, Ortelius tracks versions, usage, and ownership of microservices across clusters. Currently, Ortelius is incubating at the continuous delivery foundation. 

“Interas Labs is a Kubernetes engineering company with the mission of improving our customer’s move to a secure and simplified cloud native platform. We strongly believe in open-source projects. We choose the Ortelius project as it aligns with our corporate mission to simplify a complex microservice architecture,” said Ujwal Yelmareddy, Founder of Interas Labs. 

The post SD Times news digest: TypeScript 4.5 released; Mabl raised $40 million in Series C; OutSystems partnerships to expand tech education appeared first on SD Times.

The TypeScript 4.5 beta initially added new settings to support directly running ECMAScript modules in Node.js; however, Microsoft believes that the current experience needs more “bake time” before it can be used more broadly, according to Daniel Rosenwasser, a senior program manager at TypeScript in a blog post. 

Also, to ensure that TypeScript and JavaScript support works well out of the box, TypeScript bundles a series of declaration files (.d.ts files) that represent the available APIs in the JavaScript language, and the standard browser DOM APIs. 

TypeScript 4.5 introduces a new utility type called the ‘Awaited’ type. This type is meant to model operations like ‘await’ in ‘async’ functions, or the ‘.then()’ method on ‘Promise’s – specifically, the way that they recursively unwrap ‘Promise’s.

Also, TypeScript 4.5 now can narrow values that have template string types, and also recognizes template string types as discriminants.

In addition, the new TypeScript version includes tail-recursion elimination on conditional types.

“TypeScript often needs to gracefully fail when it detects possibly infinite recursion, or any type expansions that can take a long time and affect your editor experience. As a result, TypeScript has heuristics to make sure it doesn’t go off the rails when trying to pick apart an infinitely-deep type, or working with types that generate a lot of intermediate results,” Rosenwasser added.

Other features include Template String Types as Discriminants, –module es2022, Disabling Import Elision, type Modifiers on Import Names, Private Field Presence Checks.

Additional details on all of the new features and changes in TypeScript 4.5 RC are available here. 

The post TypeScript 4.5 RC introduces new utility type, “Awaited” appeared first on SD Times.

AWS Cloud Control API exposes five common verbs (CreateResource, GetResource, UpdateResource, DeleteResource, ListResource) in order to easily manage the lifecycle of  services. In addition, Cloud Control API will continue to add support for existing AWS  resources across services such as Amazon Elastic Compute Cloud (Amazon EC2) and Amazon Simple Storage Service (Amazon S3).

TypeScript 4.5

Microsoft recently announced the release of TypeScript 4.5 in beta. In order to get started using the beta, visit here to get it through NuGet. The release brings several highlights with it, including: ECMAScript module support in Node.js, private field presence checks, better editor support for unresolved types, and many more.

In addition, this release also brings users: supporting lib from node_modules, template string types as discriminants, –module es2022, tail-recursion elimination on conditional types, disabling import elision, type modifiers on import names, import assertions, faster load time with realPathSync.native, snippet completions for JSX attributes, and breaking changes.

For more information on this and future releases take a look at TypeScript 4.5’s iteration plan. 

Digital.ai announces solution for SAFe

The Digital.ai DevOps Value Stream Delivery for SAFe recently debuted at the 2021 Global SAFe Summit. The solution combines agile planning and DevOps solutions with next-generation AI-driven analytics and metrics integrated end to end and optimized for SAFe.

The Digital.ai Value Stream Delivery for SAFe allows organizations to solve different challenges and deliver on their SAFe initiative goals. With its unified environment the adoption of scalable agile practices are simplified. In addition, it also provides other benefits, such as: simplifying SAFe adoption, scaling agile practices, improving business decisions, connecting end to end, and increasing delivery speed and reliability.

This solution combines four different products: Digital.ai Agility, Digital.ai Release, Digital.ai Deploy, and Digital.ai Analytical Lenses. 

The post SD Times news digest: AWS Cloud Control API, TypeScript 4.5 beta, Digital.ai announces AI solution for SAFe appeared first on SD Times.