Microsoft Government Community Cloud adds Teams, Dynamics 365

Microsoft has expanded its Government Community Cloud offerings to meet the needs of more U.S. government agencies that are undergoing mandated digital transformations.

Microsoft Teams, Microsoft Power Platform and Dynamics 365 Customer Engagement are now all available for Government Community Cloud (GCC) customers, with Dynamics 365 Customer Engagement and Teams available for GCC High customers. GCC High includes a more stringent compliance certification.

Teams can help government agencies communicate and collaborate outside of email, while Power Platform uses Power BI, PowerApps and Flow to help agencies create apps regardless of coding ability. Dynamics 365 Customer Engagement will allow agencies to bring together different customer data points to better serve constituents.

Government agencies finally go digital

Microsoft’s Government Community Cloud updates follow last year’s Modernizing Government Technology Act, which is part of the 2018 National Defense Authorization Act. The act requires federal agencies to increase cloud and collaboration tools, and vendors such as Microsoft are eager to meet those requirements.

“As a natural progression, Microsoft has been providing additional capabilities to its FedRAMP-certified cloud offerings for government,” said Adelaide O’Brien, research director at IDC Government Insights. “Microsoft also has a focus on the government market, as agencies are undergoing digital transformation and need to provide government employees with tools and technologies that allow workers to be more productive.”

Technology alone isn’t the answer to modernizing government processes, however. Supportive leadership and an agile process focused on worker efficiency and providing better service to constituents are required for a successful technological upgrade, O’Brien said.

“The question for many agencies isn’t whether to move to the cloud, but what services can be provided more effectively by moving workloads to the cloud, providing the agency with additional capabilities often with less internal cost and resources,” she said.

Government agencies are among the slowest industries to adopt new technology, primarily due to security and regulation concerns, as well as years of legacy technology that impedes a digital transformation. But as cloud technology has become more widely adopted and more secure, government agencies are starting to modernize.

“Probably the biggest challenge government agencies face is, ‘How do we modernize when we have decades-old legacy systems? Do we rip and replace?'” said Susie Adams, CTO for Government Community Cloud at Microsoft. “What we’re seeing is a trend from agencies that want to move to the cloud and looking at scenarios to see if the apps are a good fit and if a hybrid solution is better.”

One example of this is bringing Microsoft Teams to government employees. Now available for Government Community Cloud High and Department of Defense environments due to improved security, Teams can provide agencies with a communication tool that supports more types of interactions.

IDC’s O’Brien said she believes agencies are more likely to adopt tools like Teams that allow for easier collaboration across multiple locations.

Microsoft is making its Teams product an option for its government agency customers.
This screenshot of Microsoft Teams shows how a government agency — in this case, a department of transportation — would use the collaboration tool.

Improved security compliance for Microsoft

The question for many agencies isn’t whether to move to the cloud, but what services can be provided more effectively by moving workloads to the cloud.
Adelaide O’Brienresearch director, IDC Government Insights

Security has long been a concern for government agencies, and Microsoft is responding by making Teams and Dynamics 365 Customer Engagement available in Government Community Cloud High, opening the products up to a larger customer base, while increasing security and compliance.

Microsoft will also add more security capabilities for its Office 365 Advanced Threat Protection P2 for Government Community Cloud. The new capabilities are expected to automate the investigation and remediation of email threats and cyberattacks, relieving security teams on response time. The new capabilities are expected to be released in the third quarter of this year. Microsoft government products have received certifications, including FedRAMP High and Moderate; Criminal Justice Information Services; IRS 1075 FTI; Health Insurance Portability and Accountability Act; International Traffic in Arms Regulation; and Department of Defense levels 2, 4 and 5.

By also adding Power Platform capabilities, Microsoft brings custom application design to government agencies, so they can analyze, act on and automate data flow.

“You look across the federal landscape and see how many business processes [are] out there that can be automated,” Adams said. “Power Platform acts as a low-code, no-code product that allows non-IT professionals to automate a workflow and attach data analysis.”

Similarly, Microsoft Government Community Cloud’s addition of Dynamics 365 Customer Engagement will allow agencies to better monitor interactions with its constituents through different channels, bringing those interactions together into one place for the agency.

Pricing for these products was not released by Microsoft.

Go to Original Article
Author:

For Sale – PC i5-6600/16GB Ram/RX580 QuickSale Needed!

For sale my gaming PC, was built only 2 weeks ago but circumstances have changed so I have to sell it.

CPU: i5 6600

Mobo: MSI H110M-PRO VD

RAM: 16GB DDR4

GPU: Sapphire 8GB RX580(handles any game in full HD at max settings)

PSU: MS Tech 600W

Storage: 240GB SSD

Case: DeppCool

Fans: 3 Blue LED Fans

Case: deepcool steam castle

Wifi: AC1200 PCI E x1

CPU cooler is not stock so gives better cooling.

Any question please ask. Willing to post first to members with high feedback.

Thank you

Price and currency: 500
Delivery: Delivery cost is included within my country
Payment method: Paypal/Bank Transfer
Location: London
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:

Windows 10 SDK Preview Build 18356 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 18356 or greater). The Preview SDK Build 18356 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=18356 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);
}
}

Updated March 20, 2019 9:08 am

Renault-Nissan-Mitsubishi launches Alliance Intelligent Cloud on Microsoft Azure – Stories

  • Alliance Intelligent Cloud built on Microsoft Azure to power the Alliance’s latest connected services
  • World’s leading automotive alliance to use Alliance Intelligent Cloud for connected infrastructure in nearly all 200 markets served by Renault, Nissan, and Mitsubishi
  • Alliance Intelligent Cloud to power the connected services in the all-new Renault Clio and the Nissan Leaf in Europe and Japan later this year

Paris / Yokohama / Seattle – March 20, 2019 – Renault-Nissan-Mitsubishi, the world’s leading automotive alliance, today announced the production release of the Alliance Intelligent Cloud, a new platform that is enabling Renault, Nissan, and Mitsubishi Motors to deliver connected services in vehicles sold in nearly all 200 markets served by the Alliance member companies. Culminating joint development efforts between the Alliance and Microsoft, the auto industry’s first global and most ambitious connected vehicle program will be deployed utilizing cloud, artificial intelligence (AI), and IoT technologies provided by Microsoft Azure. Azure provides the Alliance with a global data platform to securely capture, manage and analyze vehicle data to deliver intelligent services based on the vast volume of data created by connected vehicles.

Kal Mos, Global Vice President of Alliance Connected Vehicles at Renault-Nissan-Mitsubishi, said: “Today we are deploying a vehicle connectivity platform that will transform the digital experience for customers of Renault, Nissan, and Mitsubishi. Through our collaboration with Microsoft, we are introducing the most powerful and far-reaching connected vehicle platform. Leveraging the size and scale of the Alliance, we have built an intelligent cloud platform that sets the pace for our industry.”

“Renault-Nissan-Mitsubishi is a longstanding partner and our first strategic partner for the Microsoft Connected Vehicle Platform,” said Jean-Philippe Courtois, EVP and president, Microsoft Global Sales, Marketing and Operations at Microsoft Corp. “Today’s production release of the Alliance Intelligent Cloud enables a new generation of connected services powered by Microsoft Azure to come to market.”

The first vehicles produced with Alliance Intelligent Cloud technology will be the all-new Renault Clio and selected Nissan Leaf models sold in Japan and Europe. These are also the first vehicles powered by the Microsoft Connected Vehicle Platform available to consumers at scale.

Vehicles utilizing the Alliance Intelligent Cloud will benefit from seamless access to the internet, providing enhanced remote diagnostics, continuous software deployment, firmware updates and access to infotainment services.

The Alliance Intelligent Cloud is a highly-scalable platform and will consolidate multiple legacy connected vehicle solutions with current and future connected car features and business operations that will support mobility services. The data-driven platform will enable advanced AI and analytics scenarios and accelerate time to market for new innovations and business initiatives.

Optimized for speed and efficiency, the Alliance Intelligent Cloud will connect to vehicles and share digital features and future innovations across multiple models and brands for consumers in different regions around the world. Features consolidated onto the connected platform include remote services, proactive monitoring, connected navigation, connected assistance, over-the-air software updates, and other customer-tailored services.

The Alliance is taking a unique approach to addressing the business opportunity provided by connected vehicles by owning, operating, and designing its own intelligent cloud platform on Microsoft Azure.

The Alliance Intelligent Cloud is capable of connecting Alliance vehicles with future smart cities infrastructure as it develops and with potential future partners. With this new initiative, any third-party seeking to connect with all legacy and future connected Alliance vehicles will have a single point of contact to partner with.

ABOUT RENAULT-NISSAN-MITSUBISHI:

Groupe Renault, Nissan Motor and Mitsubishi Motors represent the world’s largest automotive alliance. It is the longest-lasting and most productive cross-cultural partnership in the auto industry. Together, the partners sold more than 10.6 million vehicles in nearly 200 countries in 2017. The member companies are focused on collaboration and maximizing synergies to boost competitiveness. They have strategic collaborations with other automotive groups, including Germany’s Daimler and China’s Dongfeng. This strategic alliance is the industry leader in zero-emission vehicles and is developing the latest advanced technologies, with plans to offer autonomous drive, connectivity features and services on a wide range of affordable vehicles.

www.alliance-2022.com

www.media.renault.com

www.nissan-newsroom.com

www.mitsubishi-motors.com/en/newsrelease/

ABOUT MICROSOFT:

Microsoft (Nasdaq “MSFT” @microsoft) enables digital transformation for the era of an intelligent cloud and an intelligent edge. Its mission is to empower every person and every organization on the planet to achieve more.

MEDIA CONTACTS

Nick Twork
Technology & Innovation Communications
Renault-Nissan-Mitsubishi
+33 (0)6 01 05 22 63
nick.twork@alliance-rnm.com

Microsoft Media Relations
WE Communications for Microsoft
+1-425-638-7777
rrt@we-worldwide.com

 

Go to Original Article
Author: Microsoft News Center

Quest targets managed services market with new partner offering

Spencer Smith and John Moore

Quest Software launched an MSP arm of its Partner Circle program as it looks to gain share in the managed services market.

The new Quest MSP program offers tiered benefits and support for MSPs in the data protection and recovery space. Quest currently has about 400 active MSP partners in North America and is looking to grow MSP revenue upward of 30% in 2019, according to the company.

While Quest has targeted the managed services market for a number of years, the company hadn’t established a formal program until now, said John O’Boyle, director of marketing and channels of Quest’s data protection business, in an interview.

O’Boyle cited the exponential growth of customer data as a major area that Quest’s MSP partners can capitalize on. “Data growth, controlling data growth and managing data growth is [a] big opportunity that we see for MSPs,” he said.

Quest tailored the program to the managed services business model in a number of ways, such as by offering options for subscription-based licensing and a pay-as-you-grow model, O’Boyle noted. Under the program, Quest will also provide several products that MSPs can use both internally and to develop services around for their customers.

John O'Boyle, director of marketing and channels at Quest SoftwareJohn O’Boyle

For backup and recovery products, Quest MSPs can tap Rapid Recovery and NetVault Backup software, O’Boyle said. MSPs can also craft offerings around Qorestor data deduplication and replication software and Foglight for Virtualization, a virtualization monitoring and management tool, he said.

He added that Quest differentiates itself from other data protection vendors in the managed services market by tightly integrating its products. The product integrations, he said, let MSPs create services that go beyond traditional backup and recovery.

“The way we have integrated these products together enables … our partners to provide … holistic data management,” he said.

Konica Minolta updates partner strategy

Konica Minolta Business Solutions recently revealed a shift in its channel strategy at its 2019 U.S. dealer conference.

In the year ahead, Konica Minolta will focus on enabling its dealer partners to offer managed IT, voice and print services, said Dino Pagliarello, vice president of product management and planning. He said the company will also look for partners to provide its Workplace Hub offering for small and medium-sized businesses. Workplace Hub combines a multifunctional printer, data storage, cybersecurity, an HP Enterprise server and Wi-Fi access points into a single offering.

“A big part of the push this year is finding the dealers that are ready for the Workplace Hub. It’s the early adopters of that strategy, that subset of dealers that are ready to take this forward,” Pagliarello said in an email.

Pagliarello noted that Konica Minolta can help its partner dealers update their enterprise resource planning (ERP) systems to handle recurring software billing and invoicing, as well as software and service bundles. In 2018, the company gained ERP capabilities through its acquisition of MWA Intelligence, an ERP platform provider in the office equipment space. MWA joined Konica Minolta’s IT services division, All Covered.

Partners can expect Konica Minolta to introduce several partner resources this year, Pagliarello added. Resources will include All Covered engagement support, as well as marketing, brand development and sales training.

Asked to point to top market opportunities for partners, Pagliarello cited the digital office and industrial print spaces. Those market segments, he said, are “new and exciting areas of expansion for [dealers] today and focuses for Konica Minolta.”

Other news

  • HYCU Inc., a data backup, recovery and monitoring software company in Boston, has inked a distribution pact with Arrow Electronics. The deal will let Arrow’s enterprise computing solutions business distribute HYCU Data Protection for Nutanix backup and recovery software to channel companies in Western Europe. HYCU in October 2018 launched a channel program to reward partners that sell the company’s software for Nutanix environments.
  • In other Arrow news, the company has launched ArrowPlus powered by Freelancer.com, a marketplace that lets companies access electronic and electrical engineers.
  • IT Glue, an IT documentation vendor acquired by IT management vendor Kaseya, released new professional services automation (PSA) integrations. IT Glue said its users can now use ticketing functions within ConnectWise and Autotask’s PSA platforms.
  • Security vendor Barracuda Networks reported it has expanded its presence in the managed services market. The vendor said its MSP customer base grew by about 280% in the previous two years. Additionally, the number of MSPs using multiple Barracuda products has increased 34% year over year as of February 2019, the vendor said. Barracuda last month purchased Avast’s Managed Workspace remote monitoring and management software, further building out its MSP software portfolio.
  • EfficientIP, a network security and automation vendor based in West Chester, Pa., bolstered its Smart Partner Program and named a new channel chief. The program now offers a streamlined onboarding process and upgraded support, the vendor said. EfficientIP’s regional strategy in North America will be overseen by John Ricciardi, who was appointed the vendor’s new channel development director this week. Prior to EfficientIP, Ricciardi served in business development and global partner management roles at Nokia.
  • Managed services automation company BitTitan updated its cloud-based MigrationWiz tool with new coexistence features for Office 365 tenant migrations. BitTitan’s coexistence features are included for free in its User Migration Bundle, the company said.
  • Cloud infrastructure provider DigitalOcean last week unveiled an online marketplace for developers to buy partner-built products. DigitalOcean Marketplace will offer partners’ services, components and tools for modern application development, the company said.
  • Skuid, an application development platform provider, has partnered with Carahsoft Technology Corp. Under the partnership, Carahsoft will offer Skuid products in the public sector through its various government contracts, according to Skuid.
  • Data platform vendor MapR Technologies added T-Systems to its roster of global solutions partners. T-Systems is a digital services provider headquartered in Frankfurt, Germany.
  • Logicalis, an IT solutions and managed services provider, has promoted Mike Houghton to president of Logicalis U.S., which is based in New York.
  • Vectra, a network cyberattack detection and response company in San Jose, Calif., appointed Didi Dayton as vice president of worldwide channels and alliances.

Market Share is a news roundup published every Friday.

Go to Original Article
Author:

Wanted – HP Microserver Gen 8

Discussion in ‘Desktop Computer Classifieds‘ started by DarkBlade, Mar 5, 2019.

  1. DarkBlade

    DarkBlade

    Active Member

    Joined:
    Mar 26, 2007
    Messages:
    576
    Products Owned:
    0
    Products Wanted:
    0
    Trophy Points:
    28
    Ratings:
    +51

    Hi all,

    Looking to pick up a HP Microserver Gen 8. Ideally with 16GB RAM and an E3-1265Lv2 CPU, but a base unit will be fine.
    No storage disks required, may be interested in SSD drive for OS.

    Anyone have one they are thinking of moving on?

    Location: Andover

    ______________________________________________________
    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.

Share This Page

Loading…

Go to Original Article
Author: