Beiträge von chesstiger

Hi,

wie hast du Spannung und/oder Strom gemessen? Imho muss nicht unbedingt ein strombegrenzender Defekt vorliegen. Ich habe auch schon defekte Treiber mit Gleichrichtern gehabt, wo eben die Gleichrichtung nicht mehr so ganz hingehauen hat, d.h. Sinusanteile im gerichteten Teil angekommen sind. Da kamen dann verwaschene Rechtecksignale mit 50Hz raus.

Wenn sowas passiert, hast du ggf. einen PWM-Effekt, der bei LEDs wie ein Dimmen für das menschliche Auge wirkt. Je nach Duty Cycle des "PWM"-Signals misst man mit einem herkömmlichen Multimeter genau gar nichts davon, weil die Abtastraten von den Teilen viel zu niedrig sind. Das sieht man dann nur sauber mit einem Oszi.

Nicht dass das jetzt mehr zur Lösung beiträgt, ich hab leider nie erforscht, was genau dann an dem Treiber defekt war.

Hi,

ich hab zwar mit der konkreten Organisation nichts zutun, aber ich kann dir da allgemein helfen.

In größeren Projekten und Communities wird üblicherweise nicht direkt auf dem jeweiligen Upstream-Repository gearbeitet, weil das relativ schwer zu maintainen ist. Man spricht an der Stelle von sogenannten Git Workflows, d.h. die Funktionen von Git werden auf eine bestimmte Weise zur Zusammenarbeit genutzt. Soweit mir bekannt, ist der üblicherweise auf GitHub verwendete Workflow der Fork Workflow. Das heißt:

• Du erstellst einen persönlichen Fork vom Upstream-Repository auf deinem GitHub-Account
• Du erstellst in deinem Fork einen entsprechenden Feature Branch
• Du commitest deine Änderungen auf diesen Branch und pushst die Änderungen auf dein persönliches Repo
• Du erstellst einen Pull Request im Upstream-Repository, der sich auf dein persönliches Repo bezieht
• Ein Maintainer mit entsprechenden Rechten kann diesen Pull Request dann akzeptieren, dann werden die Änderungen in den jeweiligen Branch vom Upstream-Repo eingepflegt (dieser Schritt geht komplett über die GitHub Web-UI)
• (Den letzten Schritt kann man - um die Übersichtlichkeit zu wahren - mit einem Squash kombinieren. Damit kann man all deine Commits auf deinem Fork in einen einzelnen Commit im Upstream-Repo zusammenpressen, was die Commit-History klar und übersichtlich hält.)

Um diesen Workflow zu erzwingen, wird dann üblicherweise der Master-Branch im Upstream-Repository für direkte Schreibänderungen gesperrt (siehe deine Fehlermeldung: "Protected Branch - Changes must be made through a Pull Request".

Huhu,

ich hab mittlerweile mit vier RDBMS recht viel zutun, mit einem eher wenig.

Beruflich gesehen meistens SQLite und T-SQL/MS-SQL, ganz selten mal noch DB2 für Altsysteme.

Privat tatsächlich durch diverse Open Source Projekte MySQL bzw. MariaDB, und für Analysen und Scripte usw. sehr sehr gerne mittlerweile DuckDB (fehlt übrigens oben).

Am "wohlsten" fühle ich mich dabei mittlerweile mit DuckDB, weil es super viele Funktionen über "standard" SQL hinaus hat.

Liebe Grüße!

Die Bonusaufgabe schaue ich mir morgen mal noch an:

Func _IntegerToRoman($num)
	Local Static $4 = ["", "M", "MM", "MMM", "MMMM"]
	Local Static $3 = ["", "C", "CC", "CCC", "CD", "D", "DC", "DCC", "DCCC", "CM"]
	Local Static $2 = ["", "X", "XX", "XXX", "XL", "L", "LX", "LXX", "LXXX", "XC"]
	Local Static $1 = ["", "I", "II", "III", "IV", "V", "VI", "VII", "VIII", "IX"]
	Return 	$4[Int($num / 1000)] & _
			$3[Int(Mod($num, 1000) / 100)] & _
			$2[Int(Mod($num, 100) / 10)] & _
			$1[Mod($num, 10)]
EndFunc

Func _RomanToInteger($roman)
    Local Static $lookup = "M1000D500C100L50X10V5I1"
    Local $value = 0, $last = 0, $num
    For $i = 1 To StringLen($roman)
        $num = Int(StringMid($lookup, StringInStr($lookup, StringMid($roman, $i, 1)) + 1))
        $value += $num - 2 * ($num > $last) * $last
        $last = $num
    Next
    Return $value
EndFunc

Wirklich interessante Ergebnisse!

Wie UEZ schon sagt: Nicht immer liegt in der Kürze die Würze.

Zitat von AspirinJunkie

Eher das Hauptaugenmerk auf die Entlastung des Interpreters legen anstatt Operationen nach teuer und günstig einzuteilen und darauf hin zu optimieren.

Und dieses Zitat trifft den Nagel auf den Kopf. Ich hatte auch über LUT und Caching nachgedacht, fand aber tatsächlich die Kürze und Prägnanz des "reinen" Algorithmus viel zu schick.

Aber an der Hand voll Zeilen, die ich abgegeben habe, habe ich ziemlich viel rumgebastelt - was aber den Interpreter allesamt kaum interessiert hat. Witzigerweise war in meinen Tests die (De-)Normalisierung durch Multiplikation mit bool'schen Ausdrücken einen Tick performanter als die Formulierung mit ternären Operatoren.

Allerdings tu ich mich auch schwer, abzuschätzen, inwieweit da meine Tests repräsentativ sind. Ich habe alles auf einem M2 Mac mit virtualisiertem Windows 11 getestet. Es kann auch gut sein, dass dadurch die einzelnen CPU-Instruktionen andere Zeiten beanspruchen als auf echter x86-Hardware.

Jedenfalls, herzlichen Glückwunsch an die Gewinner! Und nochmal vielen vielen Dank an Schnuffel für's Organisieren!

Gut, wenn's alle machen.

Kanashius Wir hatten dieselbe Basisidee, die Lücke in der Special-Gruppe einfach "rauszunormalisieren".

Func _CypherEnigma($sInput, $nLower, $nUpper, $nSpecial, $nExtra)
	$a = StringToASCIIArray($sInput)
	For $i = 0 To UBound($a) - 1
		If $a[$i] >= 97 And $a[$i] <= 122 Then
			$a[$i] = Mod($a[$i] + $nLower + ($i + 1) * $nExtra - 97, 26) + 97
		ElseIf $a[$i] >= 65 And $a[$i] <= 90 Then
			$a[$i] = Mod($a[$i] + $nUpper + ($i + 1) * $nExtra - 65, 26) + 65
		ElseIf $a[$i] >= 32 And $a[$i] <= 126 Then
			$a[$i] -= (($a[$i] > 64) + (($a[$i] - 26) > 96)) * 26
			$a[$i] = Mod($a[$i] + $nSpecial + ($i + 1) * $nExtra - 32, 43) + 32
			$a[$i] += (($a[$i] > 64) + (($a[$i] + 26) > 96)) * 26
		EndIf
	Next
	Return StringFromASCIIArray($a)
EndFunc   ;==>_CypherEnigma

Hi!

Du bist da schon auf einem guten Weg. Ein paar Gedanken dazu...

• Du musst nicht unbedingt für jeden Datensatz ein extra IniRead verwenden. IniReadSection liest nicht nur die Schlüssel aus, sondern auch die gespeicherten Werte.
• Du greifst in einer Schleife immer wieder schreibend auf ein und dieselbe Variable $data zu (Zeile 8). Dabei überschreibst du bei jedem Durchlauf den letzten Wert, deshalb hast du am Ende auch nur den letzten Datensatz übrig.
• Wenn es deutlich mehr Datensätze als in dem Beispiel werden, ist eine Ini-Datei vermutlich nicht die richtige Wahl. Dann macht es mehr Sinn, mit Datenbanken zu arbeiten.

So könnte man das relativ elegant lösen, allerdings ohne Fehlerbehandlung (also z.B. fehlerhaft formatierte Einträge ignorieren oder so):

#include <MsgBoxConstants.au3>
#include <Array.au3>
$ini = 'shortlist.ini'
$sections = IniReadSectionNames($ini)
For $a = 1 To UBound($sections) - 1
	;IniReadSection gibt ein Array im Größenformat [n][2] zurück.
    $data = IniReadSection($ini, $sections[$a])
	;Wir erweitern das Array mit ReDim auf [n][4].
	ReDim $data[UBound($data, 1)][4]
	;Jetzt gehen wir durch alle Zeilen durch.
	For $b = 1 To UBound($data) - 1
		;Wir zerlegen jeden Daten-String anhand des Trennzeichens "|"
		$line = StringSplit($data[$b][1], "|")
		;Wir setzen jetzt unsere getrennten Daten in unser Haupt-Array $data ein
		$data[$b][1] = $line[1]
		$data[$b][2] = $line[2]
		$data[$b][3] = $line[3]
	Next
Next

_ArrayDisplay($data)

Dabei kommt dann ein Array im Format [n][4] raus.

Liebe Grüße

Auf die Zeit habe ich nur bedingt geachtet, wird aber irgendwo um die 30 Minuten liegen.

Func _CreateID($aUserdata)
	Local Enum $FIRSTNAME, $SECONDNAME, $LASTNAME, $DAYOFBIRTH, $GENDER
	Local $sReturn = "", $aASCII, $sASCII = ""
	$sReturn &= StringReplace(StringFormat("%-5.5s", StringReplace($aUserdata[$LASTNAME], "-", "")), " ", "9")
	$sReturn &= StringMid($aUserdata[$DAYOFBIRTH], 9, 1)
	$sReturn &= StringFormat("%02d", StringMid($aUserdata[$DAYOFBIRTH], 4, 2) + ($aUserdata[$GENDER] = "W") * 50)
	$sReturn &= StringMid($aUserdata[$DAYOFBIRTH], 1, 2)
	$sReturn &= StringMid($aUserdata[$DAYOFBIRTH], 10, 1)
	$sReturn &= StringReplace(StringFormat("%-2.2s%-2.2s", $aUserdata[$FIRSTNAME], $aUserdata[$SECONDNAME]), " ", "9")
	$aASCII = StringToASCIIArray($sReturn)
	For $s In $aASCII
		$sASCII &= $s
	Next
	$sReturn &= calcCrossSum($sASCII)
	Return $sReturn
EndFunc   ;==>_CreateID

Func calcCrossSum($sInput)
	$iSum = 0
	$aDigits = StringSplit($sInput, "", 3)
	For $sDigit In $aDigits
		$iSum += $sDigit
	Next
	Return ($iSum > 9) ? calcCrossSum($iSum) : $iSum
EndFunc

Ich bin deutlich dafür.

VS Code ist ein super schöner und gut konstruierter Editor. Für nahezu alle Sprachen (und Dateiformate) gibt es passende Erweiterungen im VS-Code-Universum, was diesen Editor sehr vielfältig macht. Auch die Plattformunabhängigkeit ist für mich ein großer Punkt, weil damit meine Arbeitsumgebung unter Linux, Windows, Unix und macOS (nutze ich alles aus verschiedenen Gründen parallel) relativ identisch ist. Das spielt aber natürlich für AutoIt keine wirkliche Rolle.

Mit einer guten AutoIt-Integration senkt man mit Sicherheit die Einstiegshürde für den ein oder anderen Administrator, der mit AutoIt Dinge automatisieren möchte.

Schade ist es natürlich um die ganzen Integrationen, die im Laufe der Zeit für SciTE (auch durch uns hier) entwickelt wurden. Gerade die älteren Sachen zu portieren, wird mit Sicherheit ein großer Akt werden. Andererseits bietet VS Code auch sehr gut dokumentierte Schnittstellen zur Entwicklung von Erweiterungen.

Ansonsten ist es schön, zu sehen, dass noch etwas Leben im Projekt AutoIt steckt, und sei es nur im Bereich IDE/Editor.

Naja, desto schlimmer Windows auch wird... Einen Vorteil haben manche eher fragwürdigen Trends in der Softwareentwicklung: Dadurch, dass mittlerweile jede zweite Software auf super ineffiziente Webtechnologien setzt, bekommt man immerhin einen gewissen Grad an Plattformunabhängigkeit als Trostpreis dazu. Dass Linux sich als Desktop-Betriebssystem durchsetzt, werden wir aber wohl alle nicht mehr erleben. Aber immerhin wird immer mehr Software unabhängig vom Betriebssystem - dafür abhängig von irgendwelchen Hersteller-Clouds.

Bei uns im Betrieb (Lebensmittelgroßhandel, knapp 65 Mitarbeiter) ist es mittlerweile so, dass es quasi nur noch die Buchhaltungssoftware gibt, die rein Windows-basiert ist (DATEV, mag dem ein oder anderen ein Begriff sein). Alle anderen Anwendungen (ERP, Mail, CRM, Telefonanlage etc…) sind entweder reine Webanwendungen, oder stellen PWAs für nahezu jede Plattform zur Verfügung. Dadurch wäre es jetzt schon grundsätzlich möglich, alle Rechner, die nicht gerade in der Buchhaltung stehen, "eben mal" auf irgendeine Linux-Distribution umzustellen (okay, stimmt nicht ganz. Da gibt es noch so an die 30 AutoIt-Skripte, die ich so in den letzten Jahren mal geschrieben habe, die man dann auch mal zu Python portieren müsste^^). Aber, und das muss man an dieser Stelle Microsoft zusprechen, unter Linux gibt es keine so komfortable und homogene Möglichkeit, die Clients zu administrieren, wie durch Gruppenrichtlinien. Klar kann man sich das alles per Puppet zusammenbasteln oder sowas modernes wie NixOS nutzen und einfach immer neue Configs pushen... Oder im schlimmsten Fall per ssh auf jede Kiste gehen und ein Shell-Script remote ausführen oder so. Aber so schick und einfach wie GPOs ist das halt alles nicht.

Davon ab: Ich bin privat mittlerweile bei einem Mischmasch aus macOS und Arch Linux hängengeblieben, macOS einfach wegen der phänomenalen Hardware. Ich administriere mit meinem MacBook Air aber dennoch ein komplettes Windows-Firmennetzwerk, und entwickle schwerpunktmäßig Software unter Linux. An den meisten Tagen habe ich also alles drei in der Hand. Und deshalb habe ich mittlerweile auch eine weniger ideologische Sicht auf die ganze Geschichte. Für mich ist das Betriebssystem mittlerweile einfach ein Werkzeug geworden. Wenn ich einen Nagel in die Wand schlagen will, nehm ich ja auch keinen Akkuschrauber. So nehme ich auch für die passende Aufgabe mittlerweile das passende OS.

Irgendwie hat mich die Aufgabe hier gerade gecatcht.

Aber AutoIt hatte ich leider nicht zur Verfügung...

                   +
                  +++
                 ++++[
                >+>+<<-
               ]>[<+>-]>
              ---[<++>-]<
             +++++>>>>>>++
            ++++++++[<+<+++
           <++++++++++++<+++
          ++++++<++++>>>>>-]<
         <++<++++<--<++<[>>>>>
        >+>+<<<<<<<-]>>>>>>[<<< 
       <<<+>>>>>>-]>-[<+>--]<[-<
      <.>>]<<<<<.>>>>.<<<<<<-->>>
     >>>>+<<<<<<<[>[>>>>>>>+>+<<<<
    <<<<-]>>>>>>>[<<<<<<<+>>>>>>>-]
   <[>+>>+<<<-]>>>[<<<+>>>-]<<[>-<-]
  >[<+>--]<[-<<<.>>>]<[<<<<.>>>>>+<-]
 >[<+>-]<++<.<<<<<<-]>>>>>>>[-]<<<<<<[
>>>>>>+>+<<<<<<<-]>>>>>>[<<<<<<+>>>>>>-
              ]>---[<+>--
              ]<[-<<.>>]<
              <<.>.<.>>.>

Wer online testen möchte: https://gc.de/gc/brainfuck/

Hat mich jetzt knappe 3 Stunden gekostet, das zu entwerfen.

Das erste Element auf dem Stack ist nebenbei die gesamte Baumhöhe. Heißt kurz gesagt, für jedes + was man der Baumspitze hinzufügt, wird der generierte Baum eine Ebene höher.

Ja, das ist eine sehr schöne Idee. Auf Structs bin ich an der Stelle noch nicht gekommen. Ich nehme dafür - je nach Komplexitätsgrad - folgende Wege:

1. Index-Konstanten mit Enum

Global Enum $ID, $LASTNAME, $FORENAME, $BIRTHDAY
Global $aData[2][$BIRTHDAY + 1]
$aData[0][$LASTNAME] = "Schwahfel"
$aData[0][$FORENAME] = "Heribert"
$aData[0][$BIRTHDAY] = "2022-11-09"

2. Array of Dictionary

Global $aoData[2]
$aoData[0] = ObjCreate("Scripting.Dictionary")
$aoData[0]("LastName") = "Schwahfel"
$aoData[0]("ForeName") = "Heribert"
$aoData[0]("Birthday") = "2022-11-09"

Habe den Code jetzt gerade aus dem Kopf runtergetippt. Es ist gerade kein Windows mit Au3 greifbar.

Aber solche Methoden können die Lesbarkeit des Codes um einiges erhöhen.

Dafür gibt es normalerweise TRUNCATE TABLE

Du hast recht, das muss AutoIt regeln.

Beim Ausführen des folgenden Codes unter Windows springt der Speicherbedarf bei mir von 1.420K auf 1.054.092K.

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <string.h>

/* defs */
typedef unsigned char byte_t; /* sizeof(byte_t) assumed to be 1 */
#define K (1024)
#define M (1024 * 1024)

/* settings */
#define TEST_DATASIZE   (1 * M)  /* size of the 'original' data in bytes */
#define TEST_COPIES     (1024)      /* number of copies */
/* NOTE: total memory usage will be TEST_DATASIZE * TEST_COPIES */

/* code */
int main(void) {
    byte_t data[TEST_DATASIZE];

    /* fill 'data' with random numbers */
    srand(time(NULL));
    for(int i = 0; i < sizeof(data); i++) {
        data[i] = rand() % 256;
    }

    /* let user look at the task manager */
    printf("please look at memory usage. press any key to continue.");
    fflush(stdout);
    getc(stdin);

    /* copy 'data' multiple times */
    byte_t *current;
    for(int i = 0; i < TEST_COPIES; i++) {
        current = malloc(sizeof(data));
        if(current) memcpy(current, data, sizeof(data));
    }

    /* let user look at the task manager AGAIN */
    printf("data prepared. please look at memory usage again. press any key to exit.");
    fflush(stdout);
    getc(stdin);

    return 0;
}

Dann frage ich mich wirklich, was da Jons Motivation war.

Edit: Doch tatsächlich im Eifer des Gefechts src und dest bei memcpy verwechselt... Eben korrigiert.

Edit 2:

Vielleicht passiert das doch in den Standard-Libs.

Es gibt scheinbar Implementierungen von std::string, die über Referenzzähler eine Art Copy-on-Write realisieren.

Je nach Version von libc++ kann das also automatisch passieren (Vgl Google-Suche nach "std string copy on write").

AspirinJunkie Das wirft für mich jetzt die spannende Frage auf, wer von uns beiden im Detail richtig vermutet.

Wird Copy on Write hier von AutoIt umgesetzt? Oder vom Betriebssystem? In den StdLibs auf keinen Fall, da hat das nichts verloren.

Wie du selber schon sagst, wäre eigentlich nicht zu erwarten gewesen, dass AutoIt das selber umsetzt. Garantiert nicht auf String-Basis.

Und auch wenn man an AutoIts komplette interne Speicherverwaltung denkt, halte ich das eigentlich für unplausibel.

Was sollte das Motiv dafür sein? Das durchschnittliche AutoIt-Skript speichert ja keine Unmengen an Daten im RAM.

Und bei der Programmierung wurde mit Sicherheit nicht berücksichtigt, wie sehr das deutsche Forum AutoIt schon mal missbraucht und verbiegt.

Es scheint für mich logischer zu sein, dass das tatsächlich innerhalb der Windows-Speicherverwaltung umgesetzt wird.

Das würde dann aber ja heißen, dass auch ein Programm ohne eigene Speicherverwaltung von dem Effekt betroffen sein müsste.

Ich such mir grad mal eine Windows-Kiste zum Testen.

Klingt für mich nach (intelligentem) Copy on Write.

Wikipedia

Keine Ahnung, wie der NT-Kernel das handhabt, aber alle halbwegs modernen Linux und Unix Systeme verwenden CoW im Hauptspeicher auf Memory-Page-Basis.

Im Linux-Kernel sind 4 KB als Standard-Page-Größe eingestellt.

Falls die Windows-Speicherverwaltung sowas wie CoW intelligent und eigenständig (=> d.h. ohne Notwendigkeit einer expliziten Copy-Anweisung) umsetzt, könnte das das Phänomen erklären.

1 MB wird in 250 Pages a 4 KB aufgeteilt. Ab dem zweiten 1MB-Block ist nur die letzte Page vom ersten Block verschieden, d.h. nur diese wird tatsächlich neu im RAM abgelegt.

Edit: Das scheint Windows ja nicht so zu machen.

Welche MySql.au3 verwendest Du denn? Die von cdkid? => https://www.autoitscript.com/forum/topic/20814-mysql-udfs/

Die Signatur der MySqlConnect-Funktion sieht da wie folgt aus:

_MySQLConnect($sUsername, $sPassword, $sDatabase, $sServer, $sDriver = "{MySQL ODBC 3.51 Driver}", $iPort=3306)

Der Port wird also in einem eigenen Parameter angegeben, und nicht im Format "Hostname:Port".

Der ADODB-Treiber erwartet das auch so.

Hast Du das hier wahrgenommen und umgesetzt?

Hatte gerade gezielt danach gesucht, weil es eigentlich normal ist, dass (Free-)Webspace-Hoster die dazugehörigen Datenbanken nur für den Zugriff von localhost aus freigeben.

Es ist auch nicht wirklich üblich, einen Datenbankserver "direkt" ins Netz zu hängen. Normal baut man eher eine API in PHP oder Python oder so und regelt darüber auf dem Webspace die Datenzugriffe.

Das Makes Variante schneller ist, war zu erwarten. Grundsätzlich lassen sich rekursive Algorithmen immer sehr schön schreiben und lesen... Aber in der Ausführung sind fast immer iterative Verfahren überlegen. Dazu ist der Overhead bei rekursiven Funktionsaufrufen zu groß.

Das hat mich grad auch gecatcht.

Func happy($iNum)
    ;$iNum is an integer from 1 to 100
    If $iNum = 1 Then Return 1
    If $iNum = 20 Then Return 0
    Local $aNum = StringSplit(String($iNum), "", 3)
    Local $i, $iSum = 0
    For $i = 0 To UBound($aNum) - 1
        $iSum += Int($aNum[$i])^2
    Next
    Return happy($iSum)
EndFunc

For $i = 1 To 100
    If happy($i) Then ConsoleWrite($i & " -> 1 :)" & @CRLF)
Next