@AndreasLahmeWD @ErnstvAll weil es andere Gründe gibt. U.a. der nun beschleunigte Ausbau von WKA‘s, der gegen den #Artenschutz und die #Biodiversität umgesetzt werden kann (#WindBG).

Bitte Unterschreiben und weiter verteilen:
Hier geht es zur aktuellen Petition wg. Robert Habeck‘s #Notverordnung durch das #WindBG. „Stoppen des Gesetzes zur Erhöhung und Beschleunigung des #Ausbaus von #WKA's an Land.“
Das Gesetz mit der #Ermächtigung für das @BMWK umgeht den #Artenschutz und die #Biodiversität.
Hier die Petition:

https://www.change.org/WKA_Notverordnung_Stoppen

#windbg displays PIDs in **hexadecimal**?? What??

RT @TMueller_Wue@twitter.com

Am Mittwoch treten das neue #Windenergieflächenbedarfsgesetz (#WindBG) und die Änderungen im Baugesetzbuch (BauGB) zur #Flächenausweisung für die #Windenergie in Kraft. Ein wichtiger Schritt für mehr Windenergie, aber mit Defiziten beim Tempo – eine Einordnung mit Ausblick 1/n

🐦🔗: https://twitter.com/TMueller_Wue/status/1619975368877961216

Gute Zusammenfassung zu Fortschritt und Handlungsbedarfen bei der Windenergie an Land.

RT @TMueller_Wue@twitter.com

Am Mittwoch treten das neue #Windenergieflächenbedarfsgesetz (#WindBG) und die Änderungen im Baugesetzbuch (BauGB) zur #Flächenausweisung für die #Windenergie in Kraft. Ein wichtiger Schritt für mehr Windenergie, aber mit Defiziten beim Tempo – eine Einordnung mit Ausblick 1/n

🐦🔗: https://twitter.com/TMueller_Wue/status/1619975368877961216

7/

I generally build one of these #windbg scripts for every library I work with. My debugger instance often has 20+ of these loaded. It's such a massive productivity boost for me.

You can even go so far as to set up means by which certain scripts can automatically load when they detect certain modules loaded (e.g.: load this script if you see dwarf.dll in the module list).

Play with it... I guarantee it'll make you more productive too :)

6/

But the real magic happens with that "getPreferredRuntimeTypedObject" method.

When #windbg displays something (or binds a name in 'dx'), it tries to find the "runtime type" of an object (usually via v-tables or RTTI).

Scripts, however, can hook into this with a "getPreferredRuntimeTypedObject" method.

Here, this method literally just says "the runtime type of any Dwarf_Die_s" is the type "Dwarf_Die_s" **WITHIN** dwarf.dll.

Now, I get a *LOT* better experience in locals/watch magically!

5/

So instead I have a #windbg #JavaScript script that I've written specifically for helping me with libdwarf. I can add things to it as I'm going along live in the script editing window of WinDbg preview.

Let's take a look at one small piece of this:

A few things are familiar from the #AdventOfCode examples:

1) I associate this class with Dwarf_Die_s (typeSignatureExtension)

2) I add some properties (die_offset and tag). The implementations of those aren't important right now...

2/

#windbg uses a lot of libraries. Some are internal. Some are #oss.

To demonstrate this in a way you can follow, I'll talk about one of the OSS ones (so you can go build from source if you so desire).

For parsing DWARF information, we (currently) use libdwarf:

https://www.prevanders.net/dwarf.html

Since I'm often looking at Linux/Mac/etc... and the debugger, I often need to debug the debugger (including understanding what's going on in those libraries). Let's take an example...

1/

The last few days, I've been doing a goofy solve #AdventOfCode problems using the #windbg #debugger and it's scripting and expression evaluation capabilities.

Why do I do this...? Because understanding and using some of the concepts used there can make you *massively* more productive with the debugger.

So today, I'm going to take a break and walk through a *CONCRETE* example.

7/

And now, it's a simple matter of projection to the "getPriority" method we just added.

Any method in a #windbg #JavaScript script can just be called via the @$scriptContents alias. It's literally the amalgamation of the namespaces of all executed scripts.

At the end, it's a simple .Sum() and we have the answer!

I'll note that there are *LOTS* of things which can be extended in #windbg with techniques like this:

- Processes
- Threads
- Modules
- Stack Frames
- Target Types
etc...

1/

Continuing on that whole #AdventOfCode using the #windbg #debugger theme: day 3!

If you were following along: day 1 entirely used a #JavaScript script and day 2 entirely used the expression evaluator without any scripting.

Today's answer (day 3) will mix both in some interesting ways!

The first thing to note here is that the scripting in #windbg allows you not only to just call functions but to extend the debugger and its types (internal and target). We'll do both here...

@osandov I've *tried* to pay attention to both -- especially since #windbg started supporting post-mortem #linux debugging (including kernel cores).

It's certainly super interesting to see other perspectives and tools in that space.

7/

So let's use this and get our answer to #AdventOfCode day 2 solely from the #windbg 'dx' EE:

Each array index of the @$guide variable is a "round" so we'll project that using .Select to the @$scoreGame method we created earlier...

Once we have the results from each individual round, we can simply .Sum() them to get the final answer.

And there it is: entirely from the expression evaluator with no "scripting" involved!

6/

Now, how can we use all of this to actually run the data we've created through all these little convenience methods...? Don't we need some scripting or something...!?

Nope. #windbg supports a very C# like LINQ paradigm:

https://learn.microsoft.com/en-us/windows-hardware/drivers/debugger/using-linq-with-the-debugger-objects

4/

The second thing to know here is that, in addition to variables, the #windbg 'dx' EE allows you to define first class functions (lambda expressions with capture) with a very C# like syntax.

So here, we'll define two methods. One that plays a round based on the ABC / XYZ characters in the game and one that subsequently scores that game's outcome based on the -1 (loss), 0 (tie), 1 (win) result:

2/

So that this makes sense, let's make one quick observation about the AoC #2 rock-paper-scissors game.

If you assign a value to each play (rock = 0, paper = 1, scissors = 2), simply doing "my play" minus "my opponent's play" turns the round into a simple lookup.

The other important thing to know here is that the 'dx' EE in #windbg allows you to create and use variables by prefixing @$ to a name.

Let's play...

1/

If you were following yesterday, I decided to play a goofy game of #AdventOfCode using the #windbg #debugger as the means of solving the problems.

Yesterday's answer to #1 used the built-in #JavaScript scripting to solve that problem. You might say that's "cheating" since I was really just writing a solution in JS.

So today -- I'm going to do something completely different! Day #2 of AoC using only the expression evaluator of the debugger:

https://learn.microsoft.com/en-us/windows-hardware/drivers/debugger/dx--display-visualizer-variables-

3/

There are two important methods of interest in any #windbg #JavaScript script:

initializeScript() - Called to initialize the script. Must return an array of objects describing how the script is bridged to the data model.

invokeScript() -- Called when you click the "Execute" button on the scripting tab of the ribbon in WinDbg Preview (or do a .scriptrun from console).

'host.namespace' is also an important concept that gives access to the root namespace of the #debugger (what 'dx' shows)

2/

First off, a basic introduction to debugger scripting. Yes, #windbg introduced #JavaScript as it's official means of scripting years back:

https://learn.microsoft.com/en-us/windows-hardware/drivers/debugger/javascript-debugger-scripting