duangsuse::Echo

#py #code #recommend 说到有趣的py接口，有个 iself() def read_as_io(f): class T(io.TextIOBase): read=lambda o,size: f(o) return T -匿名对象之前写贪吃蛇 snk.c 就用到链表不想缓冲区溢出的话Vec还是好的。C里你要实现[] 需要懂链表/strcat， rust 里你写 Vec<i32> push 就好了 Rust的生命周期现在基本不需要考虑（尤其是对应用开发时）， type infer…

#py 周刊阅读笔记
https://t.me/NewlearnerChannel/12060
https://t.me/NewlearnerChannel/12097

https://www.kdnuggets.com/why-you-should-not-overuse-list-comprehensions-in-python
#code

primes =lambda upper_limit: [x for x in range(2, upper_limit + 1) if  x > 1 and all(x % i != 0 for i in range(2, int(math.sqrt(x)) + 1))]
primes(50)

#拆分后

is_prime=lambda num: num > 1 and all(num % i != 0 for i in range(2, int(math.sqrt(num)) + 1))

primes = [x
  for x in range(2, 50 + 1)
  if is_prime(x)
]

后面

def flatten_matrix(matrix):
def find_prime_indices(matrix, flattened_matrix):

求和排序的我不想写，因为明显可以用 yield和np.vectorize

# Parse&flatten the JSON string with deep"inner_key" into a Python dictionary
这个也不想，因为用match和递归更常见吧，elif isinstance 是什么py2地狱绘图

https://bernsteinbear.com//blog/simple-python-repl/#:~:text=readline%20API
https://www.skywind.me/blog/archives/2761
如何利用RegExp/创建REPL

出自 https://docs.python.org/3.11/library/re.html
#js #code 当输入 "3 hello 1world" 时展开缩写，并且补齐出现过的词

Lexer=kv=>{
  let re=Object.keys(kv).map(x=>`(${x})`).join('|'), mf=Object.values(kv),m,i,j=0
  re=RegExp(re, 'gy')
  return (s,ontok)=>{
    for(m of re[Symbol.matchAll](s)) ontok(
      mf[(j=m.findIndex((x,i)=>null!=x &&i!=0))-1](m[j]),  (i=m.index), i+m[0].length
    )
  }
}

f=Lexer({
  '\\d+':parseInt,
  '[a-zA-Z]+':s=>s,
  '\\s+'(){}
})

rep=(txt,on, n=null)=>f(txt,x=> (x==null)?on(' '):
  (x.substr)? (on(x.repeat(n)),n=null) : 
  (n=x)
)

buildAry=(f,a=[])=>(f(x=>a.push(x)), a)

buildAry(rep.bind(0,"3hi 1end")).join('')

因为JS部分都这么长，还是懒得移植到PyExecJS了，总之分词器、括号配对啥的可以靠正则，提供补齐列表也不难

就用 <body ContentEditable>+CSS.hilights 示例吧？
https://jsbin.com/kamufijomu/edit?js,output 😅

参考^回复，这样就有分词和括号配对高亮了？

—续周刊
https://github.com/stickfigure/blog/wiki/How-to-(and-how-not-to)-design-REST-APIs
十多项 REST API 的最佳实践规则，解释了规则的含义及实现
作者嘲笑了几家公司被广泛使用的 API，将它们作为规则的反例。

[Django 5.0 发布了！](https://docs.djangoproject.com/en/5.0/releases/5.0)
新增`Field.db_default` 参数，可设置由数据库计算的日期等默认值；`GeneratedField` 可以创建由数据库计算的列，简化了表单字段相关元素的呈现
FastAPI 已经支持 python-dependency-injector 实现依赖注入的方法。

[kolo VSCode 插件：查看 Django 应用的执行过程](https://github.com/kolofordjango/kolo)
具有帧可视化、漂亮的火焰图、显示执行了 SQL 查询的代码行
[autometrics-py：函数级的指标监测工具](https://github.com/autometrics-dev/autometrics-py)
只加一个装饰器，可检测函数的请求率、错误率和延迟，开箱即用仪表板、自定义告警、运行开销小

https://dev.to/taipy/new-open-source-vs-old-open-source-33k7
10 组在 Python 社区很知名的库的替代库，这里最没争议的估计是 Ruff 替代 Pylint，
其它则还有：Taipy/Streamlit、Polars/Pandas、Dask/PySpark、PyTorch/TensorFlow ……

[Python 借助 Gopy 库实现调用 Go.whl 包](https://last9.io/blog/using-golang-package-in-python-using-gopy/)
https://preslav.me/2023/11/27/python-is-easy-golang-is-simple-simple-is-not-easy/#:~:text=also%20at%20the-,core%20of%20Django,-%2C%20which%20speaks%20to

[对比 Python 与 Rust 的编程习惯用法](https://programming-idioms.org/cheatsheet/Python/Rust) 有意思的网站，可比较不同编程语言在 300 多项习惯用法上的区别
就像 https://component-party.dev/
https://kobzol.github.io/rust/python/2023/05/20/writing-python-like-its-rust.html
从 Rust 中学到的一些编程习惯：使用类型提示、使用数据类代替元组或字典、使用代数数据类型、使用“newtype”、使用构造函数、使用互斥锁等

[Python 工具箱系列文章](https://www.cnblogs.com/shanxihualu/p/17391082.html)
这是一个系列文章，目前包含 31 篇文章，最近介绍的几个工具是数据库相关的：Neo4j（一个 NoSQL 图数据库，使用 Py2neo 操作）、PostgreSQL

[trogon：为 CLI 程序生成友好的GUI](https://github.com/Textualize/trogon)
[当在终端输入“ls”后会发生什么？](https://www.warp.dev/blog/what-happens-when-you-open-a-terminal-and-enter-ls)（英文）
有一道很类似的常见的面试题：“当在浏览器输入 google.com 后会发生什么？”
[solara：一个纯 python、React-风格的ipywidget框架](https://github.com/widgetti/solara)
[用tkinter、PySimpleGUI 和 Jupyter Notebook 播放 GIF？](https://www.blog.pythonlibrary.org/2023/12/05/viewing-an-animated-gif-with-python/)
https://toga.readthedocs.io/en/stable/tutorial/tutorial-0.html#:~:text=()%0A%0A%20%20%20%20button%20%3D-,toga.Button,-(%22Hello%20world
Toga是跨平台的pyGUI
kanban-python：终端中的看板应用程序，和Vue TUI 一样

Newlearnerの自留地

#Python潮流周刊

Python 潮流周刊#27：应该如何处理程序的错误？

🦄文章&教程
1、将 Python 错误作为值：比较 Go 和 Rust 的使用模式
2、调试 Django 中的 CSRF 失败/403 禁止错误
3、对 Python 环境和包管理工具的公正分析
4、让我们一起创建一个 Python 调试器
5、揭开 Python 3.12 的面纱：Python 世界有哪些新东西？
6、Python 的哈希表指南
7、运行不可信的 Python 代码
8、了解 Linux cp 命令并用…

51 viewsedited 14:34

duangsuse::Echo

#js #code 上帝说，要有光？ https://rcuv.hkbs.org.hk/CUNP1s/GEN/21/

// ==UserScript==
// @name         圣经高德
// @match        https://rcuv.hkbs.org.hk/CUNP1s/GEN/*
// ==/UserScript==

$(document).on('keyup', e => e.which == 39 ? $('.nx').click() : e.which == 37 ? $('.pr').click() : null);
(function(){$(document).on('keyup',arguments.callee)

setTimeout(function() {
    'use strict';

let AB={'耶和华神?':'高德', 那人:'亚当',女人:'夏娃'}
// 遍历所有文本节点，将其中的"a"替换为"b"。基于RegExp 和js字典提供一个 replace({a:b, A:B}) (str) 的方法
function replace(str, dict) {
    const keys = Object.keys(dict), vals=Object.values(dict);
    const regex = new RegExp(keys.map(key => `(${key})`).join('|'), 'gi');
    return str.replace(regex, (s,...m) => dict[s.toLowerCase()] || (dict[s]= vals[m.findIndex(x=>x!='')]) || s);
}
function replaceTextContent(node) {
    if (node.nodeType === Node.TEXT_NODE) {
        node.textContent = replace(node.textContent, AB);
    } else {
        node.childNodes.forEach(replaceTextContent);
    }
}

replaceTextContent(document.body);


},1000); })()

评价：缩进不对的地方是我手改的， 85% 是AI生成的
我一般只用 ()=> ，但用上 on('keyup',arguments.callee) 也挺有意思

AI提供全文替换的方法超过SO上的全部回答（虽然只是dfs
—
上帝的“帝”是一个相当世俗化的人间概念，用来形容一神教中的那个绝对之神很不妥，属于以凡人之心度god之腹。
关于「耶和华神」「上帝」有个更贴切的翻译：高德太原

把god 翻译为“高德”符合基督教中上帝是至高的善的定位，也有利于占据道德高地。
有人说“基因”这个词的翻译是非常绝妙的，“高德”这个词有异曲同工之妙。 😂

// ==UserScript==
// @name         括号树图
// @description  支持括号格式思维导图
// @match        *://sketchviz.com/new
// @run-at document-body
// @grant unsafeWindow
// ==/UserScript==

//onclick=()=>console.log(式=read(prompt('括号嵌套')||'1 (2 3) 4'),图(式))
const
read=cod=>{let tok=cod.split(/\s+|([()])/).filter(x=>!!x).values(),
par=s=>{let a=[],x;for(;(x=s())&&x!=')';)a.push(x=='('?par(s):x); return a}
return par(()=>tok.next().value)//^ 一般需配对。此省行数
},
图=t0=>{
  let sb=[],写=a=>{
    let x0=a[0],x; if(x0[0]!='_')for(x of a.slice(1))sb.push(`${x0}->${(x instanceof Array)?写(x):x}`)
    return x0
  };sb.push(写(t0));return sb.join('\n')
},
hook=(o,k,f)=>o[k]=f(o[k].bind(o));

let it=unsafeWindow, _1=1
hook(it,'fetch',f=>(url,c)=>(0>_1--)?0: (c=>{
  hook(editor.getSession().getDocument(),'getValue',f=>()=>`digraph G{${c[0]} ${图(read(f()))}[shape=${c[1]}}`); editor.setOptions({wrap:20,fontSize:20})
  hook(it,'updateGraph',f=>()=>c[2]?f() :0)
  it.onload=()=>it.$(".logo").removeAttr("href").click(ev=>ev.ctrlKey? (c[2]^=1) : c[3](prompt('Font,Node0')||'Sans,cds];rankdir=LR;') ); c[3]("Handlee,Mdiamond];")
})(["","",true, function(s){let[fnt,sty]=s.split(',',2);this[1]=sty;this[0]="graph,node,edge".split(',').map(k=>`${k} [fontname = ${fnt}]`).join('\n')}])
||f(url,c))

56 viewsedited 14:16

duangsuse::Echo

#algorithm #history 方脸：为计划经济诞生的「线性规划」 https://youtu.be/1cLWzo78Q5g?t=900
#code

import numpy as np
import scipy.optimize as lp

# 优化目标函数：maximize 2X + 3Y
c = [-2, -3]
# highs限制条件：5X + 8Y <= 50, 10X + 12Y <= 120
A = np.array([[5, 8], [10, 12]])
b = np.array([50, 120])

# 设置变量的取值范围
x_bounds = (0, None)
y_bounds = (0, None)

# 解决线性规划问题
r = lp.linprog(c, A_ub=A, b_ub=b, bounds=(x_bounds, y_bounds), method='highs')
val,x,y=-r.fun,*r.x
print(f"最大利润为 ${val}，此时生产 {x} 个产品 A 和 {y} 个产品 B。")

在列宁格勒呢，有一家胶合板生产厂。它有80台两种型号的机床，生产5种不同型号的胶合板。而不同型号的机床生产胶合板的能力不同。

那么，如何合理的分配每台机床的作业时间和物料投入，使得胶合板的产量最大，就是胶合板问题。这个呢，看起来是一个简单的数学问题，和我们日常做的一些高考数学题呢是类似的。当然了这对一个高中生来说，只要好好学数学，这个问题呢，并不难解。但是问题是这里面我们能解出来是因为我们只考虑了单一工厂的前提之下的。可是苏联的实际情况却不同，

就比如这个胶合板的生产。除了要考虑自己的工厂怎么样生产效率最高，它还要考虑胶合板的原材料，比如木材的供应量。而考虑到木材的供应量，除了要考虑伐木工人的数量，还要考虑到伐木机的生产数量。而伐木机的制造数量又要考虑到钢厂的产量。此外，胶合板的生产还要考虑到使用的问题。胶合板有的时候用于房屋建设，有的时候呢也用于飞机制造。因此，还要考虑整个国家的房屋建设数量以及飞机制造数量。而飞机制造数量房屋制造数量又牵扯到非常多的问题。所以一个胶合板的生产规划是远比我们想象的要复杂得多的。

而根据苏联自己的记载呢，在1960年代，苏联国家计划委员会要对苏联及其加盟国的10,500个商品实施生产计划，而统一规划生产的工厂更是达到百万之多。想要分配这些产能在没有计算机的时代是一个非常困难的事情啊，甚至在当下有计算机这也是一个非常困难的事情。而为了优化这个计算，苏联时期还诞生了不少的知名经济学家，比如列昂尼德坎托罗维奇，他就在优化上面提到了胶合板生产问题时提出了线性规划，从而获得了1975年的诺贝尔经济学奖。所以这个计划经济虽然是个笑话，但是实施起来并不像我们想象的那么简单，只要国家一声令下就可以搞起来。

我们看历史总说中苏交恶之后苏联撤走了原子弹的专家撤走了这个那个专家导致中国的科技发展停滞。但其实对于当时中国最为致命的不是撤走专家之后原子弹发明不出来，而是撤走专家之后中国的计划经济搞不起来了。苏联因为有一系列的数学大师和经济专家，虽然他的计划经济呢可能会因为生产规划的问题导致大饥荒，但是，起码在有数学家和经济学家的前提下，这个计划经济他是能跑起来的。 🤓

YouTube

方脸说：客观评价毛泽东！为什么我说毛泽东搞不好经济全是他个人的问题？又该如何看待早期的毛泽东？

00:00 讨论毛泽东应该分为两个阶段
01:23 早期毛泽东-屠龙者变恶龙的故事
08:16 执政时期毛泽东-地板水平
13:33 心比天高，但能力不足的毛泽东
21:13 总结

103 viewsedited 06:26

duangsuse::Echo

#java #code serde codegen
用jshell API 实现了一个ini序列化，大概比直接靠javac 简单
>以下代码实现了 dumps(Pair::class) (Pair(0,0), mutableMapOf("first" to 3))


fun dumps(T:KClass<*>, ld:T=JS("(void)(${T} o, java.util.Map<String,Object> m){"+
  T.memberProperties.joinToString(""){"  m.put(\"${it.name}\",o.get${it.name.capitalize()}());"}+"}")!!
)=fun(o:Any, m:Map<*,*>)=ld.main(o,m).let{m}

所以说py真的太解压了.. setattr() 就算动静态隔离，typehint还能做格式验证
js稍微乱点
java 连个规范的元编程方法都没有，一群魔法师

我是觉得一个老古董语言就不要和jspy 比面向event和类型反射
Compiler 和 JShell API 就是tools.jar里的，做不到比 CLI更强的功能，就是调用快点
JS("") 和runtime其实是完全隔离的，它的classpath 相当于是编译期的，你可以把生成的代码按行号缓存下来，不需要defineClass
vs

// 定义一个 data class
data class UPair(val A: Int, val B: Int)
@Mapper
interface UPairMapper {
    // 定义一个映射方法，用于将 Map 转换为 UPair
    fun mapToUPair(map: Map<String, Int>): UPair
}
val mapper = Mappers.getMapper(UPairMapper::class.java)

mapper.mapToUPair(mapOf("A" to 1, "B" to 1))

https://github.com/mapstruct/mapstruct/issues/1672#issuecomment-969265894
https://gist.github.com/duangsuse/d022c7ad037bb7fed446f72ec9b38ef7

GitHub

Kotlin data classes and mapstruct · Issue #1672 · mapstruct/mapstruct

141 views12:58

duangsuse::Echo

#py #tool 浏览器缓存图片爬虫
python a.py 'x\.com' 200 ~/.cache/chromium/Default/Cache/Cache_Data/*

python imgdump.py 'www' 100 `ls  --sort time --reverse ~/.cache/chromium/Default/Cache/Cache_Data/*`

#code

import re,struct, os

def ls_cache(urlRegex, kbSizeMin, *cache_files):
  key_marker = struct.pack('Q', 0xf4fa6f45970d41d8)
  def deco(b):
    # header is 8+4+4:keylen+4+ bytes[keylen]
    key_len = struct.unpack('I', b[12:16])[0]+4
    key = b[20:20+key_len].decode()
    body = b[20+key_len:b.find(key_marker)]
    if len(body)>kbSizeMin*1024 and re.search(urlRegex,key): 
        return mstrip(100,re.sub('[\x00/]','', key)),body
  mapFiles(cache_files,deco)

mstrip=lambda n,s: s if len(s)<n else f"{s[:n//2-2 -2]}..{s[n//2:]}"
def mapFiles(a, fOut):
    os.system('rm -rf png;mkdir png')
    for i,file in enumerate(a):
        with open(file, 'rb') as f:
            if f1:=fOut(f.read()):
                k,v=f1
                with open(f'png/{i}-{k}', 'wb+') as out_f:out_f.write(v)

if __name__ == '__main__':
    import fire
    fire.Fire(ls_cache)

你可以逐文件夹拼图： #bash 各种相对路径真的吐了

vcat() { cd $1;a=`find *|sort -n|xargs printf "-i %s\n"`
ffmpeg $a -filter_complex vstack=inputs=`wc -l <<<$a` ../$1.png ;cd -;}
for f in `ls`;do vcat $f;done

for f in find * -type d; do thunar -B $f/*; done #按文件夹 批量重命名
cp-id() { i=1; for x in "$@"; do X=$(basename "$x"); cp "$x" "${i}-${X%.*}.${X##*.}"; i=$((i+1)); done; }

最开始考虑了 https://t.me/dsuses/5305 和binwalk但太慢

mkdir a tar
cp `grep 'x.com' -FRl ~/.cache/chromium/Default/Cache/|find -size +200k` tar
binwalk -C a -D image:png tar/*
find a/ -name '*.png'|nl

duangsues.is_a? SaltedFish

To retrieve the N most recent images from the Chrome cache in Linux that are greater than 100KB in size using Python, you can use the following script. This script uses the sqlite3 library to access Chrome's cache database. Please note that accessing the…

73 viewsedited 13:14

duangsuse::Echo

#learn #cg #go #bilibili #algorithm > https://www.bilibili.com/video/BV16g411B7Ff 尝试实现下视频里的”大一“代码，感兴趣的话可以深耕并不天才啊，就是 https://www.desmos.com/calculator/ 里像素化个灰度函数 (y-abs(x)^c)^2+x^2=1 可以把每个运算当成对样条的变换，例如删掉abs(x)不会对称 https://mathworld.wolfram.com/HeartCurve.html…

This media is not supported in your browser

VIEW IN TELEGRAM

#cg #code 国产剧《点燃我，温暖你》/110w 里面的一个桥段，天才程序员男主李峋期中考试中完成的爱心代码

效仿评论区就自己写了个…… 另外GL里字体/for循环是较难的

float heart(vec2 P) {
  float t= mix(.3,.8, mod(iTime,1.2)),//心跳
   r=pow(P.y-pow(abs(P.x),t), 2.)+pow(P.x,2.) -1.;//灰度函数
  return r<.3? mix(1.,4.,-r) : r; //黑心换白心
}

在 https://www.shadertoy.com/view/llGSzw main尾部加上
fragColor = heart(fragCoord.xy/iResolution.xy/.2 -2. - sin(iTime)) ;

原up清华毕业，加州工作，微软码农收获5w播放，我寻思这好像也不难…… Shader试错比IDE还容易
B站大佬也挺多的，这种开源易懂的少
其实glsl会 desmos.com 都能模拟的
https://www.geogebra.org/calculator 这些工具超好用
主要还是靠工具和html,svg 这些基础知识
现在numpy+opencv 也普及了，PIL那样的canvas库也会慢慢淘汰吧
一切皆向量一切皆矩阵

canvas就是一个比较装B的
但学了svg后就真不是啥
反而gl滤镜更有趣
因为现在对app程序员的要求太低了
转个str, list 绑下sql就能用，涉猎范围都被框架堵住了

77 viewsedited 08:42

duangsuse::Echo

#plt #code 谈到RPN，我昨天有个灵感想把js做成缩进的形式
就回顾了优先级算法（嵌套深度包括h1~h6树本质上也是优先级）

示例算法 sexp(tok('1 (2 3) 4')), exp(tok('1*2+3'), optab)

optab={[';']:-1}
"=;+ -;* /".split(';').map((a,l)=>a.split(' ').forEach(x=> optab[x]=l ))
exp=(s/*token x单项o算符 x..*/, l/*evels 大则深,紧 */)=>{
  let o,x=()=>add(Number(s())), ord=[],add=x=>ord.push(x),
  at=O=>{let A,B; x()
    for(o=s();(A=l[o])>=(B=l[O]);)if(A!=B)at(o);else{add(O);x(); O=o;o=s()}  add(O)
  }
  at(";");return ord
}

sexp=s=>{let a=[],x;for(;(x=s())&&x!=')';)a.push(x=='('?sexp(s):x); return a}
//^ 一般需配对。此省行数
sexp=(s, a=[], f=()=>{let x,i=0;for(;(x=s())&&x!=')';i++) {x=='('?f():a.push(x)} a.push(i) })=>(f(),a)
//'(a (b c) d)' 换RPN [a b c 2 d 3], 可显示步骤

tok=(cod, s=cod.split(/\s+|([()]|\W+)/).filter(x=>!!x).values())=>
 ()=>s.next().value

https://t.me/dsuse/19097 圆括号解析, CSS代码高亮
https://t.me/dsuse/19320 各种正则替代lex,trie 的妙用
https://t.me/dsuse/17410 带步骤四则计算器

https://t.me/dsuse/19387 类型推导科普, 动态和词法域,SQL的方言, 转译器 sourcemap
https://t.me/dsuse/18139 bing挑战各种算法和BNF

我还想了个有意思的鬼畜kt翻译，只用忆一事悟疑实 6个字：

忆一 忆 Pair(一 x:数, 一 y:数) 

忆 Main(一 a:行<Pair>): Events {
  悟 事 onInit() {
   一实((x,y) 于 a) 疑{ x==Z -> 不输别玩 }
  }
  说的 废物 一 Z=0 //inline private 
} 
忆悟 Events {
  道理 事 onInit()
}

可惜kt没支持 for(..a) 和 a.forEach{} 平权
不然还能更好玩
📝 明天写出来会贴gist

duangsuse::Echo

#py #code #recommend 说到有趣的py接口，有个 iself()
def read_as_io(f):
class T(io.TextIOBase):
read=lambda o,size: f(o)
return T
-匿名对象
之前写贪吃蛇 snk.c 就用到链表
不想缓冲区溢出的话Vec还是好的。C里你要实现[] 需要懂链表/strcat， rust 里你写 Vec<i32> push 就好了
Rust的生命周期现在基本不需要考虑（尤其是对应用开发时）， type…

77 views14:10

duangsuse::Echo

#code #cg 今天是3.14 PI 🥧 day ！我们用纯 #js+svg在200行以内，完成以下3个特效吧 🦄🌈
- 用WASD操控的网页广告炸弹， websiteasteroids.com 🔘
- 指向你鼠标的emoji 😄
- 可调节内外起伏的，转圈的加载环，多层豪华版 📍

首先，需要引入绝对的主角：表示点xy或速度av的Vec2。有方向，有质量！
https://p5.readthedocs.io/en/latest/tutorials/vector.html#vectors-more-algebra

console.log(x=N2().turn(.5,2), x.a==.5, x.a++) //回滚到0.5!

let L,P,vel, vKbd //画布L 点P 速度v
function draw() {
  background(220);
  P._p(vel); P._lim(L); if(P.x<0||P.y<0)vel.v*=-1//进1步并检测碰撞
  P.i(translate);rotate(vel.a*2*PI);text("⇨",0,0)//(1,0) 时a==0
}
function setup() {
  vKbd={w:N2(0,-1),s:N2(0,1), a:N2(-1,0),d:N2(1,0), q:-.1,e:.1}
  L=N2(400, 400), P=L.__.mm(2); vel=N2(0)
  L.i(createCanvas)
}
function keyPressed(k) {
  (k=vKbd[key]).turn? vel._p(k) : //to(k)
  k? vel.a+=k :0
}

N2=(x,y=x)=>new _N2(new Float32Array(2),x,y)
data=(kv,T)=>{
  let s=(T+''), sub=(s,f)=>s.replace(/(\w+)/g,f), kvs=kv.split(','), cg='',
  vec=(k,v)=>`${k.substr(1)}(v){let a=this._,i=${kvs.length-1};while(i-->0)a[i]${k[0]}=${v}; return this}`
  if(kvs[0]=='_') {
    '+p *pp -m /mm %lim \tto'.split(' ').forEach(k=> cg+=vec(k,'v')+'_'+vec(k,'v._[i]'))
    kvs.slice(1).forEach((k,i)=> cg+=`get ${k}(){return this._[${i}]}set ${k}(v){this._[${i}]=v}`) 
  }
  T=eval(sub(s,(m,k)=>kvs.includes(k)?`this.${k}`:k).replace('{\n',`{constructor(${kv}){${sub(kv, `this.$1=$1`)}}`+cg))(); this[T.name]=T
}

data('_,x,y', ({cos,sin,atan2,sqrt,PI}=Math,tr=2*PI)=>
class _N2 {
  get a(){return atan2(y,x)/tr}
  get v(){return sqrt(y**2+x**2)}
  turn(a,v){x=v*cos(a*tr);y=v*sin(a*tr); return this}
  get __(){return N2(x,y)}
  i(f){return f(x,y)}
  set a(a){this.turn(a,this.v)}
  set v(v){this.v1(); this.pp(v)}  v1(){let v=this.v; if(v!=0)this.mm(v)}
})

emoji矩阵

let Pa, dPtr=1
setInterval(()=>dPtr=random(10,40), 3000)
function draw(){
  clear()
  Pa.forEach(([x,P,a])=>{
    let d=N2(mouseX,mouseY)._m(P)
    push();P.i(translate);rotate((d.a+.25)*2*PI); a.x=d.v%dPtr; text(x,0,a.x); pop()})
}

function setup(){
  skins=['\u{1F3FB}', '\u{1F3FC}', '\u{1F3FD}', '\u{1F3FE}', '\u{1F3FF}'];
  emj=[['👩', skins],['👨', skins],
  ...[...'🧘🫅👷👮👰🤵🫅'].map(x=>
    [x, [...skins, '‍♀️', '‍♂️']]),   
  ['👩',  ['\u{200D}\u{1F9B0}','‍♀️']],
  ['👩', ['‍⚕️', '‍⚖️', '‍✈️']]
].map(a=>emojiVars(...a)).flat()
  let L=N2(400,400), mid=N2(.5)._pp(L), m=8
  L.i(createCanvas)
  Pa=emj.map((x,i)=> [x, N2(i/m>>0,i%m).pp(40)._p(mid).m(140), N2(1,0)] )
}

emojiVars=(base,[m, ...m1])=>!m1.length?[base]: emojiVars(base, m1).concat(/\p{Emoji_Modifier}/u.test(base) ? [] : emojiVars(base.replace(/\u200D|$/, m + '\u{200D}'), m1));

转圈的花色环

let L0=400,L, A,B, tr=P=>P.turn(random(1), L0)._p(L).mm(2)
let L1=420, cir,pt
function draw() {
  tr(A);tr(B)
  let i=2, d=(A.__._m(B));
  stroke(lerp(cir[0].value(),cir[1].value(), d.v/L0), 50, 100, 15);
  while(i-->0)line(A.x,A.y, B.x,B.y);
  P.a+=.01+pt.x; P.v=(P.v+pt.y)%L0 //习题：为何负P.v不向内扩？
  fill(random(360),100,100)
  L.__.mm(2)._p(P).i((x,y)=>ellipse(x,y, 10,10))
}
function setup() {
  L=N2(L1); A=N2(0),B=N2(0), pt=N2(.1,0)
  P=N2(0,L1/2), cir=[createSlider(0,360,15),createSlider(0,360,340)]
  L.i(createCanvas); colorMode(HSB)
}
function mousePressed() {
  pt.x=mouseX;pt.y=mouseY; pt._mm(L)
  pt.i(console.log)
}

请在 https://editor.p5js.org/ 执行，注意保留N2= 以下的库定义。 🤗
另外，对比一下 https://vorg.github.io/pex/docs/pex-geom/Vec2.html
的实现行数，本文在手机上也就是1屏
至于扩展性、调用难度上就见仁见智了
功能上推荐 http://victorjs.org/

79 viewsedited 14:04

duangsuse::Echo

#code #cg #apple 等待光标 🍬 https://www.shadertoy.com/view/XljXzV

#define hsv(c)  ( (c).z * ( 1. + (c).y* ( .6 * cos( 6.3*(c).x  + vec3(0,23,21)  ) -.4 ) ) ) // golfed

void mainImage( out vec4 fragColor, in vec2 fragCoord )
{
    // Position normalised into (0, 1)
    vec2 P = fragCoord.xy/iResolution.xy, M=iMouse.xy/iResolution.xy, d = 1.0 - (P * 2.0);
    // Rotation
    float L=length(d), r = acos(d.x / L) / M_PI, lv=M.y*50.;
    if (d.y < 0.0) { r = M_PI-(r + M_PI); } // Sort out the bottom half (y=-1)
    r+=sin(smoothstep(-M.y,M.x*2., .9*L));
    r =  floor( (r)*lv)/lv; 
    fragColor = vec4(2.*hsv( vec3(r/2., 1.0, 0.5)), 1.);
}

带夹层

// Position normalised into (0, 1)
vec2 P = fragCoord.xy/iResolution.xy, d = 1.0 - (P * 2.0);

float r = length(d), a = atan(d.y,d.x)/ 2./M_PI;
a+=cos(.6*r);
fragColor = vec4(hsv(vec3(a, 0.5 + 0.25*sin(iTime*a), 1.0)), 0.5);

78 viewsedited 11:29

duangsuse::Echo

#code #asm on x86-64, Diane's silk dress costs $89
>which registers are used for passing arguments in a Linux x86-64 system? make a tool in js, replaceTo arg{0-5}

ASMR="
subs=(kv,re=RegExp(Object.keys(kv).join('|'),'g'))=>s=>s.replace(re, key => kv[key])

subs(Object.fromEntries(
    'rdi rsi rdx rcx r8 r9'.split(' ').map((register, index) => [register, 'arg'+index])
))(fs.readFileSync(0, 'utf-8'))
"

从中可以看到源码调用printf() 的汇编

>find regular file in /usr/bin/* , sort size |xargs file
find `ls -d /usr/bin/* --sort=size` -type f,d|tail -n 1000|xargs file|grep ELF

>radare2 cmd to find string "usage", and show xref in code
r2 <<<'aa;`iz~usage|awk "{print $1}"`;`axtq`'  /bin/db_verify 

>objdump -d, intel-syntax, no address or bytes, .text only from 0x0000113f
objdump -d -M intel --no-show-raw-insn --no-addresses --start-address=0x0000113f  /bin/db_verify|node -p "$ASMR"

x86_64-CDEF/cdecl 科普：
The first six integer or pointer arguments are passed in registers rdi, rsi, rdx, rcx, r8, and r9.
Floating-point arguments are passed in the vector registers xmm0 through xmm7.
其他参数溢出到 rsp-.. 栈上，rsp+用于局部分配(right-to-left order)
<16 bytes 自动传值，也就是可int vec4
Integer and pointer return values are in rax. caller is responsible for cleaning up the stack(rsp-=.. SYSV/win32 STDCALL/包括C++ thiscall 是callee负责，这是唯一的区别)
Floating-point return values are in xmm0.

C语言可以说是汇编的附庸了，在编译后各种类型都会变成+8 +16 的偏移量，struct不能作为值自由地传递或返回，就连数组长度也记不住！

67 viewsedited 03:54

for file in *.{jpg,jpeg,png}; do         cwebp -quiet -q 90 "$file" -o "${file%.*}.webp" &&rm "$file";         echo "Converted $file to WebP format."; done

89 viewsedited 13:28

duangsuse::Echo

#learn #bash with #tool 入门+优质冷知识 😋 图为 asciinema.org/explore 。没有 #linux 的极客可打开 WebVM.io Linux Deploy; (Mac)Git Bash; winetricks; screenfetch 甚至 bashttpd; pacman/OpenRC init 基于bash shell 是类似 Windows.ps1 但使用纯文本或行IO的脚本编程语言。每当你看见awk|sed|grep ，那就是在 #sql sele…

— Linux与命令行
"外壳"提供了调用软件的人机接口。在 kernel.org 已对内存cpu分时分址复用、解码/dev/sdXY 分区, /sys/内设外设+网 ls {/proc,/sys/class}/net 的基础上。这是DOS.COM 所不具有的
.bashrc 和 etc/XXX.d/ 以run-command而非json注册表的方式配置设置，这既先进又落后。 rc的灵活性远优于yml，但bash的无类型,单全局表将其化神奇😅为腐朽了（毕竟1971年老古董）


pacaur -S xonsh elvish pwsh

拥有更合理的弱类型API

您的终端通过 ANSI 清屏=printf '\e[2J\e[14t' 来控制显示效果，但对于TUI应用..有少数stdio管道不能实现的接口， https://docs.python.org/zh-cn/2/library/termios.html .iospeed.O_NONBLOCK
->py termios 如何进入非阻塞(游戏按键)模式？编写 key echo demo
->表格出所有ANSI escape，然后函数化为 clear=lambda: CSI('2J'); ...
bash连接到的tty服务器=$(fuser -s $(readlink /proc/$$/fd/0)) ，如 xfce4-terminal;ssh;tmux

— 进程管理
^C终止 ^Z挂起到jobs
htop; powertop TUI监视器

yes sir|tee just-like.dd
nohup zenity --entry --text="请输入您的姓名：" &
tail -f nohup.out
time sleep 1

#记录3态时间的后2Sum是CPU占用率，sys时间较高=IO密集型
jobs -l 查看pid; fg bg 继续任务$!, kill -9 $(pidof bash) 杀死

— 命令的组合 &; >< 与括号展开

{cat,echo}|grep #不要这样做！ 使用'<'或arg1输入文件常量，'>>', &>/dev/null 赋值文件。尽量不要使用 >

&>fp 即 1>fp 2>&1; freopen了两个换行流文件(stdbuf -oL)，就像 import subprocess.Popen(stdin=-1) 它可被读写

less -f /dev/stdin &sleep 1 &&echo>>/proc/$(pidof less)/fd/0 hi
lsof /tmp/; ss; strace -etrace=openat,getdents64,connect ls

您使用lsof即可知道进程打开了什么(网络)文件

表达式if\else

zenity --question --text="确认要执行吗？" && echo "您已确认执行。" || echo "您取消了执行。"
test -f nohup.out &&wc $_

for,case在文尾。罕见于urls|xargs cat

a=hih;echo ${a:0:2} ${#a} ${a//h/H} $((10/3)) {01..9..2} {good,bad}boy {z..a}

hi 3 HiH 3 01 03 05 07 09 goodboy badboy..
{} 允许并列,嵌套和正择 🥰
使用可嵌套的 $() 取代`` 除了可以调用文字替换API，还能提升组合力

diff <(echo hello world) <(echo hello bar)
less <<<Good #配合 ruby -p; node -e 胶水使用
JS=$(cat <<OK
  heredoc,就像""仍能内插${} ''
OK
)

不过sh系都支持多行字符串
可以手动 tmp=$(mktemp); trap 'rm -f "$tmp"' EXIT

— 目录管理
文件夹名/拖放 转到。不要用cd那个太古板了
mkdir -p 目录/树
ls -lh; tree; du -h 读目录,计算df大小
echo>>a.txt 记录
rm -rf * 清空$(dirs)
^xg #查看符合正择的文件
cp;mv 复制和移动到arg-1即 $_
chmod {+x,755} 设置可执行

set -s noglob 以禁用*正择
可深度遍历,匹配多个斜杠。正则[0-9]仍有效，但'?' 变成了(.)， [^\d]* 成了 *[![:digit:]] ，从find和sed的使用来看😅bash的RegExp是🤡

ls !(*.mp4)
echo **/*.mp4

替换文件扩展名(thunar -B ，不得不说单字符很脑残,何况bash连对象键值都停留在get/set函数名) https://wangdoc.com/bash/string#搜索和替换

fp=a.x.mp4; echo ${fp%.*} ${fp##*.}
echo ${fp/.*/} ${fp/*./}

a.x mp4
a mp4

for fp in *; do [[ $fp =~ \.png$ ]]&&ls "$fp"; done

自至剪贴板

a=$(xclip -selection clipboard -o); base64 <<<$a|xclip -selection clipboard

练习：封装这些功能为函数或basename式CLI工具，加什么参数你看着办，这幼儿园Perl我看着就难受

— sh变量
不支持str和float算式，支持?:

pargs() { echo "$@"; }
pargs x y #x y. 不像argv它不含$0
echo $PS{1,2} #为什么大佬教你要 "$var"呢？试试在文件名里加空格或 echo $(cal) ？牛逼啊，还能SQL注入了！默认语意这么脑残
IFS=":" # read分隔符为冒号, 遍历可执行注册表
for dir in $PATH; do
    echo "$dir"; done
export PATH #bash连字符串变量也不默认传给子进程
#有无屏幕, 其实 .bash_login 就是tty-only
(xdotool sleep .1 search --name tty windowsize 100% 100%)& alacritty
[ -z $DISPLAY ]&&startx /bin/sh atty.sh

read id; ${id:=Peter}
read id; ${id:?Oh no Peter}
#不建议用 declare -i c; c=1+2 或let=运算,可以
((a=1,b=2)); array=([2]=c [0]=a [1]=b) #读取 "${array[0或@]}"

— 权限
您的系统通过chown和setcap来管理特权，所有文件通过 umask: ugo(user grp other)三权分立，一般为 644, 755(=rwxrxrx 对于目录x允许进入)
6(rw-)即是位旗 0b100+0b10+0; echo $[2#100+2#10]，644以此类推
特别地，wheel 用户组(类似win/droid的SYSTEM) 可使用/bin/sudo 来鉴权到sudo的所有者root。为了防止 LD_PRELOAD注入应使用 visudo 修改配置

find / -perm /4000

列举所有自鉴权模块如su

sudo setcap cap_net_bind_service=+ep $(command -v python)

#允许bind 80端口
# cat /etc/{,g}shadow /etc/{passwd,fstab,sudoers,ssh/sshd_config} 只有root能查看。权力越大责任越小，rm -rf /* 😱享受特权吧！

— 古怪的语法
先前学过java的大佬，会觉得 if-fi case-esac for-done 比Lua和Matlab还啰嗦，这是因为bash采取了shlex 而且和TeX一样不懂变通
if [ ]; then, for in ; do 更像是2条命令(do eval字符串 done) 而不是“块”， forkBomb() { sleep; } 尾分号同理
bash 区分命令和计算的$()也很含糊，但在pwsh上都是 ()

duangsuse::Echo

#tool tty canvas #ai 编程失败
>用py实现 sudo hexdump /dev/input/mice -ve'3/1 "%d " "\n"'| for X,Y in lines: 叠加x=0,y=0 并移动终端光标
(很烂而且没有避print换行的坑)
gpmm() { #鼠标光标
stdbuf -o0 hexdump /dev/input/mice -e '3/1 "%d ""\n"'|awk -v kx=$((COLUMNS / LINES)) -e '!/*/{x+=$2/k*kx;…

85 viewsedited 06:05

duangsuse::Echo

— CLI程序服务 getopts; complete 用于获取短参数和提供补齐。少数人用while shift/read;case 来解析还有一个select in ; do，和py2 print 是异曲同工之败笔，请 ->展示zenity的所有功能，并生成一个简短的MC风格的文字冒险 #!/bin/bash while getopts ":n:s:err" opt; do #?未知 :空 case $opt in n) n=$OPTARG ;; s) s=$OPTARG ;;…

#py #code snake 贪吃蛇，最近很忙放着待改

import termios as TTY,copy, sys,time, numpy as np

from contextlib import contextmanager
from dataclasses import dataclass as d
@d
class tty:
    fd:int
    @property
    def Is(_):return TTY.tcgetattr(_.fd)
    @Is.setter
    def Is(_,v):TTY.tcsetattr(_.fd, TTY.TCSADRAIN, v)

@contextmanager
def swap(x,r, f):
    v=r.fget(x)
    try: r.fset(x,f(v1:=copy.deepcopy(v))or v1);yield
    finally: r.fset(x,v)

sdf=lambda w,h,f:np.fromfunction(lambda x,y:f(x-.5*w,y-.5*h), (w,h))
sdQuad=lambda r:lambda x,y:abs(x+y)+abs(x-y)-r
def snake(a=sdf(15,15, sdQuad(10)), fps=2):
    a=np.vectorize(lambda P: 1 if P>2 else 0)(a)
    n,m=a.shape; P=0;dP=1
    kbd={'a':-1,'d':+1,'w':-m,'s':+m,}
    def ADWS(a):a[3]=a[3] &~ TTY.ICANON|TTY.ECHO; a[-1][TTY.VMIN]=0
    def f5():
        nonlocal P
        P+=dP;a[P//m,P%m]=0
        print(a)
    with swap(tty(0), tty.Is,ADWS):
        while True:
            k=sys.stdin.read(1); dP=kbd.get(k)or dP
            print(f'\x1b[{n}A',end=''); f5(); time.sleep(1/fps)

snake()

105 viewsedited 15:49

duangsuse::Echo

#learn #kt Benny霍评论区
协程 async。自动传回调、var都打包到其class因为，比如传给sleep()后自己要return。协程对象就比()->闭包多留个switch(nthStmt){}

把sleep()外提为赋值语句，以保留和恢复调用栈而已，linux单核调度多线程，甚至你调用IO时为了鉴权，也会这么干。 cat|head 不就会await您的键盘吗？ read()就会suspend 1个C语言的“有栈”协程。
之所以要async，只是想节省pthread_create，因为你要拿mainloop去poll(定期/卡http的轮询) 触摸屏事件，设备资源是独占的。这和内核驱动(/dev/WebUSB) 才能导致死机蓝屏是一个道理

如果系统，比如Web APIs吧，只提供回调而禁止while(1)，哪怕只支持epoll(查看监听)/select(poll多项)，就根本不存在线程一词 -就像C里你并不知道read()本质上await在pipe前“生成器”的write()
--也有人叫它yield，那是因为我们不能靠return写入“文件变量”、不能重赋值函数参数以返回多个值.. 为此jspy还发明了“async*()=>生成器”..
完美复刻UI层State(val).onvar[]的轮子呢！可惜是难用难复用的阉割版。

VSCode只加两个js线程，就能运行得很稳，这难道不是App设计的常态吗？难道那些小程序比code更“架构”？
至于免锁或基于资源.transferTo()的多线程，WebGL/numpy/MapReduce(ForkJoin) 不需要重造OS 1Dispatcher:N Continuation(该叫class CPU: ()->isFinished吧)的轮子配什么池化，就能实现前后端们无法想象的性能提升。

ES5的 yield cont=>setTimeout(cont,1s) ，由awaiter链接timeout和g.next，已经是免编译协程API的巅峰了，Promise.then 只是省得你传cont回调。当然，timeout也可能返回cont=> 所以then要能接受async()

另：JS是视 fetch(u,{abort:Signal}) 取消任务的，我不认为app里会需要一堆 coroScope{} 这样图文不符的结构。kt在UIUX界敢能和H5相比么？为什么语言多项功能，app的功能却少的可怜！

kt的结构化并发不比Go的WaitGroup(semaphore)有用，但新词一大堆，初心全忘了，开始比java还八股了。真可笑，屠龙者终成恶龙
那些比Promise更繁琐的，是毫无语意的知识，迟早被py AI自动完成。看来科学界也不喜欢代码圈整这些无聊的class

就问 https://python-future.org/ 2to3这么聪明又简洁的lib，java人们啥时候能学会？态度问题，不是智商低 #statement

协程线程进程，都是Job
jobs的管理上，除了^Z SIGHUP再 fg bg 恢复，内核还支持swap(整个系统的)内存页到SSD，甚至用CRIU直接把进程快照为文件。这样的快照不仅能多拍，还可通过网络传输，简直易如截屏，又像 Termux.dev / Waydro.id / webvm.io 那样神奇；然而这样超越运行期的“时间魔法”，90%的编译器根本做不到，只能用reflect或asm模板这样的残次品搪塞；同理90%的语言里“函数值”都没有相等性--所谓闭包“值捕获”却并不能自动内联JSON，所谓RPC,protobuf还不如微软的COM,pwsh.NET普适
#os 在这一点上可比 #plt 的孤岛、围城，先进太多了
https://t.me/dsuse/19341

https://kotlinlang.org/docs/coroutines-overview.html
https://github.com/youngyangyang04/TechCPP/blob/master/problems/为什么用户态和内核态的相互切换过程开销比较大.md
http://cht.sh/podman


podman run -dt -name cnt busybox /bin/sh -c 'i=0; while true; do echo $i; i=$((i + 1)); sleep 1; done'
podman container checkpoint cnt
podman container restore cnt

https://t.bilibili.com/948850441406382096

duangsuse::Echo

#java #code serde codegen
用jshell API 实现了一个ini序列化，大概比直接靠javac 简单
>以下代码实现了 dumps(Pair::class) (Pair(0,0), mutableMapOf("first" to 3))

fun dumps(T:KClass<*>, ld:T=JS("(void)(${T} o, java.util.Map<String,Object> m){"+
T.memberProperties.joinToString(""){"…

165 viewsedited 03:23

duangsuse::Echo

#think #web #tool
https://cssgridgenerator.io/
https://crocotile3d.com/
https://fixupx.com/Oroshibu/status/1808500235263418441?t=BtGGBHj9jnN2AReHW2VTWA&s=19
三視圖？

有趣的建模工具
帅啊！
螺莉莉的黑板报:
(๑•‌ㅂ•‌)و✧
https://dataset.wav.pub/

https://brython.info/demo.html
https://github.com/Distributive-Network/PythonMonkey
#py
螺莉莉的黑板报:
https://github.com/baskerville/plato/blob/master/README.md

你们 rust 真是啥都能干……

https://www.sea-ql.org/SeaORM/

这东西好用么……求教……

https://gitlab.com/coolreader-ng/crengine-ng

有趣的引擎

https://chinese-font.netlify.app/ font
https://typst.app/universe/package/bob-draw
#svg

https://ivanceras.github.io/svgbob-editor/

#code
duangsuse:
大量复制粘贴十分抽象
list有那么难用吗
难道你没注意到近十行只变了1个参数
AIGC也没脚本化得这么严重吧

我看还是用list first!null好了，这么八股文…… 大家现在都是用get null取代预判has的

这种到处预判的风格，很像你找大佬问问题，先发「您在不在」，他只好回个在，然后你不在线……

表达式化比你想的要多哦：

>Spring如何把 @Autowired T xx; 换为 var xx=find(T.class)

var Ts = [T.class].map( applicationContext::getBean);

你在class{}里加那一堆定义，如果只引用了一次，就完全不应该引用。到底都是要查bean的

从code smell来看，只使用了1次的变量名是无效的；如果只是为了易读新建变量，只能证明你的helper fn命名的有问题

kt已经有!! 了，还想要更多
Java 一大特色，注解属于元数据，和函数调用有重大区别

duangsuse:
那这是定义“随用随扔”变量名的理由吗
函数和变量是这么用的？
java以省略[""] 为由引入太多常量复杂度的优化了，都要所谓框架来解决

纯粹是make compiler happy，把一个schema弄成它能读懂的class，然后再强转Any来构造class而已

js里一个字典让java用就是这么麻烦，其实能用几次呢？ init完就扔了，根本不是性能瓶颈。

注解的本意，应该和py的 @decorator 一样，是接受class元数据的编译期函数才对

而不是等到运行时才去查什么field有哪些@属性然后逐个.set()

要动态生成一个类型，来获取注入，简直无理取闹。明明就该在编译期产生Registry.get&fillNew的样板函数

这是属于既把元编程的路封死了，还不让基于注解的注入框架提供统一的“反射”方法

其实jawa懂这个道理，但它偏偏就做得很烂，就会个@Override
duangsuse:
为了编译速度这也太幽默了，其实，jvm作为栈机基本就是带类型签名的GNU dc计算器，不需要什么编译优化

如果递归下降一遍，校验下类型生成个push call 就能花什么编译时间，属于是用PHP的方式搞算法了

而且javac的能力还远没有到c预处理器的程度，为了优化？我看是他们不在乎程序/类定义的优雅性

什么序列化啊，也没有做规范，和py能 import json,yaml,toml,marshal 能比？就一个用来RPC的ObjStream，还被业界遗忘，哈哈

汤姆猫是大专必学

虽然汤姆猫的Biz程度也就比Node http-server强半点吧

所以问题就是Result类型为何没有重载 !!，让它看起来仿佛只是带有错误消息是null

凭什么!! 只能校验 Type? 呢？
assert也是乐观/悲观路径
Exception也是，为什么不能一起判定了？
还非得搞个ifEmpty, ifBlank.. ifNullOrBlank..
莫名其妙

duangsuse:
这不是废话吗？例如买30天大会员，肯定是30* 24*60*60秒后失效，这才是世俗意义上的电脑时间

看到py关于时间和日期/时差有3个API
我就觉得抽象

audit就是一个不懂AOP的，其实unix可以靠strace审查syscall，win32的 sysinternals.com 也有进程日志功能

与其自己搞个无人知晓的轮子，不如封装别人的，两全其美
把OS的活都包揽了，难道py是要运行在Ring0把内核驱动都带上？那必须支持啊

绷不住了，抽象程度直逼jawa

一开始就不该搞所谓orNull
默认 first{}!! 就够了

我在js里都是把Error视为object返回值的特例，和null是一个意思
这样就不存在什么orNull orElse的，catch表达式也免了

就是语言设计者对值体系的理解不过关，例如NaN就是numbers的null才对，而不是什么number?
这样才能用统一的方法去报错/换默认值

可悲的是一开始就没把悲伤/快乐路径当问题啊，真是异常搞心态

duangsuse:
幽默IDE
完全相信它的API有一大堆根本用不上的class
忸怩作态的软件没必要去维护

kcp是这样的，可 import ast 自 https://python-future.org 就没变过😋
py只是用:隔离一个表达式先于=执行，就实现了高贵语言们的静态检查

既可以用于静态分析，也能在运行时查看f.annotation ，完备的数据不需要反射

btw. 大佬应该会做一个DSL
Message.invoke{ id==mid }
Message.select{ id==mid }//多项

可是这种写法才是真正的SQL逻辑式

既然Msg(id=)能构造数据， Msg{id==} 就能查询
这不是很合理么 #kt

很简单，如果做得太标准，以至于移植到任何一门语言里都没必要修改的话
就没人给官方docs贡献流量了

duangsuse:
https://www.liuwj.me/posts/ktorm-introduction/
🤔 一个SQL函数.xml codegen 能被吹爆，还有人卖课是我没想到的
ES6里一句 sql${} 解决的东西，哈哈

「没想到他文化程度那么低」……

怎么会呢，语句能缓存，再怎么也比一次加载完dao好

你要是不喜欢，或者不相信语法糖有缓存，可以做成生成函数的形式
例如
updateId=f=sqlFn2{a,b-> Pair{B/b, A/a}}
f("bye",0)

所以说，如果你不相信DSL能被缓存，可以转为生成sql函数的形式啊

这不是MyBatis++ ?

https://github.com/JetBrains/Exposed/blob/main/exposed-core/src/main/kotlin/org/jetbrains/exposed/sql/Op.kt#L184

我只能说，缓存键要么是调用点或次数
要么是函数
似乎很难单独缓存DSL对象，除非对它们的构造器
幸运的是， key eq x 里x的修改能缓存，因为它是参数

https://jetbrains.github.io/Exposed/frequently-asked-questions.html#q-how-to-get-a-plain-sql-query-which-will-be-executed

https://stackoverflow.com/questions/74821893/postgresql-arrays-instead-of-extra-table-in-a-many-to-many-relationship
涨姿势了，以后 1:N用数组json N:N用join

duangsuse: #fp
要是kt能允许编译期生成一部分表达式，就没这问题了😅😅😅

可惜啊， unquote{bash(q(trim("trimedStr")))} 这当然是lisp的专利
其中q() 被生成为一个字面量，就像闭包捕获：
fun bash(s)=trim(s).let:
paste {system(it)}

并没有所谓的编译期，因为编译器能访问所有lib API

0开销不是瓶颈问题，但事关语言的脸面

明明就很有用，可被一些人理解为「并非瓶颈的东西」
然后被rustc拿来完魔法

要我说他们就是傻屌，只不过是把闭包「捕获」的实现方式，改为内联字面量(unquote)
就能轻松突破编译、运行的动静边界，根本没有引入任何新API ，没有什么循环展开和 kotlinpoet javapoet的区别

他们做成什么样了？正则的缓存还不如py的拿dict查😅

cssgridgenerator.io

CSS Grid Generator

CSS Grid Generator - a user-friendly tool designed for web developers to effortlessly create customizable CSS grids for seamless web development.

75 viewsedited 09:03

duangsuse::Echo

#kt #code 😊之前，v8 blog说Promise就是Continuation(含续体的回调)，我还觉得多此一举
和Kotlin“强大”的API一比，我却要变成ES6吹了。Web的先驱者们简直是先知啊！代码越复杂，成品功能越简陋。这就是为什么安卓app体积不断膨胀，功能却越来越卡。


interface Promise_<R,T> {
  fun then(ret:OrErr<R>) //delay() 后应该这么做，那之前只需调用它并return。它通过cpu{}排队，另一种排法是yield Promise
  //launch(ctx=Main+CoroName("val")) Map状链表DSL。Job等元素
  var cpu:(Runnable)->Unit; name=""
  fun go(:T?):R
  fun stop(:ErrStop)
  stdState=0,1完成,2取消
  //不要使用截获器和Key环境变量。组合优于继承，go 的WaitGroup比不伦鸡肋的scope明确多了，Android的curl比js的fetch流更复杂吗？
}
type OrErr<R>=Or<R,Err>, Err=Exception
val OrErr<R>.!!: R
sealed Or<out A,B> {
  data A(:A) data B(:B)
  fun as(A->R?, B->R?={null}): R?
  val A:A? val B:B?
}
fun T?.as(R, T->R):R
fun T?.as(T->R):R?

😊顺带把阿K没有统一的err/null错处也搞了，还要什么 o?.x?.y ?: 1
https://www.bennyhuo.com/book/kotlin-coroutines/12-why-so-called-lightweight-thread.html

上面说协程=Thread.asCallback() 只是一种go/lua的罕见情况，好理解嘛。
kt里协程是通过retAddr()作为参数，实现的链表化调用栈，其第0项一般是 runBlocking{}或thisCPU.nextJob
这样可以在主循环注册任意个delay()或flow{}的回调，优化 Promise.all。这是虚拟线程所不擅长的
https://www.bennyhuo.com/book/kotlin-coroutines/13-implementations.html

Benny Huo 的专栏

12. 协程为什么被称为『轻量级线程』？

接触新概念，最好的办法就是先整体看个大概，再回过头来细细品味。文中如果没有特别说明，协程指编程语言级别的协程，线程则特指操作系统内核线程。 1. 协程到底是啥？ Kotlin 的协程从 v1.1 开始公测(Experimental) 到现在，已经算是非常成熟了，但大家对它的看法却一直存在各种疑问，为什么呢？因为即便我们把 Kotlin 丢掉，单纯协程...

62 viewsedited 16:31

duangsuse::Echo

https://ray-eldath.me/programming/three-important-ideas/ #statement #PLT Ray: 我的一位朋友如此评论这些文章：他说真正理解抽象的唯一方式是通过抽象本身，而不是通过并不准确的类比。「为了充分地（"有用处"地）学习这些抽象，你必须去学数学，而不是通过一些糊里糊涂的文章，它们除了类比还是类比」 Dr: 要找到 “哪些代码遵循此抽象” 并不是必须的。像 Monad 这样的概念是非常抽象和通用的：它是一个描述了一套广泛的编程模式、数据结构、库和…

#PLT #learn 文中提到一个Futa对应关系(第一类二村映射 first Futamura projection)，展开讲讲还蛮有趣 🙉
首先，js人都会写计算器的，和 echo input/server 一样的难度

1+2*3
十(1, X(2,3)) -7

十=(A,B)=>A+B

这被称为「前缀式polish notation」，是Lisp的国是
教个小诀窍：js里函数只是一种字面常量，可以被for生成

Object.entries("十一Xノ").forEach(([i,x])=>
  this[x]=eval(`(A,B)=>A${"+-*/"[i]}B`))

为了更像“语言”，可以用列表(进一步就是"1+2"的代码)实现语法，便于糖化

Eval([十,1, X,2,3]) -7
Eval=([f,...x])=>(!f.call)? [f,x] : //基线返回两项，递归就都是两项
  (([A,b]=Eval(x),[B,c]=Eval(b))=>[f(A,B), c] )()

Monadic递归下降是这样AbBc的，因为不能右移流指针。不如逆波兰好看！不过这种程度的递归可以学学。

再看下「解释器interpreter」比计算器强在哪： 能够“在调用时传值”，也就是要有 argument[0] 这种“环境变量”
很厉害！现在有常数外的“语法”了，有变量了，高阶了！或许你需要学动态作用域(原型链?)、调用栈call-ret、惰性求值如&&|| blabla，还有深不可测的编译优化呢！

不就加一个箭头么。

十=(A,B)=> (env=>A(env)+B(env)) //现在知道为啥该用for生成函数？
Lit=x=> env=>x
Arg=i=> env=>env[i] //PHP写作 $x, 模仿bash的$1~$*
Fun=(n,f)=>f(Array(n).fill(0).map((x,i)=> Arg(i)))

env被称为运行时，它可以是JVM, import dis 或者别的bytecode解释器，这能减少tree-walk对递归栈的频繁依赖
这种 formSytanx.bind(consts=lit/arg/global/Types..) 的"部分传参"函数，称为编译器，而它的返回就是classFile等类型。
编译器并不需要与DSL这些技巧隔离，如果我们把 env=>x 写作 JSON(x) 而 env=>env[i] 写作$i ，既 Lit=x=> gcc? CBor.dumps(x) : (env=>x)
以这种人类或机器可读的结构序列化一些函数被"bind"到的lit，就得到了对应的代码。jvm的 lconst 1, aload_0 this参数, iadd (2->1)甚至是自动分配参数寄存器的！
https://www.yinwang.org/blog-cn/2014/01/04/authority#:~:text=partial%20evaluator。其实并不是特别神奇的东西，只需要在普通解释器里面改一两行代码就行，可是有人

二段求值。代码是流动的数据，内存是暂停的程序。本文甚至比赢王更直观： https://www.yinwang.org/blog-cn/2012/08/01/interpreter
定义个“元循环加法”吧？

十1=Fun(1, ([A])=>十(A, Lit(1)))
十1([232]) -233

//[Lit(f),x] 补丁下Eval"解析器"。计算器、解释器、编译器间，其实并非泾渭分明
Eval([十,1, X,2,X,1,3])[0]([2]) -7

如果你乐意，还可以支持基于全局表的递归 fib=f(x)=x<2? 1 : f(x-1)+f(x-2)
这一切都不会突破以上的定义框架。 If 不会，Call(f,x-1) 不会.. 这就是java的反射嘛。
我不想再写什么了。我看过许多“编译原理书”，他们连这个=>都写不明白。更何谈用Visitor实现(反)序列化这些既理论又实践的approach
#haskell

data Val=L Int|Op Char Val Val deriving(Show)
(Op '+' (L 1) (Op '*' (L 2) (L 3) ))

这类基于list或class{子类多型} 的 Eval(e=^^, env={proto:{..}})，与本文使用的闭包法是等价的。「闭包是穷人的对象」，Promise 给它暴露到了 obj.then(Continuation)

> 高阶的思想或许是本文的所有思想中最为重要的那一个 https://ray-eldath.me/programming/three-important-ideas/
你们知道函数的函数、类型的类型、语言的语法，却难以创造「语言中的语言」—跨越用途与界限而一致的语意。
我看numpy和 taichi-lang.org 就用的很好，比LLVM好一个世代
顺带一提，上文还使用了 Tagless Final 和 De Bruijn 索引 😇 。只是…… 你甚至不需要知道它们的名字。([A])=> 经常被实现为KV["A"]，但点明它的本质，却比写解释器更简单！

说到底，元编程也只是编程。就像“学会学习”只是一种策略，它对学习而言，并非例外情况。难者，不会也，譬如在谈"bind(x=1)后函数值字面是否改变"时提起「颗粒化curryArg」当然会让人迷糊
node,graal会编译js,jvm代码（这也是为何Chrome页偶尔会segfault）； JVM会使用汇编模板+JIT 的混合式优化，Cython则把“甜妹语言”翻译到C，LLVM则是个伪装成NodeGraph虚拟机的codegen
如果只用"是否该调用javac"来区分语言，认为C类型总比python更快的话，你会发现程序员钟意的都是freak！

宏，macro码可揉，是传入与生成class{}等字面的函数。和+-*/一样只是函数，而函数、类型，只是值，别被“静态分析”骗了，它们送你的class只是病态类型。
入，lambda栏目答，看x,A,B等栏目回答的算式
这点篇幅放前言都觉得寒碜吧？可就是没人做到啊。扶她投影？不知道的还以为是HP projector 的娘化版呢。。
PLT能对dev点化到的可谓寥寥，但100%都是必要且急需的知识和"抽象"，像Prolog的模板与响应式html编程("FRP") 什么的。 Monadic错误处理我不想吐槽什么，只能说不怕不识货，只怕和Kotlin比！

跑题了。当然，聪明的你会发现Fun的返回违背了"基线指明了递归的类型"这一原则，没生成 env=>
那C语言函数指针是这样的，env由*rbp[0:2]=[retRbp,retAddr]这些CPU变量提供，但JS里的闭包可以从env偷变量(Var作为值,mut ref)，所以说「闭包是穷人的(单方法)对象」

C里还有"函数符号"，那是由ld.so实现的全局表，让.o对象能先被mmap到任意地址，再去回填calls
真正的那个全局表叫 $PATH: ，以及没定义main的对象的 $LD_LIBRARY_PATH 。

duangsuse::Echo

#plt #code 谈到RPN，我昨天有个灵感想把js做成缩进的形式
就回顾了优先级算法（嵌套深度包括h1~h6树本质上也是优先级）

示例算法 sexp(tok('1 (2 3) 4')), exp(tok('1*2+3'), optab)

optab={[';']:-1}
"=;+ -;* /".split(';').map((a,l)=>a.split(' ').forEach(x=> optab[x]=l ))
exp=(s/*token x单项o算符 x..*/, l/*evels 大则深…

185 viewsedited 09:09

duangsuse::Echo

#cg https://firedancer-lang.com/ 可以和 Pi day https://t.me/dsuse/19402 结合看

#ai #game https://nicholas.carlini.com/writing/2024/how-i-use-ai.html#simpleapps
py flask 🤔#code 都是完整代码

Firedancer

Haxe-based language for defining 2D shmups bullet-hell patterns.

99 viewsedited 06:26

duangsuse::Echo

#js #code https://blog.axlight.com/posts/how-valtio-was-born/ jotai作者的博客

React 虽然很流行，很“FP”，但我不得不指出，它对“不可变”或者说「静态」的理解是有问题的…… 这点上居然输给了被它打败的MVP,MVVM等八股文

div(input(n=0)) 包含可变状态吗？许多人觉得n是一个变数，那么， class ModelThis(var n=0) 凭什么能被称为「静态类型」呢？视图的模型，到底是静态还是动态？

React 没有意识到，作为一个框架的职责，是维护JSON所对应的HTML模板；而函数式的作用，仅限于用mapfilter取代 forif 这些缺乏表现力的套路
“不可变”并不包含更多的超能力，实际上，它只是对「静态结构」的误解。JSON总是可变的，但它的Schema(struct,'type':union..)则永远是固定的！

集合类型，也包括函数，都能包含树洞。只要你定义了字典与HTML里树洞间的「对应关系」，并不需要什么设计模式就能秒杀各种UIUX。

>https://gist.github.com/duangsuse/c2703fae87c92826a482ef2dd9f523c6#file-note-woj-js-L35

口=holey
let A=口(0), B=A(x=>x+1)
A(2)

JSON.stringify({A,B}) //B: A+1 永远成立，无论保存在什么结构里
el(doc.body, el("div",{onclick:A((x,to)=>+x+1)}, el("input",{value:A}), el("u",B)))

这样就是一个Counter了 (代码比较烂就不贴完了，许多相关数据结构都还在设计中…… 相信最终会很优雅

我在React里看不到这种“口->口”（对象和箭头）构成的范畴，所以说它纯函数在哪呢？

如果React是基于关系式列表字典设计的，它只需要请 cage({n}) 把app所用到所有的洞锁起来就可以达成“状态树持久化”
何必解决什么View可变性的挑战？

btw. 冷知识: F12 是怎么显示函数源码 ƒ Object() { [native code] } 的？ 🧐
https://github.com/ChromeDevTools/devtools-frontend/blob/main/front_end/ui/legacy/components/object_ui/ObjectPropertiesSection.ts
https://github.com/ChromeDevTools/devtools-frontend/blob/main/front_end/panels/event_listeners/EventListenersUtils.ts

Daishi Kato's blog

How Valtio Was Born

Introduction There was a discussion in our team after releasing Zustand v3 and the brand new Jotai. It was about whether we could develop another library for global state.
In this post, I will reflect on the start of Valtio’s development and its API design.…

115 viewsedited 05:28

duangsuse::Echo

#rust #go #algorithm UmbraString 是对带长度指针(py.bytes, rs.slice) 的(免链接inline)，而 SwissTable 是对Hash预分组查表的免链接！我们知道，Java 存在(装箱boxing) 一说，也就是int,char等字面值的堆分配 (这是泛型擦除 vs template<>化新建的编译期细节)，因此JDK8用class Stream.OfInt{}缓解了reified泛型的缺失那么，(拆箱unwrap) 其实就是在值的内存上内联，像C++栈分配。…

#algorithm #防自学 🤓 让我来示范一下怎么概括算法思路
要介绍的是在stdlib里，用于组织集合类、JSON的3个重要结构: b"ytesPtr", {K:V}, sorted([0 2 1])=[0 1 2]
它们对各种app和其他算法性能效能的重要性，好比json(cbor.me)之于REST、zip之于jvm和pip。因为是涉及SDK实现的内容，也主观评价下语法设计

下面用胖指针(x64上void*是8b, 胖指16b)、链表、快速排序简单的实现3者 #code

#define Col(...) typedef struct{__VA_ARGS__;} T;

#define T Str
Col(size_t n; char* buf) //C的类型本应默认为指针, *胖指针，像kt那样对Int等类型免链接化。简洁的UNIX里，Type* 快成为public那样的形式主义啦

#define T_Link(E,T) struct T{E x; T* xs;}
T_Link(int,Nums)  //template<T> 允许类型推理，即一致化调用和返回处的<T>。可怜gcc/clang无论对宏还是模板的报错皆如内容农场，不具有可读性

https://colobu.com/2023/06/29/replace-std-map-faster/chunk-index-memory.jpg
用例和 #haskell #code https://gist.github.com/duangsuse/26b80c39e1d8f7549b9cf244d8de1ce4
题外话，闭包值和 x.interface_cast(T) 的双指针&dyn 随结构传入T的函数表

qsort :: (Ord a) => [a] -> [a]
qsort [] = []  
qsort (x:xs) = 
    let smallerSorted = qsort [a | a <- xs, a <= x]
        largerSorted = qsort [a | a <- xs, a > x]
    in smallerSorted ++ [x] ++ largerSorted

UmbraString 和上文Str{n,buf}胖指针一样是16b，但它的.n和jvm一样只寻址[4b:int]的长度，其后最少随4b的免链接char 用于比大小
对于n>12的buf，剩下8b换成指针，指针的高2位用于标记GC信息：持久pin、临时ref、用后即焚val

很明显！这是一种灵活利用了x86内存布局的b"length"实现，和x32压缩指针一样，节省了sort解指针的时间

SwissTable 是对Hash预分组查表的免链接。我们知道， dict/HashMap/lua.Table 这样的{K:V, K1:V} 单映射常被用于查找和缓存，在C++里更是会区分 unordered_map, rb_map(以排序radix,SortedSet,而非hash作为预分组线索)
它的最简实现是lisp里的链表 T_Link(struct {int A,B;}, int_LnKV) ：没留任何线索来减枝！

即便8b hashCode，也是一定会冲突的，哪怕是int.hash也会因 buck[hash%nBuck] 有限而退化为线性查找，负载因子(kv/nBuck 过大)，这时就要扩容。Go的扩容基于一种空间换时间的优化(图1, 为了减少求余数的冲突，除数都会采用2的指数)
扩容后的冲突集，可以用链表(UnionFind)或数组(slot), 从那往右找
Swiss 更聪明，它对每slot对应1b的元数据，最高位0x80=无效项，0xFF=null结尾，低7位用于存储hashcode的高7位，这么摘要是为了SIMD128bit 1次对比8个KV
不仅仅只是CPU CACHE友好，这样的结构配合原子操作，相信很容易做出一个并发版本的hash table

快速求余(x,n)= uint32((uint64(x) * uint64(n)) >> 32)
#dalao https://init.blog/fast-newton-sqrt/

float InvSqrt(float x) {
    float xhalf = 0.5f*x;
    int i = *(int*)&x;
    i = 0x5f3759df - (i >> 1);
    x = *(float*)&i;
    x = x*(1.5f - xhalf*x*x);
    return x;
}

最近的一种基于partition(区间而非idx)的快排也很有趣： less than pivotL | between pivotL and pivotR | greater than pivotR

98 views01:23

About

Blog

Apps

Platform