Splunk partners ‘the growth engine’ of new customer deals

Splunk has bolstered its channel program on the heels of a year’s worth of sustained growth within its partner ecosystem.

Splunk partners were a significant contributor to the company’s revenue for fiscal year 2019, which ended Jan. 31, the big data analytics vendor said. Splunk partner bookings increased 63% year over year, with partners registering more than 14,000 deals. Partners also contributed 76% of the company’s total new customers, according to Splunk.

“We are really seeing partners as the growth engine for our new customers,” said Brooke Cunningham, area vice president of global partner programs, marketing and operations at Splunk, in an interview.

Cunningham said Splunk has about 1,700 active partners worldwide. Partner business types span resellers, managed services providers (MSPs), professional services firms, systems integrators (SIs) and technology alliance partners, she said. She noted that while resellers make up a large portion of the Splunk ecosystem, many of them “are starting to evolve their business model.”

“We oftentimes see a partner participating both as a reseller and MSP,” she said. “We are seeing a lot of converging of different partner business models as partners [embrace] some of the new consumption models for customers.”

Splunk partner program enhancements

At its Global Partner Summit conference, held this week in Las Vegas, Splunk expanded its Partner+ Program with a formalized track for global and regional systems integrators. The track provides benefits specific to the systems integrator business model, including business investment funds and support for creating solutions and onboarding or enabling talent, Cunningham said.

Brooke Cunningham, area vice president of global partner programs, marketing and operations at SplunkBrooke Cunningham

The formalized track “is going to allow us to expand the number of SIs that we are able to work with. [SIs have] certainly been an important part of our business, but we have had to focus more on a smaller set. Now we will be able to open that up … and selectively recruit where it makes sense from a geographical expansion perspective and perhaps around use cases or verticals,” she said.

Cunningham cited Accenture as one of Splunk’s top global strategic alliance partners. She said Splunk has “learned a lot” through its partnership with the firm.

Splunk will also expand its partner rebate incentives in the coming year, Cunningham said. The company revealed it will continue to offer its incentive for acquiring new customers and launch rebates for landing multiyear deals and delivering professional services. Additionally, top-tier Splunk partners can earn a growth rebate for exceeding growth targets, she said. She added that incentives are stackable, so a partner could earn multiple rebates on the same deal.

Aziz Benmalek, vice president of worldwide partners and channel chief at SplunkAziz Benmalek

On top of launching the new SI track and incentives, Splunk will also be focused this year on further simplifying its deal registration process, enhancing the Splunk partner portal, and clarifying rules of engagement surrounding customer renewal policies, Cunningham said.

Attendees of the Splunk Global Partner Summit met the vendor’s new vice president of worldwide partners and channel chief, Aziz Benmalek, who joined Splunk in February. Benmalek previously served as vice president of worldwide cloud and managed service providers at Microsoft.

Other news

  • Unified storage vendor Nexsan introduced the NexCouncil Partner Advisory Program. Program members gain access to Nexsan’s executive team, quarterly product roadmap discussions and sales training, the vendor said. Members can also receive priority access to market development funds and other marketing resources.
  • Data protection vendor QuorumLabs revamped its MSP partner program in the Americas. Quorum said the program enhancements include expanded sales marketing support, deal registration protection, and volume pricing and other discounts.

    We are seeing a lot of converging of different partner business models as partners [embrace] some of the new consumption models for customers.
    Brooke Cunninghamarea vice president of global partner programs, marketing and operations, Splunk

  • Data management vendor Commvault appointed Karen Falcone as its vice president of worldwide cloud and service providers. In her new role, Falcone will identify opportunities for the vendor and its partners to develop joint offerings, Commvault said. Falcone joins Commvault from Sungard Availability Services, where she served as vice president of global channels.
  • CloudJumper, a cloud workspace software and services provider, has named Frank Pulliam as its North America channel sales manager. Pulliam will be responsible for increasing sales of the company’s Cloud Workspace for Azure offering in the midmarket, CloudJumper said.
  • Data protection provider Arcserve hired Stephen Thomas as its North America senior vice president of sales. Thomas joins Arcserve after serving as senior vice president of sales at cloud security company Armor.
  • The MSP software landscape shifted on Monday when ConnectWise announced its acquisition by private equity investment firm Thoma Bravo. Read our blog post for insight into the buyout.

Market Share is a news roundup published every Friday.

Go to Original Article
Author:

Announcing Windows 10 Insider Preview Build 18850 | Windows Experience Blog

Hello Windows Insiders, today we are releasing 20H1 Build 18850 to Windows Insiders who have opted into Skip Ahead. Remember – these builds are from the 20H1 development branch. Some things we are working on in 20H1 require a longer lead time. We will begin releasing 19H2 bits to Insiders later this spring after we get 19H1 nearly finished and ready; once 19H1 is “nearly finished and ready” we’ll also use the Release Preview ring for previews of drivers and quality updates on 19H1.
IMPORTANT: As is normal with builds early in the development cycle, these builds may contain bugs that might be painful for some. If you take this flight, you won’t be able to switch back to the Fast or Slow rings without doing a clean-install on your PC and starting over.
If you are looking for a complete look at what build is in which Insider ring – head on over to Flight Hub. You can also check out the rest of our documentation here including a complete list of new features and updates that have gone out as part of Insider flights for the current development cycle.

Snip & Sketch version 10.1901.10521.0
As some of you may have already noticed, we’re in the process of rollout out a new app update to Skip Ahead. It includes a number of fixes based on your feedback, among which are:

We fixed an issue that could result in snips being a bit blurry after saving or copying to clipboard.
We fixed an issue where copying to clipboard would fail if you switched out of the app while the copy operation was in progress.
We fixed an issue where the suggested file name was unexpectedly a GUID for snips opened from Win + Shift + S toast.
We’ve added Narrator (screen reader) confirmations when a snip is copied to clipboard.
We’ve updated the default save format to be png. You can still use the dropdown when saving to pick your desired format if it’s not png.
We fixed an issue where auto-copy changes to clipboard wasn’t working on return from Snip & Sketch settings.
We fixed an issue where the app might crash if you closed two app windows one after another.
We fixed an issue where the default save file location was documents rather than pictures. In fixing this we also fixed an issue where when saving the save dialog wouldn’t remember where you last saved a snip.

The rollout of this app is not tied to the upgrade, so you may see it outside the bounds of this flight.

We fixed an issue where Narrator continuous reading in Edge did not keep the text cursor at the position where reading was started from.
We fixed an issue where Narrator Scan mode down arrow navigation might get stuck when reading in Chrome.
In Windows Sandbox, Settings app no longer crashes when you navigate to the Narrator settings.
We fixed an issue where the time shown on the clock in Windows Sandbox might not match the clock outside of Windows Sandbox.
We fixed an issue resulting in some devices unexpectedly experiencing a 30 second wait before pin re-entry was available after a pin was incorrectly entered on the lock screen.
We fixed an issue resulting in Emoji 12 emoji showing up as boxes in certain XAML text fields.
We’ve made some adjustments to improve WIN+(period) reliability.
We fixed an issue that could result in the Start menu not launching if the GPO to turn off the all apps list in Start was enabled.
We fixed an issue where the default Microsoft Word web tile pinned to Start (in the case where Office wasn’t installed) was unexpectedly launching Microsoft Edge in inPrivate mode.
We fixed an issue resulting in Microsoft Edge sometimes crashing when editing or tabbing through PDFs.
We’ve made a change to improve cloud clipboard (if enabled) sync reliability.
We fixed an issue that could result in the lock screen unexpectedly not dismissing until Ctrl+Alt+Del was pressed.
We fixed an issue where if high contrast mode was enabled during Windows setup, that state wouldn’t persist first logon.

Launching games that use anti-cheat software may trigger a bugcheck (GSOD).
If you use third party apps to adjust the color of your screen, we’ve made a fix with this build to address feedback that certain apps were no longer working. We’re continuing to investigate feedback in this space.
For display calibration scenarios, monitors may be missing in the built-in Color Management application. As a work around, please use the Settings app to select color profile instead, under the Display Settings page.
When performing Reset this PC and selecting Keep my files on a device that has Reserved Storage enabled, the user will need to initiate an extra reboot to ensure Reserved Storage is working again properly.
Some Realtek SD card readers are not functioning properly. We are investigating the issue.
Mouse pointer color might be incorrectly switched to white after signing out and signing back in.
Creative X-Fi sound cards are not functioning properly. We are partnering with Creative to resolve this issue.
We’re investigating an issue preventing VMware from being able to install or update Windows Insider Preview builds. Hyper-V is a viable alternative if available to you.

If you install any of the recent builds from the Skip Ahead and switch to either the Fast ring or the Slow ring, optional content such as enabling developer mode will fail. You will have to remain in the Fast ring to add/install/enable optional content. This is because optional content will only install on builds approved for specific rings.

No downtime for Hustle-As-A-Service,Dona

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

On Tuesday, we released a new Windows 10 Preview Build of the SDK to be used in conjunction with Windows 10 Insider Preview (Build 18346 or greater). The Preview SDK Build 18346 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 ONLY on Windows 10 Insider Preview builds.
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=18346 once the static URL is published.

Tools Updates
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.

Breaking Changes
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.

Removals:
Note: The following recent removals have been made since earlier flights.

namespace Windows.Networking.PushNotifications {
public static class PushNotificationChannelManager {
public static event EventHandler ChannelsRevoked;
}
public sealed class PushNotificationChannelsRevokedEventArgs
}
namespace Windows.UI.Composition {
public sealed class CompositionProjectedShadow : CompositionObject {
float MaxOpacity { get; set; }
float MinOpacity { get; set; }
float OpacityFalloff { get; set; }
}
public sealed class CompositionProjectedShadowCaster : CompositionObject {
Visual AncestorClip { get; set; }
CompositionBrush Mask { get; set; }
}
public enum CompositionProjectedShadowDrawOrder
public sealed class CompositionProjectedShadowReceiver : CompositionObject {
CompositionProjectedShadowDrawOrder DrawOrder { get; set; }
CompositionBrush Mask { get; set; }
}
public sealed class CompositionRadialGradientBrush : CompositionGradientBrush {
Vector2 GradientOrigin { get; set; }
}
public interface ICompositorPartner_ProjectedShadow
}

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);
}
}

For Sale – 27″ 5K iMac 2017

I have a 2017 27″ 5K for sale which was bought from the Apple refurb store on 11/12/18.

3.8Ghz i5
16GB RAM
512GB SSD
8GB Radeon Pro 580

Change of circumstances means I’m having to go back to Windows.
Absolute mint, as new condition with the remaining Apple Care until Dec 2019 and tech support until 10/03/19.

I would prefer collection but if you need it posting I will do so on the proviso it is at your own risk and cost.

IMG_0106.JPG IMG_0107.JPG IMG_0109.JPG IMG_0110.JPG

Price and currency: £1750
Delivery: Delivery cost is not included
Payment method: Cash on collection or BT
Location: Chorley, Lancs
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:

Updated Microsoft Store App Developer Agreement: New Revenue Share – Windows Developer Blog

As of March 5th, the Microsoft Store team has updated the Microsoft Store App Developer Agreement (ADA). The next time you log into your Partner Center dashboard, you or someone with an administrative role on your account will be prompted to reaccept the ADA before you can continue to update or manage your applications.
The updated ADA includes the new Microsoft Store fee structure that delivers up to 95 percent of the revenue back to consumer app developers. To ensure you receive the full 95 percent revenue, be sure to instrument your referring traffic URLs with a CID.
When Microsoft delivers a customer through other methods (tracked by an OCID), such as when the customer discovers the app in a Microsoft Store collection, through Microsoft Store search, or through any other Microsoft-owned properties, then you will receive 85 percent of the revenue from that purchase.
When there is no CID or OCID attributed to a purchase, in the instance of a web search, you will receive 95 percent revenue.
The new fee structure is applicable to app purchases made on all Windows 10 PCs, Windows Mixed Reality, Windows 10 Mobile and Surface Hub devices. The new fee structure excludes all games and any purchases on Xbox consoles.
For full details on the new fee structure refer to the Microsoft Store App Developer Agreement. To see an overview of all the changes made to this version of the ADA please visit the change history.
Updated March 6, 2019 8:07 am

NSA releases Ghidra open source reverse-engineering tool

SAN FRANCISCO — The National Security Agency released an open source version of its reverse-engineering toolkit for malware, providing security professionals with free software that offers features only found in high-end, expensive commercial products.

The U.S. intelligence agency launched the Ghidra modular toolkit at the RSA Conference here on Tuesday. The highly anticipated release demonstrated a continued willingness on the part of the NSA to build better relations with the IT security community.

For David Mattson, a self-described “open source junkie,” Ghidra would bring a dramatic improvement to the noncommercial tools he has employed.

“It’s leaps and bounds ahead of what I’m using,” said Mattson, a security professional with health insurance company Centene Corp., based in St. Louis. “It’s like bringing a tank to a musket fight.”

Robert Joyce, a senior adviser for the NSA, explained to a packed house the standout features in Ghidra, which the NSA uses to disassemble executables into code. The process of reverse-engineering is useful in learning more about the capabilities of malware and its creator.

Ghidra for enterprise security

It’s leaps and bounds ahead of what I’m using. It’s like bringing a tank to a musket fight.
David Mattsona security professional with health insurance company Centene Corp.

Ghidra, which the NSA developed in the early 2000s, can reverse-engineer software for Windows, Mac, Linux, iOS or Android. Users can run the Java-based toolkit on Windows, Mac or Linux.

The software is modular, which means security pros can remove or add modules depending on their preference. The modularity of Ghidra lets the NSA share the software, while holding onto modules the agency wants to keep in-house.

“This is still a healthy, ongoing development within NSA,” Joyce said.

Users can employ JavaScript or Python to extend a module’s capabilities. They also can take advantage of a shared repository and version control when collaborating with colleagues and a file system for viewing, extracting and importing nested malware functions.

Ghidra has an undo-redo feature that is useful when applying different analytics while disassembling an executable, a process Joyce described as “both art and science.”

Joyce acknowledged releasing Ghidra to the open source community would lead to improvements in the toolkit that would benefit the NSA. Also, universities could use the software as a teaching tool, which would help prepare students interested in working for the agency.

In 2013, the NSA was thrust into the public spotlight after intelligence contractor Edward Snowden disclosed the agency had been collecting and analyzing logs of Americans’ domestic calls and texts. Former President George W. Bush started the program to hunt for conspirators following the Sept. 11, 2001, terrorist attacks.

The New York Times reported this week the NSA had quietly shut down the program and hadn’t used it in months.

In light of the previous revelations, Joyce assured RSA attendees Ghidra was safe to use.

“For the record, there’s no backdoor in Ghidra,” he said. “Scout’s honor.”

Go to Original Article
Author:

As offshore outsourcing grows, HR tries to measure impact

President Donald Trump became a harsh critic of the H-1B program during his campaign for president and invited IT workers who had trained visa-holding replacements to speak at campaign rallies. Trump promised to make changes to the H-1B program, and his administration is now denying roughly one in five of the H-1B visas sought by IT services firms.

But the administration’s results are mixed. Offshore outsourcing is still growing, and U.S. businesses are still shifting work overseas.

Firms don’t typically announce outsourcing agreements, because they may involve layoffs and the rebadging of workers. But there are exceptions. Take Molina Healthcare. Molina is an approximately $18 billion firm that provides health services and information management to Medicaid and Medicare recipients. It recently made public an agreement with IT services firm Infosys to manage some of its IT infrastructure.

Indeed, few actions are as politically fraught as the offshore outsourcing of jobs — externally and internally. A decision such as the one by Molina can be a morale-crushing event for employees — one that has major implications for HR. Once a firm decides to offshore work, HR departments may be tasked with measuring its impact on employee engagement and productivity. HR managers may turn to pulse surveys or invest in new technology to conduct analytics on employee behavior.

A layoff and IT services agreement

But improvements in HR’s ability to measure the impact of outsourcing is unlikely to change its reality. On the same day Molina announced its agreement with Infosys, California posted a Worker Adjustment and Retraining Notification Act notice, reporting that Molina was laying off 169 employees in Long Beach, where some of its IT work is done.

The announcement likely did not surprise Molina IT workers, some of whom had earlier received a retention offer with a financial benefit if they agreed to stay on the job. The employees were considered “important to the success of the restructuring,” according to a document obtained by TechTarget. Molina did not respond to a request for comment.

Employees at firms undergoing outsourcing are often reluctant to talk, and such was the case at Molina. But the experience is disruptive to an employer, and it can be brutal for affected workers. Marco Pena faced this situation firsthand.

Pena was an IT employee at Abbott Laboratories and one of about 150 to be laid off after their work was outsourced to an India-based firm in 2016. He chose not to take a severance, because he didn’t want to be bound to a nondisclosure agreement.

“There are several words that could apply to characterize the impact on the morale of IT professionals and not only as employees of a company, but also as citizens of a nation,” Pena said. They are “devastation, betrayal, anger, hopelessness and shock.”

Outsourcing survivors face problems

“There is also the morale impact to other employees that were not affected by the outsourcing,” Pena said. As Pena noted, offshore outsourcing affects more than the employees who are either being rebadged or losing their jobs.

“The survivors go through quite a few challenges, as well,” said Maya Garza, regional vice president for behavior science at BetterUp, a San Francisco-based firm that provides on-demand professional coaching.

Garza, who has a doctorate in industrial organizational psychology, said research on mergers and acquisitions, which have a similar impact to outsourcing, shows “a very big dip” in employee engagement that lasts for about six months.

Some firms may involve HR early in a decision to offshore to reduce the impact on employees — for those who are losing their jobs, as well as those who remain. Garza said employees who remain can feel a loss of control, and this can trigger drops in engagement and performance. People “start to think differently about the organization,” she said.

Understanding changes in morale may involve adopting pulse surveys, particularly for firms that have been relying on annual surveys, Garza said. Pulse surveys are shorter and done more frequently than annual or biannual surveys, giving HR a better sense for employee concerns. HR departments may also use analytics to look at turnover, absenteeism and performance drops overall. A 5% drop in performance can translate to millions of dollars for a large firm, she said.

Being able understand these metrics “does require having a talent analytics function that can track all of these things,” Garza said, as well as the “people who can understand that data.”

Outsourcing decisions sometimes become a catalyst for HR departments to invest more on software and services to survey and analyze what’s going on internally, said Clay Calhoun, partner at ISG, a technology research and advisory firm in Stamford, Conn.

“The HR team is surveying the retained organization as to what is working well and what is not working,” Calhoun said.

Trump’s order

The Trump administration has been trying to disrupt the offshore outsourcing model by applying more scrutiny to H-1B visa applications. The use of offshore outsourcing is closely tied with the use of H-1B visa workers. IT services firms are the largest visa users.

President Trump signs an executive order around his 'Buy American and Hire American' initiative.
President Donald Trump has been trying to make it harder for offshore outsourcing firms to use visa workers. It’s part of his ‘Buy American and Hire American’ initiative. The photo shows him signing a related executive order at a visit to Snap-On, a tools maker in Kenosha, Wis.

The Trump administration is challenging IT services firms on their use of visa workers. Outsourcing firms had lower H-1B approval rates last year, according to data released last month by the U.S. Citizenship and Immigration Services (USCIS). Infosys, for instance, had a 74% approval rate, and Tata Consultancy Services had 82%, in contrast to Apple and Microsoft, both of which had a 99% approval rate.

“As part of our efforts to fulfill President Trump’s ‘Buy American and Hire American’ executive order, USCIS has made a series of reforms designed to protect U.S. workers, increase our confidence in the eligibility of those who receive benefits, cut down on frivolous petitions, and improve the integrity and efficiency of the immigration petition process,” Jessica Collins, a USCIS spokesperson, said in an emailed statement. “It is incumbent upon the petitioner, not the government, to demonstrate that he or she meets the eligibility under the law for a desired immigration benefit.”

In response to the Trump administration, but also for other business reasons, outsourcing firms are making adjustments.

They are increasing their hiring of U.S. workers and investing more in local facilities, said Chirajeet Sengupta, analyst and partner at Everest Group, an outsourcing consultancy and research firm in Dallas.

Some of these changes were prompted by client necessity that resulted from digital transformation efforts — work that involves changes to a firm’s core business model. For that kind of work — which could involve changes not just in tech, but in business culture — outsourcers have to be in close proximity to the business. “You really need to understand the business; you need to understand the business processes,” Sengupta said.

Another driver of increased local presence by offshore firms is the use of Agile development and its reliance on continuous interactions, Sengupta said. “It’s hard to do that when you are separated by thousands of miles,” he said.

Trump’s influence on offshoring

But the Trump administration is having some impact on offshore outsourcing. Some firms, worried about the future availability of H-1B workers, are telling outsourcing providers, either explicitly or implicitly, that they don’t want visa workers on the team, according to Sengupta. There is also worry about negative press.

“It’s very clear that there is a negative perception associated with a lot of H-1B workers,” he said.

We are continuing to see an upward trajectory in demand for IT services outsourcing.
David Rutchikexecutive managing director at Pace Harmon

Trump’s biggest impact on outsourcing is a result of his rhetorical attacks more than actual policy changes, said David Rutchik, executive managing director at outsourcing consultancy Pace Harmon, based in Vienna, Va.

“Their rhetoric is pushing companies to hire more U.S.-based resources,” Rutchik said. This is having a number of effects, including enabling “a stronger affinity with U.S.-based customers by having American workers serving in customer-facing roles.”

Rhetoric alone is also causing outsourcing providers to build up their U.S. capability, “including hiring more resources out of U.S. universities and colleges, in order to be less dependent on visa holders,” he said. They are also trying to do more work remotely, he said.

An upward trajectory continues

But the Trump administration has not hurt the adoption of outsourcing IT services, Rutchik said. “In fact, we are continuing to see an upward trajectory in demand for IT services outsourcing,” he said.

Indeed, India’s largest IT industry group, Nasscom, last month released a survey of CEOs forecasting software export growth in 2019 of more than 9%.

The administration’s focus on preserving America “by making visa restrictions more stringent” misses the bigger changes going on in the economy, Rutchik said. “Automation will displace vastly more jobs than labor arbitrage.” 

As for Molina, the healthcare organization has a history of turning over work to offshore providers and has faced litigation from displaced IT workers over it.

Go to Original Article
Author:

Infinidat InfiniBox preps SMB protocol nodes for Windows

Heeding pleas from Windows Server data center customers, disk storage specialist Infinidat now supports the server message block file protocol for its InfiniBox disk arrays. Version 4.0.40 of Infinidat software also fortified data protection with immutable snapshots to combat ransomware and other viral hazards.

Existing Infinidat InfiniBox controllers support Fibre Channel and iSCSI for block and NFS for file storage. The product is intended for data centers looking to collapse petabytes (PB) of networked file storage. Most NAS storage arrays support NFS and SMB protocols.

Infinidat will support SMB via InfiniBox SMB Node appliances. The physically discrete nodes provide an air gap as code migrates to Infinidat storage controllers.

“Our systems provide a seven nines mainframe-class guarantee. The SMB nodes allow us to monitor exabyte-scale deployments over an extended period, before we allow it into the sanctuary,” Infinidat CTO Brian Carmody said.

Infinidat InfiniBox SMB Node appliances can be added instantly to a cluster using the vendor’s management pane. Projected Windows use cases include home directories and department-level file storage.

“Customers have been asking us for the ability to consolidate Windows NT workloads on InfiniBox,” Carmody said.

Infinidat, based in Waltham, Mass., supports SMB versions 2.1 to 3.1.1. The architecture allows two InfiniBox SMB nodes per system and four tenants per box. An internal InfiniBox cluster network provides node connectivity. InfiniBox SMB Node uses a separate client-facing network to export protocol shares. The code is deployed in virtual machines initially and will be containerized on storage controllers.

Compliance-based backup and archival storage

Managed services provider Thrive Networks, based in Foxborough, Mass., was a beta tester of the Infinidat InfiniBox SMB arrays. Thrive CTO Michael Gray said he plans to use Infinidat InfiniBox SMB Node to deploy new services for compliance-based backup and archival storage.

“Infinidat is becoming sort of a Swiss Army knife for us. We’re always looking at ways to build new services on top of gear we already have,” Gray said.

Thrive also uses array-based Infinidat snapshots to capture primary data and replicate it to secondary InfiniBox systems for disaster recovery. “The use of spinning disk keeps the price down, which is important,” Gray said.

Infinidat’s lock-free NAS snapshots

The Infinidat InfiniBox software license includes unlimited snapshots for volumes, file systems and consistency groups.

Infinidat InfiniBox array
Infinidat InfiniBox disk storage array now supports SMB files

SnapSecure immutable snapshots in the latest InfiniBox release use a lock-free mechanism to prevent deletions or overwrites of data. The time-stamped snapshots can’t be altered until the expiration date, including by storage administrators. Retention periods also can’t be decreased.

Customers can take hundreds of thousands of snapshots per system without a performance hit, Carmody said.

A self-service feature known as NAS Snapshot Directory provides a directory inside existing file systems, using pointers to mark each snapshot. Authorized end users are able to use Snapshot Directory to recover deleted and modified files independently of the storage administrator.

Infinidat founder and CEO Moshe Yanai spearheaded Symmetrix engineering at EMC for 10 years. He went on to launch Diligent Technologies, which sold backup and deduplication hardware, and storage array vendor XIV. Both of those companies were acquired by IBM.

The vendor said 80% of its customers manage at least 1 PB of storage and nearly 15% store 10 PB on an InfiniBox system.

Infinidat storage places metadata in dynamic RAM and places reads and writes on high-capacity nearline SAS disk. The Infinidat arrays use a small percentage of flash to accelerate write performance. The array maintains an index of all writes made to the system to enable predictions and boost storage performance.

Go to Original Article
Author:

How to configure Windows container networking

Windows containers use virtual and/or physical host networks to implement networking for applications. You can execute Windows container networking functions almost the same way you do for VMs, but container networking architecture is different.

Each Windows container implements a virtual network adapter that runs on top of the container system network driver. The virtual network adapter is connected to a Hyper-V virtual switch on the host machine. There are five different networking drivers supported by the container — Network Address Translation (NAT), overlay, transparent, l2bridge and l2tunnel — and you must choose the driver that is best suited for your infrastructure. For example, you might want to choose l2bridge if you implement networking bridging. Similarly, you might want to go for the NAT network driver if you implement NAT in your infrastructure.

Default NAT for Windows container networking

When you create a Windows container, it creates a default NAT. The system connects NAT to an internal vSwitch on the container and maps it to the WinNAT driver. The WinNAT driver is responsible for passing the communication from the container NAT driver to the Windows host machine or outside the container. Any networks you create on the host machine are also available to the Windows container. To see the list of available networks on a container, execute the docker network ls command as shown in Figure 1 below.

Available container networks
Figure 1. Show available networks in a container.

As you can see in Figure 1 above, the command lists all the network connections available on a container. The scope defines the scope of the network, which is either local or swarm.

When Docker Engine starts, it implements NAT. Then, the system applies the Docker networking process to the NAT networking driver and automatically assigns an IP address. The IP range for NAT is 172.16.0.0/16.

Implement transparent Windows container networking

If you want container applications to connect to remote endpoints — say, an application running on another host machine — you must create a transparent network connection, sometimes referred to as a user-defined network. To start the creation process, execute the docker network create command on a Windows host machine. You must use the d flag to indicate what networking driver and network type to use and create. The steps below explain how to create a transparent network for both Dynamic Host Configuration Protocol (DHCP) and non-DHCP networks.

Step 1: Issue the Docker command below to create a DHCP-enabled network.

docker network create –d transparent dhcplan

Once you execute the command above, you should see a dhcplan network in the container when you run the docker network ls command.

Step 2: The next step is to place a container image on the newly created network so it can access data outside the container and/or connect to a remote endpoint if necessary.

docker run –it –network=dhcplan Microsoft/windowsservercore

As you can see in the command above, you should specify network=dhcplan as a custom network for the Microsoft/windowsservercore container image.

For non-DHCP networks, you must specify the subnet and a gateway apart from specifying the name of the transparent network, as shown in the command below.

docker network create -d transparent --subnet=10.88.28.0/24 --gateway=10.88.28.1 nondhcplan

Go to Original Article
Author:

Pumped up automation: Fish farming in Japan adopts a new AI and IoT solution – Asia News Center

Japan’s labor-intensive fish farming sector has taken a major step toward automation with the adoption of an artificial intelligence (AI) and Internet of Things (IoT) solution that frees up highly skilled workers from a crucial, but highly time-consuming, task.

The breakthrough follows half a year of field tests at Kindai University, which plays a significant role in the national production of red sea bream – a fish known in Japanese as “Madai” that is prized by sushi and sashimi lovers both at home and abroad.

The university’s Aquaculture Research Institute hatches red sea bream and raises them to a juvenile stage, known as fingerlings. Every year, it sells around 12 million fingerlings to fish farms that grow them to adult size for the market. To meet rising demand for the delicacy, Kindai’s workers must hand sort as many as 250,000 fingerlings a day.

Fingerlings in a holding pen.

Japan’s aging demographics and other factors have made the recruitment of experienced sorters difficult, particularly when so much repetitive work is required. To counter this problem, the university approached its long-term partner company, Toyota Tsusho, which in turn brought in Microsoft Japan to help come up with ways of automating a number of processes. The aim is to relieve workers of manually intensive duties so that they can focus their valuable skills on more demanding tasks.

This latest innovation centers on software that automatically regulates the flow of water through pumps that transfer fingerlings from their pens and onto conveyor belts for sorting. IoT and AI tools continuously monitor and adjust the flows.

Now automated … Fingerlings being pumped from their pens.

“There are three processes involved in sorting fingerlings,” explains Naoki Taniguchi, who manages the Institute’s Larval Rearing Division and is Deputy General Manager of the Aquaculture Technology and Production Center. “Firstly, we gather the fingerlings near the mouth of the pump that sucks them along with seawater from the fish pens without injuring them. To do this, we must constantly adjust the pump’s water flow to the conveyor belts. Lastly, we sort them by removing fingerlings that are too small or defective from the conveyor belts.”

Naoki Taniguchi of the Institute’s Larval Rearing Division Aquaculture Technology and Production Center

Taniguchi said adjusting the water flow from a pump is crucial.

“If the flow is too fast, too many fingerlings will make it onto the conveyor belts, and our sorting teams won’t be able to keep up, and some fish that should be removed will be missed. If the flow is too slow, too few fingerlings will be sorted, and production will fall short. Until now, it’s been a process entrusted only to a few operators with sufficient experience.”

The new automated transfer system was created with Microsoft Azure Machine Learning Studio using image analysis technology that recognizes the changing ratio of fish shapes and vacant areas within a pump’s pipes. From this, the system machine-learned how expert human operators adjust flows optimally.

Field tests started last year, and within six months the system achieved the same flow control results as an operator.

Taniguchi said employees, who often used to spend their whole working day just adjusting water flows, are now able to devote their time to applying their rich experience in streamlining other fish farming processes. They will also be able to pass on their technical knowledge to a new generation of aquaculture specialists.

Sorting fingerlings on conveyor belts.

He hopes greater automation will make jobs in the sector more attractive to younger workers looking to build careers.

“Japan’s fishing industry employs about 150,000 people. But 80 percent of them are more than 40 years old. It is vital that we attract young people to the industry,” he said. “This automatic transfer system is just the beginning of our journey. Ultimately, we aim to automate the sorting process itself as well.”

 READ MORE:  AI and fish farming: High-tech help for a sushi and sashimi favorite in Japan

Go to Original Article
Author: Steve Clarke