Health in your hands: how data and AI are empowering patients

Friendly robot looking at the camera

The Karolinska University Hospital in Sweden has a very fitting example of extra attention being paid to patients – a friendly robot is being used to significantly reduce the stress of children suffering from cancer.

The robot itself doesn’t add any medical procedures to the existing treatment, but its friendly demeanour and in-built screen with games designed to inform children of their treatment procedure ahead of time, has proven to be a great help in reducing the fear of these young patients. In addition, the robot also helps reduce the stress of parents, and saves healthcare experts both time and money, by reducing the amount of time and people required per treatment session.

Lisa Karin Bergström, practitioner, nursing manager and project lead states that “We can’t always see cancer coming, or stop it, but we can control the stress children feel, and help them feel happier and more in control.”

Healthcare in your hands
Putting patients first should provide them with newer tools to not only make their lives easier, but to also provide a more personalised level of care. Virtual hospitals provide a convenient, easy to use experience which allows patients to track their health and communicate with health professionals remotely, from the comfort of their own homes. This saves patients time, and travel, which is particularly beneficial for the elderly.

In Finland, Helsinki University Hospital’s Virtual Health Village is a prime example of bringing healthcare directly into the hands of its patients. The online cloud service, based on the Microsoft Azure and Dynamics 365, provides information and support including medical care for patients, and tools for healthcare professionals. Patients have access to virtual buildings dedicated to different life situations and symptoms, such as pain management, rehabilitation, mental health, and weight management.

Virpi Rauta, PhD, eMBA, Doctor in nephrology who is involved with the kidney-damage section of the Virtual Health Village states that “We have to get rid of old habits when we adopt these new tools. It’s multidisciplinary work – clinicians, IT workers, nurses and patients all worked together to help create our kidney app.”

Empowering patients and putting their own healthcare within their control, is key. The kidney disease app in the Virtual Health Hospital shares real patient experiences and how they are coping with their treatment, to help other patients feel that their disease is manageable. Patients are more likely to listen to people going through the same experiences, and this genuine relatability helps morale, while increasing the chances of them correctly following their treatment plan.

In Scotland, technology is bringing personalised care to patients suffering from Chronic Obstructive Pulmonary Disease (COPD) – a condition which affects 1.2 million people in the UK, and is the second most common cause of emergency hospital admissions. Without treatment, the symptoms (which include breathlessness, chest infections and a persistent cough) get worse, but a new trial brings an easier way to manage the illness to patients, from the comfort of their own homes.

Patients use wearable devices combined with Microsoft’s Azure cloud platform to remotely monitor their breathing. AI algorithms, based on machine learning, are then used to monitor results, and automatically detect and predict issues, so that healthcare experts can vary their treatment accordingly, based on their individual needs.

This not only saves patients from making regular trips to the hospital, it also means that if their condition gets worse, their healthcare providers will automatically be alerted, allowing timely treatment, and a better quality of life.

Chris Carlin, a Consultant Respiratory Physician involved in the trial, states that “It’s about delivering treatment earlier by using data. If we can empower patients to self-manage their condition, we can significantly reduce hospital admissions. That self-management might be helping them with their breathing, escalating their existing treatment, recommending new treatment or reaching out to the community respiratory team.”

In another corner of the world, one of the oldest diseases known to mankind – leprosy – is being treated with AI. The Novartis Foundation and Microsoft are developing an AI-enabled digital health tool and a Leprosy Intelligent Image Atlas to help the early detection of leprosy.

Over 200,000 people are diagnosed with leprosy every year, with Brazil, India, and Indonesia accounting for about 80 percent of new cases. The disease is made more complicated by the fact that it can be difficult to diagnose, and if left untreated, can cause other disabilities and spread to others.

Microsoft and the Novartis Foundation are collaborating with local investigators from Oswaldo Cruz Foundation (Fiocruz) in Brazil to develop a machine learning algorithm which examines anonymized images before automatically detecting if a patient has leprosy.

To save patients (who are often in remote rural areas) from travelling long distances to hospitals, they are able to instead visit local businesses and have their photos taken there, before the shots are examined by the AI programme. The imagery and AI code are planned to be made publicly accessible at a later stage to empower leprosy researchers to accelerate research excellence in this field, leading to better outcomes.

Dr. Ann Aerts, Head of Novartis Foundation states that “Bundling expertise from the health and tech sectors to pioneer innovative digital health solutions such as this one, can make it possible to reimagine the way we fight leprosy. Early detection and prompt treatment of patients remains the best way to interrupt leprosy transmission. Together with Microsoft we are pioneering an innovative digital tool to accelerate leprosy detection, to make this ancient disease history once and for all.”

Go to Original Article
Author: Steve Clarke

How to uninstall Exchange 2013 after a cutover migration

It might feel like the Exchange Server migration is complete when the mail starts to flow into the new server, but a premature shutdown of the old system could bring things to a grinding halt.

After a cutover migration from Exchange 2013 to Exchange 2016 in a hybrid configuration, you should wait several weeks to make sure the setup works properly before you uninstall Exchange 2013. If the system folders do not get moved from Exchange 2013, then there will be problems with mail flow, connection to virtual directories and more severe issues with functionality.

All user mailboxes, public folders and archive mailboxes should reside in the new configuration, which could be on-premises Exchange 2016 or Exchange Online. Check the following items off the list before you decommission Exchange 2013.

1. Check the send connectors

Verify the status of the new servers by checking the send connectors, and then remove the old servers. Go to the Exchange admin center, select Mail Flow and then click Send Connectors.

Change the external connector to include the new Exchange servers, restart the transport service on the old servers and then pause the service. This forces any messages on the old servers over to the new ones and stops mail processing on the old servers.

2. Test email flow

Next, see if mail flows to an internal and external email address. Open Exchange Management Shell, and type the following command using your own email addresses and Simple Mail Transfer Protocol (SMTP) server name:

Send-MailMessage –From test@domain.com –To external@emailaddress.com –Subject “Test Email” –Body “Test E-mail (body)” -SmtpServer smtp.domain.com

If the mail arrives in your inbox, then the test was a success.

3. Test the PowerShell connection

You might have some scripts that integrate with your remote PowerShell, so it’s important to confirm connectivity. Type in the following PowerShell command:

Add-PSSnapin *.exch*

Then, type the following, but change the URL to align with your remote PowerShell URL:

$Session = New-PSSession -ConfigurationName Microsoft.Exchange -ConnectionUri https://outlook.domain.com/PowerShell/ -Authentication Basic -Credential $UserCredential

Change the -ConnectionUri parameter to test each new server as well.

4. Adjust the Autodiscover settings

Change Autodiscover to point your new servers to your organization’s Autodiscover URL. Check the Autodiscover settings with this PowerShell command:

Get-ClientAccessService | fl identity,*uri*

A message similar to the one below will appear showing the old server’s settings and the new one’s configuration.

Identity                       : OLDServerName
AutoDiscoverServiceInternalUri : https://autodiscover.domain.com/Autodiscover/Autodiscover.xml

Identity : NEWServerName
AutoDiscoverServiceInternalUri : https://newservername.corp.domain.com/Autodiscover/Autodiscover.xml

Next, change the new server’s Autodiscover entry to match the old server entry by using Exchange Management Shell and typing in the following command but swapping the URI to match your domain:

Set-ClientAccessServer -Identity NEWServerName -AutoDiscoverServiceInternalUri https://autodiscover.domain.com/Autodiscover/Autodiscover.xml

Verify that change by typing the following command:

Get-ClientAccessServer | fl identity,*uri*

You might need to make Client Access Server changes on the virtual directories. To check, go to the Exchange admin center, click Servers and then select Virtual Directories. For each site in the virtual directory, check both the general settings and authentication settings against what is in place in the existing servers.

Verify the settings for all the following virtual directories:

  • Autodiscover (Default Web Site)
  • ECP (Default Web Site)
  • EWS (Default Web Site)
  • MAPI (Default Web Site)
  • Microsoft-Server-Active-Sync (Default Web Site)
  • OAB (Default Web Site)
  • PowerShell (Default Web Site)

Next, reboot the server, or recycle MSExchangeAutodiscoverAppPool via IIS. A server reboot requires brief downtime, while the IIS recycle does not.

5. Move the arbitration mailboxes to Exchange 2016

Exchange 2013 creates several system mailboxes during the setup process. You cannot uninstall Exchange 2013 if these mailboxes still exist. First, get a list of the arbitration mailboxes using the following command:

Get-Mailbox –Arbitration

To move the arbitration mailboxes, use this command:

Get-Mailbox -Arbitration | New-MoveRequest -TargetDatabase DBName

Verify the move to the new server database with the following command:

Get-Mailbox –Arbitration

6. Uninstall Exchange 2013

Decommission Exchange 2013 by uninstalling the old server’s programs and features. This is the best way to confirm all the Exchange 2013 features are now on the Exchange 2016 system. After you reboot the Exchange 2013 server, then you can shut it down.

Go to Original Article
Author:

Windows 10 SDK Preview Build 18362 available now! – Windows Developer Blog

Today, we released a new Windows 10 Preview Build of the SDK to be used in conjunction with Windows 10 Insider Preview (Build 18362 or greater). The Preview SDK Build 18362 contains bug fixes and under development changes to the API surface area.
The Preview SDK can be downloaded from developer section on Windows Insider.
For feedback and updates to the known issues, please see the developer forum. For new developer feature requests, head over to our Windows Platform UserVoice.

This build works in conjunction with previously released SDKs and Visual Studio 2017. You can install this SDK and still also continue to submit your apps that target Windows 10 build 1809 or earlier to the Microsoft Store.
The Windows SDK will now formally only be supported by Visual Studio 2017 and greater. You can download the Visual Studio 2017 here.
This build of the Windows SDK will install on Windows 10 Insider Preview builds and supported Windows operating systems.
In order to assist with script access to the SDK, the ISO will also be able to be accessed through the following URL: https://go.microsoft.com/fwlink/?prd=11966&pver=1.0&plcid=0x409&clcid=0x409&ar=Flight&sar=Sdsurl&o1=18362 once the static URL is published.

Message Compiler (mc.exe)

The “-mof” switch (to generate XP-compatible ETW helpers) is considered to be deprecated and will be removed in a future version of mc.exe. Removing this switch will cause the generated ETW helpers to expect Vista or later.
The “-A” switch (to generate .BIN files using ANSI encoding instead of Unicode) is considered to be deprecated and will be removed in a future version of mc.exe. Removing this switch will cause the generated .BIN files to use Unicode string encoding.
The behavior of the “-A” switch has changed. Prior to Windows 1607 Anniversary Update SDK, when using the -A switch, BIN files were encoded using the build system’s ANSI code page. In the Windows 1607 Anniversary Update SDK, mc.exe’s behavior was inadvertently changed to encode BIN files using the build system’s OEM code page. In the 19H1 SDK, mc.exe’s previous behavior has been restored and it now encodes BIN files using the build system’s ANSI code page. Note that the -A switch is deprecated, as ANSI-encoded BIN files do not provide a consistent user experience in multi-lingual systems.

IAppxPackageReader2 has been removed from appxpackaging.h
The interface IAppxPackageReader2 was removed from appxpackaging.h. Eliminate the use of use of IAppxPackageReader2 or use IAppxPackageReader instead.
Change to effect graph of the AcrylicBrush
In this Preview SDK, we’ll be adding a blend mode to the effect graph of the AcrylicBrush called Luminosity. This blend mode will ensure that shadows do not appear behind acrylic surfaces without a cutout. We will also be exposing a LuminosityBlendOpacity API available for tweaking that allows for more AcrylicBrush customization.
By default, for those that have not specified any LuminosityBlendOpacity on their AcrylicBrushes, we have implemented some logic to ensure that the Acrylic will look as similar as it can to current 1809 acrylics. Please note that we will be updating our default brushes to account for this recipe change.
TraceLoggingProvider.h  / TraceLoggingWrite
Events generated by TraceLoggingProvider.h (e.g. via TraceLoggingWrite macros) will now always have Id and Version set to 0.
Previously, TraceLoggingProvider.h would assign IDs to events at link time. These IDs were unique within a DLL or EXE, but changed from build to build and from module to module.

Additions:

namespace Windows.AI.MachineLearning {
public sealed class LearningModelSession : IClosable {
public LearningModelSession(LearningModel model, LearningModelDevice deviceToRunOn, LearningModelSessionOptions learningModelSessionOptions);
}
public sealed class LearningModelSessionOptions
public sealed class TensorBoolean : IClosable, ILearningModelFeatureValue, IMemoryBuffer, ITensor {
void Close();
public static TensorBoolean CreateFromBuffer(long[] shape, IBuffer buffer);
public static TensorBoolean CreateFromShapeArrayAndDataArray(long[] shape, bool[] data);
IMemoryBufferReference CreateReference();
}
public sealed class TensorDouble : IClosable, ILearningModelFeatureValue, IMemoryBuffer, ITensor {
void Close();
public static TensorDouble CreateFromBuffer(long[] shape, IBuffer buffer);
public static TensorDouble CreateFromShapeArrayAndDataArray(long[] shape, double[] data);
IMemoryBufferReference CreateReference();
}
public sealed class TensorFloat : IClosable, ILearningModelFeatureValue, IMemoryBuffer, ITensor {
void Close();
public static TensorFloat CreateFromBuffer(long[] shape, IBuffer buffer);
public static TensorFloat CreateFromShapeArrayAndDataArray(long[] shape, float[] data);
IMemoryBufferReference CreateReference();
}
public sealed class TensorFloat16Bit : IClosable, ILearningModelFeatureValue, IMemoryBuffer, ITensor {
void Close();
public static TensorFloat16Bit CreateFromBuffer(long[] shape, IBuffer buffer);
public static TensorFloat16Bit CreateFromShapeArrayAndDataArray(long[] shape, float[] data);
IMemoryBufferReference CreateReference();
}
public sealed class TensorInt16Bit : IClosable, ILearningModelFeatureValue, IMemoryBuffer, ITensor {
void Close();
public static TensorInt16Bit CreateFromBuffer(long[] shape, IBuffer buffer);
public static TensorInt16Bit CreateFromShapeArrayAndDataArray(long[] shape, short[] data);
IMemoryBufferReference CreateReference();
}
public sealed class TensorInt32Bit : IClosable, ILearningModelFeatureValue, IMemoryBuffer, ITensor {
void Close();
public static TensorInt32Bit CreateFromBuffer(long[] shape, IBuffer buffer);
public static TensorInt32Bit CreateFromShapeArrayAndDataArray(long[] shape, int[] data);
IMemoryBufferReference CreateReference();
}
public sealed class TensorInt64Bit : IClosable, ILearningModelFeatureValue, IMemoryBuffer, ITensor {
void Close();
public static TensorInt64Bit CreateFromBuffer(long[] shape, IBuffer buffer);
public static TensorInt64Bit CreateFromShapeArrayAndDataArray(long[] shape, long[] data);
IMemoryBufferReference CreateReference();
}
public sealed class TensorInt8Bit : IClosable, ILearningModelFeatureValue, IMemoryBuffer, ITensor {
void Close();
public static TensorInt8Bit CreateFromBuffer(long[] shape, IBuffer buffer);
public static TensorInt8Bit CreateFromShapeArrayAndDataArray(long[] shape, byte[] data);
IMemoryBufferReference CreateReference();
}
public sealed class TensorString : IClosable, ILearningModelFeatureValue, IMemoryBuffer, ITensor {
void Close();
public static TensorString CreateFromShapeArrayAndDataArray(long[] shape, string[] data);
IMemoryBufferReference CreateReference();
}
public sealed class TensorUInt16Bit : IClosable, ILearningModelFeatureValue, IMemoryBuffer, ITensor {
void Close();
public static TensorUInt16Bit CreateFromBuffer(long[] shape, IBuffer buffer);
public static TensorUInt16Bit CreateFromShapeArrayAndDataArray(long[] shape, ushort[] data);
IMemoryBufferReference CreateReference();
}
public sealed class TensorUInt32Bit : IClosable, ILearningModelFeatureValue, IMemoryBuffer, ITensor {
void Close();
public static TensorUInt32Bit CreateFromBuffer(long[] shape, IBuffer buffer);
public static TensorUInt32Bit CreateFromShapeArrayAndDataArray(long[] shape, uint[] data);
IMemoryBufferReference CreateReference();
}
public sealed class TensorUInt64Bit : IClosable, ILearningModelFeatureValue, IMemoryBuffer, ITensor {
void Close();
public static TensorUInt64Bit CreateFromBuffer(long[] shape, IBuffer buffer);
public static TensorUInt64Bit CreateFromShapeArrayAndDataArray(long[] shape, ulong[] data);
IMemoryBufferReference CreateReference();
}
public sealed class TensorUInt8Bit : IClosable, ILearningModelFeatureValue, IMemoryBuffer, ITensor {
void Close();
public static TensorUInt8Bit CreateFromBuffer(long[] shape, IBuffer buffer);
public static TensorUInt8Bit CreateFromShapeArrayAndDataArray(long[] shape, byte[] data);
IMemoryBufferReference CreateReference();
}
}
namespace Windows.ApplicationModel {
public sealed class Package {
StorageFolder EffectiveLocation { get; }
StorageFolder MutableLocation { get; }
}
}
namespace Windows.ApplicationModel.AppService {
public sealed class AppServiceConnection : IClosable {
public static IAsyncOperation SendStatelessMessageAsync(AppServiceConnection connection, RemoteSystemConnectionRequest connectionRequest, ValueSet message);
}
public sealed class AppServiceTriggerDetails {
string CallerRemoteConnectionToken { get; }
}
public sealed class StatelessAppServiceResponse
public enum StatelessAppServiceResponseStatus
}
namespace Windows.ApplicationModel.Background {
public sealed class ConversationalAgentTrigger : IBackgroundTrigger
}
namespace Windows.ApplicationModel.Calls {
public sealed class PhoneLine {
string TransportDeviceId { get; }
void EnableTextReply(bool value);
}
public enum PhoneLineTransport {
Bluetooth = 2,
}
public sealed class PhoneLineTransportDevice
}
namespace Windows.ApplicationModel.Calls.Background {
public enum PhoneIncomingCallDismissedReason
public sealed class PhoneIncomingCallDismissedTriggerDetails
public enum PhoneTriggerType {
IncomingCallDismissed = 6,
}
}
namespace Windows.ApplicationModel.Calls.Provider {
public static class PhoneCallOriginManager {
public static bool IsSupported { get; }
}
}
namespace Windows.ApplicationModel.ConversationalAgent {
public sealed class ConversationalAgentSession : IClosable
public sealed class ConversationalAgentSessionInterruptedEventArgs
public enum ConversationalAgentSessionUpdateResponse
public sealed class ConversationalAgentSignal
public sealed class ConversationalAgentSignalDetectedEventArgs
public enum ConversationalAgentState
public sealed class ConversationalAgentSystemStateChangedEventArgs
public enum ConversationalAgentSystemStateChangeType
}
namespace Windows.ApplicationModel.Preview.Holographic {
public sealed class HolographicKeyboardPlacementOverridePreview
}
namespace Windows.ApplicationModel.Resources {
public sealed class ResourceLoader {
public static ResourceLoader GetForUIContext(UIContext context);
}
}
namespace Windows.ApplicationModel.Resources.Core {
public sealed class ResourceCandidate {
ResourceCandidateKind Kind { get; }
}
public enum ResourceCandidateKind
public sealed class ResourceContext {
public static ResourceContext GetForUIContext(UIContext context);
}
}
namespace Windows.ApplicationModel.UserActivities {
public sealed class UserActivityChannel {
public static UserActivityChannel GetForUser(User user);
}
}
namespace Windows.Devices.Bluetooth.GenericAttributeProfile {
public enum GattServiceProviderAdvertisementStatus {
StartedWithoutAllAdvertisementData = 4,
}
public sealed class GattServiceProviderAdvertisingParameters {
IBuffer ServiceData { get; set; }
}
}
namespace Windows.Devices.Enumeration {
public enum DevicePairingKinds : uint {
ProvidePasswordCredential = (uint)16,
}
public sealed class DevicePairingRequestedEventArgs {
void AcceptWithPasswordCredential(PasswordCredential passwordCredential);
}
}
namespace Windows.Devices.Input {
public sealed class PenDevice
}
namespace Windows.Devices.PointOfService {
public sealed class JournalPrinterCapabilities : ICommonPosPrintStationCapabilities {
bool IsReversePaperFeedByLineSupported { get; }
bool IsReversePaperFeedByMapModeUnitSupported { get; }
bool IsReverseVideoSupported { get; }
bool IsStrikethroughSupported { get; }
bool IsSubscriptSupported { get; }
bool IsSuperscriptSupported { get; }
}
public sealed class JournalPrintJob : IPosPrinterJob {
void FeedPaperByLine(int lineCount);
void FeedPaperByMapModeUnit(int distance);
void Print(string data, PosPrinterPrintOptions printOptions);
}
public sealed class PosPrinter : IClosable {
IVectorView SupportedBarcodeSymbologies { get; }
PosPrinterFontProperty GetFontProperty(string typeface);
}
public sealed class PosPrinterFontProperty
public sealed class PosPrinterPrintOptions
public sealed class ReceiptPrinterCapabilities : ICommonPosPrintStationCapabilities, ICommonReceiptSlipCapabilities {
bool IsReversePaperFeedByLineSupported { get; }
bool IsReversePaperFeedByMapModeUnitSupported { get; }
bool IsReverseVideoSupported { get; }
bool IsStrikethroughSupported { get; }
bool IsSubscriptSupported { get; }
bool IsSuperscriptSupported { get; }
}
public sealed class ReceiptPrintJob : IPosPrinterJob, IReceiptOrSlipJob {
void FeedPaperByLine(int lineCount);
void FeedPaperByMapModeUnit(int distance);
void Print(string data, PosPrinterPrintOptions printOptions);
void StampPaper();
}
public struct SizeUInt32
public sealed class SlipPrinterCapabilities : ICommonPosPrintStationCapabilities, ICommonReceiptSlipCapabilities {
bool IsReversePaperFeedByLineSupported { get; }
bool IsReversePaperFeedByMapModeUnitSupported { get; }
bool IsReverseVideoSupported { get; }
bool IsStrikethroughSupported { get; }
bool IsSubscriptSupported { get; }
bool IsSuperscriptSupported { get; }
}
public sealed class SlipPrintJob : IPosPrinterJob, IReceiptOrSlipJob {
void FeedPaperByLine(int lineCount);
void FeedPaperByMapModeUnit(int distance);
void Print(string data, PosPrinterPrintOptions printOptions);
}
}
namespace Windows.Globalization {
public sealed class CurrencyAmount
}
namespace Windows.Graphics.DirectX {
public enum DirectXPrimitiveTopology
}
namespace Windows.Graphics.Holographic {
public sealed class HolographicCamera {
HolographicViewConfiguration ViewConfiguration { get; }
}
public sealed class HolographicDisplay {
HolographicViewConfiguration TryGetViewConfiguration(HolographicViewConfigurationKind kind);
}
public sealed class HolographicViewConfiguration
public enum HolographicViewConfigurationKind
}
namespace Windows.Management.Deployment {
public enum AddPackageByAppInstallerOptions : uint {
LimitToExistingPackages = (uint)512,
}
public enum DeploymentOptions : uint {
RetainFilesOnFailure = (uint)2097152,
}
}
namespace Windows.Media.Devices {
public sealed class InfraredTorchControl
public enum InfraredTorchMode
public sealed class VideoDeviceController : IMediaDeviceController {
InfraredTorchControl InfraredTorchControl { get; }
}
}
namespace Windows.Media.Miracast {
public sealed class MiracastReceiver
public sealed class MiracastReceiverApplySettingsResult
public enum MiracastReceiverApplySettingsStatus
public enum MiracastReceiverAuthorizationMethod
public sealed class MiracastReceiverConnection : IClosable
public sealed class MiracastReceiverConnectionCreatedEventArgs
public sealed class MiracastReceiverCursorImageChannel
public sealed class MiracastReceiverCursorImageChannelSettings
public sealed class MiracastReceiverDisconnectedEventArgs
public enum MiracastReceiverDisconnectReason
public sealed class MiracastReceiverGameControllerDevice
public enum MiracastReceiverGameControllerDeviceUsageMode
public sealed class MiracastReceiverInputDevices
public sealed class MiracastReceiverKeyboardDevice
public enum MiracastReceiverListeningStatus
public sealed class MiracastReceiverMediaSourceCreatedEventArgs
public sealed class MiracastReceiverSession : IClosable
public sealed class MiracastReceiverSessionStartResult
public enum MiracastReceiverSessionStartStatus
public sealed class MiracastReceiverSettings
public sealed class MiracastReceiverStatus
public sealed class MiracastReceiverStreamControl
public sealed class MiracastReceiverVideoStreamSettings
public enum MiracastReceiverWiFiStatus
public sealed class MiracastTransmitter
public enum MiracastTransmitterAuthorizationStatus
}
namespace Windows.Networking.Connectivity {
public enum NetworkAuthenticationType {
Wpa3 = 10,
Wpa3Sae = 11,
}
}
namespace Windows.Networking.NetworkOperators {
public sealed class ESim {
ESimDiscoverResult Discover();
ESimDiscoverResult Discover(string serverAddress, string matchingId);
IAsyncOperation DiscoverAsync();
IAsyncOperation DiscoverAsync(string serverAddress, string matchingId);
}
public sealed class ESimDiscoverEvent
public sealed class ESimDiscoverResult
public enum ESimDiscoverResultKind
}
namespace Windows.Perception.People {
public sealed class EyesPose
public enum HandJointKind
public sealed class HandMeshObserver
public struct HandMeshVertex
public sealed class HandMeshVertexState
public sealed class HandPose
public struct JointPose
public enum JointPoseAccuracy
}
namespace Windows.Perception.Spatial {
public struct SpatialRay
}
namespace Windows.Perception.Spatial.Preview {
public sealed class SpatialGraphInteropFrameOfReferencePreview
public static class SpatialGraphInteropPreview {
public static SpatialGraphInteropFrameOfReferencePreview TryCreateFrameOfReference(SpatialCoordinateSystem coordinateSystem);
public static SpatialGraphInteropFrameOfReferencePreview TryCreateFrameOfReference(SpatialCoordinateSystem coordinateSystem, Vector3 relativePosition);
public static SpatialGraphInteropFrameOfReferencePreview TryCreateFrameOfReference(SpatialCoordinateSystem coordinateSystem, Vector3 relativePosition, Quaternion relativeOrientation);
}
}
namespace Windows.Security.Authorization.AppCapabilityAccess {
public sealed class AppCapability
public sealed class AppCapabilityAccessChangedEventArgs
public enum AppCapabilityAccessStatus
}
namespace Windows.Security.DataProtection {
public enum UserDataAvailability
public sealed class UserDataAvailabilityStateChangedEventArgs
public sealed class UserDataBufferUnprotectResult
public enum UserDataBufferUnprotectStatus
public sealed class UserDataProtectionManager
public sealed class UserDataStorageItemProtectionInfo
public enum UserDataStorageItemProtectionStatus
}
namespace Windows.Storage.AccessCache {
public static class StorageApplicationPermissions {
public static StorageItemAccessList GetFutureAccessListForUser(User user);
public static StorageItemMostRecentlyUsedList GetMostRecentlyUsedListForUser(User user);
}
}
namespace Windows.Storage.Pickers {
public sealed class FileOpenPicker {
User User { get; }
public static FileOpenPicker CreateForUser(User user);
}
public sealed class FileSavePicker {
User User { get; }
public static FileSavePicker CreateForUser(User user);
}
public sealed class FolderPicker {
User User { get; }
public static FolderPicker CreateForUser(User user);
}
}
namespace Windows.System {
public sealed class DispatcherQueue {
bool HasThreadAccess { get; }
}
public enum ProcessorArchitecture {
Arm64 = 12,
X86OnArm64 = 14,
}
}
namespace Windows.System.Profile {
public static class AppApplicability
public sealed class UnsupportedAppRequirement
public enum UnsupportedAppRequirementReasons : uint
}
namespace Windows.System.RemoteSystems {
public sealed class RemoteSystem {
User User { get; }
public static RemoteSystemWatcher CreateWatcherForUser(User user);
public static RemoteSystemWatcher CreateWatcherForUser(User user, IIterable filters);
}
public sealed class RemoteSystemApp {
string ConnectionToken { get; }
User User { get; }
}
public sealed class RemoteSystemConnectionRequest {
string ConnectionToken { get; }
public static RemoteSystemConnectionRequest CreateFromConnectionToken(string connectionToken);
public static RemoteSystemConnectionRequest CreateFromConnectionTokenForUser(User user, string connectionToken);
}
public sealed class RemoteSystemWatcher {
User User { get; }
}
}
namespace Windows.UI {
public sealed class UIContentRoot
public sealed class UIContext
}
namespace Windows.UI.Composition {
public enum CompositionBitmapInterpolationMode {
MagLinearMinLinearMipLinear = 2,
MagLinearMinLinearMipNearest = 3,
MagLinearMinNearestMipLinear = 4,
MagLinearMinNearestMipNearest = 5,
MagNearestMinLinearMipLinear = 6,
MagNearestMinLinearMipNearest = 7,
MagNearestMinNearestMipLinear = 8,
MagNearestMinNearestMipNearest = 9,
}
public sealed class CompositionGraphicsDevice : CompositionObject {
CompositionMipmapSurface CreateMipmapSurface(SizeInt32 sizePixels, DirectXPixelFormat pixelFormat, DirectXAlphaMode alphaMode);
void Trim();
}
public sealed class CompositionMipmapSurface : CompositionObject, ICompositionSurface
public sealed class CompositionProjectedShadow : CompositionObject
public sealed class CompositionProjectedShadowCaster : CompositionObject
public sealed class CompositionProjectedShadowCasterCollection : CompositionObject, IIterable
public sealed class CompositionProjectedShadowReceiver : CompositionObject
public sealed class CompositionProjectedShadowReceiverUnorderedCollection : CompositionObject, IIterable
public sealed class CompositionRadialGradientBrush : CompositionGradientBrush
public sealed class CompositionSurfaceBrush : CompositionBrush {
bool SnapToPixels { get; set; }
}
public class CompositionTransform : CompositionObject
public sealed class CompositionVisualSurface : CompositionObject, ICompositionSurface
public sealed class Compositor : IClosable {
CompositionProjectedShadow CreateProjectedShadow();
CompositionProjectedShadowCaster CreateProjectedShadowCaster();
CompositionProjectedShadowReceiver CreateProjectedShadowReceiver();
CompositionRadialGradientBrush CreateRadialGradientBrush();
CompositionVisualSurface CreateVisualSurface();
}
public interface IVisualElement
}
namespace Windows.UI.Composition.Interactions {
public enum InteractionBindingAxisModes : uint
public sealed class InteractionTracker : CompositionObject {
public static InteractionBindingAxisModes GetBindingMode(InteractionTracker boundTracker1, InteractionTracker boundTracker2);
public static void SetBindingMode(InteractionTracker boundTracker1, InteractionTracker boundTracker2, InteractionBindingAxisModes axisMode);
}
public sealed class InteractionTrackerCustomAnimationStateEnteredArgs {
bool IsFromBinding { get; }
}
public sealed class InteractionTrackerIdleStateEnteredArgs {
bool IsFromBinding { get; }
}
public sealed class InteractionTrackerInertiaStateEnteredArgs {
bool IsFromBinding { get; }
}
public sealed class InteractionTrackerInteractingStateEnteredArgs {
bool IsFromBinding { get; }
}
public class VisualInteractionSource : CompositionObject, ICompositionInteractionSource {
public static VisualInteractionSource CreateFromIVisualElement(IVisualElement source);
}
}
namespace Windows.UI.Composition.Scenes {
public enum SceneAlphaMode
public enum SceneAttributeSemantic
public sealed class SceneBoundingBox : SceneObject
public class SceneComponent : SceneObject
public sealed class SceneComponentCollection : SceneObject, IIterable, IVector
public enum SceneComponentType
public class SceneMaterial : SceneObject
public class SceneMaterialInput : SceneObject
public sealed class SceneMesh : SceneObject
public sealed class SceneMeshMaterialAttributeMap : SceneObject, IIterable, IMap
public sealed class SceneMeshRendererComponent : SceneRendererComponent
public sealed class SceneMetallicRoughnessMaterial : ScenePbrMaterial
public sealed class SceneModelTransform : CompositionTransform
public sealed class SceneNode : SceneObject
public sealed class SceneNodeCollection : SceneObject, IIterable, IVector
public class SceneObject : CompositionObject
public class ScenePbrMaterial : SceneMaterial
public class SceneRendererComponent : SceneComponent
public sealed class SceneSurfaceMaterialInput : SceneMaterialInput
public sealed class SceneVisual : ContainerVisual
public enum SceneWrappingMode
}
namespace Windows.UI.Core {
public sealed class CoreWindow : ICorePointerRedirector, ICoreWindow {
UIContext UIContext { get; }
}
}
namespace Windows.UI.Core.Preview {
public sealed class CoreAppWindowPreview
}
namespace Windows.UI.Input {
public class AttachableInputObject : IClosable
public enum GazeInputAccessStatus
public sealed class InputActivationListener : AttachableInputObject
public sealed class InputActivationListenerActivationChangedEventArgs
public enum InputActivationState
}
namespace Windows.UI.Input.Preview {
public static class InputActivationListenerPreview
}
namespace Windows.UI.Input.Spatial {
public sealed class SpatialInteractionManager {
public static bool IsSourceKindSupported(SpatialInteractionSourceKind kind);
}
public sealed class SpatialInteractionSource {
HandMeshObserver TryCreateHandMeshObserver();
IAsyncOperation TryCreateHandMeshObserverAsync();
}
public sealed class SpatialInteractionSourceState {
HandPose TryGetHandPose();
}
public sealed class SpatialPointerPose {
EyesPose Eyes { get; }
bool IsHeadCapturedBySystem { get; }
}
}
namespace Windows.UI.Notifications {
public sealed class ToastActivatedEventArgs {
ValueSet UserInput { get; }
}
public sealed class ToastNotification {
bool ExpiresOnReboot { get; set; }
}
}
namespace Windows.UI.ViewManagement {
public sealed class ApplicationView {
string PersistedStateId { get; set; }
UIContext UIContext { get; }
WindowingEnvironment WindowingEnvironment { get; }
public static void ClearAllPersistedState();
public static void ClearPersistedState(string key);
IVectorView GetDisplayRegions();
}
public sealed class InputPane {
public static InputPane GetForUIContext(UIContext context);
}
public sealed class UISettings {
bool AutoHideScrollBars { get; }
event TypedEventHandler AutoHideScrollBarsChanged;
}
public sealed class UISettingsAutoHideScrollBarsChangedEventArgs
}
namespace Windows.UI.ViewManagement.Core {
public sealed class CoreInputView {
public static CoreInputView GetForUIContext(UIContext context);
}
}
namespace Windows.UI.WindowManagement {
public sealed class AppWindow
public sealed class AppWindowChangedEventArgs
public sealed class AppWindowClosedEventArgs
public enum AppWindowClosedReason
public sealed class AppWindowCloseRequestedEventArgs
public sealed class AppWindowFrame
public enum AppWindowFrameStyle
public sealed class AppWindowPlacement
public class AppWindowPresentationConfiguration
public enum AppWindowPresentationKind
public sealed class AppWindowPresenter
public sealed class AppWindowTitleBar
public sealed class AppWindowTitleBarOcclusion
public enum AppWindowTitleBarVisibility
public sealed class CompactOverlayPresentationConfiguration : AppWindowPresentationConfiguration
public sealed class DefaultPresentationConfiguration : AppWindowPresentationConfiguration
public sealed class DisplayRegion
public sealed class FullScreenPresentationConfiguration : AppWindowPresentationConfiguration
public sealed class WindowingEnvironment
public sealed class WindowingEnvironmentAddedEventArgs
public sealed class WindowingEnvironmentChangedEventArgs
public enum WindowingEnvironmentKind
public sealed class WindowingEnvironmentRemovedEventArgs
}
namespace Windows.UI.WindowManagement.Preview {
public sealed class WindowManagementPreview
}
namespace Windows.UI.Xaml {
public class UIElement : DependencyObject, IAnimationObject, IVisualElement {
Vector3 ActualOffset { get; }
Vector2 ActualSize { get; }
Shadow Shadow { get; set; }
public static DependencyProperty ShadowProperty { get; }
UIContext UIContext { get; }
XamlRoot XamlRoot { get; set; }
}
public class UIElementWeakCollection : IIterable, IVector
public sealed class Window {
UIContext UIContext { get; }
}
public sealed class XamlRoot
public sealed class XamlRootChangedEventArgs
}
namespace Windows.UI.Xaml.Controls {
public sealed class DatePickerFlyoutPresenter : Control {
bool IsDefaultShadowEnabled { get; set; }
public static DependencyProperty IsDefaultShadowEnabledProperty { get; }
}
public class FlyoutPresenter : ContentControl {
bool IsDefaultShadowEnabled { get; set; }
public static DependencyProperty IsDefaultShadowEnabledProperty { get; }
}
public class InkToolbar : Control {
InkPresenter TargetInkPresenter { get; set; }
public static DependencyProperty TargetInkPresenterProperty { get; }
}
public class MenuFlyoutPresenter : ItemsControl {
bool IsDefaultShadowEnabled { get; set; }
public static DependencyProperty IsDefaultShadowEnabledProperty { get; }
}
public sealed class TimePickerFlyoutPresenter : Control {
bool IsDefaultShadowEnabled { get; set; }
public static DependencyProperty IsDefaultShadowEnabledProperty { get; }
}
public class TwoPaneView : Control
public enum TwoPaneViewMode
public enum TwoPaneViewPriority
public enum TwoPaneViewTallModeConfiguration
public enum TwoPaneViewWideModeConfiguration
}
namespace Windows.UI.Xaml.Controls.Maps {
public sealed class MapControl : Control {
bool CanTiltDown { get; }
public static DependencyProperty CanTiltDownProperty { get; }
bool CanTiltUp { get; }
public static DependencyProperty CanTiltUpProperty { get; }
bool CanZoomIn { get; }
public static DependencyProperty CanZoomInProperty { get; }
bool CanZoomOut { get; }
public static DependencyProperty CanZoomOutProperty { get; }
}
public enum MapLoadingStatus {
DownloadedMapsManagerUnavailable = 3,
}
}
namespace Windows.UI.Xaml.Controls.Primitives {
public sealed class AppBarTemplateSettings : DependencyObject {
double NegativeCompactVerticalDelta { get; }
double NegativeHiddenVerticalDelta { get; }
double NegativeMinimalVerticalDelta { get; }
}
public sealed class CommandBarTemplateSettings : DependencyObject {
double OverflowContentCompactYTranslation { get; }
double OverflowContentHiddenYTranslation { get; }
double OverflowContentMinimalYTranslation { get; }
}
public class FlyoutBase : DependencyObject {
bool IsConstrainedToRootBounds { get; }
bool ShouldConstrainToRootBounds { get; set; }
public static DependencyProperty ShouldConstrainToRootBoundsProperty { get; }
XamlRoot XamlRoot { get; set; }
}
public sealed class Popup : FrameworkElement {
bool IsConstrainedToRootBounds { get; }
bool ShouldConstrainToRootBounds { get; set; }
public static DependencyProperty ShouldConstrainToRootBoundsProperty { get; }
}
}
namespace Windows.UI.Xaml.Core.Direct {
public enum XamlPropertyIndex {
AppBarTemplateSettings_NegativeCompactVerticalDelta = 2367,
AppBarTemplateSettings_NegativeHiddenVerticalDelta = 2368,
AppBarTemplateSettings_NegativeMinimalVerticalDelta = 2369,
CommandBarTemplateSettings_OverflowContentCompactYTranslation = 2384,
CommandBarTemplateSettings_OverflowContentHiddenYTranslation = 2385,
CommandBarTemplateSettings_OverflowContentMinimalYTranslation = 2386,
FlyoutBase_ShouldConstrainToRootBounds = 2378,
FlyoutPresenter_IsDefaultShadowEnabled = 2380,
MenuFlyoutPresenter_IsDefaultShadowEnabled = 2381,
Popup_ShouldConstrainToRootBounds = 2379,
ThemeShadow_Receivers = 2279,
UIElement_ActualOffset = 2382,
UIElement_ActualSize = 2383,
UIElement_Shadow = 2130,
}
public enum XamlTypeIndex {
ThemeShadow = 964,
}
}
namespace Windows.UI.Xaml.Documents {
public class TextElement : DependencyObject {
XamlRoot XamlRoot { get; set; }
}
}
namespace Windows.UI.Xaml.Hosting {
public sealed class ElementCompositionPreview {
public static UIElement GetAppWindowContent(AppWindow appWindow);
public static void SetAppWindowContent(AppWindow appWindow, UIElement xamlContent);
}
}
namespace Windows.UI.Xaml.Input {
public sealed class FocusManager {
public static object GetFocusedElement(XamlRoot xamlRoot);
}
public class StandardUICommand : XamlUICommand {
StandardUICommandKind Kind { get; set; }
}
}
namespace Windows.UI.Xaml.Media {
public class AcrylicBrush : XamlCompositionBrushBase {
IReference TintLuminosityOpacity { get; set; }
public static DependencyProperty TintLuminosityOpacityProperty { get; }
}
public class Shadow : DependencyObject
public class ThemeShadow : Shadow
public sealed class VisualTreeHelper {
public static IVectorView GetOpenPopupsForXamlRoot(XamlRoot xamlRoot);
}
}
namespace Windows.UI.Xaml.Media.Animation {
public class GravityConnectedAnimationConfiguration : ConnectedAnimationConfiguration {
bool IsShadowEnabled { get; set; }
}
}
namespace Windows.Web.Http {
public sealed class HttpClient : IClosable, IStringable {
IAsyncOperationWithProgress TryDeleteAsync(Uri uri);
IAsyncOperationWithProgress TryGetAsync(Uri uri);
IAsyncOperationWithProgress TryGetAsync(Uri uri, HttpCompletionOption completionOption);
IAsyncOperationWithProgress TryGetBufferAsync(Uri uri);
IAsyncOperationWithProgress TryGetInputStreamAsync(Uri uri);
IAsyncOperationWithProgress TryGetStringAsync(Uri uri);
IAsyncOperationWithProgress TryPostAsync(Uri uri, IHttpContent content);
IAsyncOperationWithProgress TryPutAsync(Uri uri, IHttpContent content);
IAsyncOperationWithProgress TrySendRequestAsync(HttpRequestMessage request);
IAsyncOperationWithProgress TrySendRequestAsync(HttpRequestMessage request, HttpCompletionOption completionOption);
}
public sealed class HttpGetBufferResult : IClosable, IStringable
public sealed class HttpGetInputStreamResult : IClosable, IStringable
public sealed class HttpGetStringResult : IClosable, IStringable
public sealed class HttpRequestResult : IClosable, IStringable
}
namespace Windows.Web.Http.Filters {
public sealed class HttpBaseProtocolFilter : IClosable, IHttpFilter {
User User { get; }
public static HttpBaseProtocolFilter CreateForUser(User user);
}
}

JavaScript popularity drives TypeScript adoption among devs

JavaScript continues to top the lists of programming languages developers know and use, and TypeScript has also come along for the ride.

JavaScript’s popularity continues to outpace Java, Python, and other familiar tier 1 languages, according to the latest rankings of top programming languages by analyst firm RedMonk, in Portland, Maine. In the study, the biggest change is in the increased adoption of TypeScript, a superset of JavaScript, which moved up four notches to the 12th most popular programming language. It follows Swift, a language for iOS development. Swift is the fastest growing language in the history of the firm’s rankings.

The language of the web and beyond

There are more than 10 million JavaScript developers worldwide, according to SlashData, a London-based developer research firm.

Web development is the key to JavaScript’s popularity. The web is the only universal runtime that works everywhere: desktop, mobile, kiosks, wearables, devices, IoT and more. And JavaScript is the language that makes the web more than just a bunch of static pages.

“JavaScript is the language of the web, and I will always bet on the web,” said Ben Simmons, vice president of engineering at Sworkit, creator of a health and fitness app, in Rockville, Md. “You can use [it] across the full stack. Add cross-platform mobile development and strong typing to help make development easier, and using JavaScript is really a no-brainer.”

JavaScript also has expanded outside of the browser and into areas such as server-side development with Node.js, mobile development with Ionic and React Native, IoT with Johnny-Five, and artificial intelligence with TensorFlow.js.

Max Lynch, CEO, IonicMax Lynch

“The prevalence of JavaScript has made it so that nearly every modern application uses the language at some point,” said Max Lynch, co-founder and CEO at Ionic, a mobile development platform maker in Madison, Wis.

Moreover, the JavaScript world features more reused open source code compared to other ecosystems, which allows for speedier development times. However, that also creates competitive challenges for commercial developers, said Havoc Pennington, co-founder and head of product at Tidelift, a Boston-based marketplace for open source code maintainers.

“With over 1,000 fast-moving dependencies in typical JavaScript applications, commercial users have more work to keep dependencies up to date, keep packages working well together and monitor security and licensing risks,” he said.

JavaScript developers remain in high demand among programming language experts. There were more than 165,000 JavaScript jobs posted on Upwork.com in 2018, a platform to hire freelancers, based in Mountain View, Calif. In the fourth quarter, JavaScript job postings ranked seventh out of more than 5,000 skills in the Upwork marketplace.

Meanwhile, a recent survey from HackerRank, a Mountain View, Calif., technology hiring platform that tracks developer skills, showed that JavaScript unseated Java as the most well-known language in 2018, as 73% of developers said they knew JavaScript, an increase from 66% in 2017.

JavaScript popularity pulls TypeScript along

TypeScript’s relationship to JavaScript is absolutely a significant factor in its adoption, in that it dramatically expands the targetable footprint for an up and coming new language.
Stephen O’GradyAnalyst, RedMonk

JavaScript’s popularity has significantly benefited TypeScript, said Stephen O’Grady, a RedMonk analyst. “TypeScript’s relationship to JavaScript is absolutely a significant factor in its adoption, in that it dramatically expands the targetable footprint for an up and coming new language,” he said.

TypeScript also has a wide, growing base of projects that have helped propel the language forward in a brief period of time. TypeScript also was the eighth most popular language in HackerRank’s 2018 list, right after Java, C, Python, C++, PHP and C#.

Microsoft introduced TypeScript in 2012 to address JavaScript’s shortcomings to build large-scale applications. As a superset of JavaScript, TypeScript compiles down to plain JavaScript and can be used anywhere that normal JavaScript runs. As such, it has enjoyed the popularity and ubiquity of both JavaScript and the web.

“The reason developers love it is that it takes the goodness of JavaScript, and adds a bunch of extras that you don’t get with vanilla JavaScript,” Lynch said. “Things like developer tooling, along with code completion and refactoring to help you write code faster. It also helps catch bugs in development with static type checking, and adds additional language features that aren’t yet available in JavaScript.”

Go to Original Article
Author:

For Sale – M-ITX Desktop Computer – Intel Atom – 2GB DDR3 Ram – 500GB Hard Drive – Slim DVD – Windows 7 Pro

I have a Mini-ITX build for sale.

The motherboard and case are new, never used before, the ram was taken from another machine, the hard drive has been used before but is in full working order.

Running Windows 7 Professional already activated with a key.

Mini-ITX case
Jetway Mini-ITX NC9KDL-2550 Motherboard
2GB DDR3 Ram
Seagate 500GB Hard Drive
Intel Atom 1.86Ghz CPU
Slim DVD Re-writer drive
PS/2 Mouse
PS/2 Keyboard
HDMI
VGA
USB 2.0
2 X Ethernet
SPDIF

Power cable included.

Price and currency: 40
Delivery: Delivery cost is included within my country
Payment method: paypal or bt
Location: leeds
Advertised elsewhere?: Advertised elsewhere
Prefer goods collected?: I have no preference

______________________________________________________
This message is automatically inserted in all classifieds forum threads.
By replying to this thread you agree to abide by the trading rules detailed here.
Please be advised, all buyers and sellers should satisfy themselves that the other party is genuine by providing the following via private conversation to each other after negotiations are complete and prior to dispatching goods and making payment:

  • Landline telephone number. Make a call to check out the area code and number are correct, too
  • Name and address including postcode
  • Valid e-mail address

DO NOT proceed with a deal until you are completely satisfied with all details being correct. It’s in your best interest to check out these details yourself.

Go to Original Article
Author:

Manufacturing a better future: Microsoft announces intelligent industry innovations – The Official Microsoft Blog

It’s a time of great disruption but great opportunity in the manufacturing industry, as businesses seek to find novel ways to create new business value, empower and upskill their workforce, optimize their operations and innovate for a sustainable future. Advanced technologies like AI, mixed reality and automation are helping drive Industry 4.0, creating a future where “intelligent manufacturing” is a reality. Today, we are introducing updates that help bring this reality even closer for our customers and partners, to deliver increased security, productivity and efficiency, which will help them achieve new business outcomes.

As we head to Hanover, Germany, next week to join global leaders at the world’s biggest trade show for industrial technology, we are announcing several improvements to our trusted, innovative manufacturing solutions, including:

  • Azure is now the first major public cloud with end-to-end security for IoT for your devices, hubs and cloud resources. We are adding advanced threat protection for IoT to three key services: Azure Security Center for IoT can now be used to implement security best practices and mitigate threats across entire IoT projects including hubs, compute and data. Azure Sentinel, the first cloud-native security information and event management (SIEM) offering, can now protect the entire enterprise from threats including those affecting IoT devices. Azure IOT Hub now integrates with Azure Security Center for IoT to provide IoT security information directly inside the hub portal experience.
  • The introduction of OPC Twin and OPC Vault in our Azure Industrial IoT Cloud Platform solution, which respectively provide manufacturers a digital twin of their OPC UA-enabled machines and significantly enhance security and certification management. We’re also announcing important enhancements to the Connected Factory solution accelerator, which now integrates with OPC Twin to greatly simplify the process of installing IoT Edge.
  • An expansion of Azure IP Advantage to IoT, which extends Azure IP Advantage benefits to Azure customers with IoT devices connected to Azure, and devices that are powered by Azure Sphere and Windows IoT. Additionally, qualified startups who join the LOT Network have the ability to acquire Microsoft patents through LOT for free.

You’ll find more details on the Azure IoT Platform updates in this blog from Sam George, and more information on Azure IP Advantage below. We will also share additional business updates including:

  • Intelligent innovations for industry: Onsite at Hannover Messe we will showcase our wide range of offerings for manufacturers including breakthroughs in AI experiences, mixed reality with HoloLens 2, business-ready solutions with Dynamics 365 and tools to close the skills gap with Microsoft 365.
  • Customers achieving business outcomes: We’re supporting leading manufacturers including Bühler, Electrolux, Siemens Gamesa and ZEISS as they accelerate their own innovations, as outlined below.
  • New partner solutions: We continue to grow the ecosystem of partners collaborating with Microsoft to help manufacturers succeed, with several announcing news this week.
  • The latest in our Future Computed book series: The Future Computed: AI and Manufacturing explores the way manufacturers from across the world are embracing AI. It shares insights from our customers on the importance of creating the right company culture and talent pipeline to realize AI’s potential, and explores the role of public policy in addressing labor market disruption and fostering the ethical use of AI. We’ll preview the book’s key themes at Hannover Messe ahead of its release in May.
  • More than 25 innovative companies will join us in our Hannover Messe booth to showcase how we are working together to harness IoT, mixed reality, AI and other key technologies that revolutionize manufacturing.

Protecting and connecting the factory of the future

Today we are sharing details about a series of new product and program advancements for the manufacturing industry prior to Hannover Messe:

Azure IoT Security: The complexity and scale of the IoT and Industrial IoT (IIot) challenge is reinforced by leading market research firms estimating there will be over 20 billion installed end-point devices worldwide by 2020 — each of which pose a potential security risk. While some cloud providers address pieces of this puzzle, Azure is the world’s first cloud offering to deliver an end to end, unified approach to IoT security.

Garth Beaumount, CISO for Volpara Solutions and an early adopter of Azure Security Center for IoT said, “The Microsoft Azure IoT Security solution provides us with management and threat protection for the full stack, including IoT devices, IoT hubs as well as the computing and data resources utilized by our solutions. Effectively saving us from ‘rolling our own’ and aligning our IoT security neatly with our other Azure based solutions and line of business application usage.”

With Azure Security Center for IoT, customers can find missing security configurations across IOT devices, the edge and cloud. For example, they can check which ports are open on their IOT devices, confirm their SQL database is encrypted and act to remediate any issues. Azure Security Center for IoT protects from ever-evolving threats, drawing upon the vast threat intelligence information in the Microsoft Intelligent Security Graph, which analyzes six trillion signals per day. This means manufacturers can take advantage of a single view of security across all their Azure solutions — including Azure IoT solutions, from edge devices to applications — using hundreds of built-in security assessments in a central dashboard.

With Azure Sentinel, users can hunt for or respond to active threats spanning the entire enterprise from IOT devices to Azure to Office 365 and on-premise systems.

SecOps teams now have the right tools to reduce the surface attack of IoT solutions, remediate issues before they become serious, prevent attacks with machine learning and gain significant value from simplifying threat detection and security posture management for entire IoT deployments. Combining these new offerings with previously announced device security offerings such as Azure Sphere, customers will have access to IoT innovation with the confidence of end-to-end security that only Microsoft provides – spanning devices, the edge and cloud. You’ll find more information here.

 Connected Factory and Industrial IoT: In a connected factory, all machines communicate with each other, leveraging data, IoT and automation to monitor and control all aspects of production. We’ve enhanced our offering for these Industrial IoT scenarios by developing components that simplify and secure our customers’ digital operations. At our booth at Hannover Messe, we’ll be showcasing OPC Twin, which creates a digital twin for your OPC UA-enabled machines and makes the information model of that specific machine available in the cloud. Customers can control and manage their OPC Twins directly from the cloud by using microservices running on Azure. In addition, we’ll showcase our progress in security with OPC Vault. OPC Vault automates security management by creating, managing and revoking certificates for your OPC UA servers on a global scale. ​Both components provide simplicity and security for your industrial IoT solutions and are fully open source and available on GitHub.

We also understand the importance of simplicity and speed in getting started with a proof-of-concept for Industrial IoT scenarios. For that purpose, we continue to enhance the Connected Factory solution accelerator, which is designed to accelerate proof-of-concepts in Industrial IoT and additionally offers OEE data across customers’ factories via a centralized dashboard. Today, Connected Factory integrates with an OPC Twin dashboard and empowers manufacturers to streamline the process of getting started with Industrial IoT and generating insights from their digital operations.

Supporting business innovation

As businesses become more connected, security remains paramount to success. Microsoft is taking end-to-end security one step further for our customers to protect their data and intellectual property:

 Azure IP Advantage: The Microsoft Azure IP Advantage program now includes new benefits for Azure IoT innovators and startups. We first announced Azure IP Advantage in February, 2017, to provide comprehensive protection against intellectual property (IP) risks for our cloud customers. We are now expanding the program to customers who are innovating in IoT and at the edge to do predictive maintenance, manage digital and physical assets, and improve overall efficiency, safety and quality of products—all of which create massive volumes of data and unique business innovations. We’re responding to input from our manufacturing customers and delivering greater value to the Azure IP Advantage program, with new benefits focused on the Azure-powered IoT ecosystem and startups, including:

  • Uncapped indemnification coverage for Microsoft’s Azure Sphere and Windows IoT.
  • Access to 10,000 patents for customers using Azure to power IoT devices to defend themselves against IP lawsuits.
  • The ability for startups on Azure to acquire Microsoft patents for free.

In addition to the expanded program, we also joined the Open Invention Network and the LOT (license on transfer) Network last year to help address patent assertion risk for our customers and partners. Taken together, we believe Microsoft offers the most comprehensive, end-to-end framework for addressing IP risks in the cloud. More detail can be found in this Microsoft on the Issues blog.

Manufacturers building on Microsoft technologies

Customers are leveraging Microsoft technology in their manufacturing operations and seeing real business results. Recent examples include:

  • Bühler, one of the world’s largest providers of food processing solutions, is leveraging Microsoft blockchain technology to improve global food safety standards and reduce food poisoning rates, while increasing production efficiencies.
  • Electrolux, the Swedish home appliance manufacturer, launched a new Azure IoT smart connected air purifier and app in a matter of weeks with minimal R&D time. The Pure A9 removes ultra-fine dust particles, pollutants, bacteria, allergens and bad odors from indoor rooms.
  • Siemens Gamesa, the leader in renewable energy, is streamlining and automating how technicians inspect and maintain industrial wind turbines by migrating its autonomous drone-digital process to Microsoft Azure and infusing it with Azure AI. Integrating Azure AI services will greatly expedite the process, with image recognition reduced to 34 seconds, as opposed to 4 to 6 hours using the manual method, which also was prone to errors.
  • ZEISS teamed up with Microsoft to present a spectroscopy measurement and data sharing solution that connects the compact all-round spectrometer ZEISS Corona process with Microsoft Azure. By uploading production data from spectroscopic analysis to the cloud, clients get invaluable insights about their products and production – whenever and wherever they need it. The solution can be implemented in food production processes to monitor important quality indicators (e.g. fat, moisture, salt content) directly in the production line. This enables production managers to react immediately to process variations and helps to increase quality and productivity, while using raw materials and energy in a more efficient way at the same time.

Partners highlight new offerings

Several of our partners showcasing their solutions at the Microsoft Hannover Messe booth will make news about their latest innovations, including:

  • Intel is working with Microsoft on a new modern industrial PC reference design for factories and industrial applications. Using the reference design, which will be available later this year, device partners can build fully provisioned and customized industrial PCs that can be connected to a range of devices to discover, manage and analyze data in real time, using AI on the machine or in the Azure cloud.
  • JDA, a leading global supply chain company, will be showcasing its new Azure-based Luminate solution, which serves as an end-to-end crisis control center allowing companies to see, interpret, and act on real-time information from the entire supply chain and extended third-party digital ecosystem.

Empowering an intelligent manufacturing firstline

From the front office to supply chain to the factory floor, Microsoft solutions can help improve manufacturing operations by streamlining daily work, driving greater efficiency, safety and productivity as well as helping enhance employee performance. For example:

  • Microsoft 365 is equipping organizations, including Firstline Workers on the factory floor with the skills and tools they need to keep up with digital manufacturing in a secure environment. Microsoft Teams is transforming how today’s manufacturing workforce collaborates and communicates securely. Learn more how Microsoft 365 is being used in manufacturing here.
  • Customers have a growing need to move cloud computing closer to the edge. Azure Data Box Edge helps meet this need as a powerful, AI-enabled edge appliance that sits within a customer’s own environment – in their data center or on a factory floor – right alongside their existing hardware. It brings Azure computing power to where data originates, eliminating any network latency.
  • With mixed reality applications Dynamics 365 Remote Assist and Layout, companies are using Microsoft HoloLens and HoloLens 2 to dramatically boost productivity, compliance and safety. You’ll find more information about a broad range of Dynamics 365 innovations in manufacturing here.
  • Available later this year, the new Microsoft Dynamics 365 Guides for HoloLens and HoloLens 2 will empower employees to learn by doing, with step-by-step instructions guiding them to the tools, parts and institutional knowledge they need in real work scenarios.
  • Delivering a unified approach to financial and business operations across manufacturing, supply chain, distribution and retail is made easier by Dynamics 365 for Finance and Operations.
  • Intelligent, connected field service through Dynamics 365 Connected Field Service can help manufacturers quickly detect and resolve issues, leveraging connected devices and machine learning and in the process, driving efficiency and reducing costs.

The future of manufacturing is all about applying new levels of intelligence across all aspects of operations, with disruption triggered by AI, mixed reality and IoT, redefining the value chain from engineering design to customer engagements to supply chains. We look forward to meeting with you next week to discuss how we’re empowering intelligent manufacturing around the world. Until then, please visit Microsoft at Hannover Messe 2019 for additional details about what’s planned, how to engage our team and where to find our booth in Hall 7, Stand C40.

Tags: , , , , , , ,

Go to Original Article
Author: Microsoft News Center

NSS Labs CTO discusses advanced endpoint protection testing, challenges

NSS Labs this month unveiled its first major endpoint protection group test since filing an antitrust lawsuit last September, and the tests mark significant changes in methodology and displaying the results.

The security technology testing firm, based in Austin, Texas, released the results of its 2019 Advanced Endpoint Protection Group Test, which featured a whopping 19 different vendor products, during RSA Conference earlier this month. Fourteen of the products were rated “recommended” based on NSS Labs’ security effectiveness and metrics for total cost of ownership per agent, with Sophos Intercept X Advanced v2.0.10 achieving the highest overall marks.

The Advanced Endpoint Protection Group Test follows NSS Labs’ antitrust suit against the Anti-Malware Testing Standards Organization, as well as CrowdStrike, Symantec and ESET for allegedly conspiring to prevent NSS Labs from testing the companies’ products. The three vendors and AMTSO deny the allegations. Despite the lawsuit, Symantec participated in the group test, and its Endpoint Protection and Advanced Threat Protection v14.2.1023.0100 received a “recommended” rating.

NSS Labs CTO Jason Brvenik said his company had to take a different approach to testing this time around because of how advanced endpoint protection products have evolved. In addition, NSS Labs made a small, but significant, change with its final report by redacting the names of three vendors that received a “caution” rating.

Brvenik spoke with us at RSA Conference about how the endpoint security market has changed, the challenges posed to testing firms and why NSS Labs removed the names of lower-scoring products. Here is part one of the conversation with Brvenik.

Editor’s note: This interview was edited for clarity and length.

How is this advanced endpoint protection test different than what NSS Labs has done in the past?

Jason Brvenik: The endpoint space specifically has gotten really good at sharing information with each other — at least sharing intelligence and knowledge. And so, in this round, we found that we actually had to do testing in parallel in under a minute and a half before results got tainted.

That fast?

Brvenik: Yes. We had to actually get that fast before other vendors were able to piggyback somebody else’s work.

Are vendors going through platforms like VirusTotal and others?

Brvenik: Yes, it’s through things like VirusTotal and side channels and all the other services. And you can’t tell the vendors to turn that functionality off, because that’s a benefit to the market in general. Everybody benefits the faster you get to those kinds of outcomes.

What else was different about this series of tests?

Brvenik: The speed and parallel testing is one element. Another element is the depth we’ve gone to in a number of other cases looking at exploitation and lateral movement and evasion techniques.

The fascinating thing for me is there’s a continual improvement in endpoint. The bar has clearly been rising, and the market is responding and working to do better. There’s no real clear line to me on whether or not one approach over the other has a significant advantage.

It seems like the products that are best suited [for enterprises] take each of the approaches and use them accordingly. Every approach has strengths and weaknesses, and the products that are best integrated across them seem to be the ones who are doing really well.

What are some of the things the leaders in this test did well?

Brvenik: Overall, it was better, faster outcomes. Good blocking, good detection, great timeliness, good analytics — all of those things come together in producing an output.

Were there some endpoint security products where you saw the opposite, and they just weren’t getting to those outputs fast enough?

Brvenik: Yes. There are certainly some legacy vendors and products that have a good opportunity to engage the market differently. But there have been improvements, too.

The big improvement we saw this year is [the] handling of ransomware and the different ransomware detection methods and capabilities in those products. Naturally, you would expect — with all the pain that’s been caused in years past — the market to produce a solution that’s much more effective there.

Because there’s so much data being shared so quickly among the vendors, does that produce similar results when you test for specific threats?

Brvenik: No, we get very different results. And that’s why the time window matters so much. It actually lets you assess the technology’s own merits, not the industry’s collective capability. We do see good variation in there, especially when we start looking at how much information these products are gleaning and capable of delivering in those briefs windows.

We assessed a number of elements when we look at the forensic capability, for example, when we look at the ability of a product to prevent an attack and when we look at the ability of a product to identify different techniques. Some are stronger than others in reputation versus machine learning, for example. It’s interesting — there’s no one technology that is resistant itself to direct attack. All of them have weaknesses you can find, but their general capability and ability to respond is continuously improving.

How much does signature-based detection matter now that so many vendors have moved toward advanced analytics and machine learning? Is that something that still distinguishes the vendors in the endpoint protection space?

Brvenik: It’s still very much relevant. And it does distinguish in some respects. In one of our test cases, it’s all about offline functionality where these systems do not have internet connectivity. And [some] use cases there would be you’re on an airplane, you’re on vacation or you’re at a coffee shop where an attacker controls things, and you don’t necessarily get the benefit of cloud-based analytics and that other functionality.

There are some interesting data sets you see here. Signatures are still very relevant in much the same way reputation is still very relevant. Rapid response effectively gets very specific things, but it’s not durable against mutation and attack. And so, I don’t [think] signatures are going away. Certainly, there’s value to them in the rapid response; you don’t have to do the heavy analytics. But it really is ultimately affording you the opportunity to have the analytics on the remainder, where signatures kind of are taking care of that.

Looking at advanced endpoint protection today, do you feel like the products in this space are getting better at identifying new threats?

Brvenik: I feel like they’re getting better at rapidly concluding new things are threatening. I don’t know that I would say they’re getting better at stopping threats outright, but the ability of these products to conclude in one place and share [the data] in all other places at the same time is a pretty powerful thing.

The endpoint security market seems like it’s gotten very crowded and competitive, and some vendors have said there’s too much noise and too much infighting in the space right now.

Brvenik: That’s actually one of the reasons I looked at the A, B and C vendors and the unvalidated vendors and [removed their names]. I wanted to level-up that conversation, because the market does have this issue where they’ll take shots at each other behind the scenes, and I just don’t want to [contribute to that]. I want talk about the people that are doing well, that care about their customers, care about their products, and really want to understand what the opportunities are and then go after them. I don’t want talk about all this other stuff. And I don’t think a vendor that wants to do well but isn’t quite there yet should necessarily be penalized. There shouldn’t be a ton of sharks waiting to jump on them.

We’re trying a different approach of focusing more on the vendors that are doing well and having the right conversations about the opportunities there. If vendors are not in the recommended [quadrant], then they have some room to grow. But if you’re looking to buy more products, you should be looking up in that top quadrant right now.

Is that why you didn’t say who those vendors were that fell outside the recommended quadrant?

Brvenik: Yes. I prefer a ‘promote, not demote’ perspective, rather than having somebody participate in a test because they want to do well, but they’re not quite there. I don’t want to discourage people from getting that experience and getting that exposure through testing and being able to go address [shortcomings] and ultimately help their customers in the market.

At the end of the day, what I care about is getting the best security in the hands of the enterprise. The data from our testing is available; you can see everything there. We’re not just throwing that name up on the board so that it makes it possible for everybody to start taking shots at one another.

Go to Original Article
Author:

For Sale – Watercooled PC (i7 4770K, GTX 980ti, 16GB DDR3, Corsair AX860) 480mm + 420mm Rads

Plan to strip this down. Would like to sell as complete system first.

Price: 1,100 GBP

Case:
Phanteks Enthoo Primo (includes PWM fan controller)

IMG_20190211_125918.jpg

Price and currency: 1,100 GBP
Delivery: Delivery cost is not included
Payment method: BT
Location: Bristol / North Somerset
Advertised elsewhere?: Not advertised elsewhere
Prefer goods collected?: I prefer the goods to be collected

______________________________________________________
This message is automatically inserted in all classifieds forum threads.
By replying to this thread you agree to abide by the trading rules detailed here.
Please be advised, all buyers and sellers should satisfy themselves that the other party is genuine by providing the following via private conversation to each other after negotiations are complete and prior to dispatching goods and making payment:

  • Landline telephone number. Make a call to check out the area code and number are correct, too
  • Name and address including postcode
  • Valid e-mail address

DO NOT proceed with a deal until you are completely satisfied with all details being correct. It’s in your best interest to check out these details yourself.

Go to Original Article
Author: