EQ 域好评

程墨Morgan 发布了想法：我猛然发现，Java中synchronized这个关键字真的很不友好，至少对中国人不友好。 https://www.zhihu.com/pin/1039906058327801856

普通用户就别研究这几百兆的内存差距啊，加钱优化体验就好了。任务管理器第一页显示的内存占用是 private working set，不是真正的内存占用。（如果想学习的话参见 http://blogs.microsoft.co.il/sasha/2016/01/05/windows-process-memory-usage-demystified/ ）

真要死抠内存占用，Fx 是可以把多进程模式关掉的，很省内存。当然为了预防杠精，你要说 Chrome 可以用系统 KSM 来节约内存啊那好像也行，就是首先你系统得有 KSM，然后你还得会配。

Fx 的黑点基本上有那么几个：
* 网络栈 bug 很多，尤其是 IPv4/IPv6 混合部署环境
* 视频软解性能不行，尤其是 Google 亲儿子 VP9

Chrome 的黑点主要在傻逼产品经理和傻逼设计师那边……本身没啥好黑的

既然是普通人，比较东西就还是来点实际的，别扯性能这类虚的东西。Edge 跑分牛逼，可实际体验呢？

这次的 Nightly 更新后，会无视设置自动清理 Cookie 的样子

#MozillaSB

听说 Red Hat 内部出了奸细！🐶 #工程师的日常

#learn #teck #dev

#recommended #statement #performance #using

#java #threading

#INFO #WARN #firefox #mozilla

其实普通用户对比了也可以，不过就是要稍微了解一下前置知识，分清楚资源占用和性能怎么量化好就好了，FX 和 Chrome 的用户体验包括开发者工具的我感觉也都差不多，当然我不是 web 前端

这个跑分测试主要不好之处是在于对「内存占用」也即工作集合大小没有区分好的来说，但不管是专业的 pref 还是业余的 pref 都能反映出一些问题，但可能比较 useless

大家看看就好了，为了 Vim/Emacs, GNU&Linux/Windows/MacOS, CLion/VisualStudio Code 什么的问题就不用撕逼了... 爱用谁用谁呗 Ruby、Perl 那么慢不还是有人用，开发效率在那里啊！（其实这里也可以加个 PHP... 不过 PHP 不如 Ruby 灵活语法也比较拘束所以快很多）

#task

- [x] 确保 InScript 草稿的安全
- [x] 广播预先规划的知识点们
- [x] 点名器
- [ ] Gekyll
- [ ] aRsi tree-walkig 解释器
- [ ] 想办法让 Telegram Desktop Text field 导航时学会将中文全角字符正确切分...

如果可能的话还想写点 Rust extern 和 unsafe 的内容呢...

btw. （其实是完全无关的）想自动内存管理的时候突然想到 Xor 的 HexagonVM 使用了一个比较 trivial 的 naive dfs tracing GC，内存分配是基于 Rust std 类型的

https://github.com/losfair/hexagon/blob/master/src/object_pool.rs#L143

    /// Run the garbage collector with the execution context
    /// provided by the given call stack.
    pub fn collect(&mut self, stack: &CallStack) {
        let mut visited: Vec<bool> = vec![false; self.objects.len()];

        let mut dfs: Vec<usize> = Vec::new();
        dfs.push(0); // static root

        for id in stack.collect_objects() {
            dfs.push(id);
        }

        while !dfs.is_empty() {
            let id = dfs.pop().unwrap();

            if visited[id] {
                continue;
            }
            visited[id] = true;

            let obj = &self.objects[id].as_ref().unwrap();
            for child in obj.as_object().get_children() {
                dfs.push(child);
            }
        }

        for i in 0..visited.len() {
            if self.objects[i].is_some() && !visited[i] {
                if !self.objects[i].as_ref().unwrap().has_native_refs() {
                    self.objects[i].as_mut().unwrap().gc_notify();
                    self.deallocate(i);
                }
            }
        }
    }
}

... 真应该好好学习一下，目前还是 Rust（不管是不是 unsafe 的）菜鸡的 duangsuse 如是说

https://github.com/losfair/banXiaocao

#low #Chinese #backend 小曹消息屏蔽权重判断插件（可以做一个适配的 Telegram 插件平台... emmm

https://github.com/losfair/FutureCore-Terminal

#backend #system 貌似一个嵌入式应用的虚拟机，居然还有 virtualAddressing 实现

#daily #tech #cs #pl 又是一周的 duangsuse 随机瞎想集合

今天的格言是 想给你一个拥抱，让全世界知道。 ——微微一笑很倾城 via 一言 API （闲的了）

+ #Rust 奇怪的 ty 标记类型名称

对 Rust 宏稍微有一点了解的人（比如我）（但我只限于·一点·了解）（我还会学）知道宏可以按标记类型匹配（其实是我搞错了... Rust 这个宏处理过程有点奇葩弄得我糊涂了）

宏模式中还可以包含捕获。这允许输入匹配在某种通用语法基础上进行，并使得结果被捕获进某个变量中。此变量可在输出中被替换使用。

\+ item: 条目，比如函数、结构体、模组等。
\+ block: 区块(即由花括号包起的一些语句加上/或是一项表达式)。

但是 模式（Rust 支持模式匹配如 (_, 1)）、类型、标记树的类型被称为是 pat、ty、tt 怎么说呢... 感觉还是称为 pattern、type、tree 好一些... （其实我也可以写一个宏修改 rust 的 macro_rules! 语法，但是现在太菜了写不了...）

+ #functional Haskell: 面向 Currying 编程和 right precedence "二元运算符右优先级"

Haskell 的确是一门比较复杂的语言... 比 Java 难学多了（毕竟 declarative），其名称是取自计算机科学家、逻辑学家 Haskell B. Curry 的 "Haskell" 名字 https://www.haskell.org

其实嘛... Haskell 在语言上还是很简洁的，但是函数式老是递归、集合处理 currying 什么的小白们就只能望 declaration 兴叹了（233 我下面给大家一下 Haskell 语法的资料）

\+ antlr/grammars-v4#210 btw. InScript 也不是 Context-free grammar 的，因为我们的语言结构是基于 indentation 缩进的... 虽说我们的分词器能够自动插入内部的 end 关键字以使它（狭义解析器层面的）变成 CFG

\+ https://www.haskell.org/onlinereport/haskell2010/haskellch10.html （Haskell 2010 的报告，语法部分）

稍微对 Haskell 函数定义有点了解的人会知道（初学者难度），假设我们有一个这样的函数

square x = x * x

它（符号 square）的类型是 Int -> Int 然后我们可以在 Haskell 里静态写明它的类型： square :: Int -> Int

大家可能和我一样菜到不行所以连 Haskell 的 -> （函数类型）声明都看不懂... 非常简单嘛，函数式 value -> value 态射（morphism）「在集合论中，态射就是函数」，简单的模式就是

arg1_type -> result_type

现在你别问是多参函数那怎么办，接下来才是重点，如果我们要定义一个有两个参数的函数 compose，在 Python 里等价（其实并不，区别易见平凡读者自己领悟）的代码：

def bcompose(f, g): # b means 'back'
  return lambda x: g(f(x))

def add2(x):
  return x + 2

def mul10(x):
  return x * 10

add2mul10 = bcompose(add2, mul10)
print(add2mul10(2)) # prints 40: (2 + 2) * 10

Haskell（我们这里自动推导类型）（其实是我不了解 Haskell HM 类型系统所以... 没法显式写类型）（抄的，生而为码农我很抱歉...）：

compose :: (b -> c) -> (a -> b) -> (a -> c) -- 貌似 REPL 会出问题，你们看定义就好了...
compose f g = \x -> f(g(x))

-- 我使用 do let add2 = (+2) in let mul10 = (*10) 的时候出问题了... 只能这样

add2 = (+2)
mul10 = (*10)
add2mul10 = compose mul10 add2
print(add2mul10 2)

我们来看看类型：

add2 :: Integer -> Integer
mul10 :: Integer -> Integer
add2mul10 :: Integer -> Integer
compose :: (b -> c) -> (a -> b) -> (a -> c)

add2mul10 = compose mul10 {- which 类型是 Int -> Int -} add2 {- 同左 -}
compose {- add2mul10 -} :: (b:Int -> c:Int) -> (a:Int -> b:Int) -> (a:Int c:Int)

-- 简单点来说
print add2mul10(1:type of a) -- 先计算的是 add2 which add2mul10 = compose(a->c) -> mul10(b -> c) add2(a -> b) (括号: 类型提示)

首先你已经知道了（并不） why compose 函数的类型是 (b->c) -> (a->b) -> (a->c) 因为我会告诉你下面这些代码 which Python 原 compose 函数根本写不出来

print' = compose print
print' (+1) 1
-- 2
printAddOne = print' (+1)
printAddOne 3

-- 4

那么现在我们终于知道了... 首先 Haskell 的 Currying 函数类型写法... 不是什么「最后一个是返回值」（实际上的确是，但容易误解为 Haskell 是为了「好看」而这么做的），而是天然的 Currying 导致每「填写」「填充」一个函数参数（假设函数是 a -> b -> c，你只给了 a），Haskell 再返回给你一个函数（b -> c，a 的值已经拿到了），which 参数列表长度少了你已经填充完毕的那一项，直到最后返回 arg1 -> result 的时候，给你的才是真正的返回值（c）...（这就是 Currying，柯里化，btw. 其实它不是柯里本人发明的技巧，是 Moses Schönfinkel 发明的，但 Haskell 本人做了很大贡献）

同时我们也知道了，Haskell 类型声明里 -> 的右优先级（right precedence）比左优先级高，正如 Ruby 里的 :: 一样，因为我们知道 a -> b -> c 其实是 a -> (b -> c) which (b -> c) 是一个函数，就是说它返回一个函数。高阶函数（higer-order function）。

而 Ruby 里 Object::ObjectSpace::WeakMap （其实等于 ObejctSpace::WeakMap 为啥你自己猜）显然我们要先求值（假设没有优化，或者说不管有没有优化语义都不该发生变化） Object 然后 Object::ObjectSpace 最后才是获得常量 WeakMap 的引用，那也就是说 :: 的右优先级比左优先级高喽

+ #cs duangsuse 的九条命

曾经 duangsuse 很菜的时候（其实也就是六七个月前）认识了 @ice1000 等（好吧其实大体只有他一个）（现在都认识我了，当然第一印象全是负面的...）

这个标题是说什么呢... 就是说已经被很多 CS 讨论 （QQ）群给踢出去了（因为开始的时候技术很菜... 然后我又喜欢到处参与技术讨论... 然后说的全 TM 是错的... 大佬群容不得小白）

好吧，现在只剩下一个编译原理群了... 且行且珍惜，里面基本都是讨论编译原理、有时也有热点话题和操作系统、线程池什么的 😭

所以说吃瓜群众一定不要插话神仙打架：

一定不要参与自己 *完全* 不了解的讨论
一定不要参与自己 *完全* 不了解的讨论
一定不要参与自己 *完全* 不了解的讨论