1. IT-Security >
  2. Programmierung




Machine Learning Insights & Applications

Programmierung vom 16.11.2018 um 02:15 Uhr | Quelle youtube.com



In case you missed it: October 2018 roundup

Programmierung vom 15.11.2018 um 23:17 Uhr | Quelle blog.revolutionanalytics.com

In case you missed them, here are some articles from October of particular interest to R users.

Peter Provost ports some 80's-era BASIC programs for kids to R.

In a podcast for Fringe FM, I discuss the ethics of AI, Microsoft and Open Source, and the R Community.

Roundup of AI, Machine Learning and Data Science news from October 2018.

In this episode of "Guy in a Cube", R is used to visualize Anscombe's Quartet via Power BI.

Di Cook suggests using computer vision to automate statistical model assessment for machine learning in the 2018 Belz Lecture.

R provides the analysis behind a front-page story on bridge safety in the Baltimore Sun.

Tomas Kalibera describes the big impacts of a small tweak to the logical comparison operators in R.

The Economist is now using R to calculate its famous "Big Mac Index".

Behind-the-scenes details of how R gets built on Windows, from a presentation by Jeroen Ooms.

The R Consortium has accepted another round of grant applications for R community projects.

A list of upcoming R conferences.

A recap of AI, Machine Learning and Data Science announcements from the Microsoft Ignite conference.

And some general interest stories (not necessarily related to R):

As always, thanks for the comments and please send any suggestions to me at [email protected]. Don't forget you can follow the blog using an RSS reader, via email using blogtrottr, or by following me on Twitter (I'm @revodavid). You can find roundups of previous months here



Announcing TypeScript 3.2 RC

Programmierung vom 15.11.2018 um 23:08 Uhr | Quelle blogs.msdn.microsoft.com

Today we’re announcing TypeScript 3.2 RC, the release candidate of our next version of TypeScript.

To get started using the RC, you can get it through NuGet, or use npm with the following command:

npm install -g [email protected]

You can also get editor support for TypeScript 3.2 by:

We have some important information below for NuGet users and Visual Studio 2015 users, so please continue reading if you use either product.

Let’s look at some of what’s coming in TypeScript 3.2!


As you might’ve guessed from the title of this section, TypeScript 3.2 introduces stricter checking for bind, call, and apply. But what does that mean?

Well in JavaScript, bind, call, and apply are methods on functions that allow us to do things like bind this and partially apply arguments, call functions with a different value for this, and call functions with an array for their arguments.

Unfortunately, in its earlier days, TypeScript lacked the power to model these functions, and bind, call, and apply were all typed to take any number of arguments and returned any. Additionally, ES2015’s arrow functions and rest/spread arguments gave us a new syntax that made it easier to express what some of these methods do – and in a more efficient way as well.

Still, demand to model these patterns in a type-safe way led us to revisit this problem recently. We realized that two features opened up the right abstractions to accurately type bind, call, and apply without any hard-coding:

  1. this parameter types from TypeScript 2.0
  2. Modeling parameter lists with tuple types from TypeScript 3.0

Combined, the two of of them can ensure our uses of bind, call, and apply are more strictly checked when we use a new flag called strictBindCallApply. When using this new flag, the methods on callable objects are described by a new global type called CallableFunction which declares stricter versions of the signatures for bind, call, and apply. Similarly, any methods on constructable (but not callable) objects are described by a new global type called NewableFunction.

As an example, we can look at how Function.prototype.apply acts under this behavior:

function foo(a: number, b: string): string {
    return a + b;

let a = foo.apply(undefined, [10]);              // error: too few argumnts
let b = foo.apply(undefined, [10, 20]);          // error: 2nd argument is a number
let c = foo.apply(undefined, [10, "hello", 30]); // error: too many arguments
let d = foo.apply(undefined, [10, "hello"]);     // okay! returns a string

Needless to say, whether you do any sophisticated metaprogramming, or you use simple patterns like binding methods in your class instances (this.foo = this.foo.bind(this)), this feature can help catch a lot of bugs. For more details, you can check out the original pull request here.

Object spread on generic types

JavaScript supports a handy way of copying existing properties from an existing object into a new one called “spreads”. To spread an existing object into a new object, you define an element with three consecutive periods (...) like so:

let person = { name: "Daniel", location: "New York City" };

// My secret revealed, I have two clones!
let shallowCopyOfPerson = { ...person };
let shallowCopyOfPersonWithDifferentLocation = { ...person, location: "Seattle" };

TypeScript does a pretty good job here when it has enough information about the type. The type system closely tries to model the behavior of spreads and overwrites new properties, tries to ignore methods, etc. But unfortunately up until now it wouldn’t work with generics at all.

function merge<T, U>(x: T, y: U) {
    // Previously an error!
    return { ...x, ...y };

This was an error because we had no way to express the return type of merge. There was no syntax (nor semantics) that could express two unknown types being spread into a new one.

We could have come up with a new concept in the type system called an “object spread type”, and in fact we had a proposal for exactly that. Essentially this would be a new type operator that looks like { ...T, ...U } to reflect the syntax of an object spread.
When both T and U are known, that type would flatten down to some new object type.

However, this is pretty complex and requires adding new rules to type relationships and inference. While we explored several different avenues, we recently arrived at two conclusions:

  1. For most uses of spreads in JavaScript, users were fine modeling the behavior with intersection types (i.e. Foo & Bar).
  2. Object.assign – a function that exhibits most of the behavior of spreading objects – is already modeled using intersection types, and we’ve seen very little negative feedback around that.

Given that intersections model the common cases, and that they’re relatively easy to reason about for both users and the type system, TypeScript 3.2 now permits object spreads on generics and models them using intersections:

// Returns 'T & U'
function merge<T, U>(x: T, y: U) {
    return { ...x, ...y };

// Returns '{ name: string, age: number, greeting: string } & T'
function foo<T>(obj: T) {
    let person = {
        name: "Daniel",
        age: 26

    return { ...person, greeting: "hello", ...obj };

Object rest on generic types

Object rest patterns are sort of the dual of object spreads. Instead of creating a new object with some extra/overridden properties, it creates a new object that lacks some specified properties.

let { x, y, z, ...rest } = obj;

In the above, the most intuitive way to look at this code is that rest copies over all the properties from obj apart from x, y, and z. For the same reason as above, because we didn’t have a good way to describe the type of rest when obj is generic, we didn’t support this for a while.

Here we also considered a new rest operator, but we saw we already had the facilities for describing the above: our Pick and Exclude helper types in lib.d.ts. To reiterate, ...rest basically picks off all of the properties on obj except for x, y, and z in the following example:

interface XYZ { x: any; y: any; z: any; }

function dropXYZ<T extends XYZ>(obj: T) {
    let { x, y, z, ...rest } = obj;
    return rest;

If we want to consider the properties of T (i.e. keyof T) except for x, y, and z, we can write Exclude<keyof T, "x" | "y" | "z">. We then want to pick those properties back off of the original type T, which gives us

Pick<T, Exclude<keyof T, "x" | "y" | "z">>`.

While it’s not the most beautiful type (hey, I’m no George Clooney myself), we can wrap it in a helper type like DropXYZ:

interface XYZ { x: any; y: any; z: any; }

type DropXYZ<T> = Pick<T, Exclude<keyof T, keyof XYZ>>;

function dropXYZ<T extends XYZ>(obj: T): DropXYZ<T> {
    let { x, y, z, ...rest } = obj;
    return rest;

BigInt Support

BigInts are part of an upcoming proposal in ECMAScript that allow us to model theoretically arbitrarily large integers. TypeScript 3.2 brings type-checking for BigInts, as well as support for emitting BigInt literals when targeting esnext.

BigInt support in TypeScript introduces a new primitive type called the bigint (all lowercase). You can get a bigint by calling the BigInt() function or by writing out a BigInt literal by adding an n to the end of any integer numeric literal:

let foo: bigint = BigInt(100); // the BigInt function
let bar: bigint = 100n;        // a BigInt literal

// *Slaps roof of fibonacci function*
// This bad boy returns ints that are *so* big!
function fibonacci(n: bigint) {
    let result = 1n;
    for (let last = 0n, i = 0n; i < n; i++) {
        const current = result;
        result += last;
        last = current;
    return result;


While you might imagine close interaction between number and bigint, the two are separate domains.

declare let foo: number;
declare let bar: bigint;

foo = bar; // error: Type 'bigint' is not assignable to type 'number'.
bar = foo; // error: Type 'number' is not assignable to type 'bigint'.

As specified in ECMAScript, mixing numbers and bigints in arithmetic operations is an error. You’ll have to explicitly convert values to BigInts.

console.log(3.141592 * 10000n);     // error
console.log(3145 * 10n);            // error
console.log(BigInt(3145) * 10n);    // okay!

Also important to note is that bigints produce a new string when using the typeof operator: the string "bigint". Thus, TypeScript correctly narrows using typeof as you’d expect.

function whatKindOfNumberIsIt(x: number | bigint) {
    if (typeof x === "bigint") {
        console.log("'x' is a bigint!");
    else {
        console.log("'x' is a floating-point number");

We’d like to extend a huge thanks to Caleb Sander for all the work on this feature. We’re grateful for the contribution, and we’re sure our users are too!


As we mentioned, BigInt support is only available for the esnext target. It may not be obvious, but because BigInts have different behavior for mathematical operators like +, -, *, etc., providing functionality for older targets where the feature doesn’t exist (like es2017 and below) would involve rewriting each of these operations. TypeScript would need to dispatch to the correct behavior depending on the type, and so every addition, string concatenation, multiplication, etc. would involve a function call.

For that reason, we have no immediate plans to provide downleveling support. On the bright side, Node.js 11 and newer versions of Chrome already support this feature, so you’ll be able to use BigInts there when targeting esnext.

Certain targets may include a polyfill or BigInt-like runtime object. For those purposes you may want to add esnext.bigint to the lib setting in your compiler options.

Breaking changes and deprecations

JSX resolution changes

Our logic for resolving JSX invocations has been unified with our logic for resolving function calls. While this has simplified the compiler codebase and improved some use-cases, there may be some differences which we may need to reconcile. These changes are likely unintentional so they are not breaking changes per se, but upgraders should note take note of any issues they encounter and report them.

lib.d.ts changes

More specific types

Certain parameters no longer accept null, or now accept more specific types as per the corresponding specifications that describe the DOM.

More platform-specific deprecations

Certain properties that are WebKit-specific have been deprecated. They are likely to be removed in a new version.

wheelDelta and friends have been removed.

wheelDeltaX, wheelDelta, and wheelDeltaZ have all been removed as they are deprecated properties on WheelEvents.

As a solution, you can use deltaX, deltaY, and deltaZ instead. If older runtimes are a concern, you can include a file called legacy.d.ts in your project and write the following in it:

// legacy.d.ts

interface WheelEvent {
     readonly wheelDelta: number;
     readonly wheelDeltaX: number;
     readonly wheelDeltaZ: number;

A note for NuGet and Visual Studio 2015

We have some changes coming in TypeScript 3.2 for NuGet and VS2015 users.

First, TypeScript 3.2 and future releases will only ship an MSBuild package, and not a standalone compiler package. Second, while our NuGet packages previously shipped with the Chakra JavaScript engine to run the compiler, the MSBuild package now depends on a globally invokable version of Node.js to be present. While machines with newer versions of Visual Studio 2017 (versions 15.8 and above) will not be impacted, testing/CI machines, users with Visual Studio 2015, and users of Visual Studio 2017 15.7 and below will need to install Node.js and will likely see a message like the following:

The build task could not find node.exe which is required to run the TypeScript compiler. Please install Node and ensure that the system path contains its location.

Lastly, TypeScript 3.2 will be the last TypeScript release with editor support for Visual Studio 2015 users. To stay current with TypeScript, we recommend upgrading to Visual Studio 2017 for the latest editing experience.

What’s next

We’ve actually got plenty more coming up in TypeScript 3.2, and you can track the list of major features we’ve been working on our Roadmap. We hope you give TypeScript 3.2 RC a try and give us some feedback on your experience. In the meanwhile, we’ll be listening to the community and polishing the 3.2 release over the next 2 weeks. Happy hacking!

– Daniel Rosenwasser and the TypeScript team



Why do we need Q#?

Programmierung vom 15.11.2018 um 23:00 Uhr | Quelle blogs.msdn.microsoft.com

You may be familiar with the Microsoft Quantum blog, which shares general news about our quantum computing program and about quantum computing in general. This blog is its developer- and community-focused partner. It will host technical posts, deep dives into the language and libraries, and tutorials. There will also be developer event announcements and recaps, new release information, and the like.

Why We Wrote Q#

tl;dr: Because we want to write algorithms, not circuits.

History and Requirements

Q# grew out of a project to build a follow-on to LIQUi|〉 that would be oriented towards writing, compiling, and executing algorithms on both short-term small-scale “NISQ” and eventual large-scale quantum computers. While supporting simulation is important in the short term as the primary available execution platform, and even in the long term as an aid for debugging, the goal of the project is execution on quantum hardware, not simulation. In addition, we wanted to support scalability of development as well as of execution; that is, the project should allow productive development of large numbers of complex applications, not just one or two simple canned algorithms.

To meet these goals, we came up with the following requirements for the language, compiler, and runtime:

  1. Algorithms must be expressed in terms of abstract qubits, rather than physical qubits. For large numbers of qubits, the compiler and runtime should manage the mapping from program qubits to logical (error-corrected) qubits, and then eventually to physical qubits. Doing this by hand becomes unmanageably complicated for any non-trivial algorithm. The compiler and runtime should also be responsible for selecting and implementing the error correction and fault tolerance approach.
  2. Algorithms need to allow integrated quantum and classical computation. In particular, classical flow control based on quantum measurement outcomes must be supported. This is required to support quantum patterns such as repeat-until-success and
    adaptive phase estimation.
  3. Higher-order protocols such as phase estimation and oblivious amplitude amplification must be expressible. A common pattern in quantum computing is “meta-algorithms” such as these, which operate on other operations rather than on qubits. It is necessary for development scalability to allow such algorithms to be expressed abstractly and used with the appropriate input algorithms.
  4. Higher-order transformations such as taking the adjoint of an operation must be natively expressible. There are two common ways to derive a new operation from an existing one in quantum computing: taking the adjoint of the operation and controlling the operation with a qubit or multiple qubits. To support writing higher-level protocols cleanly, there should be a way to express that the adjoint or controlled version of an operation should be invoked. It greatly aids development scalability for the compiler to be able to auto-generate the adjoint or controlled version of an operation.
  5. Tasks such as gate synthesis, gate sequence optimization, and ancilla management should be delegated to the compiler. Performing these tasks manually becomes unmanageable rapidly, even for medium-size algorithms. This implies that the compiler must be able to determine a great deal of information statically, so that tasks such as rotation synthesis may be done at compile time rather than during execution.
  6. Algorithms should be required to respect the laws of physics. For instance, copying the state of a qubit should not be possible. Direct access to the qubit state should not be possible, although we allow a certain amount of validation and state examination to facilitate debugging with a simulator.

Our first attempt, not surprising given our LIQUi|〉 heritage, was to use a quantum library embedded in the functional portion of F#. We used the F# quotations feature to examine and process the quantum algorithm code.

As a functional language with rich support for generics and type inference, F# made the first four requirements easy to meet. Meta-operations were easy to express as F# functions that took function arguments. Adjoint and Controlled were implemented as F# functions that were recognized and processed specially by the compiler.

Initially we had a fair amount of success with this approach, when we had only the compiler developers writing quantum algorithms. As more and more people started using the platform, though, we found that the code for compiler features such as generating adjoints and synthesizing gates became more and more complicated. Providing these features depends on being able to comprehend the semantics of an algorithm in order to perform symbolic computation on the algorithm. Unfortunately for this purpose, F# (like any modern general-purpose language) is a rich language with a very rich set of libraries, so that it is difficult for a compiler to look at code and determine what it means. When there were only a few developers writing algorithms, it was possible for our compiler to recognize and handle the specific idioms that those developers used. Every time we got a new user, though, they brought with them a new set of idioms that the compiler had to recognize. This approach was clearly not scalable in terms of platform development.

Q#: A Domain-Specific Language

After a significant effort to make the embedded approach work, we finally decided that moving to a custom domain-specific language for quantum computing would offer significant enough advantages to be worth the development cost of building our own compiler front-end and libraries. In the summer of 2017, we started designing Q#.

Execution Model

One decision we made at the start was that we were going to treat the quantum computer as an accelerator, similar to the way that a GPU is treated. This means that there will be a main application program written in C#, F#, or some other .NET language, and the quantum code will run as a subroutine to the main program. This also means that the quantum routine can be limited to just the accelerated portion of the application; capabilities such as file I/O and user interaction can be safely omitted from Q# and left to the main program.

Design Principles

We knew that designing a new language isn’t quick and easy, and that we were unlikely to get everything right first time. Thus, we decided on a set of core principles to guide our process both initially and as Q# evolves:

  1. Start minimal and evolve carefully based on user experience.
  2. Be quantum first, familiar second.
  3. Use libraries wherever possible, rather than language features.
  4. Keep clear, well-defined semantics to enable rich optimizations and transformations in the compiler back-end.

Starting minimal led us to defer many features that we could have put into Q# at the beginning, and instead to wait and see if they’re needed. For example, the first preview of Q# did not support a C-like ternary operator. We subsequently heard from users that lacking this operator over-complicated the code for a simple situation; specifically, a mutable variable and an `if` statement were required to simply have a conditional return. Thus, in our 0.3 release we will add support for a ternary operator.

An example of quantum first is the repeat-until statement, which directly expresses the quantum repeat-until-success pattern. While it’s possible to express this pattern using a C-like while or do/while loop, doing so requires multiple flags and some awkward logic that obscures the pattern. Having a specialized statement allows this pattern to be apparent in the code, both to the reader and to optimizers and other code transformations.

Some Key Q# Features

Qubit Management

In Q#, qubits are a resource that are requested from the runtime when needed and returned when no longer in use. This is similar to the way that classical languages deal with heap memory.

The Q# language doesn’t specify whether qubits are logical or physical. This can be decided by the runtime when the algorithm is executed. Similarly, the mapping from a qubit variable in a program to an actual logical or physical qubit is decided by the runtime, and that mapping may be deferred until after the topology and other details of the target device is known. The runtime is responsible for determining a mapping that allows the algorithm to execute, including any qubit state transfer and remapping required during execution.

Q# also supports “dirty ancillas”: There are quantum routines that require additional workspace qubits (ancillas) during execution, but that are guaranteed to return the qubits back to their original state by the end of the routine. These ancillae can be qubits that are currently in use but that are not accessed during the routine in question. The Q# compiler and runtime can determine which qubits are safe for use this way, avoiding the need of additional “clean” qubits and reducing the overall space requirements of an algorithm.

First-Class Operations

Operations and functions in Q# are first-class entities; they can be passed to other operations, assigned to variables, and used like any other value. This makes it easy to express protocols such as amplitude amplification, phase estimation, and others in the Q# Canon library.

A related feature, partial application, enhances the power of first-class operations by making it easy to define new operations as specialized versions of existing operations. The Canon implementation of the Trotter-Suzuki expansion demonstrates the power Q# gets from the combination of first-class operations and partial application.

Adjoint and Controlled Derivations

Q# provides two ways of deriving a new operation from an existing one:

  • The Adjoint of an operation is, mathematically, the complex conjugate transpose of the operation. For the unitary operations common in quantum computing, the adjoint of an operation is its inverse; that is, it undoes the computation that the operation performs.
  • The Controlled version of an operation takes one or more additional qubits and performs the base operation if and only if the additional “control” qubits are in the computational 1 state. Of course, it does this in superposition, so the result is typically an entangled state of the control qubits and the operated-on qubits.

Both the adjoint and controlled derivations require non-trivial code transformations on the base operation. Q# allows the developer to ask the compiler to generate the derived versions following general rules for unitary operations. In the relatively rare situation that an operation requires special processing, or if there is a more efficient derived version that the developer can provide using special knowledge, the developer can explicitly specify the derived version.

In Q#, the `Adjoint` and `Controlled` modifiers are used with a base operation to refer to the respective derived operations. For instance, if `SomeUnitary` is an operation that has an adjoint, `Adjoint SomeUnitary` is the derived operation that is the adjoint of that operation. The modifiers may be applied to operation-valued variables, as well, which is critical for supporting higher-level operations such as phase estimation.

Beyond Circuits

Q# supports general classical control flow during the execution of an algorithm. For instance, the loop required for probabilistic algorithms such as Grover search can easily be expressed in Q#, rather than having to return to the classical driver to test whether the result satisfies the oracle and rerunning if not.

Q# supports rich classical computation as well as quantum operations. This allows clean expression of adaptive algorithms such as the random walk phase estimation operation in the non-commercial library. Such algorithms are difficult to express directly in the circuit model of a fixed sequence of quantum gates.

These features imply that the execution runtime must be capable of handling significant runtime variation in gate sequences. Ensuring this capability is a key part of Microsoft’s quantum full-stack architecture.

Coming Soon

Some topics we’re planning:

  • Quantum katas: learning quantum computing with Q#
  • What’s new in 0.3
  • Why do we care about quantum computing?
  • Drill down: Qubits in Q#
  • Drill down: The new Hamiltonian simulation library
  • Inside the Q# compiler

Please let us know in comments if there are specific topics you’d like us to cover!

Useful Links

Alan Geller, Software Architect, Quantum Software and Applications

Alan Geller is a software architect in the Quantum Architectures and Computation group at Microsoft. He is responsible for the overall software architecture for Q# and the Microsoft Quantum Development Kit, as well as other aspects of the Microsoft Quantum software program.



Q# Advent Calendar 2018

Programmierung vom 15.11.2018 um 23:00 Uhr | Quelle blogs.msdn.microsoft.com

The F# and C# communities have blogging events called Advent Calendars (F#, C#), in which every day in December one awesome community member publishes a blog post about the language. I think it’s an amazing way to bid farewell to the old year and to celebrate the new one, and Q# needs one too!

(I asked Sergey Tihon for permission)

So, let’s write some Q# blog posts!

The rules are simple:

  1. Reserve a slot by leaving a comment on this post. The slots are assigned on the first come, first serve basis. You do not have to announce the topic of your blog post until you’re ready to publish it, but we’d really love to hear it beforehand!
  2. Prepare a blog post (in English) about Q#, learning Q#, teaching Q#, using Q# for research, tools for working with Q#… You got the idea.
  3. Publish your blog post on your assigned date. Don’t forget to link back to the Q# Advent Calendar from your post, so that your readers can find the entire advent.
  4. Leave the link to your blog post in a comment to this post, and we’ll add it to the calendar. If you share a link to your post on Twitter, use hashtags #qsharp and #QsAdvent.

We are pursuing publishing a compendium of all of the posts to the arXiv, the standard repository for work on quantum computing.
If you would like to have your post included, please make sure that it is published under a Creative Commons CC-BY license.

Let’s start with 24 slots, December 1st through December 24th, and if we have more volunteers than that we’ll add extra slots. We have a couple of blogs by our team members in store, but we’ll keep those flexible to fill the slots which end up unclaimed.

Thanks to everybody who will participate!

Useful Links

Mariia Mykhailova, Senior Software Engineer, Quantum

Mariia Mykhailova is a software engineer at the Quantum Architectures and Computation group at Microsoft. She focuses on developer outreach and education work for the Microsoft Quantum Development Kit. In her spare time she writes problems for programming competitions and creates puzzles.



Official support for Windows 10 on ARM development

Programmierung vom 15.11.2018 um 22:59 Uhr | Quelle blogs.windows.com

Today is an exciting day for Windows 10 on ARM. With the official release of Visual Studio 15.9, developers now have the officially supported SDK and tools for creating 64-bit ARM (ARM64) apps. In addition, the Microsoft Store is now officially accepting submissions for apps built for the ARM64 architecture.

This news comes at a great time, as this holiday season, our partners Lenovo and Samsung are offering new Windows 10 on ARM devices featuring the Qualcomm Snapdragon 850 processor. These second-generation ARM64 devices provide even more computing power for developers to tap into while continuing to deliver the beyond-all-day battery life customers expect from Windows 10 on ARM. Like the first-generation ARM64 devices, they are also thin, light, fast, and designed with instant-on 4G LTE connectivity in mind, while able to run the wide ecosystem of Windows applications thanks to an x86 emulation layer.

Developers can use Visual Studio 15.9 today to recompile apps – both UWP and C++ Win32 – to run natively on Windows 10 on ARM devices. Running natively allows applications to take full advantage of the processing power and capabilities of Windows 10 on ARM devices, resulting in the best possible experience for users.


Back in May, we documented a number of steps needed in order to build as ARM64 using early preview tools. With official support in Visual Studio, that’s much easier.

To start, update to Visual Studio 15.9. If you are going to build ARM64 C++ Win32 apps, ensure you have installed the individual component “Visual C++ compilers and libraries for ARM64” as shown below:

To start, update to Visual Studio 15.9. If you are going to build ARM64 C++ Win32 apps, ensure you have installed the individual component “Visual C++ compilers and libraries for ARM64.

After updating, for new UWP projects, you will see ARM64 as an available build configuration.

After updating, for new UWP projects, you will see ARM64 as an available build configuration.

For existing projects, or for C++ Win32 projects, add an ARM64 configuration to your project:

  1. Right click on your Solution and select Properties, then navigate to Configuration Properties and select “Configuration Manager.”
  2. Under “Active solution platform:” select “<New…>” and call it ARM64. Copy settings from “ARM” or “x64” and check to create new project platforms.

Hit build, and you should have ARM64 binaries ready to run.

To debug your app, you can use remote debugging, which is fully supported on ARM64. The download and instructions can be found at Remote Debugging on docs.microsoft.com. You can also create a package for sideloading or directly copy binaries over to a Windows 10 on ARM device to run your app.

To deliver your app to customers, the Store is now accepting ARM64 UWP apps, both C++ and .NET Native. You can also use the Desktop Bridge (instructions on docs.microsoft.com) to wrap ARM64 binaries into a package that can be submitted to the Store. And as always, you can also host dedicated ARM64 versions of your Win32 apps on your website or integrate ARM64 into existing multi-architecture installers.


With new Windows 10 on ARM devices sporting more powerful processors, the ARM64 platform continues to mature and improve. The release of Visual Studio 15.9 continues that evolution, and we can’t wait to see what amazing experiences developers can produce using these tools.

For answers to any questions or if you have feedback to share, head to our Windows 10 on ARM development page at http://aka.ms/Win10onARM or leave comments below.

The post Official support for Windows 10 on ARM development appeared first on Windows Developer Blog.



State of CSS Houdini

Programmierung vom 15.11.2018 um 21:35 Uhr | Quelle youtube.com



Blazor 0.7.0 experimental release now available

Programmierung vom 15.11.2018 um 19:30 Uhr | Quelle blogs.msdn.microsoft.com

Blazor 0.7.0 is now available! This release focuses on enabling component coordination across ancestor-descendent relationships. We've also added some improvements to the debugging experience.

Here's what's new in the Blazor 0.7.0 release:

  • Cascading values and parameters
  • Debugging improvements

A full list of the changes in this release can be found in the Blazor 0.7.0 release notes.

Get Blazor 0.7.0

Install the following:

  1. .NET Core 2.1 SDK (2.1.500 or later).
  2. Visual Studio 2017 (15.9 or later) with the ASP.NET and web development workload selected.
  3. The latest Blazor Language Services extension from the Visual Studio Marketplace.
  4. The Blazor templates on the command-line:

    dotnet new -i Microsoft.AspNetCore.Blazor.Templates

You can find getting started instructions, docs, and tutorials for Blazor at https://blazor.net.

Upgrade an existing project to Blazor 0.7.0

To upgrade a Blazor 0.6.0 project to 0.7.0:

  • Install the prerequisites listed above.
  • Update the Blazor packages and .NET CLI tool references to 0.7.0. The upgraded Blazor project file should look like this:

    <Project Sdk="Microsoft.NET.Sdk.Web">
        <RunArguments>blazor serve</RunArguments>
        <PackageReference Include="Microsoft.AspNetCore.Blazor.Browser" Version="0.7.0" />
        <PackageReference Include="Microsoft.AspNetCore.Blazor.Build" Version="0.7.0" />
        <DotNetCliToolReference Include="Microsoft.AspNetCore.Blazor.Cli" Version="0.7.0" />

That's it! You're now ready to try out the latest Blazor features.

Cascading values and parameters

Blazor components can accept parameters that can be used to flow data into a component and impact the component's rendering. Parameter values are provided from parent component to child component. Sometimes, however, it's inconvenient to flow data from an ancestor component to a descendent component, especially when there are many layers in between. Cascading values and parameters solve this problem by providing a convenient way for an ancestor component to provide a value that is then available to all descendent components. They also provide a great way for components to coordinate.

For example, if you wanted to provide some theme information for a specific part of your app you could flow the relevant styles and classes from component to component, but this would be tedious and cumbersome. Instead, a common ancestor component can provide the theme information as a cascading value that descendents can accept as a cascading parameter and then consume as needed.

Let's say the following ThemeInfo class specifies all of the theme information that you want to flow down the component hierarchy so that all of the buttons within that part of your app share the same look and feel:

public class ThemeInfo 
    public string ButtonClass { get; set; }

An ancestor component can provide a cascading value using the CascadingValue component. The CascadingValue component wraps a subtree of the component hierarchy and specifies a single value that will be available to all components within that subtree. For example, we could specify the theme info in our application layout as a cascading parameter for all components that make up the layout body like this:

@inherits BlazorLayoutComponent

<div class="sidebar">
    <NavMenu />

<div class="main">
    <div class="top-row px-4">
        <a href="http://blazor.net" target="_blank" class="ml-md-auto">About</a>

    <CascadingValue Value="@theme">
        <div class="content px-4">

@functions {
    ThemeInfo theme = new ThemeInfo { ButtonClass = "btn-success" };

To make use of cascading values, components can declare cascading parameters using the [CascadingParameter] attribute. Cascading values are bound to cascading parameters by type. In the following example the Counter component is modified to have a cascading parameter that binds to the ThemeInfo cascading value, which is then used to set the class for the button.

@page "/counter"


<p>Current count: @currentCount</p>

<button class="btn @ThemeInfo.ButtonClass" onclick="@IncrementCount">Click me</button>

@functions {
    int currentCount = 0;

    [CascadingParameter] protected ThemeInfo ThemeInfo { get; set; }

    void IncrementCount()

When we run the app we can see that the new style is applied:

Counter with cascading parameter

Cascading parameters also enable components to collaborate across the component hierarchy. For example, let's say you have a TabSet component that contains a number of Tab components, like this:

    <Tab Title="First tab">
        <h4>First tab</h4>
        This is the first tab.

    @if (showSecondTab)
        <Tab Title="Second">
            <h4>Second tab</h4>
            You can toggle me.

    <Tab Title="Third">
        <h4>Third tab</h4>

            <input type="checkbox" bind=@showSecondTab />
            Toggle second tab

In this example the child Tab components are not explicitly passed as parameters to the TabSet. Instead they are simply part of the child content of the TabSet. But the TabSet still needs to know about each Tab so that it can render the headers and the active tab. To enable this coordination without requiring any specific wire up from the user, the TabSet component can provide itself as a cascading value that can then be picked up by the descendent Tab components:

In TabSet.cshtml

<!-- Display the tab headers -->
<CascadingValue Value=this>
    <ul class="nav nav-tabs">

This allows the descendent Tab components to capture the containing TabSet as a cascading parameter, so they can add themselves to the TabSet and coordinate on which Tab is active:

In Tab.cshtml

[CascadingParameter] TabSet ContainerTabSet { get; set; }

Check out the full TabSet sample here.

Debugging improvements

In Blazor 0.5.0 we added some very preliminary support for debugging client-side Blazor apps in the browser. While this initial debugging support demonstrated that debugging .NET apps in the browser was possible, it was still a pretty rough experience. Blazor 0.7.0 picks up the latest runtime updates, which includes some fixes that makes the debugging experience more reliable. You can now more reliably set and remove breakpoints, and the reliability of step debugging has been improved.

Improved Blazor debugging

Give feedback

We hope you enjoy this latest preview release of Blazor. As with previous releases, your feedback is important to us. If you run into issues or have questions while trying out Blazor, file issues on GitHub. You can also chat with us and the Blazor community on Gitter if you get stuck or to share how Blazor is working for you. After you've tried out Blazor for a while please let us know what you think by taking our in-product survey. Click the survey link shown on the app home page when running one of the Blazor project templates:

Blazor survey

Thanks for trying out Blazor!



The Next Leap: How AI Will Change the 3D Industry

Programmierung vom 15.11.2018 um 18:52 Uhr | Quelle youtube.com



DevOps for Blockchain Apps

Programmierung vom 15.11.2018 um 18:00 Uhr | Quelle blogs.msdn.microsoft.com
Blockchain has emerged from the shadow of its cryptocurrency origins to be seen as a transformative data technology that can power the next generation of software for multi-party Enterprise and consumer scenarios.  With the trust and transparency that blockchain can deliver, this shared data technology is seen as a disruptor that can radically transform assumptions,... Read More


Update 18.11 for Azure Sphere in public preview

Programmierung vom 15.11.2018 um 17:29 Uhr | Quelle azure.microsoft.com

In September 2018, Azure Sphere was released for public preview. Today, we are pleased to announce the 18.11 update to the Azure Sphere Operating System, Azure Sphere Security Service, and Visual Studio development environment. This release includes substantial investments in our security infrastructure and our connectivity solutions, and it incorporates some of your feedback.

This is the first update to our public preview release, and we plan to release additional updates quarterly. Notification of software updates, new product features, tips and tricks, termination of support for older preview software, and other useful information will be posted on the Azure Updates website. Subscribe to Azure Update notifications through the RSS Feed to stay up to date with the latest Azure Sphere news.

Features in the 18.11 release

This release features strategic improvements in our internal security mechanism to allow devices that have been offline for an extended period to easily reconnect to the Azure Sphere Security Service. After manufacture, connected devices might spend months in a warehouse, during which root certificates stored on the device could expire. The Azure Sphere Security Service now seamlessly handles expired root certificates to ensure that devices that are intermittently connected or are disconnected for long periods of time can always connect and securely update to the latest OS.

In response to customer feedback, we have also invested in connectivity solutions. You wanted a way to configure Wi-Fi on the Azure Sphere device without using a PC. The 18.11 release includes a reference solution that demonstrates how to configure a Bluetooth Low Energy (BLE) module to work with Azure Sphere. We provide sample code, design information, and documentation. By implementing a custom solution based on the sample, you can configure Wi-Fi for Azure Sphere by using a mobile app with a Bluetooth connection.

Additional new features include:

  • Real-time clock (RTC). A Beta API enables applications to set and use the internal clock and leverages support for using a coin-cell battery to ensure the RTC continues to keep time when power is lost.
  • Mutable storage. A Beta API provides access to a maximum of 64k for storage of persistent read/write data.
  • External MCU update. A reference solution shows how your application can update the firmware of additional connected MCUs.
  • Private Ethernet. The MT3620 now supports connecting to a private, 10 Mbps network via the Microchip Ethernet part over a serial peripheral interface (SPI). This functionality allows an application running on the A7 chip to communicate with devices on a private network via standard Transmission Control Protocol (TCP) or User Datagram Protocol (UDP) networking. Stay tuned to the Azure Updates website for more information about this capability.
  • Beta API targeting. Beta APIs are still in development and may change in or be removed from a later release. Starting with this release, we make them available for testing and feedback so that you can get a head start on using new features. You can target applications for either the production APIs or the production and Beta APIs.


Thank you to all our preview customers for your comments and suggestions. If you have not yet engaged with us, we encourage you to do so. Microsoft engineers and Azure Sphere community experts respond to product-related questions on our MSDN Forum and development questions on StackOverflow. We also welcome product feedback and new feature requests.

Visit our website for documentation and more information on how to get started with your Azure Sphere development kit.



The Power of Web Components

Programmierung vom 15.11.2018 um 16:06 Uhr | Quelle hacks.mozilla.org

Web Components comprises a set of standards that enable user-defined HTML elements. These elements can go in all the same places as traditional HTML. Despite the long standardization process, the emerging promise of Web Components puts more power in the hands of developers and creators.

The post The Power of Web Components appeared first on Mozilla Hacks - the Web developer blog.



Visual Studio 2019: Vorschau auf UX- und UI-Änderungen

Programmierung vom 15.11.2018 um 13:40 Uhr | Quelle microsoft.com
Im Rahmen der Entwicklung von Visual Studio 2019 wurden bzw. werden auch einige Änderungen an der Benutzeroberfläche sowie in der Nutzerführung vorgenommen. Unter anderem wurde das Produktsymbol überarbeitet. Außerdem wird es für finale und Preview-Versionen von Visual Studio künftig unterschiedliche Icons geben. Eine detaillierte Vorschau auf die Neuerungen in der Usability und der Benutzeroberfläche von Visual Studio 2019 finden ...


How I Optimized My JS Sheet Music Rendering Engine

Programmierung vom 14.11.2018 um 21:45 Uhr | Quelle youtube.com



Zero to Production with the Serverless Framework

Programmierung vom 14.11.2018 um 19:13 Uhr | Quelle youtube.com



New & Experimental Web Design Tools: Feedback Requested

Programmierung vom 14.11.2018 um 17:00 Uhr | Quelle hacks.mozilla.org

We’re currently hard at work on some new tools for web designers: a comprehensive Flexbox Inspector as well as CSS change-tracking. Tell us about your biggest CSS and web design issues and pain points in the first-ever Design Tools survey from Mozilla! We want to hear from developers and designers, no matter what browser you use.

The post New & Experimental Web Design Tools: Feedback Requested appeared first on Mozilla Hacks - the Web developer blog.



Visual Studio Code in Version 1.29 verfügbar

Programmierung vom 14.11.2018 um 11:47 Uhr | Quelle microsoft.com
Visual Studio Code wurde als Oktober-Update 2018 in Version 1.29 veröffentlicht. In dieser Version gibt es einige wichtige Updates. Zu den wichtigsten Highlights gehören: Mehrzeilensuche - Durchsuchen von Dateien mit mehrzeiligen Regex-Ausdrücken. ...


Neue Studie: Jeder dritte TV- und Smartphone-Käufer ist ROPO-Kunde

Programmierung vom 14.11.2018 um 01:00 Uhr | Quelle thinkwithgoogle.com
Im Auftrag der MediaMarktSaturn Retail Group und Google hat GfK die Customer Journey für die Produkte TV-Geräte und Smartphones untersucht.


"Why wasn't I consulted" - How Rust does OSS

Programmierung vom 13.11.2018 um 20:33 Uhr | Quelle youtube.com



MariaDB 10.2.19 now available

Programmierung vom 13.11.2018 um 19:26 Uhr | Quelle mariadb.org

The MariaDB Foundation is pleased to announce the availability of MariaDB 10.2.19, the latest stable release in the MariaDB 10.2 series. See the release notes and changelogs for details. Download MariaDB 10.2.19 Release Notes Changelog What is MariaDB 10.2? MariaDB APT and YUM Repository Configuration Generator Contributors to MariaDB 10.2.19 Alexander Barkov (MariaDB Corporation) Alexey […]

The post MariaDB 10.2.19 now available appeared first on MariaDB.org.



The Bits Between the Bits: How We Get to main()

Programmierung vom 13.11.2018 um 19:03 Uhr | Quelle youtube.com



Private by Design: How we built Firefox Sync

Programmierung vom 13.11.2018 um 16:09 Uhr | Quelle hacks.mozilla.org

Firefox Sync lets you share your bookmarks, browsing history, passwords and other browser data between different devices, and send tabs from one device to another. We think it’s important to highlight the privacy aspects of Sync, which protects all your synced data by default so Mozilla can’t read it, ever. In this post, we take a closer look at some of the technical design choices we made in order to put user privacy first.

The post Private by Design: How we built Firefox Sync appeared first on Mozilla Hacks - the Web developer blog.



Visual Basic in .NET Core 3.0

Programmierung vom 13.11.2018 um 13:39 Uhr | Quelle microsoft.com
Wie auch andere .NET-Sprachen wird Visual Basic weiterhin im .NET Framework unterstützt, sodass Sie an Ihren Anwendungen keine Änderungen vornehmen müssen. Ein aktueller Beitrag auf dem Blog des Visual Basic-Teams erläutert, was die Änderungen in .NET Core 3.0 für Visual Basic.NET-Nutzer, die an .NET Core interessiert sind, bedeuten. Die Kurzversion lautet: Visual Basic.NET wird bisher in .NET Core kompiliert und ausgeführt, un...


Neue Features in C# 8.0

Programmierung vom 13.11.2018 um 12:11 Uhr | Quelle microsoft.com
Der aktuelle Plan des .NET Engineering Teams sieht vor, dass C# 8.0 zur gleichen Zeit wie .NET Core 3.0 ausgeliefert wird. Einen ersten Überblick über die geplanten Features in C# 8.0 gibt ein aktueller Artikel auf dem .NET Blog. Unter anderem werden Neuerungen bezüglich nullbarer Referenztypen, Async-Streams, Standardimplementierungen von Interface-Members, rekursiven Patterns, Switch Expressions u.v.m. vorgestellt. Weitere Informati...


Controversial PEPs You (Probably) Never Heard Of

Programmierung vom 13.11.2018 um 04:26 Uhr | Quelle youtube.com



Wie sich Fernsehsender im digitalen Zeitalter die Aufmerksamkeit der Zuschauer sichern können

Programmierung vom 13.11.2018 um 01:00 Uhr | Quelle thinkwithgoogle.com
Ben Napier, Strategic Partner Lead for Broadcast & Sport bei Google, erläutert anhand von Beispielen aus der Welt des Sports, wie sich Fernsehsender die Aufmerksamkeit der Zuschauer sichern können.


BVG: "YouTube wird langfristig wichtiger Bestandteil unseres Marketing-Mixes bleiben."

Programmierung vom 13.11.2018 um 01:00 Uhr | Quelle thinkwithgoogle.com
Im Rahmen des "YouTube GOLDENE KAMERA Digital Awards" hat YouTube gemeinsam mit der FUNKE MEDIENGRUPPE die Berliner Verkehrsbetriebe (BVG) als erfolgreichsten YouTube Brand Channel ausgezeichnet. Im Interview mit Think with Google erklärt Dr. Martell Beck, Bereichsleiter Vertrieb & Marketing, BVG, das Erfolgsrezept hinter den viralen Videos.


Zufriedene Kunden: Was Sie vermeiden sollten

Programmierung vom 13.11.2018 um 01:00 Uhr | Quelle thinkwithgoogle.com
Wer seine Kunden zufriedenstellen möchte, darf sich keine Fehler erlauben. David Baekholm, Senior VP of Growth Marketing bei HomeAway, erzählt aus eigener Erfahrung, was man nicht tun sollte, um mehr Wachstum zu erreichen.


Vorabrecherchen: Was suchfreudige Internetnutzer antreibt

Programmierung vom 13.11.2018 um 01:00 Uhr | Quelle thinkwithgoogle.com
Lisa Gevelber, VP of Marketing for the Americas bei Google, erklärt, welche Rolle die Suche im Internet für immer mehr Nutzer bei der Optimierung von Erlebnissen spielt.


Fundierte Geschäftsentscheidungen – Umfragen machen es möglich

Programmierung vom 13.11.2018 um 01:00 Uhr | Quelle thinkwithgoogle.com
Zufriedene Kunden sind der Schlüssel zum Erfolg. Dieser Aussage wird wohl kaum ein Unternehmer widersprechen. Doch es ist gar nicht so einfach, Kunden dauerhaft zufriedenzustellen. Daher dominiert diese eine Frage die Geschäftswelt: Wie kann man herausfinden, was Menschen wirklich wollen?


Reife im digitalen Marketing erlangen, um Werbung in großem Maßstab zu personalisieren

Programmierung vom 13.11.2018 um 01:00 Uhr | Quelle thinkwithgoogle.com
Die Nutzer erwarten interessante und individuelle Onlineinteraktionen. Aber vielen Werbetreibenden gelingt es nicht, mithilfe digitaler Daten während des gesamten Kaufprozesses relevante Inhalte bereitzustellen.


Auf einen Kaffee mit Christian Bärwind und Maike Schnell: "Suchinteresse nach Unterhaltungselektronik ist auch nach Weihnachten sehr hoch"

Programmierung vom 13.11.2018 um 01:00 Uhr | Quelle thinkwithgoogle.com
Die Weihnachtszeit ist die umsatzstärkste Zeit des Jahres für den Handel. Dabei darf auch Unterhaltungselektronik nicht unter dem Weihnachtsbaum fehlen. Wir haben mit zwei Experten aus dem Retail-Bereich bei Google gesprochen: Christian Bärwind und Maike Schnell erläutern, wie die typische Suche der Konsumenten aussieht und wie Unternehmen sich optimal wappnen können.


Das Such- und Kaufverhalten der Generation Z

Programmierung vom 13.11.2018 um 01:00 Uhr | Quelle thinkwithgoogle.com
Schon bald gehört die Generation Z zu der größten Gruppe an Verbrauchern. Wie haben uns am Beispiel Haushaltsgeräte angeschaut, wie ihr Einkaufsverhalten aussieht.


So tickt die Generation Z

Programmierung vom 13.11.2018 um 01:00 Uhr | Quelle thinkwithgoogle.com
Mehr als die Hälfte der Generation Z sieht sich als Early Adopter, wenn es um neue Technologien geht, verglichen mit 40 % aller Deutschen.


Durch Einfühlungsvermögen zum Erfolg

Programmierung vom 13.11.2018 um 01:00 Uhr | Quelle thinkwithgoogle.com
Kate Spade New York setzt auf einfühlsameres Marketing. Mary Beech, Executive Vice President und CMO dieses Modeunternehmens, verrät drei Erkenntnisse, die auch für andere Unternehmen interessant sind.



Seite 12 von 38 Seiten (Bei Beitrag 385 - 420)
1.318x Beiträge in dieser Kategorie

Auf Seite 11 zurück | Nächste 13 Seite | Letzte Seite
[ 7 ] [ 8 ] [ 9 ] [ 10 ] [ 11 ] [12] [ 13 ] [ 14 ] [ 15 ] [ 16 ] [ 17 ] [ 18 ] [ 19 ] [ 20 ] [ 21 ] [ 22 ]