The content below is taken from the original (Software-defined storage hits the bargain rack), to continue reading please visit the site. Remember to respect the Author & Copyright.

Some small and medium-sized businesses need fast, and flexible storage gear as much as large enterprises. The need to quickly spin up new applications, even without a storage specialist on staff, can drive those demands. The gear for doing so is gradually getting more affordable.

On Monday, Hewlett-Packard Enterprise extended two of its storage product lines into more affordable territory, in one case adopting an ARM processor to help cut the cost of a system.

HPE says the new systems give smaller organizations a way in on two of the hottest trends in enterprise storage: software-defined storage and flash. The former helps to line up the right storage for each application, even as a company’s demands quickly change, while the latter can give a speed boost to any type of storage arrangement.

To put storage under software control, HPE launched its StoreVirtual arrays in 2014. There are now in about 200,000 deployments worldwide, the company says. StoreVirtual systems can provide shared storage capacity alongside HPE ProLiant servers and hyperconverged appliances, using the company’s Synergy software.

Up to now, typical StoreVirtual systems have been mult-terabyte systems costing tens of thousands of dollars. On Monday, HPE introduced the StoreVirtual 3200 Storage, with capacities starting at 1.2TB and a street price starting at US$6,055.

Hewlett Packard Enterprise

HPE says the 3200 is a way for SMBs to get a foot in the door with software-defined storage, consolidate workloads and gradually migrate to the new type of infrastructure over time. Beyond that base price and configuration, the new system stays cheaper even in a more typical arrangement like a two-node system with 14TB of capacity, HPE says. That system would be less than half the cost of the current StoreVirtual 4000 model with a similar configuration, the company says.

Part of the reason is that the processor at the heart of the 3200 uses an ARM microarchitecture rather than the x86 technology used in most other enterprise data-center gear. The ARM chip, which comes from AppliedMicro, delivered the computing power the company needed at a lower price than an x86 processor, said Brad Parks, HPE’s director of go-to-market strategy for storage. It might be the first of many used in HPE storage gear, though the company is only beginning to explore this approach, he said.

Hewlett Packard Enterprise

Also on Monday, HPE introduced the MSA 2042, a new member of its MSA line of arrays that includes 800GB of SSD (solid-state drive) capacity and flash storage software as standard features. The flash can be used as a read cache accelerator or as a read and write performance tier, with automatic tiering software included. That hardware and software has been optional on MSA systems, but at an additional cost of about $7,500, Parks said. In the 2042, which is priced starting at $9,877, they are included at no extra cost.

Both the StoreVirtual 3200 and the MSA 2042 are available immediately worldwide.

The content below is taken from the original (NVIDIA brings desktop-class graphics to laptops), to continue reading please visit the site. Remember to respect the Author & Copyright.

With the GeForce GTX 1080, NVIDIA pushed the boundaries of what a $600 graphics card can do. That flagship card was joined by the GTX 1070 and GTX 1060, two lower-power cards based on the same 16nm Pascal architecture at a much more affordable price. Now, it’s bringing mobile versions of those cards that match their desktop counterparts in almost every area — including being VR ready.

That’s not hyperbole. The top-of-the-line 1080M has 2,560 CUDA cores and 8GB of 10Gbps GDDR5x memory. The desktop chip has the same. The only difference is clock speed: it’s set at 1,556MHz, while the desktop version is 1,607MHz. The two do share the same boost clock (1,733MHz) though, and both have access to all the new technology introduced for the Pascal architecture. That means simultaneous multi-projection, VRWorks, Ansel and the rest.

If you want an idea what those specs translate to in real-world performance, how’s this: when paired with an i7-6700HQ (a quad-core 2.6GHz chip with 3.5GHz turbo), Mirror’s Edge Catalyst, 126; Overwatch, 147; Doom, 145; Metro Last Light, 130; Rise of the Tomb Raider, 125. Those are the 1080M’s FPS figures when playing at 1080p with "ultra" settings at 120Hz. NVIDIA is really pushing 120Hz gaming, and many of the first crop of Pascal laptops will have 120Hz G-Sync displays.

4K gaming, too, is more than possible. At 4K with "high" settings the same setup can push 89FPS on Overwatch, 70FPS with Doom, and 62FPS with Metro Last Light (according to NVIDIA). Only Mirror’s Edge Catalyst and Rise of the Tomb Raider fall short of 60FPS, both clocking in at a very playable 52FPS. At the chip’s UK unveil, NVIDIA showed the new Gears of War playing in 4K in real-time, and there were absolutely no visible frame drops. With figures like that, it goes without saying that VR will be no problem for the 1080M. The desktop GTX 980 is the benchmark for both the HTC Vive and Oculus Rift, and the 1080M blows it away. If you’re looking for more performance, the 1080M supports overclocking of course — NVIDIA suggests as high as 300MHz — and you can expect laptops sporting two in an SLI configuration soon.

The major drawback for the 1080M is power. We don’t know its exact TDP yet, but given the near-identical desktop version runs at 180W, you’d imagine it’s got to be at least 150W. NVIDIA has tech that counters that heavy power load when you’re not plugged in, of course. Chief among these is BatteryBoost, which allows you to set a framerate (i.e. 30FPS), and downclocks the GPU appropriately to save power — if your card is capable of pushing 147FPS plugged in, that’s going to be a fair amount of power saved. Whatever the battery savings possible, though, it won’t change the fact that the 1080M is only going to slide into big laptops.

That’s fine for those already used to carrying around behemoths on the go, but plenty of gamers prefer something more portable. Enter the 1070M. NVIDIA says this chip will fit into any chassis that currently handles the 980M, which covers a lot of laptops.

Just like the 1080M, the 1070M matches its desktop sibling in many ways. You’ve actually got slightly more in the way of CUDA cores — 2,048 vs. the desktop’s 1,920, but again they’re clocked slower (1,442MHz vs. 1,506MHz). Memory is the same — 8GB 8Gbps GDDR5 — and it too benefits from both the Pascal architecture itself and the new software features that come with it.

When faced off against the desktop 1070, the 1070M holds its own. In nearly every test we saw, it got within a couple of percentiles of the desktop card. We’re talking 77FPS in The Witcher 3 (1080p maxed settings, no HairWorks) vs. 79.7FPS on the 1070; 76.2FPS in The Division (1080p ultra) vs. 76.6FPS; and 64.4FPS in Crysis 3 (1080p very high) vs. 66.4FPS. The one outlier was Grand Theft Auto V, which dropped down to 65.3FPS vs. 73.7FPS on the desktop 1070. 4K gaming is a stretch on the desktop 1070, and that carries over here, but this card is more-than VR ready. NVIDIA says that it’ll support factory overclocking on the 1070M soon, so you may see laptops offering a little more grunt "in a couple of months."

Rounding off the lineup is the 1060M, the mobile version of NVIDIA’s $249 "budget" VR-ready card. It’s something of the exception to the rule here. Yes, it offers 1,280 CUDA cores and 6GB 8Gbps GDDR5 memory, which is equal to the desktop 1060. But at the lower end of the range the fact that they’re clocked lower (1,404MHz vs. 1,506MHz) hurts performance quite a bit more. In side-by-side comparisons, NVIDIA’s benchmarks suggest you’ll get within ten percent or so of the desktop card. That’s not to say that the 1060M is a slouch. For traditional gaming, you’re not going to hit 60FPS at 1080P in every game without thinking about settings, but if you can play it on a desktop GTX 980, it’s probably a safe bet that the 1060M can handle it. That’s insanely impressive when you consider that the 1060M will fit into the same chassis as the 970M — think "ultra portable" gaming laptops.

In reality, the 10-percent gap between the 1060 and the 1060M probably makes it slightly slower than the GTX 980, but the difference is almost negligible. I wasn’t able to push the 1060M too hard on the "VR ready" promise — you can read about the demo and why the 1060M matters in a separate article — but the demo I had was solid. And really, being able to plug an Oculus into something as slim as a Razer Blade was unthinkable a few months ago, so it’s probably best not to complain.

Acer, Alienware, Asus, Clevo, EVGA, HP, Gigabyte, Lenovo, MSI, Origin, Razer, Sager and XMG are just some of the OEMs signed up to make laptops with the new Pascal chips. Many will announce updated and all-new models today, while some might hold off a while. But expect lots of super-powerful, VR-ready gaming laptops very soon.

The content below is taken from the original (How to link Windows 10 license to Microsoft Account), to continue reading please visit the site. Remember to respect the Author & Copyright.

The content below is taken from the original (Testing PowerShell with Pester), to continue reading please visit the site. Remember to respect the Author & Copyright.

If you are an experienced PowerShell user, chances are you have heard of Pester. This is an open source project that Microsoft started shipping as part of Windows 10. I’m not going to try and teach Pester here, although it really isn’t that difficult to pick up. But I wanted to show you some ways to use Pester that you might not have considered.

Pester is typically designed for software testing. You build a test script to run through different parts of your code and Pester validates it. This is a quick way to verify you haven’t broken something while introducing something new.

A traditional Pester test (Image Credit: Jeff Hicks)

But there’s no reason we can’t use the Pester logic to test other things. Perhaps that status of a critical server. The centerpiece of Pester is a logical test of “If some condition meets some test it should be some value”. It’s not that difficult to write a test that says “the DNS service should be running.” Here’s a simple Pester test to validate the state of my primary Hyper-V server.

#requires -version 5.0

$computername = "CHI-P50"

Describe $Computername {

It "should have Hyper-V Feature installed" {
    Get-windowsFeature -Name Hyper-V -ComputerName $Computername | Should Be $True
}

It "Hyper-V service should be running" {
    $s = Get-Service -Name vmms -ComputerName $computername
    $s.status | Should Be "running"
}

It "DNS service should be running" {
    $s = Get-Service -Name dns -ComputerName $computername
    $s.status | Should Be "running"
}

It "Should have 25% free space on drive C:" {
    $c = Get-CimInstance -ClassName Win32_LogicalDisk -Filter "deviceid = 'c:'" -ComputerName $computername
    ($c.FreeSpace/$c.size)*100 | Should BeGreaterThan 25
}

It "Should have 10% free space on drive E:" {
    $e = Get-CimInstance -ClassName Win32_LogicalDisk -Filter "deviceid = 'e:'" -ComputerName $computername
    ($e.FreeSpace/$e.size)*100 | Should BeGreaterThan 10
}

}

I could run this as a regular PowerShell script. But I prefer to use the Invoke-Pester cmdlet.

Invoking a Pester test script (Image Credit: Jeff Hicks)

By using Invoke-Pester I can pass the results to the pipeline, output the results to XML and even specify what tests to run if I’ve named any of my tests. The benefit of using Pester is that you can automate the process running the test and taking action should there be any failures.

To test this, I’ll modify one of my tests so that it will result in a failure.

A Pester test failure (Image Credit: Jeff Hicks)

The failure is pretty easy to pick out. I also used the -Passthru parameter so you can see what kind of output to expect. I can then automate code like this which will email me failures.

Invoke-Pester c:\scripts\pester-chi-p50.ps1 -PassThru | 
Select -ExpandProperty TestResult | Where {-not $_.passed} |
foreach {
    Send-MailMessage -Subject "$($_.Describe) Test Failure" -body ($_ | Out-String)
}

Failure email notice (Image Credit: Jeff Hicks)

I think that’s pretty slick. But it gets even better.

Since we’re talking PowerShell, you can use it to dynamically build your Pester tests. Here’s a test file that dynamically generates the same tests but with different expectations per server.

#use pester to validate servers or other infrastructure

<#
 Read in data to test per server. Could be read from an XML file

 Invoke-Pester <this file>
#>

$all = [pscustomobject]@{
Computername = "CHI-P50"
Services = @{Running = "vmms","vmcompute"},@{Stopped= "RemoteRegistry","Spooler"}
Features = @{Installed = "Hyper-V","Containers","Windows-Server-Backup"},@{NotInstalled = "Direct-Play","Internet-Print-Client"}
Versions = @{PowerShell = 5; Windows = 2016}
},
[pscustomobject]@{
Computername = "CHI-DC04"
Services = @{Running ="DNS","ADWS","KDC","NetLogon"},@{Stopped= "RemoteRegistry","Spooler"}
Features = @{Installed = "DNS","AD-Domain-Services","Windows-Server-Backup"},@{NotInstalled = "SMTP-Server","Internet-Print-Client"}
Versions = @{PowerShell = 5; Windows = 2012}
},
[pscustomobject]@{
Computername = "CHI-HVR2"
Services = @{Running ="vmms"},@{Stopped= "RemoteRegistry"}
Features = @{Installed = "Hyper-V","Windows-Server-Backup"},@{NotInstalled = "SMTP-Server","Internet-Print-Client"}
Versions = @{PowerShell = 4; Windows = 2012}
}

foreach ($item in $all) {

    Describe $($item.Computername) -Tags $item.Computername {

        $computername = $($item.Computername)
        $ps = New-PSSession -ComputerName $computername
        $cs = New-CimSession -ComputerName $computername
    
        It "Should be pingable" {
            Test-Connection -ComputerName $computername -Count 2 -Quiet | Should Be $True
        }

        It "Should respond to Test-WSMan" {
            {Test-WSMan -ComputerName $computername -ErrorAction Stop} | Should Not Throw
        }

    Context Features {

    $installed = Get-WindowsFeature -ComputerName $computername | Where Installed
    $Features = $($item.Features.Installed)  
    foreach ($feature in $features) {

       It "Should have $feature installed" {
            $installed.Name -contains $feature | Should Be $True
        }
    
    }

    $NotFeatures = $($item.features.notinstalled)
            foreach ($feature in $Notfeatures) {

               It "Should NOT have $feature installed"  {
                   $installed.Name -contains $feature | Should Be $False
                }
    
             }
    } #features

    Context Services  {

    $Stopped = $($item.services.Stopped)
    $Running = $($item.services.Running)

    $all = Invoke-Command { Get-Service } -session $ps
    foreach ($item in $Stopped) {
  
      It "Service $item should be stopped" {
        $all.where({$_.name -eq $item}).status | Should Be "Stopped"
      }

    }

    foreach ($item in $Running) {
  
      It "Service $item should be running" {
        $all.where({$_.name -eq $item}).status | Should Be "Running"
      }

    }

    } #services

    Context Versions {
        $winVer = $($item.versions.Windows)
        It "Should be running Windows Server $winVer" {
            (Get-CimInstance win32_operatingsystem -cimSession $cs).Caption | Should BeLike "*$winver*"
        }

        $psver = $($item.versions.powershell)
        It "Should be running PowerShell version $psver" {
            Invoke-Command { $PSVersionTable.psversion.major } -session $ps | Should be $psver
        }
    } #versions

    Context Other {
        It "Security event log should be at least 16MB in size" {
            ($cs | Get-CimInstance -ClassName win32_NTEVentlogFile -filter "LogFileName = 'Security'").FileSize | Should beGreaterThan 16MB
        }
        
        It "Should have C:\Temp folder" {
            Invoke-Command {Test-Path C:\Temp} -session $ps | Should Be $True
        }    
    } #other

    $ps | Remove-PSSession
    $cs | Remove-CimSession

    } #describe

} #foreach

I’ve hard coded the input values, but you could just as easily input them from an external source such as XML.

Testing server infrastructure with Pester (Image Credit: Jeff Hicks)

And, of course, I could build a response script to take remedial action for failures. Depending on what you are testing, if you configured the server with DSC, you have similar testing options. Although with Pester I can test for more intangible items like free disk space or free memory.

Or, here’s a simple Pester file for testing Active Directory and my domain controllers.

#requires -version 5.0
#requires -Module ActiveDirectory, DNSClient


<#

Use Pester to test Active Directory

Last updated: July 5, 2016

#>


$myDomain = Get-ADDomain
$DomainControllers = $myDomain.ReplicaDirectoryServers
$GlobalCatalogServers = (Get-ADForest).GlobalCatalogs

Write-Host "Testing Domain $($myDomain.Name)" -ForegroundColor Cyan
Foreach ($DC in $DomainControllers) {

    Describe $DC {

        Context Network {
            It "Should respond to a ping" {
                Test-Connection -ComputerName $DC -Count 2 -Quiet | Should Be $True
            }

            #ports
            $ports = 53,389,445,5985,9389
            foreach ($port in $ports) {
                It "Port $port should be open" {
                #timeout is 2 seconds
                [system.net.sockets.tcpclient]::new().ConnectAsync($DC,$port).Wait(2000) | Should Be $True
                }
            }

            #test for GC if necessary
            if ($GlobalCatalogServers -contains $DC) {
                It "Should be a global catalog server" {
                    [system.net.sockets.tcpclient]::new().ConnectAsync($DC,3268).Wait(2000) | Should Be $True
                }
            }
            
            #DNS name should resolve to same number of domain controllers
            It "should resolve the domain name" {
             (Resolve-DnsName -Name globomantics.local -DnsOnly -NoHostsFile | Measure-Object).Count | Should Be $DomainControllers.count
            }
        } #context
    
        Context Services {
            $services = "ADWS","DNS","Netlogon","KDC"
            foreach ($service in $services) {
                It "$Service service should be running" {
                    (Get-Service -Name $Service -ComputerName $DC).Status | Should Be 'Running'
                }
            }

        } #services

        Context Disk {
            $disk = Get-WmiObject -Class Win32_logicaldisk -filter "DeviceID='c:'" -ComputerName $DC
            It "Should have at least 20% free space on C:" {
                ($disk.freespace/$disk.size)*100 | Should BeGreaterThan 20
            }
            $log = Get-WmiObject -Class win32_nteventlogfile -filter "logfilename = 'security'" -ComputerName $DC
            It "Should have at least 10% free space in Security log" {
                ($log.filesize/$log.maxfilesize)*100 | Should BeLessThan 90
            }
        }
    } #describe

} #foreach

Describe "Active Directory" {

    It "Domain Admins should have 5 members" {
        (Get-ADGroupMember -Identity "Domain Admins" | Measure-Object).Count | Should Be 5
    }
    
    It "Enterprise Admins should have 1 member" {
        (Get-ADGroupMember -Identity "Enterprise Admins" | Measure-Object).Count | Should Be 1
    }

    It "The Administrator account should be enabled" {
        (Get-ADUser -Identity Administrator).Enabled | Should Be $True
    }

    It "The PDC emulator should be $($myDomain.PDCEmulator)" {
      (Get-WMIObject -Class Win32_ComputerSystem -ComputerName $myDomain.PDCEmulator).Roles -contains "Primary_Domain_Controller" | Should Be $True
    }
}

Testing Active Directory with Pester (Image Credit: Jeff Hicks)

As you can see, I have some disk space issues to sort out.

Pester is a skill I think every PowerShell professional needs to begin developing. Start with simple tests for your modules. Once you gain a better understanding of how to construct effective tests, you’ll realize there are many things you can test and your investment in learning PowerShell continues to pay off.

The post Testing PowerShell with Pester appeared first on Petri.

The content below is taken from the original (A computer program that can replicate your handwriting), to continue reading please visit the site. Remember to respect the Author & Copyright.

Handwriting is a skill that feels personal and unique to all of us. Everyone has a slightly different style — a weird quirk or a seemingly illegible scrawl — that’s nearly impossible for a computer to replicate, especially as our own penmanship fluctuates from one line to the next. A team at University College London (UCL) is getting pretty close, however, with a new system it’s calling "My Text in Your Handwriting." A custom algorithm is able to scan what you’ve written on a piece of paper and then reproduce your style, to an impressive degree, using whatever words you wish.

To capture your scrawl, the team will ask you to write on four A4-sized sheets of paper (as little as one paragraph can deliver passable results, however). The text is then scanned and converted into a thin, skeletal line. It’s broken down by a computer and a human moderator, assigning letters and their position within a word. They also look for "splits," where the line changes from a letter into a "ligature," — the extra bits you need for joined-up handwriting. Finally, there are "links" which indicate that two separate marks are part of the same letter, for instance when crossing a "t."

The algorithm then works to replicate your handwriting style by referencing and adapting your previously scanned examples. You will have written the same letter on a number of different occasion, so the computer will look for the one that works best for the word or phrase it’s trying to sketch out. A degree of randomness is then applied to ensure that the same letters and combinations aren’t used more than once (an easy way for humans to figure out if a computer has written something).

Once your written examples or "glyphs" have been selected, the computer will figure out the appropriate spacing in between each letter. The height of each character and where it sits on the line is also taken into consideration. Finally, the "ligatures" are added to the computer-generated piece, along with some basic texturing to mimic the pen and ink you were using.

The results are fairly believable. As an experiment, the team asked a group to decide which envelopes — all seemingly handwritten — were produced by a computer. They chose incorrectly 40 percent of the time.

"Up until now, the only way to produce computer-generated text that resembles a specific person’s handwriting would be to use a relevant font," Dr Oisin Mac Aodha, a member of the UCL team said. "The problem with such fonts is that it is often clear that the text has not been penned by hand, which loses the character and personal touch of a handwritten piece of text. What we’ve developed removes this problem and so could be used in a wide variety of commercial and personal circumstances."

The ability to scan and interpret handwriting isn’t new — plenty of apps let you sketch with a stylus or finger, and then convert this into text. Similarly, it’s possible for software to reproduce digital text in a variety of seemingly human, handwritten styles. But the ability to reproduce your personal penmanship — with words and sentences you might not have shown the computer — is unprecedented. It could be used to help elderly people who are starting to lose their writing ability, or translate handwritten text into new languages while keeping the personality of the author.

If you’re wondering if this sort of technology could be used to forge signatures and documents, the answer is yes, it’s possible. The team at UCL has stressed, however, that their system works both ways, meaning it could be used by law enforcers to spot computer-aided forgeries too. Still, it’s best to be wary the next time someone tries to sell you an autograph.

Via: BBC

Source: UCL, My Text In Your Handwriting (Paper)

The content below is taken from the original (New – AWS Application Load Balancer), to continue reading please visit the site. Remember to respect the Author & Copyright.

The content below is taken from the original (Now Available – IPv6 Support for Amazon S3), to continue reading please visit the site. Remember to respect the Author & Copyright.

http://bit.ly/2bkgphX

http://bit.ly/2aZJIkR

The content below is taken from the original (New – Bring Your Own Keys with AWS Key Management Service), to continue reading please visit the site. Remember to respect the Author & Copyright.

$ openssl rand -out plain_text_aes_key.bin 32
$ openssl rsautl -encrypt -in plain_text_aes_key.bin -oaep \
  -inkey wrappingKey_fcb572d3-6680-449c-91ab-ac3a5c07dc09_0804104355 \
  -pubin -keyform DER -out enc.aes.key

The content below is taken from the original (The 16 most pivotal events in Windows history), to continue reading please visit the site. Remember to respect the Author & Copyright.

The content below is taken from the original (Create a Self-Signed Certificate Using PowerShell), to continue reading please visit the site. Remember to respect the Author & Copyright.

In today’s Ask the Admin, I’ll show you how to quickly create a self-signed certificate.

Self-signed certificates are not recommended for use in production environments, but come in handy for test scenarios where a certificate is a requirement but you don’t have the time or resources to either buy a certificate or deploy your own Public Key Infrastructure (PKI).

Create a self-signed certificate using PowerShell (Image Credit: Russell Smith)

But generating self-signed certificates in Windows has traditionally been a bit of a pain, at least if you didn’t have Visual Studio or IIS on hand, as both these products include the ability to generate self-signed certificates. The makecert command line tool was otherwise the “go to” tool, but was only available as part of the Windows SDK, which is a hefty product to download and install just for the sake of using makecert.

Starting in PowerShell version 4.0, Microsoft introduced the New-SelfSignedCertificate cmdlet, making it much easier to create self-signed certificates. To get started, you’ll need a Windows device running PowerShell 4.0 or higher.

• Open a PowerShell prompt. In Windows 10, type powershell in the search dialog on the taskbar, right-click Windows PowerShell in the list of app results, select Run as administrator from the menu and then enter an administrator username and password. The New-SelfSignedCertificate can only install certificates to the My certificate store, and that requires local administrator rights on the device.
• If you’re running a different version of Windows, check the PowerShell version by running the code shown below.

$PSVersionTable.PSVersion

If you need to update PowerShell to version 5, you can download the Windows Management Framework for Windows 7 and Windows 8.1 here.

• Now run the New-SelfSignedCertificate cmdlet as shown below to add a certificate to the local store on your PC, replacing testcert.petri.com with the fully qualified domain name (FQDN) that you’d like to use.

$cert = New-SelfSignedCertificate -certstorelocation cert:\localmachine\my -dnsname testcert.petri.com

The next step is to export a self-signed certificate. But first we’ll need to create a password as shown below:

$pwd = ConvertTo-SecureString -String ‘passw0rd!’ -Force -AsPlainText

Now we can export a self-signed certificate using the Export-PfxCertificate cmdlet. We’ll use the password ($pwd) created above, and create an additional string ($path), which specifies the path to the certificate created with New-SelfSignedCertificate cmdlet.

$path = 'cert:\localMachine\my\' + $cert.thumbprint Export-PfxCertificate -cert $path -FilePath c:\temp\cert.pfx -Password $pwd

Note that the c:\temp directory, or whatever directory you specify in the -FilePath parameter, must already exist. You can now import the cert.pfx file to install the certificate.

The post Create a Self-Signed Certificate Using PowerShell appeared first on Petri.

The content below is taken from the original (Office 365 training courses to increase your expertise), to continue reading please visit the site. Remember to respect the Author & Copyright.

The content below is taken from the original (Windows Store for Business), to continue reading please visit the site. Remember to respect the Author & Copyright.

Windows Store for Business home page [Credit: Microsoft]

In today’s Ask the Admin, I’ll take a look at Microsoft’s Windows Store for Business, which was launched at the end of 2015.

Windows Store for Business (Image Credit: Russell Smith)

If you’re familiar with the Windows Store, a curated app store for consumers that first appeared in Windows 8, then the Windows Store for Business extends that model for enterprises in the form of a web-based portal and is available in 21 markets. Windows Store for Business can be accessed by anyone who’s signed up for the service, but businesses can also use it to create their own private portals for distributing purchased apps or apps developed in-house.

The Windows Store for Business makes managing volume licensing easier too, giving organizations control over purchasing administration and licensing through integration with Azure Active Directory (AAD). Instead of requiring a Microsoft ID, Windows Store for Business allows apps to be purchased under an organizational identity, and licenses can be revoked and reissued as required. For more information on AAD, see What is Azure Active Directory? on the Petri IT Knowledgebase.

Windows Store for Business basics

To get started with Windows Store for Business, you’ll need an AAD account that has Global Administrator permissions for your tenant, and employees who need access to the store will also need AAD accounts if you don’t have infrastructure in place to distribute offline apps, which requires Microsoft System Center Configuration Manager (SCCM), Intune, or other Mobile Device Management (MDM) compatible service.

Licensing apps in the Windows Store for Business (Image Credit: Microsoft)

Apps can be assigned to an organization’s private store, from which users can download apps manually, or apps can be assigned directly to users or teams. Only AAD Global and Billing Administrators can purchase and distribute apps. It’s worth noting that disconnected (offline) licensing, where apps can be distributed using SCCM or other solution, is only available for purchased apps if the developer has enabled Disconnected (offline) licensing.

Custom Line-of-Business apps

If you have custom line-of-business (LOB) apps to distribute, they can be added to your organization’s private portal in Windows Store for Business using the Windows Dev Center, and then distributed using MDM, SCCM or Intune. To publish LOB apps, you’ll need a developer account in the Windows Dev Center.

Private portal in the Windows Store for Business (Image Credit: Microsoft)

Although Windows Store for Business is only a version 1 product at this point, it’s a welcome development for organizations wanting to purchase or distribute their own Universal Windows Platform (UWP) apps or purchase in volume from the store. With the ability to package Win32 desktop apps so that they can be distributed via Windows Store in a UWP wrapper in the Anniversary Update for Windows 10, the Windows Store for Business will become even more useful for enterprises that want to manage app distribution.

The post Windows Store for Business appeared first on Petri.

The content below is taken from the original (Cognitive computing: IBM uses phase-change material to model your brain’s neurons), to continue reading please visit the site. Remember to respect the Author & Copyright.

IBM scientists claimed – for the first time – to have created artificial spiking neurons using a phase-change material, opening up the possibilities of building a neural network that could be used for AI.

The brain is the biggest inspiration for researchers working in cognitive computing: the exact mechanisms that describe how a brain learns remains a mystery, but the whitecoats know it operates much better than any computer.

To capture the essence of intelligence, researchers turned to mimicking the brain. IBM has built artificial neurons that can fire and carry an electric pulse, recreating the biological processes happening in grey matter.

Biology versus technology

In biological neurons, two thin lipid layers keep any electrical charge within the cell. If an impulse carried along by a dendrite – the long spines of the neuron – is large enough, it can excite the electrical potential in between the lipid layers and the neuron fires a zap of electricity.

Photo credit: Shutterstock

In artificial neurons, however, the lipid layers are replaced with electrodes and another layer of a chalcogenide-based phase-change material sandwiched in between. Input signals pass through the artificial neuron and increased the electric potential of the electrodes. If the voltage pulses are great enough, the electric current passing through will melt the phase-change material, increasing its conductivity.

The electrical current flowing through it increases. Once the conductance reaches a threshold level, the electric pulse becomes large enough to fire and the phase-change device resets. The chalcogenide-based material returns back to its crystalline phase.

The “integrate-and-fire” mechanism is consistent across a range of timescales and frequencies similar to the brain (10⁸ nanoseconds corresponding to a 10Hz update frequency) and beyond.

The ability for the phase-change material to reset means that the artificial neuron can be reused. The switching cycles between a crystalline and amorphous phase can be repeated 10¹² times, corresponding to over 300 years of operation if the artificial neuron was working at a frequency of 100Hz, Big Blue’s paper stated.

Another feature IBM has achieved when imitating biology is the randomness of artificial neurons – a feature known as stochasticity.

The positions of the atoms in the material are never the same after the artificial neuron goes through the integrate-and-fire process. The change in phase alters the thickness of the material after it is fired and reset every time, which means each firing event is slightly different.

This is where neuromorphic computing diverges from conventional computing, Tomas Tuma, lead author of the study and researcher working at IBM’s Zurich Research Laboratory, told The Register.

“Conventional computers are never perfect, but any randomness is suppressed. In neuromorphic computing, however, we don’t mind the randomness. Actually, this random behaviour is parallel to the brain. Not all the neurons in the brain work the same, some are dead or not as effective,” Tuma said.

Stochasticity is actually essential in harnessing the full power of neural networks, Evangelos Eleftheriou, co-author of the study and IBM Fellow at the Zurich Research Laboratory, added.

Machine intelligence

A single neuron is not as effective as a network of neurons for unsupervised learning – a type of machine learning used in AI.

The artificial neuron has the potential to detect correlations in large streams of data that act as the input signal. IBM used 1,000 streams of binary events, where 100 were mutually correlated as the input signal.

Initially, the neuron fired at a high rate as it tried to find the correlations between the signal. But over time, the system evolves and the feedback loop means uncorrelated signals are more likely to be depressed and correlated signals begin to take over.

The strength of correlation between signals results in a growing electric pulse which will eventually lead to a large spike once the 100 correlated signals have been singled out.

Neural networks have a greater ability to make sense of data quickly as they reach higher levels of computing power generated from many neurons. The input signal could be signals fed from other neurons, which would result in a more thorough and quicker search for correlations between data. The output signals that trickled down from the neurons would become increasingly refined as it passed through layers of neurons.

Diagram of how artificial neuron works. Photo credit: Nature Nanotechnology and Tuma et al.

Pattern recognition is the main aim in machine learning, said Professor Leslie Smith, a researcher working in the Cognitive Computation research group at the University of Stirling, who was not involved in IBM’s research.

“You want neurons firing as it means that patterns can be spotted in real time,” Smith told The Register. “For example, you don’t want autonomous vehicles to analyse images one by one. It needs to be looking and analysing data all the time to adapt to its surroundings,” Smith said.

Neuromorphic computing is a relatively new area and is growing in popularity. “It grew in the 1960s with Marvin Minsky and Seymore Papert, then died down in the 1980’s. But it’s coming back into vogue again,” Smith said.

The number of possible applications for neuromorphic computing stretches beyond AI. It could also be used in the Internet of Things craze, sensors that operate on cognitive computing could collect and analyze volumes of weather data collected at the edge for faster forecasts, IBM said.

The need to deal with huge sets of data quickly and at low power is becoming increasingly apparent. “We are in the cognitive era of computing,” Tuma told The Register. “In the future, neuromorphic chips could even be used as co-processors,” he claimed. ®

Sponsored:
Accelerated Computing and the Democratization of Supercomputing

The content below is taken from the original (Build, buy or rent your IoT communications stack?), to continue reading please visit the site. Remember to respect the Author & Copyright.