Facebook is moving to Microsoft's Visual Studio Code for internal development

facebook-visual-studio

Facebook is adopting Visual Studio Code for all of its software engineers, and is currently in the process of finishing the migration from its mix of Nuclide and Emacs for internal development. As part of the partnership with Microsoft, the company will also help improve remote development extensions, which is ultimately going to benefit many more developers around the world.

Amazon’s own Echo Buds may have revealed a future fitness tracking feature

amazon-echo-buds

Amazon’s truly wireless Echo Buds earbuds are excellent for their $130 price, to the point that they were the elephant in the room when we reviewed Apple’s new AirPods Pro. And they managed that resounding feat without one of their biggest rumored features — the ability to double as a fitness tracker and measure the calories you’ve burned.

But don’t rule out fitness tracking just yet, because CNBC and The Verge both spotted a new “Fitness” tab in the Echo Buds section of the Alexa app today. You can see a few screenshots from our app below:

While we’re waiting on an Amazon spokeperson to confirm whether we should actually be excited for more functionality — or if this just a vestigial component of an earlier test — CNBC’s Todd Haselton says he managed to successfully start a few workouts, ones where the Echo Buds appeared to be tracking his steps.

You can find Echo Buds on Amazon.

image

Apple is quietly working on the perfect iPhone

iPhone-perfect1

iPhone owners know that Apple only refreshes the handset’s design every once in a while, usually when it has something significant to say, design-wise.

But, if you’ve been following the iPhone from the start, you probably realized that all the changes Apple made to the iPhone over the years, from the first model all the way to the iPhone X, are baby steps that Apple has been taking towards delivering the perfect iPhone design.

The iPhone X is the latest major design refresh, of course, which Apple used for the iPhone XS and iPhone 11. Come next year, we’re going to get a brand new design, one that’s said to be inspired by the iPhone 4, and a design that should get us even closer to the perfect all-screen iPhone. And Apple is quietly working on bringing that ideal design to life, a new discovery shows.

The iPhone X is a design compromise that Apple had to make and then stick to. The phone features the best screen-to-body ratio Apple could come up with without sacrificing the front-facing camera experience in any way, and without ditching the sophisticated 3D face recognition system that is Face ID.

Apple’s rivals made similar compromises, including hole-punch displays, slide-up cameras, and rear-facing secondary screens. But all of these companies, Apple included, are working on technologies that will let them create true all-screen phones.

iPhone-perfect2

These devices will feature sensors and cameras under the display, and have no physical buttons. Oppo has already demoed an under-display camera, and Huawei launched a phone with a waterfall display.

Apple usually doesn’t announce tech advances that aren’t ready for the market, with the AirPower wireless charger being a rare exception. But the company’s various patents do reveal clues as to what types of innovations it’s working on.

A well-known patent describing an iPhone with a wraparound display was published all the way back in 2013, prompting speculation at the time, and in the years that followed, that Apple would make such a phone

Google has been tracking nearly everything you buy online

google-purchase-history

Google has been quietly keeping track of nearly every single online purchase you’ve ever made, thanks to purchase receipts sent to your personal Gmail account, according to a new report today from CNBC. Even stranger: this information is made available to you via a private web tool that’s been active for an indeterminate amount of time. You can go view it here.

According to CNBC, the company says it does not use this information for personalized ad tracking; Google said back in 2017 that it would stop using data collected from Gmail messages to personalize ads. You can also delete the information from the Purchases webpage, but you must do so individually for each recorded transaction.

Google, like Facebook, knows an immense amount of information about you, your personal habits, and, yes, what you buy on the internet. And like the social network it dominates the online advertising industry alongside, Google gets this information mostly through background data collection using methods and tools its users may not be fully aware of, like Gmail purchase receipts. This is true of web tools like Gmail and smart assistants, which are increasingly coming under scrutiny for the ways the data that software collects is observed by human employees during the artificial intelligence training process.

Microsoft brings PowerToys back to let anyone improve Windows 10 for power users

windows10_power_toys

Microsoft first introduced the concept of “PowerToys” in Windows 95. It was originally a way for Windows engineers to test a prototype feature, and Microsoft packaged some of the best ones into a PowerToys bundle. These PowerToys included popular utilities like Tweak UI to customize the Windows user interface, Quick Res to quickly change screen resolutions, and Send To X that let you send files and folders to the command line, clipboard, or desktop.

PowerToys disappeared after Windows XP, during a time when co-founder Bill Gates ordered a security review of everything that was going into Windows. These useful utilities are now being revived by Microsoft in a new effort to focus on what power users need in Windows 10. The software giant is open-sourcing PowerToys on GitHub, so anyone can contribute and create power user tools for Windows 10.

MTNDWidget

The first two utilities that Microsoft is working on for Windows 10 are a new maximize to desktop widget and a Windows key shortcut guide. The maximize to desktop widget places a pop-up button over the maximize button when you hover over it. It’s designed to let you quickly send an app to another desktop, utilizing Windows 10’s multi-desktop view. The Windows shortcut guide utility simply shows a keyboard shortcut guide when you hold down the Windows key.

Microsoft is also considering 10 other utilities for these new PowerToys for Windows 10:

  1. Full window manager, including specific layouts for docking and undocking laptops
  2. Keyboard shortcut manager
  3. Win+R replacement
  4. Better alt+tab including browser tab integration and search for running apps
  5. Battery tracker
  6. Batch file re-namer
  7. Quick resolution swaps in task bar
  8. Mouse events without focus
  9. Cmd (or PS or Bash) from here
  10. Contents menu file browsing

Microsoft is looking for feedback and contributions over on GitHub, much like how the company recently open-sourced its Windows calculator for additional input and ideas. That effort resulted in a graphing mode being added to the Windows calculator. Microsoft is now planning to preview these PowerToys utilities in the summer, alongside the corresponding source code being published on GitHub.

GitHub Package Registry

github-package-registry-1200x630

From today, GitHub Package Registry, a package management service that makes it easy to publish public or private packages next to your source code, is fully integrated with GitHub, so you can use the same search, browsing, and management tools to find and publish packages as you do for your repositories. You can also use the same user and team permissions to manage code and packages together. GitHub Package Registry provides fast, reliable downloads backed by GitHub’s global CDN. And it supports familiar package management tools: JavaScript (npm), Java (Maven), Ruby (RubyGems), .NET (NuGet), and Docker images, with more to come.

You can try GitHub Package Registry today in limited beta. It will always be free to use for open source—more pricing details will be announced soon.

Sign up for the beta

Microsoft’s Chromium Edge browser is now officially available to test

Microsoft is making its Chromium-powered Edge browser available to developers today. The software giant is releasing its Canary and Developer builds, offering daily or weekly updates to the changes that are coming to Edge. Both downloads are available on Microsoft’s new Edge insider site, and they are designed for developers to get an early look at how Edge is changing.

Microsoft has focused on the fundamentals of browsing, reliability, and extension support for this early version of Edge built on Chromium, and the company is looking for feedback about the basics to start. Encouragingly, this new Edge browser runs surprisingly well, with full support for existing Chrome extensions. Microsoft is even building in sync support for things like favorites, browsing history, and extensions to sync across Edge. Favorites is only supported in this early version today, but sync support will be gradually improved before this new version of Edge is more broadly available in a beta version.

Both Microsoft and Google engineers have been working together to improve the underlying Chromium project so that Chrome and Edge run better on Windows. Microsoft has had around 150 commits accepted into Chromium, paving the way for improvements to Edge and Chromium on Windows 10. That includes improving accessibility, smooth scrolling support, Windows Hello integration, and things like ensuring the touch keyboard shows up reliably.

image

image

Using dependency injection in a .Net Core console application

One of the key features of ASP.NET Core is baked in dependency injection.

Whether you choose to use the built in container or a third party container will likely come down to whether the built in container is powerful enough for your given project. For small projects it may be fine, but if you need convention based registration, logging/debugging tools, or more esoteric approaches like property injection, then you'll need to look elsewhere.

Why use the built-in container?

One question that's come up a few times, is whether you can use the built-in provider in a .NET Core console application? The short answer is not out-of-the-box, but adding it in is pretty simple. Having said that, whether it is worth using in this case is another question.

One of the advantage of the built-in container in ASP.NET Core is that the framework libraries themselves register their dependencies with it. When you call the AddMvc() extension method in your Startup.ConfigureServices method, the framework registers a whole plethora of services with the container. If you later add a third-party container, those dependencies are passed across to be re-registered, so they are available when resolved via the third-party.

If you are writing a console app, then you likely don't need MVC or other ASP.NET Core specific services. In that case, it may be just as easy to start right off the bat using StructureMap or AutoFac instead of the limited built-in provider.

Having said that, most common services designed for use with ASP.NET Core will have extensions for registering with the built in container via IServiceCollection, so if you are using services such as logging, or the Options pattern, then it is certainly easier to use the provided extensions, and plug a third party on top of that if required.

Adding DI to a console app

If you decide the built-in container is the right approach, then adding it to your application is very simple using the Microsoft.Extensions.DependencyInjection package.

aspnet-core-di

To demonstrate the approach, I'm going to create a simple application that has two services:

public interface IFooService
{
    void DoThing(int number);
}

public interface IBarService
{
    void DoSomeRealWork();
}

Each of these services will have a single implementation. The BarService depends on an IFooService, and the FooService uses an ILoggerFactory to log some work:

public class BarService : IBarService
{
    private readonly IFooService _fooService;
    public BarService(IFooService fooService)
    {
        _fooService = fooService;
    }

    public void DoSomeRealWork()
    {
        for (int i = 0; i < 10; i++)
        {
            _fooService.DoThing(i);
        }
    }
}

public class FooService : IFooService
{
    private readonly ILogger<FooService> _logger;
    public FooService(ILoggerFactory loggerFactory)
    {
        _logger = loggerFactory.CreateLogger<FooService>();
    }

    public void DoThing(int number)
    {
        _logger.LogInformation($"Doing the thing {number}");
    }
}

As you could see above, I'm using the new logging infrastructure in my app, so I will need to add the appropriate package to my project.json. I'll also add the DependencyInjection package and the Microsoft.Extensions.Logging.Console package so I can see the results of my logging:

{
  "dependencies": {
    "Microsoft.Extensions.Logging": "1.0.0",
    "Microsoft.Extensions.Logging.Console": "1.0.0",
    "Microsoft.Extensions.DependencyInjection": "1.0.0"
  }
}

Finally, I'll update my static void main to put all the pieces together. We'll walk through through it in a second.

using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;

public class Program
{
    public static void Main(string[] args)
    {
        //setup our DI
        var serviceProvider = new ServiceCollection()
            .AddLogging()
            .AddSingleton<IFooService, FooService>()
            .AddSingleton<IBarService, BarService>()
            .BuildServiceProvider();

        //configure console logging
        serviceProvider
            .GetService<ILoggerFactory>()
            .AddConsole(LogLevel.Debug);

        var logger = serviceProvider.GetService<ILoggerFactory>()
            .CreateLogger<Program>();
        logger.LogDebug("Starting application");

        //do the actual work here
        var bar = serviceProvider.GetService<IBarService>();
        bar.DoSomeRealWork();

        logger.LogDebug("All done!");
    }
}

The first thing we do is configure the dependency injection container by creating a ServiceCollection, adding our dependencies, and finally building an IServiceProvider. This process is equivalent to the ConfigureServices method in an ASP.NET Core project, and is pretty much what happens behind the scenes. You can see we are using the IServiceCollection extension method to add the logging services to our application, and then registering our own services. The serviceProvider is our container we can use to resolve services in our application.

In the next step, we need to configure the logging infrastructure with a provider, so the results are output somewhere. We first fetch an instance of ILoggerFactory from our newly constructed serviceProvider, and add a console logger.

The remainder of the program shows more dependency-injection in progress. We first fetch an ILogger<T> from the container, and then fetch an instance of IBarService. As per our registrations, the IBarService is an instance of BarService, which will have an instance of FooService injected in it.

If can then run our application and see all our beautifully resolved dependencies!

output

Adding StructureMap to your console app

As described previously, the built-in container is useful for adding framework libraries using the extension methods, like we saw with AddLogging above. However it is much less fully featured than many third-party containers.

For completeness, I'll show how easy it is to update the application to use a hybrid approach, using the built in container to easily add any framework dependencies, and using StructureMap for your own code.

First you need to add StructureMap to your project.json dependencies:

{
  "dependencies": {
    "StructureMap.Microsoft.DependencyInjection": "1.2.0"
  }
}

Now we'll update our static void main to use StructureMap for registering our custom dependencies:

public static void Main(string[] args)
{
    // add the framework services
    var services = new ServiceCollection()
        .AddLogging();

    // add StructureMap
    var container = new Container();
    container.Configure(config =>
    {
        // Register stuff in container, using the StructureMap APIs...
        config.Scan(_ =>
                    {
                        _.AssemblyContainingType(typeof(Program));
                        _.WithDefaultConventions();
                    });
        // Populate the container using the service collection
        config.Populate(services);
    });

    var serviceProvider = container.GetInstance<IServiceProvider>();

    // rest of method as before
}

At first glance this may seem more complicated than the previous version, and it is, but it is also far more powerful. In the StructureMap example, we didn't have to explicitly register our IFooService or IBarService services - they were automatically registered by convention. When your apps start to grow, this sort of convention-based registration becomes enormously powerful, especially when couple with the error handling and debugging capabilities available to you.

In this example I showed how to use StructureMap with the adapter to work with the IServiceCollection extension methods, but there's obviously no requirement to do that. Using StructureMap as your only registration source is perfectly valid, you'll just have to manually register any services added as part of the AddPLUGIN extension methods directly.

Dependency Injection with constructor parameters

The following code shows you how to configure DI for objects that have parameters in the constructor.

using Microsoft.Extensions.DependencyInjection;
using System;

namespace NetCoreDIDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            var services = new ServiceCollection();
            services.AddTransient<IMyService>(s => new MyService("MyConnectionString"));
            var provider = services.BuildServiceProvider();
            var myService = provider.GetService<IMyService>();
            
            Console.WriteLine($"The constructor parameter is: {myService.GetConstructorParameter()}");
            Console.ReadKey();
        }
    }

    public interface IMyService
    {
        string GetConstructorParameter();
    }

    public class MyService : IMyService
    {
        private string connectionString;
        public MyService(string connString)
        {
            this.connectionString = connString;
        }

        public string GetConstructorParameter()
        {
            return connectionString;
        }
    }
}

Happy coding!

The Windows 3.0 File Manager is now available in the Microsoft Store

FileManager-for-Windows10

Microsoft open sourced the original File Manager that shipped with Windows 3.0, allowing users to make changes and if they want, compile it for use on Windows 10. Now, the firm is making it easier to run the legacy app, as it's offering the Windows 3.0 File Manager through the Microsoft Store (via Aggiornamenti Lumia) as a UWP app.

The app is listed as being available on PC, mobile, Surface Hub, and HoloLens; however, it also requires the device to be installed on Windows 10 build 16299 or newer. Obviously, there are no mobile devices that qualify. If you do have a Windows phone that you want to try it out on, you could always download the code and try to compile it for an earlier build.

Obviously, there were some modifications that had to be made to the original app to get it to run on Windows 10. After all, Windows 3.0 was a 16-bit operating system. Microsoft also had to add header files that were previously stored in the NT source tree, and it had to make some APIs public.

This isn't the first time that Microsoft has dabbled in software nostalgia. As an April Fool's joke in 2015, it released an MS-DOS Mobile app for Windows phones. If you want to download the Windows File Manager app, you can find it here.

Latest Windows 10 build puts desktop apps in a 3D world

Mixed-Reality-Portal

Microsoft has released a new Insider preview build of Windows 10. Build 18329 should be available now to most people who have opted into the fast preview ring. Though it's not available to everyone because, for some reason, the new build isn't available in all the languages it'd normally be shipped in.

Top-Apps-In-Search

The strangest new feature is that you can now launch and run regular Win32 apps—2D apps built for the desktop—in the Windows Mixed Reality environment that's used for both virtual reality headsets and the HoloLens augmented reality headset. Previously, it was only possible to run apps built using the modern UWP API. Now, it seems that any Windows application will work. If you want to use Photoshop or Visual Studio with a headset on, you can.The new build also adds a couple of new scripts to support the writing of languages that until recently had no adequate written form. There's the Osage language spoken by the Osage Nation in Oklahoma (which prior to 2006 used the Latin alphabet with various diacritics) and the ADLaM script used to write Pular, the language of the Fulani people in West Africa (which, similarly, used the Roman alphabet with diacritics prior to the development of the new alphabet in the 1980s). ADLaM and Osage were both added to Unicode in 2016.

Advertsing

125X125_06

Planet Xamarin

Planet Xamarin




TagCloud

MonthList