#py #code 缩进列表 ; YAML版本
#bing 并没有帮我避坑 😒，Group(匹配是否成功) 这玩意它也理解不了；不过 indentedBlock 自带嵌套深度倒是挺巧妙，我以为应该有 流.字典.. 活到老学到老

import pyparsing as P
item = P.Forward()# 递归

LB,RB,LS = map(P.Suppress, "[]:")

item <<= P.pyparsing_common.number() \
|P.Group(LB + P.delimitedList(item, delim=P.Empty()) + RB) \
|LS+P.indentedBlock(ls:=P.ungroup(item), nTabs:=[1]) #不分组会平铺delim

ls.parseString('[1 2]').asList()

周刊文章

#china #history #life 通缩造成的影响体感不明显🤔
失业率带来的恶果要在3~5年后产生
“中国不会失去多少年，一切都是伟大的探索”
https://m.youtube.com/watch?v=CWT1UfQa3co
6:00 奥姆教的地铁毒气事件
15:00 日本在2002年左右才流行“失去了十年”的反思
Leonard: 🐻微服私访，为何没有安全感：党大于法，猎人亦猎物
https://m.youtube.com/watch?v=8doj1q1RKhM&t=7m

#plt 这几天灵感非常乱， 但修正了 改同/file.RwEq<T>, 可见/可定性 (abstract 啥的,语序改后缀)
我最喜欢的就是基于 tailrec 的无限循环:

lets:
  say("hello")
  loop()

有灵感是好事，但设计稿经常变动也是让实现者相当困扰的。 作为既要设计也要实现的人，重复学习的痛苦不可避免。

不过话说回来这个 emoji 😋 翻译真是太有趣了。原来跨语言的编程语言.. 不用语言来思考问题， 是真的可以有的！

原先 .ju 的文化是 .ju_zh(cn) ，我打算改成默认英文了。 尽管初期都是中文在出力(包括统一 operator fun 为 受XX, 可为Either 可同Eq)，就目前看来英文对OOP 简化(data type let lets 比 Kt 的 class interf run apply 高到不知哪去) 的贡献比中文还要大

从长远看， emoji❤️ 或许在API枚举时有大作用，表情化能揭露“设计的逻辑指数”，如同苔藓害怕雾霾。意想不到的收获

👀现在看来，绝句已经完全不像 Java,C# 那样的OOP了。
我们从 - 复杂函数 ^now - 函数值参 推导到 data ^named TYPE等静态量; 而不是凭空蹦出对象类,方法反射的抽象

我们用 data type named made, at at now "物类例同造 量此刻", 而不是 interf class object ctor, val var
我们的 override 是 ^,impl{?,??,!} "可未终定"; abstract只能标在data上. 用 our{api,,type,pkg} "公私族组内"取代 pub private protect internal

enum/seal/data 以 when- XX, when- as() Data 获得统一的ADT写法
扩充函数和隐式转换的本质都如

data- Int as Num

基于''量纲=N`it>0` 做的 check() 和 泛型,typealias 却和 rust, haskell 不一样

物词只能访问 data made(), made: 的变量，禁止参数构造器 (struct式)
幕后字段隔离到 made 可见性 now?: k v ,而 at N neg=-this 只是get
并且以 at xx now Var.our(0) 取代 var private get
get,set,lets,as,wasXX 只是常见的魔术方法

tailrec,"nocross"inline 并不存在，它们是 lets: loop() 和 -! N.plus1(now_fn)=fn.as<JavaFn>(this)+1
await,yield, launch/coroScope 也不存在，只允许 - main=Wait: ,=Seq:add 1 和 Job:, CoPU.Waits:
loop&if (do while) 不是语法，甚至 if q: or: 都可以由语言内建翻译
? ?. 也不是，它们是 decorator - T?.`??`(:Fn1, :函续)
但只要你不设计DSL ，就完全不知道有这层复杂性，你什么术语也不需要理解。

因此 x?+y 和 1 let:+1, [2 3]let:+2 是优雅的

user or: return
1.may{it<2}: return it
Try{ user.name }!

是做得到的

以前放在一行里说不明白的术语， 现在不放一块才显得奇怪
这才叫“英文”编程语言。算是实现一半了

#py #backend https://t.me/NewlearnerChannel/11360
Python 潮流周刊 #10：Twitter 的强敌 Threads 是用 Python 开发的
👉
3、Python 3.12 预览版：支持 Linux 性能分析器 (英)
4、FastDepends：从 FastAPI 中提取的依赖注入框架，异步和同步模式都支持 (英)
5、https://github.com/0xpayne/gpt-migrate ：将代码仓从一种框架或语言迁移成其它 (英)
6、使用 Golang 和 Docker gRPC 运行 Python 代码

7、DisCo：通过指示生成现实世界的人类舞蹈 (英)
8、用 Python 实现一门简易的编程语言 (英)
如何用 Python 来实现一门编程语言呢？这是一个系列教程，第一篇中实现了一个非常基础的编程语言，可以执行 print 语句，第二篇则拓展成支持变量和数学表达式

#ai CuPy：将 NumPy 数组调度到 GPU 上运行


#statement Paul: 如何选择你的工作
“不要计划太多，不管学过多少，只要做最有趣和最能拓展选择的事情。我叫这种方法“逆风而行”。这是大多数成功人士的秘诀。”
年轻人有时间的极大优势。应该用它来追求好奇心、创造力和专业知识：学习一些你不需要了解的东西，只是出于好奇，或者试着构建一些酷炫的东西，或者成为某个领域的高手。

年轻人容易受到他人的影响。他们常常觉得自己无足轻重。
“避免虚伪”是一个有用的规则，但怎么积极地实践呢？怎么找到自己的方向呢？如果你不诚实，你怎么能对真理有敏锐的眼光呢？
爱因斯坦就是这样做的。他能看透麦克斯韦方程的奥妙，不只是因为他有新思想，而是因为他更严谨。注意那些不合理或缺失的地方。99%可能是你弄错了，但也别忽略它们。

也许有些工作需要愤世嫉俗和悲观主义，但如果你想做出伟大的工作，乐观主义更有用
我不喜欢“创造过程”这个词。它有点误导人。独创性不是一个过程，而是一种思维方式。
我们用独创性、创造力和想象力来描述这种能力，一种特殊的技能。很多人有很多“技术能力”，但在这方面却很少。

#dev #java 又做了意义不大的重写： Observer 实现 Trello 任务-状态 看板

use! py time json datetime

data TaskSubject @impl??
  - attach(:Observer)
  - detach(:Observer)
  - notify(:Tasker)
  ^now
    ''(named ts) Tasker=Pair<Task User>

type Observer
  - update(:Tasker)
  ^now
    ''Author=Pair<User datetime>
    - User as=Author(this,datetime.now())
    
named BoardUpdate Observer
  ^- update(ts) = ts.A let:
    at prev=st_history.first{it.id==id}?.history[_-1].status
    prev? :
      boards[prev].may{it has id}: it pop id  //什么逻辑
    boards[status] add id

//显示 “小明刚更新了 吃饭->已完成”
named StatusTrack Observer
  ^- update(ts) = ts let:[(task uid)]
    st_history.first{it.id==task.id}?.history?
    .lets:
      add (uid by task.status)
    .or:
      st_history add task.id 这TM不就是defaultdict吗

made:
  tasks rw.Ln<Task.Raw>
  st_history rw.Ln<Pair<Str Author>>
  boards [:"To-Do" [].as<Ln<Task>>, "In-Progress" [] ]

data Task(:rw.Ln<Observer>) TaskSubject
  ^- notify(ts)
    observers: update(ts)
  ^- attach==observers{add}
  ^- detach==observers{pop}
  when- as
    Raw'id created updated'(_ed Author, updated=created,status="")

  - create(:Tasker)
    tasks add Raw(tasks.size+1, ts.B)
    notify(ts)
  - update(:Tasker, st1:Str)
    tasks.letsIf{id==task}:
      status=st1; updated=uid
      break

      

什么烂代码，尤其是原文， 我才不想写这种

我不讨厌各种UI和"Java版CMS" ，也不觉得有技术很厉害，但好代码一定要恰如其分

1. 《答案在代码中：“实现需求”的双重含义》
😒我倒不觉得 (a+1)%N 往复<N是个坏写法 ，反而是 (剪刀, 石头) in (0~2).zipWithNext.toDict 会多此一举
#py #code
import random

def game(rules="石头 剪刀 布".split(),胜=+1):
comparin=lambda a,b: "平" if a==b else\
"胜"if (a+胜)%len(rules) == b else\
"败"

a=tuple(random.choice(rules) for x in range(2))
return (comparin(*map(rules.index,a)), a)

至于 data Duck(name:Str) - quack=say("$name") 的OOP是否胜于函数式，我倒觉得 class vs. {it+1} 下, 还是前者更值得删掉
毕竟 Event, Observer, UI 这些都不是Duck("唐老鸭") 这么弱组合的; 退一步讲 json={dump,load} 也比class简洁有效

2. 此作者的 #dalao #ai 观 🤔 https://www.piglei.com/articles/chatgpt-and-how-we-programming/ @lilydjwg 依云 也写了评论
不过，他的代码审美观点倒是和我很像 #zhihu
“匈牙利命名法就是把变量的『类型』缩写，放到变量名的最前面。

关键在于，这里说的变量『类型』，并非指传统意义上的 int/str/list 这种类型，而是指那些和你的代码业务逻辑相关的类型。”

3.Django. HTTP模型

微软 Office 的新默认字体终于定了
经过好多年的测试，微软终于在最初圈定的 5 款字体里找到了新的默认继承者，并且改名叫做了 Aptos，事实上这也是风格上最保守的一款了~

Stability AI 发布草图图像生成工具 Stable Doodle

2023-07-18 17:52 by 火星众神

开源文本图像生成模型 Stable Diffusion 的开发商 Stability AI 发布了一个将草图瞬间变成真实图像的在线工具 Stable Doodle。Stability AI 称它既适合专业人士也适合新手，无论他们熟悉不熟悉 AI 工具。只要有基本的绘图技能，能上网，就能在数秒内生成高质量的原创图像。Stable Doodle 也支持基于用户输入的文字描述提示词去生成图像，它目前支持 14 种艺术风格。

https://clipdrop.co/stable-doodle

#人工智能

Redhat对付GPL的方案：

1.不向非付费用户分发二进制程序
（不分发二进制文件就没有分发源代码的义务）
2.只向付费用户分发二进制程序
（此时产生了向用户分发不受限制的源代码的义务）
3.付费用户可以免费申请获得源代码，
但申请成功会导致账户订阅被锁定。

为符合GPL的规定，该用户将拥有当前锁定时间点获得的源代码的一切权利，包括不受限制的编译使用以及再分发源代码的权利，
但用户同时也失去了继续获得新版本二进制文件的能力（GPL并没有规定开发者必须要向用户分发新版本二进制文件，不分发二进制文件就没有分发源代码的义务）

😭可恶的表述式编程，不知道怎么命名变量了

- Ary<Int> mergeSort(rn=eachI) = rn.size/2 lets:[d2]
    if d2==0: return
    at now:
      i rn.A; N i+d2
      a (rn(B=N-1):go(this)).Seq
      b (rn(A=N):go(this)).Seq
      //a,b 半都指向升序

    loop if a.posR & b.posR:
      this[i]=get(a) to get(b) lets:
        if A<B: a goesR; A
        or: b goesR; B
      i goesR
    a: this[i]=get(it); i goesR
    b: this[i]=get(it); i goesR

可视化
我是很讨厌把 while a-a0 < size/2 换成右移new Range.Iter 的，毕竟栈上分配好，

但定义式编程禁止我用不严谨的指针变量；真的干脆我也 subarray slice 了最优雅，要么 l,r,ijk 那样的面条代码也省心

绝句真的不是为CS专业的代码设计的，它就只能写成羊皮纸算法；气死了，竟然不能大方的用指针变量，而且并没有更易读
(刚才发现merge 需要copy左右数组防覆盖，可以用 ListIterator, 舒服了

#china “
它说人民伟大，人民却说它伟大
他说人民是主人，人民却说 他 替咱做主人”
#tw 台湾人真正的敌人是什么
“我记不得我哪天生了我爸爸” https://m.youtube.com/watch?v=ehZzrFe04VI&t=6m

#life 调整分母为应届生后，失业比率可超50%, 既得利益者给会未来带来什么

anyway, 维尼熊的小学鬼畜文还挺解压的

人们对 GPT-4 能力退化的怀疑是正确的

过去三个月，GPT-4 识别素数的能力从97.6%下降到2.4%，而 GPT-3.5 却从7.4%上升到了86.8%。GPT-4 和 GPT-3.5 生成代码的格式错误都比三个月前多。GPT-4 在6月份比3月份更不愿意回答敏感问题，AIM攻击 (一种越狱攻击) 的应答率也从78%下降到了31%。视觉推理任务二者变化较小。

https://arxiv.org/abs/2307.09009

频道：@TestFlightCN

#dalao #web #rust 书作者 https://faultlore.com/blah/c-isnt-a-language/

#algorithm #bing 二分查找 spiral sorted ndarray
最好把它转换为1d，再转换回来以获取 '1'的位置
#py #code
def unrot(a, out):
while a.size:
out.extend(a[0]); a=np.rot90(a[1:])

#难以用concat矩阵滚出螺旋
def rot(a, m):
ia=np.reshape(range(len(a)), (m,-1))
unrot(ia, ord:=[])
return np.vectorize(lambda i:a[ord.index(i)] )(ia)

#make range(0,9) a spiral(cols=3)
[[0 1 2]
[7 8 3]
[6 5 4]]
a=rot([*range(0,9)], 3)
unrot(a, na:=[])

na[na.index(4)]=-1
print(a)
np.where(rot(na,3)==-1) #'4'=>[2,2]

def binary_search_matrix(matrix, target): 同理，可以是2d转1d
def binary_search_first_last(*a):
import bisect
left,right = (f(*a)for f in [bisect.bisect_left, bisect.bisect_right])
# 如果右边界超出了数组范围，说明目标出现1次
return (left, left if right == len(nums) else right - 1)

感觉很无语，居然为了无意义的“高性能”算法浪费2h ，还不如直接就用自己本来会的 a[ord.index(i)] 序号对应..

我发现2d.bisect 是以 (row=a[i])[0] 为线索再去 row.bisect ，这就更无聊了。Trie 前缀树至少还有 AC 的优化版(窄化为 KMP )，kD/quad 树至少还有切割公式 ，RB树有 std::(orderd_)map，但bisect 对Nd都只是Trie那样剪枝..
我觉得放在现实语境下就理所当然的策略，根本不该叫算法…


我很好奇除了用等价关系导入list里的算法，螺旋矩阵能怎么bisect，毕竟这东西本质就是list的重排序，它没啥性质可言

搜索发现这个螺旋数组 是 [4,5,6,7,0,1,2] 这种螺旋(shift..) 好奇怪的条件啊：
左右两段中，一定是有一段有序的，另一段可能有序可能无序(有序，则一定有段首值<段尾值)
需要 if nums[mid] >= nums[start] 判断左面是否有序
看的我都糊涂了，它是说 '//'状数组二分会产生 '/ _/'状无序右侧 ；算法是相当于只优化了“左侧”，对另一侧继续拆.. 这过度解读题意了。还不如直接拿拐点切分list，各自bisect()

螺旋数组 LC#54 不知为何大家用的都是Excel式四向法.. 虽然我写2048.js 时也是用了4向线性扫描了
括号匹配 LC#20 可以用调用栈，我又试了2h. bing反而误导我 😭
测试
pairs = {'(':')', '[':']', '{':'}'}
def eat(s,c0):
for c in s:
# 如果是左括号，就把它压入栈中
if c in pairs: eat(s,pairs[c])
elif c==c0:return # 如果是右括号，左括号便与之匹配
else: assert'','多余项而栈空'
assert c0=='eof','栈尚不为空'

#394 字串“编码” ，晕了，这标题为何如此民科啊！我还以为是词表替换
decodeString('hello,2[wo]rld')
'hello,woworld'

decodeString=(s)=>s.replace(/(\d+)\[(\w+)\]/,
(m,n,s)=>s.repeat(+n) )
本意是让你用 char 去累积 \d+[ ，累积[]里的字符，然后在 ']' 的时候输出repeat的文本，但这就是文本解析而已..

如你们所见，解法越简洁，我敲键盘的时间越少、敲脑门的时间越多……

#learn #FP 从“面向运气编程”到“设计程序”，「编程是什么」有许多天差地别的答案。

编程语言的范式。以社区的主流写法而定(FP之前后:统称过程式 vs. 定义式)：

PP结构化- C,Go,Perl,Lua

C是会计算(跳转)栈、整数/struct* 类型到成员地址的汇编，它的对象检查很弱，也没有规范的List,KV数据类型(SDL,linux,qemu 这些都有自己的"utils")

GC需要定期"stop THE WORLD"并自 static/调用栈变量遍历对象图，连[]{} 都没有的C当然找不出“0引用”指针，更多人使用shared_ptr<T> 引用计数实现Pair<AB>等数据

OOP面向对象- C++, Java~, .NET~

FP函数式- JS,Py, Rust

若对象用 函数值参数/监听器字典，取代override 那就叫“闭包closure” (其可见/可定性同interface,都为 public open)

类比，AbstractAnimal=(T={eat,say})=>“构造器”(name)=>{name, __proto__:T“类型T也有proto”}

“弱结构强脚本”轻松于万物class{}。fn=a=>(b=>a+b) 能从词法上文捕获a，不用 new fn$1(fn.arg[1]) 手动把a放入匿名对象

PF纯函数- Haskell Scala Lisp~

冷门:
FRP响应式- Rx,React

- x86 wasm
在 .data 段加个字符常量, 再在 .text push bp;sub sp,N 栈分配调用 libc:printf
甚至需要关心 nasm; ld 仅仅来让print() 能跳转到dll的“地址”，不会SEGV

LP逻辑式- SQL Prolog #relational #types

逻辑问题也有函数域和'='，只是'a=b' 的含义是“解构赋值” 出解集。b能含变量: [1 x]=[y 2]
a=b, b=1 应求出a=1 ，因此执行流程是 cut(=) 深解构, ',|'and or 靠约束过滤解集, 最后 cat 深建构

若等号右边必须已知，在 ([1]+x)=[1 2] 的求解中

(+) A B
|A=[], B
|A=[x a], [x (a+B)]

即

appendo A B O
|A=[], O=B
|A=[x a], O=[x appendo(a B)]

里，O=[x 递归] 就无法匹配出 A=[$x ] 这些输入参数了

当然，变量是值。“解”可以是 [List T] 这样的含“类型”变量，<T> 一定是“类型函数”加过的变量，所以:[List T]就是函数签名
可以取各处T的成员(接口)交来infer调用、单独查找fun重载，但本质上都是这样：

fun Box<T>.let(f:(T)->R)=listOf(f(item))
let A B
|A=[Box T],B=[Fn T R], listOf(B.invoke(A.item))
|重载,.
listOf T..|[List T]

阮一峰 体验 👉 swish.swi-prolog.org/example/grammar.pl //在左边粘贴关系, 右边查询,如 murderer(X)
tomstu.art/hello-declarative-world