xtodo

todo stuff

xtodo
xtodo
xtodo
xtodo
xtodo
xtodo
xtodo
xtodo
xtodo

grok ai code

xtodo
xtodo
xtodo
xtodo
xtodo
xtodo
xtodo
xtodo
xtodo
xtodo
xtodo
xtodo
xtodo
xtodo
xtodo
xtodo
xtodo
xtodo
xtodo
xtodo 
Clear[fcurve, ftangent]
fcurve = Function[t, {t, 2 Cos[t] + t}]
ftangent = fcurve'
Definition @ ftangent
Function[t, {t, 2*Cos[t] + t}]
Function[t, {1, 1 - 2*Sin[t]}]

ftangent = Function[t, {1, 1 - 2*Sin[t]}]
xtodo
xtodo
xtodo
xtodo
xtodo
xtodo 
[
Object.create(Object.prototype),
 [3, 4],
new Date(),
function () {},
RegExp("x", ""),
]
 .forEach((xx) => {
const xparent = Reflect.getPrototypeOf(xx);
console.assert("------");
console.log("obj โ†’ ", xx);
console.log("subtype โ†’ ", Reflect.apply(Object.prototype.toString, xx, []));
console.log("parent โ†’ ", xparent);
console.log("subtype is โ†’ ", Reflect.apply(Object.prototype.toString, xparent, []));
console.log("has constructor property โ†’ ", Reflect.has(xparent, "constructor"));
 });

/*
------
obj โ†’  {}
subtype โ†’  [object Object]
parent โ†’  [Object: null prototype] {}
subtype is โ†’  [object Object]
has constructor property โ†’  true
------
obj โ†’  [ 3, 4 ]
subtype โ†’  [object Array]
parent โ†’  Object(0) []
subtype is โ†’  [object Array]
has constructor property โ†’  true
------
obj โ†’  2026-01-30T03:39:54.712Z
subtype โ†’  [object Date]
parent โ†’  {}
subtype is โ†’  [object Object]
has constructor property โ†’  true
------
obj โ†’  [Function (anonymous)]
subtype โ†’  [object Function]
parent โ†’  {}
subtype is โ†’  [object Function]
has constructor property โ†’  true
------
obj โ†’  /x/
subtype โ†’  [object RegExp]
parent โ†’  {}
subtype is โ†’  [object Object]
has constructor property โ†’  true

*/
xtodo 
// 2026-01-21
// todo

const idNumbers = {
checksum:((x) => { }),
call:((x) => return "haha"),
};
/* demo of what Function.prototype.call not work */

// create a object
const jj = {};

jj.fdad = function faa(xstr) {
// create a property
 this[xstr] = 1;
};

jj.fson = function fbb(xstr) {
// create a property
 this[xstr] = 1;
};

// Reflect.setPrototypeOf(jj.fson, jj.fdad);

// (jj["faa"]) ["call"] = function () { this[xstr] = 2; }

jj["faa"].ccc = 44;

console.log(jj);
// { fdad: [Function: faa], fson: [Function: fbb] }

jj.fdad("a");

console.log(jj);
// { fdad: [Function: faa], fson: [Function: fbb], a: 1 }

// create a object
const xx = {};

jj.fdad.call(xx, "a");

console.log(xx);
// { a: 1 }
xtodo
xtodo 
// 2026-01-17
// idea of a sequence of expressions, like lisp progn
console.log([1 + 2, console.log(1 + 3), 4].at(-1));
xtodo

sitewide change key chord to key combo

xtodo
emacs community logo
emacs community logo
emacswiki org logo 2026-01-05 17409
emacswiki org logo 2026-01-05 17409

looks like the emacswiki org logo by Daniel Lundin , got removed in 2016, due to the social justice warrior movement.

xtodo 
(eval
(cons
'+
  (apply
#'cl-mapcar #'list
(let (elts)
     (with-current-buffer "the-table"
(while (not (eobp))
         (push (read (current-buffer)) elts)))
     (seq-partition elts (cl-position-if #'numberp elts))))))

2026 new year resolution. daily todo:

xtodo
xtodo
xtodo
xtodo
xtodo

http://timkadlec.com/2012/04/media-query-asset-downloading-results/

xtodo
xtodo 
((lambda (x) (+ x 1)) 2)
;; 3

(funcall (lambda (x) (+ x 1)) 2)
;; 3

;; name a lambda, by set to a var
(setq my-ff (lambda (x) (+ x 1)))

(my-ff 2)
;; Debugger entered--Lisp error: (void-function my-ff)

(funcall my-ff 2)
;; 3
xtodo

problem, figure out how to make this not mutate variable 

(let ((x "abc") )
  (setq x (string-replace "a" "1" x))
  (setq x (string-replace "b" "2" x))
  (setq x (string-replace "c" "3" x)))
;; "123"

;; s------------------------------

(seq-reduce
(lambda (xstate xfn) (funcall xfn xstate))
   (list
(lambda (x) (string-replace "a" "1" x))
    (lambda (x) (string-replace "b" "2" x))
    (lambda (x) (string-replace "c" "3" x)))
"abc")
;; "123"
xtodo
xtodo
xtodo
xtodo
xtodo
xtodo
xtodo
xtodo
xtodo
xtodo
xtodo
xtodo 
package main

import (
"fmt"
"os"

"golang.org/x/net/html"
)

// extractLinks recursively traverses the HTML node tree and collects all href attributes from <a> tags.
func extractLinks(n *html.Node) []string {
var links []string
if n.Type == html.ElementNode && n.Data == "a" {
for _, attr := range n.Attr {
if attr.Key == "href" {
                links = append(links, attr.Val)
            }
        }
    }
for c := n.FirstChild; c != nil; c = c.NextSibling {
        links = append(links, extractLinks(c)...)
    }
return links
}

func main() {
if len(os.Args) != 2 {
        fmt.Println("Usage: go run script.go <html_file_path>")
        os.Exit(1)
    }

    filePath := os.Args[1]
    file, err := os.Open(filePath)
if err != nil {
        fmt.Printf("Error opening file %s: %v\n", filePath, err)
        os.Exit(1)
    }
defer file.Close()

    doc, err := html.Parse(file)
if err != nil {
        fmt.Printf("Error parsing HTML from %s: %v\n", filePath, err)
        os.Exit(1)
    }

    links := extractLinks(doc)
if len(links) == 0 {
        fmt.Println("No links found in the HTML file.")
return
}

    fmt.Printf("Found %d links:\n", len(links))
for i, link := range links {
        fmt.Printf("%d. %s\n", i+1, link)
    }
}
xtodo
xtodo
xtodo
xtodo

Intertwined Relation of Syntax and Semantics

This is a example of intertwined relation of syntax and semantics.

let's dive into detail.

in programing languages, you have statements and expressions.

For example, in python, to specify branch control, you have if-statement. But you do not have if-expression.

In JavaScript, you have both if-statement (e.g. if (x === 1) { f() } else { g() } ) and if-expression. (e.g. (( x === 1 ) ? f() : g() ))

Are the difference of statements vs expressions, a semantic issue? Yes. Because their meaning is different. One is procedure, the other return a value (besides also is procedure).

now, similarly, in many programing languages, a function can be defined by a statement and or by an expression. e.g. in JavaScript, use keyword function at top level to define function via statement, and you can also use JS: Arrow Function e.g. (x => x + 1) to define function as expression. it returns the function as a value.

in python, you use def statement to define a function. or you can use lambda, it is an expression.

one advantage of function expression in programing language is that it is convenience to embed it inside another expression.

but python's indentation syntax, requires complicated expression to be multiple lines, because not all basic semantics of python can be expressed as expression, such as the conditional if.

so with you use the lambda function expression, and if it requires a if conditional, it must be multiple lines of the indentation syntax.

this indentation syntax, prevents the embedding or nesting of arbitrary expressions.

xtodo
xtodo
xtodo
xtodo
xtodo
xtodo
xtodo
xtodo
xtodo
xtodo
xtodo
xtodo
xtodo
xah coprographia unix culture 2022-12-26 vjBPY
xah coprographia unix culture 2022-12-26 vjBPY
xtodo

CC_Engine_x64.exe is a legitimate executable file developed by MSI (Micro-Star International Co., Ltd.). It is a core component of MSI's system management software, specifically part of MSI Center (the current version) or its predecessor Dragon Center (also known as One Dragon Center).

writing twitter bot

xahweb user facing

xahweb, less important

old

xtodo