Nach langer Pause hier wiedermal ein nützlicher “Powershell-Einzeiler”

Habe einen neuen Laptop bekommen, diesen natürlich neu aufgesetzt, und jetzt benötige ich eine Liste der Programm vom alten Laptop, um diese durchzusehen, zu filtern, und dann natürlich einige der Programme auch am neuen Laptop wieder zu installieren.

Screenshots aus der Systemsteuerung “Programme und Funktionen” sind etwas mühsam, und auch einem Geek nicht würdig

Daher mal schnell ein Powershell Script gebaut, wie es sich gehört, natürlich als Einzeiler:

1 get-wmiobject -class "Win32_Product" -namespace "root\CIMV2" -computername "." | format-list Vendor, Name, Caption, Description, Version, InstallDate, HelpLink

Ergebnis:

Oder, falls wir die Liste in Excel noch bearbeiten oder filtern möchten, senden wir das ganze gleich direkt in ein CSV File:

1 get-wmiobject -class "Win32_Product" -namespace "root\CIMV2" -computername "." | select-object Vendor, Name, Version, InstallDate, HelpLink | Export-Csv -path c:\installierte_programme.csv -UseCulture

JavaScript and HTML5 benchmarks such as IEFishtank or Androids are nice enough but less significant for daily use. They are definitely interesting for the “web of the future” but currently the Internet isn’t primarily used for complex HTML5 games and virtual aquariums but to pull up normal websites such as Google, Facebook, YouTube, CNN etc.

I wanted to carry out a practical speed test of browsers — specifically the loading time of each individual browser from the startup of the browser (mouse click) until the site is fully loaded and rendered. This test was quite extensive and time-consuming and further below I will explain the methodology used but here are the results: 

The following websites were tested:

• Facebook
• Amazon.de
• Youtube.com
• CNN.com
• NYTimes.com
• Wikipedia.org

Each site was individually loaded with each browser and the time from the first mouse click until the site was fully loaded and displayed was measured.

For each site a rank was awarded—here you see the average of the loading time (in red) and the average rank in blue. One can argue whether Chrome or Firefox are on ranks 3 or 4, depending on whether you consider the average load time or the average rank of the individual tests more significant.
 
Mean rank and mean loading time (smaller is better.)

Conclusion: Internet Explorer 9 RTM isn’t only impressively speedy at HTML5 and JavaScript benchmarks but is also the fastest browser when tested in practical use scenario tests.

Methodology

The basic idea was to call up typical websites with current browsers and measure the total loading time from the first click to the fully loaded and displayed site. 
Originally I wanted to automate the tests and the tool HttpWatch was recommended to me. By further examination I noticed that this tool wasn’t appropriate for this test as it only measured the loading time of the markup and not how long the browser takes to start up, load the markup and render the complete page.

I had to measure the time manually. Naturally I didn’t use a stopwatch since the time differences between measurements were only  hundredths of a second. I wrote a Power Shell script and set it loose against the six websites with the six various browsers. Every seven seconds (15 seconds in the second test run) a website was pulled up with a browser. At the same time Camtasia Studio was used to capture a screen video.

In order to later see the click in the timeline of the video editing program Camtasia Studio, a peep tone was played back immediately before triggering the browser. That way I only had to look in the video for the point where the peep tone is, and measure the time from there to where the page has finished loading and rendering. This is pretty straightforward – but I had to repeat this 48 times, which made the whole thing pretty time consuming.
The process is quite precise – at 15 frames per second the resulting duration is precise to fifteen hundredth of a second, with the Video analyzed frame by frame.

For who wants to bother checking my results, you can find the whole screencast with all measurements on Youtube:

JavaScript und HTML5 Benchmarks wie IEFishtank oder Asteroids sind ja recht nett, aber für den Alltag wenig aussagekräftig. Sie sind sicher interessant für das “Web der Zukunft”, aber momentan wird das Internet nicht primär für aufwändige HTML5 Games und virtuelle Aquarien verwendet, sondern um normale Webseiten aufzurufen wie Google, Facebook, YouTube, CNN etc.

Ich wollte daher einen praxisnahen Browsertest durchführen und konkret die Ladezeit der einzelnen Browser testen, und zwar vom Starten des Browsers (Mausklick) bis die Seite fertig geladen ist. Dieser Test war ziemlich aufwändig und weiter unten werde ich die Methoden näher erläutern, aber hier zunächst die Ergebnisse:

Getestet wurden die Webseiten

• Facebook
• Amazon.de
• Youtube.com
• CNN.com
• NYTimes.com
• Wikipedia.org

Jede Seite wurde in jedem Browser geladen und die Zeit vom Mausklick bis zur fertig geladenen und dargestellten Seite danach gemessen.

Für jede Seite wurde auch ein Rang ermittelt, hier sieht man den Mittelwert der Ladezeit (rot) und den mittleren Rang (blau). So könnte man in der Gesamtwertung darüber diskutieren ob Chrome oder Firefox auf Platz 3 oder 4 liegen, je nachdem ob man die durchschnittliche Ladezeit heranzieht oder den durchschnittlichen Rang bei den einzelnen Tests.

Mittlerer Rang und Mittlere Ladezeit (kleiner ist besser).

Fazit: Internet Explorer 9 RTM kann nicht nur bei HTML5 und JavaScript Benchmarks mit seiner Geschwindigkeit überzeugen, sondern auch im Praxistest ist er der schnellste Browser.

Methodik

Die Grundidee war, typische Webseiten mit allen aktuellen Browsern aufzurufen und die gesamte Ladezeit zu messen, vom Klick bis zur fertig dargestellten Seite.
Ursprünglich wollte ich die Testreihe möglichst automatisieren und mir wurde dafür ein Tool namens HttpWatch empfohlen. Bei genauerer Betrachtung war dieses Tool aber ungeeignet, da es nur die Ladezeit des Markups misst, und nicht wie lange der Browser zum starten braucht und wie lange er zum Rendern der Seite braucht.
Ich musste also die Zeiten händisch messen. Natürlich würde das mit einer Stoppuhr nicht funktionieren, da die Unterschiede im Hundertstelbereich liegen. Ich erstellte daher ein Power Shell Skript um die  6 verschiedenen Browser auf 6 verschiedene Webseiten loszulassen. Alle 8 Sekunden (im zweiten Test 15 Sekunden) wurde ein Browser mit einer Webseite aufgerufen, gleichzeitig wurde das ganze mit Camtasia Studio als Screen-Video aufgezeichnet.
Um den Klick in der Timeline des Schnittprogramms Camtasia Studio später auch visuell erkennen zu können, wurde unmittelbar vor dem Aufruf des Browsers ein Biep-Ton ausgelöst. So musste ich nachher nur im Video die Stelle mit dem Biep suchen und die Zeit von dort bis zu dem Punkt wo die Seite fertig geladen wurde messen. Dies ist eigentlich recht einfach – das ganze musste ich aber 48 mal wiederholen, was die Sache etwas zeitaufwändig machte.
Der Prozess ist ziemlich genau – bei 15 Frames pro Sekunde sind die Ergebnisse dementsprechend auf fünfzehn Hundertstelsekunden genau, wenn man das Video framegenau auswertet.

Wer sich gerne die Mühe machen will, in meinem Video die Zeiten nachzumessen, der findet hier den gesamten Screencast mit allen Messungen auf Youtube:

Die Detailergebnisse meiner Messungen:

Insgesamt hatte ich zwei Testläufe, da ich im ersten Testlauf das Testfenster mit 7 Sekunden zu knapp bemessen hatte, und vor allem für die Seiten, die besonders lange zum Laden brauchten, (wie New York Times und CNN) einen zweiten Messwert haben wollte, außerdem ergänzte ich im zweiten Testlauf noch Wikipedia – die Seite im Test die übrigens am schnellsten geladen wurde.

Internet Explorer 9 konnte im Test Wikipedia in nur 13 Hundertstelsekunden laden!

Wer das ganze gerne selber ausprobieren möchte, muss sich alle genannten Browser installieren und folgendes Power Shell Skript ausführen:

Ich bin mir bewusst, dass man für aussagekräftigere Ergebnisse mehrere Durchläufe machen müsste, und vielleicht noch ein paar Webseiten mehr in den Test einbeziehen sollte, aber da die Messungen ja manuell erfolgen, habe ich dafür die Zeit nicht. Aber irgendwie denke ich, dass das das Ergebnis nicht stark verändern würde

Vor zwei Jahren habe ich ein WSH Skript vorgestellt, mit dem man die Priorität von Prozessen verändert.

Das Skript hat selbst in seiner Kurzform 18 Zeilen, wobei man es sicher noch kürzen könnte.

War ich früher ein großer Fan von WSH gilt meine Vorliebe heute Powershell und den wunderbaren Powershell Einzeilern die so manchem Admin das Leben erleichtern.

So läßt sich das ganze Skript in Powershell in einer Zeile zusammenfassen:

gps <ProcessName>| % { $_.PriorityClass = "High" }

Dabei ist gps die Kurzform von get-process und % die Kurzform von foreach.

Also man könnte es auch so schreiben:

Get-Process <ProcessName>| foreach { $_.PriorityClass = "High" }

Am Beispiel von Internet Explorer würde das also so aussehen:

gps iexplore | % { $_.PriorityClass = "High" }

Falls man sich die Prozess Priority Klassen nicht merken kann, einfach einen ungültigen Parameter angeben, und Powershell liefert in der Fehlermeldung die Liste der richtigen Parameter:

Mögliche Enumerationswerte sind "Normal, Idle, High, RealTime, BelowNormal, AboveNormal"

GetProductKey.ps1

$map="BCDFGHJKMPQRTVWXY2346789"
$value = (get-itemproperty "HKLM:\\SOFTWARE\Microsoft\Windows NT\CurrentVersion").digitalproductid[0x34..0x42] 
$ProductKey = "" 
for ($i = 24; $i -ge 0; $i--) {
  $r = 0
  for ($j = 14; $j -ge 0; $j--) {
    $r = ($r * 256) -bxor $value[$j]
    $value[$j] = [math]::Floor([double]($r/24))
    $r = $r % 24
  }
  $ProductKey = $map[$r] + $ProductKey
  if (($i % 5) -eq 0 -and $i -ne 0) {
    $ProductKey = "-" + $ProductKey
  }
}
echo "Product Key:" $ProductKey

get-wmiobject win32_winsat | select *score

This script requires PowerShell v2 in it’s final version (as included in Windows 7 RTM).

This script will download any Youtube video in it’s best available quality as an MP4 file.

Syntax: GetYouTube Video-ID

Example: GetYouTube irp8CNj9qBI

Of course, one can also send a list of video ids to the script via a prepared text file, like so:

foreach ($video in get-content list.txt) { getyoutube.ps1 $video  } 

Here is the script GetYouTube.ps1:

Import-Module bitstransfer
$ErrorActionPreference = "SilentlyContinue"
$v=$args[0]
#$v="irp8CNj9qBI"
#Grab Youtube Page
$s=(New-Object System.Net.WebClient).DownloadString("http://www.youtube.com/watch?v=" + $v)
#extract token
$t=$s | % {$_.substring($_.IndexOf("`"t`": `"")+6,44)}
#extract title
$r="<title\b[^>]*>YouTube - (.*?)</title>" ; $f = $s | ?{ $_ -match $r } |  %{ $_ -match $r | out-null ; $matches[1] }
#Try downloading 720p version of video
$u = "http://www.youtube.com/get_video?fmt=22&video_id=" + $v + "&t=" + $t
$o = $Env:Userprofile + "\Videos\" + $f + "(HQ).mp4"
Start-BitsTransfer –source $u -destination $o
#Try downloading regular mp4 version of video, if HQ version failed
if (!$?) {
$u = "http://www.youtube.com/get_video?fmt=18&video_id=" + $v + "&t=" + $t
$o = $Env:Userprofile + "\Videos\" + $f + ".mp4"
Start-BitsTransfer –source $u -destination $o
}

get-process
gibt mir eine Liste aller Prozesse

([Object[]](Get-Process)).Count
gibt mir die Anzahl aller Prozesse

Eine Liste aller Fenster – d.h. Prozesse die auch über ein Fenster verfügen bekomme ich so:

get-process | where {$_.mainWindowTitle} | format-table id, name, mainwindowtitle -autosize

Und so bekomme die Anzahl der offenen Fenster:

([Object[]](Get-Process  | where {$_.mainWindowTitle})).Count

$a = (Get-TransportConfig).InternalSMTPServers ; $a += "192.168.10.5" ; Set-TransportConfig -InternalSMTPServers $a

Habe mir in Windows Powershell einen netten Einzeiler zurechtgelegt, der mir automatisch alle Dienste startet, die eigentlich automatisch starten sollten, aber (aus welchem Grund auch immer) nicht laufen.
Auf einigen meiner Server kommt es immer mal wieder vor, das Services nicht laufen, die eigentlich laufen sollen. Mit diesem Powershell Skript ist das Problem schnell behoben:

Get-WmiObject Win32_Service | where {$_.StartMode -eq "Auto"} | where {$_.State -eq "Stopped"} | Start-Service