Q News Google Ad Completely Abandons Flash, 100% To HTML5; Technology To Be Repealed at .NET Core; Angular Releases 1.5 Official Release

Google Ads Abandon Flash Altogether, 100% Turn To HTML5

Adobe Flash's long and painful demise continues as Google's Display Network announces it will soon stop running Flash ads.

In a blog post shared on the AdWords Google Plus page, Google Display Network and DoubleClick said that "in order to give more people a better browsing experience on more devices", Google Display Network and DoubleClick Digital Marketing is now 100% to HTML5. "

As of June 30, 2016, AdWords and DoubleClick will no longer allow ad uploads built with Flash. Starting January 2, 2017, Flash ads will not run on Google Display Network or DoubleClick. Google will continue to provide AdWords help to advertisers to help them transition to HTML5.

The change also affected Google's Flash-to-HTML5 tool, Swiffy, which will not be converted with new ads starting in July 2016. Google recommends that users visit the AdWords Help page for more resource information that converts Flash ads to HTML5 ads.

Most communities were unsurprised by Google's news, and many commentators welcomed the company's announcement.

Flash's future has been in doubt for some time. In 2015, InfoQ reported that Mozilla had "defaulted" to blocking Flash in Firefox as Adobe announced two major vulnerabilities. And InfoQ's research article "Flash is under fire: Do you only use HTML5/JavaScript?" HTML5 received an 89% relevance rating, while Adobe Flash received a relevance rating of less than 50%.

It is clear that Adobe also helped bring the end of Flash, announcing at the end of 2015 that it would change its name to Animate CC to show that it would be more focused on HTML5.

In November 2015, Rich Lee, Adobe's senior product marketing manager, wrote that more than a third of the content created using Flash Professional used HTML5. Lee says the tool has been completely rewritten over the past few years "to include native HTML5 Canvas and WebGL support" "due to the advent of HTML5 and the need to take advantage of Web standard animation."

In a blog post confirming the "Animate CC Is Coming" on February 8, 2016, Lee said that, in addition to the name change, Animate was one of the company's "most significant releases to date."

It doesn't seem like a coincidence that the announcement coincides with Google's AdWords announcement. Key features of Animate include "supporting HTML5 Canvas templates and allowing developers to customize with any code editor (for example, developers can add scripts for Doubleclick or AOL tracking) and support for Typekit integration with HTML5 Canvas documents." "

Other improvements and updates to Animate CC include replacing the dedicated libraries used in previous versions with the latest version of the Combined CreateJS library. Adobe says the goal of the change is to reduce the number of server calls from published HTML5 Canvas output stoking to improve performance.

Animate also enhances the HTML5 Spritesheet UI, which provides separate controls over PNG and JPEG settings that can be enabled or banned. Animate content can also be imported into OAM (.oam) animation plug-in files from ActionScript, WebGL, or HTML5 Canvas.

The most recent update on the Adobe Flash Runtime roadmap was March 2015, and Adobe has not provided any closer information about the future of Flash.

Original English:http://www.infoq.com/news/2016/02/google-flash-ads-html5

Technology that will be repealed at .NET Core

Although there is a part of the existing. NET applications, especially ASP.NET MVC-based applications, will be able to migrate relatively simply to .NET Core but another part. NET apps may experience some problems during migration. Some issues are obvious, such as moving from WinForms or WPF apps to Universal Windows Applications (UWP), while others are more subtle, and this relates to the more underlying implementation of the core functionality of the .NET Framework.


The reflection API has made a big difference in .NET Core. As in winRT, reflection is divided into a lightweight version and a more expensive version. Immo Landwerth from Microsoft wrote:

When we launched .NET Native, we used a technique that allowed us to make static links to the framework and third-party dependencies. For this link functionality to work, it must be able to identify the part of the framework feature that is not used in your app. This process is not complicated for other technologies, such as C, because the system does not have the dynamic capability to reflect. Of course, reflection is still supported in .NET Native, but we want to make this platform as low as possible, which means you don't have to add overhead for features you don't need. This is especially true for reflection because it imposes great restrictions on what the runtime and compilers can do based on static information.

Therefore, ideally, reflection should be an optional component in .NET Core, and you can choose to give it up completely in your own app. The trouble is that System.Object relies on reflection solely when it does Object.GetType(). To break this dependency, we decided to let System.Type stop presenting the entire reflection type information, but only the name of the type. This also means that System.Type in .NET Core no longer includes APIs such as GetMembers(), but still exposes APIs such as Name.

An extension method called GetTypeInfo lets you get the information you can get from the Type object in general. The TypeInfo class contains less information than it used to be, but Microsoft recently decided to reintroduce a portion of the reflection API in .NET Core, a change that was beyond its original plan.

To make it easier for code to port, the .NET 4.5 and later versions provide some support for TypeInfo, similar to the version used in .NET Core.

App Domain

App Domain was implemented in CoreCLR, but not in .NET Native. Because the implementation of App Domain requires a lot of runtime feature support, there is currently no support plan for app Domain. "For code isolation, we recommend implementing it through processes or containers. For dynamic loading of assemblies, we recommend using the new AssemblyLoadContext class. "


Today, few developers can remember the existence of the Remoting library, let alone how to use it. Even if someone else is using it, they have been complaining about its performance, high complexity, and overall performance vulnerability.

Today, multiple. NET applications are largely replaced by WCF, which provides better performance for pipeline or memory mapping files. For cross-machine communications, Microsoft recommends "using a low-cost plain text protocol, such as HTTP." As a result, Microsoft did not support Remoting's program in .NET Core.


.NET Core will support most serializers, such as data contract serialization, XML serialization, JSON. NET as well as protobuf-net. An important role that is excluded is binary serialization.

Through this decade's experience, we have finally learned that serialization is a very complex task, and that the types that support serialization face a heavy burden in terms of compatibility. Therefore, we have decided to make serialization a protocol that will be implemented on the basis of the available open APIs. However, the implementation of binary serialization requires a deeper understanding of the type itself, as it can serialize the entire object graph, even including private state information.


In theory, a sandbox is an excellent idea that allows partial trust code to execute in a secure manner. In practice, however, it is very difficult to apply it correctly, and even a small amount of error can lead to security vulnerabilities. Immo Landwerth also says it "makes implementation more difficult and often negatively impacts on the performance of applications that don't use sandboxes." "

The recommended alternative is to run them through a user account with limited permissions using a separate process. In this way, the runtime does not have to repeat some expensive permission checking because the operating system has already done this for you.

Other components

Microsoft is considering opening source the components listed in the table below and porting them to .NET Core.

  • System.Data. Although its underlying layer features, the provider model and SQL client, have become part of the .NET Core, some features are still unavailable, such as support for DataschemaTable, and DataSet.

  • System.Directory Services..NET Core does not currently support communication with LDAP or the active directory through this component.

  • System.Drawing. Although it should be a client API in a strict sense, there are still a large number of developers on the service side to implement thumbnail or watermark generation through the drawing API. We do not currently support the use of these APIs in .NET Core.

  • System.Transactions. Although ADO.NET supports transactions, it does not include support for distributed transactions, which include the concepts of ambient transactions and resource collection.

  • System.Xml.Xsl and System.Xml.Schema. .NET Core supports XmlDocument and XDocument, including XPath, introduced by Linq. However, XSD (XmlSchema) and XSLT (XslTransform) are not yet supported.

  • System.Net.Mail. E-mail is not currently supported in .NET Core through these APIs.

  • System.IO.Ports. .NET Core does not currently support communication with serialized ports.

  • System.Workflow. The Windows Workflow Foundation (WF) is currently unavailable in .NET Core.

  • System.Xaml. When developing a UWP app, developers will use the WinRT XAML API. Therefore, .NET Core currently does not support the managed XAML framework, which includes the ability to parse XAML and instantiate the description of object diagrams.

Are you interested in helping us port a component? Part of the source code implemented by the .NET Framework has been opensourced through MIT licenses as part of The Reference Source. We are trying to get the community to support our transplant efforts. If you would like to participate in this project, please send an email to immol@microsoft.com.

Original English:http://www.infoq.com/news/2016/02/Core-Discontinued

Release 1.5 Official Release, Focusing on Transition to Angular 2

The Angular team recently released the official version of Angular 1.5, which delivered a major upgrade that left the company still in use with 1. Developers of version X will be able to make it easier to transition to angular 2 development.

Pete Bacon Darwin wrote in a blog post in the announcement that the purpose of the release was to "improve the upgrade path for Angular 2." We introduced some new features in this release that bring the Angular 1 app written by developers closer to the structure of the application in the application in 2. "

In this release, the new module.component() secondary is the biggest change to the transition to Angular 2. By using this approach, developers no longer have to follow the traditional definition of object style to write directive. If the reader is already familiar with the way Angular 2 is written, he should be aware of this similarity. In the article, the author presents an example of how to define a new component:

myModule.component('myComponent', {  template: '<h1>Hello {{ $ctrl.getFullName() }}</h1>',  bindings: { firstName: '<', lastName: '<' },  controller: function() {    this.getFullName = function() {      return this.firstName + ' ' + this.lastName;    };  } });

Prior to the advent of component, developers could only use, or through the unconventional use of the controller, to implement certain scenarios. This is not to say that component will completely replace the role of the directive, for example, component cannot be used to manipulate the DOM, and all components must be activated by custom HTML elements, rather than triggering through the properties of the element. Component, as defined in the above manner, can be used by the following code:

<my-component first-name="'Alan'" last-name="'Rickman'"></my-component>

The new component guide provides a more complete description of the difference between the traditional directive and the component.

  • One-way binding

  • Life cycle hooks

  • Binding to required directive

  • Transclusion with multiple slots

  • Default transclusion content

Developers currently using version 1.4 can read the migration guide to understand what necessary changes are required to migrate, as some disruptive changes are introduced in version 1.5.

Version 1.5 should be the biggest change for a foreseeable period of time. When InfoQ asked Bacon Darwin where the 1.X version would go from, he replied:

We haven't started planning the next release cycle for Angular 1. As the official release date for 2 is getting closer, if we continue to develop Angular 1, we will try to bring it closer to Angular 2. If destructive changes are required to achieve this, version 1.6 can be expected. At the same time, we will continue the development of the Angular 1.5.x version, providing bug fixes and some smaller features. All in all, this does not conflict with our goal of making It Easier to migrate to Angular 2.

The new router feature should be released later this week.

Original English:http://www.infoq.com/news/2016/02/angular-1-5-released

This article is an original launch of InfoQ and has been declined for unauthorized reproduction.

InfoQ Original Translation Editor and Technology Editor Recruitment, Resume Fast Hit: editors@cn.infoq.com