https://www.javaassignmenthelp.com/blog/zig-vs-nim/

Zig vs Nim

Nim vs Rust

https://www.javaassignmenthelp.com/blog/nim-vs-rust/

https://github.com/knownsec/RD_Checklist

通用技能

公司与个人

• 公司是盈利性组织
• 个人和公司必须双赢
• 在认同公司理念且能够给公司创造足够价值的基础上，为个人发展而工作

Who am I

黑客是守正出奇且具备创造力的群体

守正出奇

• 这条正道/底线得坚守
• 但如果太过正就迂腐了，为了搞定任务有时得出奇招

创造力

• 一个没有创造力的人是多么的可怜，对于团队来说也是一种耻辱
• 本技能表的本质目的只有一个：引导你拥有足够的创造力

黑客也可以是一种思维方式

我们需要对得起名片上的那个头衔：工程师、研究员

牛人姿态

• 即使现在不是牛人，也得具备这样的姿态
• 没有一定扎实内功与远见的人很少有这样的姿态
• 拥有不将就的做事风格，迟早是牛人

如何做事

方法论

• 完成一件事有好几条途径，优秀的人的途径最短
• 任务拆分很容易得出做事的方法论
• 好的「方法论」会让你具备更强的「创造力」！
  • 时刻问自己：「是否具备创造力？」

任务拆分

成长过程会经历：能力越大、责任越大、事情越多

思路

• 拆分细化为多个点
• 排好优先级

任务四象限，决定优先级

• 紧急重要
  • 赶紧搞定
• 重要不紧急
  • 时刻保持关注，以免沦为「紧急重要」
• 紧急不重要
  • 少少益善，学会拒绝
• 不紧急不重要
  • 靠自律

SMART 原则

• S：任务是否明确
  • 不明确的任务搞起来就是浪费生命
• M：任务是否可度量
  • 不可度量如何体现价值？
• A：任务是否可搞定
  • 搞不定就不应该接，接就得有魄力搞定
• R：任务的相关性如何
  • 决定了任务的价值，相关性越高越能体现价值，比如这个任务搞定了能让团队获得公司、客户等更大的认可
• T：任务的时间
  • Timeline：任务时间轴，什么时间点需要搞定什么
  • Deadline：任务的最后期限，做评估时最好提前，因为总会有各种意外或拖延本性
  • Timeline
    上一些很关键的时间点我们可以称为里程碑，搞定每个里程碑应该庆祝下

自己欠缺什么，立马发现

是否需要寻求帮助，谁能帮你，自己单干？

团队

士气第一

• 当你有团队时，分配与调度好任务很关键
  • 做得好是真并发
  • 做不好会死锁

沟通、反馈与责任

• 一个无沟通能力的人，要么是天才，要么是不可爱的人，不过天才也就寥寥无几而已，你并不是
• 反馈要及时
  • 避免出问题不反馈，影响进度
  • 方式
    • 正式的：邮件
    • 临时的：微信等即时通信
    • 着急的：给个电话
• 工作有大小，责任心无大小
• 周报的透明
  • 意义：大家互相了解工作与心得，有利于自己的判断与成长
    • 观察是一种很重要的技能
    • 不是单纯的给领导汇报工作
  • 周报需体现本周工作总结、下周工作计划、心得/问题/建议（我们叫唧唧歪歪）
  • 周报可以很好体现一个人的
    • 总结能力
    • 计划能力
    • 分享能力
      • 想象下：一个人从来没有心得/问题/建议的沉淀或反馈，这个人是一个相对封闭的人，在团队作战中很难达到默契
      • 当然，这种分享能力远不仅仅是在周报这种形式里

团队意识

• 很多人都说自己具备足够好的团队意识，但是有些人却并不是这样
  • 举个小例子：一个 10 人团队约定早上 10 点开会，而你迟到了 10
    分钟，对于团队来说你浪费了整个团队 100 分钟（10 人 * 10
    分钟）的生命。有些人无羞愧之心要么是意识不到这点，要么这个团队的风气就是这样...
• 团队意识是建立在互相信任的基础上
• "尺有所短，寸有所长" 是一个优秀的团队必须要达成的共识
• Leader 最关键，优秀的 Leader 一定会有个优秀团队
  • 兵熊熊一个
  • 将熊熊一窝
• 如何拥有个优秀的团队是一个复杂的话题

成长

新事物的敏感性

• 保持好奇心
• 不要局限在自己的圈子，适当跨界吸收灵感
• 订阅国内外优秀博客/资源
• 选择性参与一些必要的会议，听必要的主题，讨论必要的话题

关于知识

• 好记性不如烂笔头，勤做笔记所带来的收益远超你想象
• 尽快尽早的将自己的知识形成系统化认知，会达到事半功倍的效果
• 对知识的渴望程度决定了前进动力的大小
• 当知识很廉价地摆在你面前，你反而不会珍惜
• 对知识保持敬畏之心

关于信息获取

• 拓宽自己获取信息的渠道，但不要陷入低信噪比的泥潭
• 信息筛选
  • 与你相关性如何？
  • 整体可信度多高？
  • 有效信息量多少？
• 处理并重新组织为你自己的理解

不要让自己成为矫情/浮夸的人

和比你厉害的人在一起，和一流的人工作

• 指点往往是精华
• 杜绝笨蛋爆炸
  • 二流的人招进来的人不太可能是一流的
  • 久而久之一个团队就笨蛋爆炸了

思考

• 批判性思考
• 解构与系统化思考
• 换位思考
  • 对于一个团队来说，这点太关键

提问的智慧

• 遇到问题先独立思考，尝试独立解决，尽最大努力后再提问
• 很多技术，明天就会过时，如果你掌握的是学习方法，那你还有下一个机会，如果你掌握的仅仅是这个技术本身，你就没有机会了。
• 提问时，礼貌很关键（对知识的敬畏），清晰表达很关键
• 解决后，分享出来帮助更多需要帮助的人

小事心态

• 越基础的事越关键，越需要细心
• 不要一味盲目追求「高级感」，而忽视「小事」/「简单事」/「基础事」
• 基础不牢、地动山摇
• 小事做不好，别提大事

无论是个人还是团队的成长都需要不断沉淀知识，没有沉淀根基不稳

完成的定义

比如写个 POC

1. 搞懂了目标 Web 应用漏洞的原理
2. 熟练运用 Python 各相关模块与机制
3. 熟练了解了 HTTP 协议
   • HTTP 请求
   • HTTP 响应
4. 代码写得够规范，让人看起来就是爽
5. 程序经过足够的测试
   • 黑盒测试
   • 白盒测试
6. 及时反馈进度
   • 我遇到困难了
   • 我搞定了
7. 更新相关文档，沉淀

熟练的定义

比如熟练 SQL 注入

• SQL 语句这门”语言”能脱离文档顺手写出
• 主流数据库的 SQL 特有函数、存储过程、机制我都了如指掌
  • MySQL
  • PostgreSQL
  • ...
• 牛逼的工具我不仅用的顺其自然，源码还读过几遍，我能修改
  • pocsuite3
  • sqlmap
  • metasploit
  • nmap
  • ...
• 我具备创造性，而不仅仅是跟在大牛身后
  • 研究出了几个不错的技巧
  • 发了几篇不错的 Paper
  • 对外会议/沙龙等进行了几次分享
  • 写出了自己的相关工具，爽
• 我实战了 N 回，遇到了很多奇葩环境，我有足够的信心绕过
• 以上这些之后，这才叫熟练！其他同理

好书推荐

推荐理由

• 打通任督二脉的书，怎能不看？
  • 但，尽信书不如无书
• 任何科学研究最终必须至少到哲学层面，触碰到上帝的脚
• 具体技术类书籍请见「专业技能」相关部分

鸡汤类

UNIX 编程艺术

极客的思维哲学

• 使用简洁的接口拼合简单的部件
• 清晰胜于机巧
• 设计时考虑拼接组合
• 策略同机制分离，接口同引擎分离
• 设计要简洁，复杂度能低则低
• 除非确无它法，不要编写庞大的程序
• 设计要可见，以便审查和调试
• 健壮源于透明与简洁
• 把知识叠入数据以求逻辑质朴而健壮
• 接口设计避免标新立异
• 如果一个程序没什么好说的，就保持沉默
• 出现异常时，马上退出并给出足量错误信息
• 宁花机器一分，不花程序员一秒
• 避免手工hack，尽量编写程序去生成程序
• 雕琢前先得有原型，跑之前先学会走
• 决不相信所谓”不二法门”的断言
• 设计着眼未来，未来总比预想快

黑客与画家

印象深刻：设计者的品味

• 好设计是简单的设计
  • 抓住本质
• 好设计是永不过时的设计
  • 如果解决方法是丑陋的，那就肯定还有更好的解决方法，只是还没有发现而已
• 好设计是解决主要问题的设计
• 好设计是启发性的设计
• 好设计通常是有点趣味性的设计
• 好设计是艰苦的设计
• 好设计是看似容易的设计
• 好设计是对称的设计
• 好设计是模仿大自然的设计
• 好设计是一种再设计
• 好设计是能够复制的设计
• 好设计往往是奇特的设计
• 好设计是成批出现的
• 好设计常常是大胆的设计

浪潮之巅

感受 IT 帝国的崛起与没落，我们现在站在又一个互联网浪潮之巅

代码2.0 - 网络空间中的法律

网络不是法外之地

洁癖类

• 重构
• 代码整洁之道
• 代码大全 2

敏捷类

• Rework中文版
  • 37signals 团队的敏捷经验
• 高效程序员的 45 个习惯

产品类

• 人人都是产品经理
• 结网

神书

• 自私的基因
• 失控

...

问题

以下是ChatGPT的回复

HEVC (Main) 和 H.264 (High) 是两种不同的视频编码标准，它们有几个主要区别：

1. 编码效率和压缩比

• HEVC (H.265)：比 H.264 更高效，能够在相同的视频质量下提供更低的比特率。换句话说，HEVC 可以在更小的文件大小下保持更好的画质。
• H.264：相较于 HEVC，压缩效率较低，相同质量的视频会有较大的文件大小。

2. 视频质量

• HEVC：能够提供更高的压缩率和视频质量，特别是在高分辨率视频（如 4K）和低比特率的情况下表现更好。
• H.264：虽然它也提供高质量的视频，但相对于 HEVC 来说，压缩率较低，可能在较低比特率下会出现更多的压缩损失或画质下降。

3. 硬件支持

• HEVC：因为 HEVC 比 H.264 更复杂，许多旧的硬件设备（如老款的电视、手机、平板等）可能不支持 HEVC 解码或编码，尤其是低端设备。
• H.264：几乎所有设备和平台都支持 H.264，无论是硬件解码还是软件解码。

4. 编码复杂度

• HEVC：编码复杂度高，需要更多的计算资源来进行编码和解码，因此会消耗更多的 CPU 或 GPU 资源。
• H.264：编码和解码相对简单，因此对于低功耗设备或实时视频流应用更为合适。

5. 广泛应用

• HEVC：主要用于高分辨率视频（如 4K 视频），而且在流媒体和广播等新兴领域越来越流行。
• H.264：依然是网络视频流、视频会议、蓝光光盘等领域的主流编码格式。

6. 兼容性

• HEVC：新兴的编码格式，虽然它在压缩和质量上有优势，但老旧设备和浏览器的兼容性相对较差。
  • Linux(Ubuntu)的Chrome浏览器不支持
  • Windows/MacOS/Andriod都支持
• H.264：几乎所有设备和平台都支持，兼容性最好。

浏览器适配方案

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

<!DOCTYPE html>
<html lang="zh-CN">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>视频播放示例</title>
</head>
<body>
  <h1>视频播放示例</h1>
  <video id="video-player" controls width="640">
    <!-- 默认的视频文件，支持 H.264 格式 -->
    <source id="video-source" src="video_h264.mp4" type="video/mp4">
    <!-- 如果浏览器支持 HEVC 格式，可以加载 HEVC 视频 -->
    <source src="video_hevc.mp4" type="video/mp4; codecs=hevc">
    <!-- 备用格式 WebM -->
    <source src="video.webm" type="video/webm">
    <!-- 如果浏览器不支持视频格式 -->
    您的浏览器不支持视频播放，请更新浏览器或使用支持的视频格式。
  </video>

  <script>
    var videoElement = document.getElementById('video-player');
    var h264Support = videoElement.canPlayType('video/mp4; codecs="avc1.42E01E"');
    var hevcSupport = videoElement.canPlayType('video/mp4; codecs="hevc"');

    if (hevcSupport) {
      // 如果支持 HEVC，则加载 HEVC 格式的视频
      document.getElementById('video-source').src = 'video_hevc.mp4';
    } else if (h264Support) {
      // 如果支持 H.264，则加载 H.264 格式的视频
      document.getElementById('video-source').src = 'video_h264.mp4';
    } else {
      // 如果两者都不支持，加载 WebM 格式
      videoElement.innerHTML = '<source src="video.webm" type="video/webm">';
    }
  </script>
</body>
</html>

安装Python3.13.2

Windows: 安装python3.13, 直接下载即可，在安装目录的 python3.13t

• 在”Advanced Options”下，确保选择“Download free-threaded binaries(experimental)”选项，然后点击“安装”

Ubuntu: 下载代码编译

1
2
3
4
5
6
7
8

./configure --disable-gil --enable-optimizations
make

# 会覆盖系统的python
make install

# 或者， 不覆盖系统的python
make altinstall

运行测试代码:

1
2
3
4
5
6
7
8
9

import threading


def f():
    while 1:
        pass

for i in range(16):
    threading.Thread(target=f).start()

使用python3.13t 或 python3.13 运行代码 python3.13t test.py 或 PYTHON_GIL=0 python3.13 test.py 或 python3.13 -Xgil=0 test.py, 查看16核CPU的占用率100%

• 如何没有设置 PYTHON_GIL， 那么 python3.13默认是无GIL的

• 对比python3.13的无GIL版本:
  

• 对比python3.13 的有GIL版本:

  

• 对比python3.12版本(有GIL)
  

PEP-703

https://peps.python.org/pep-0703/

关于容器的线程安全

https://peps.python.org/pep-0703/#container-thread-safety

python底层的实现中，每个object内部使用临界区来实现线程同步

Per-object locks with critical sections provide weaker protections than the GIL. Because the GIL doesn’t necessarily ensure that concurrent operations are atomic or correct, the per-object locking scheme also cannot ensure that concurrent operations are atomic or correct. Instead, per-object locking aims for similar protections as the GIL, but with mutual exclusion limited to individual objects.

• 在object加锁
  • list.append, list.insert, list.repeat, PyList_SetItem
  • dict.__setitem__, PyDict_SetItem
  • list.clear, dict.clear
  • list.__repr__, dict.__repr__, etc.
  • list.extend(iterable)
  • setiter_iternext
• 在2个object加锁
  • list.extend(list), list.extend(set), list.extend (dictitems), and other specializations where the implementation is specialized for argument type.
  • list.concat(list)
  • list.__eq__(list), dict.__eq__(dict)
• 无锁
  • len(list) i.e., list_length(PyListObject *a)
  • len(dict)
  • len(set)
• 看情况, 需要根据内存分配器的实现而定， 尽量会少用锁提升性能
  • list[idx] (list_subscript)
  • dict[key] (dict_subscript)
  • listiter_next, dictiter_iternextkey/value/item
  • list.contains

no-GIL + async/await

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

import threading
import asyncio
import time

async def async_range(n):
    for i in range(n):
        yield i

# 异步任务
async def async_task(name):
    for i in range(20):
        print(f"异步任务 {name} 开始执行")
        async for i in async_range(1000_0000):
            pass
        print(f"异步任务 {name} 执行结束")
    return f"结果 {name}"

# 在线程中运行异步任务
def run_async_in_thread(name):
    # 创建一个新的事件循环
    loop = asyncio.new_event_loop()
    asyncio.set_event_loop(loop)

    # 运行异步任务
    result = loop.run_until_complete(async_task(name))

    # 关闭事件循环
    loop.close()

    return result

# 线程函数
def thread_function(name):
    print(f"线程 {name} 开始执行")
    result = run_async_in_thread(f"Async-{name}")
    print(f"线程 {name} 执行结束，结果: {result}")

# 主函数
def main():

    start  = time.time()
    # 创建并启动线程
    threads = []
    for i in range(16):
        thread = threading.Thread(target=thread_function, args=(f"Thread-{i+1}",))
        threads.append(thread)
        thread.start()

    # 等待所有线程完成
    for thread in threads:
        thread.join()


    print(f"所有任务执行完毕, 耗时: {time.time() - start} s" )


if __name__ == "__main__":
    main()

• 多进程

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67

  import threading import asyncio import time import multiprocessing from typing import List async def async_range(n): for i in range(n): yield i # 异步任务 async def async_task(name): for i in range(20): print(f"异步任务 {name} 开始执行") async for i in async_range(1000_0000): pass print(f"异步任务 {name} 执行结束") return f"结果 {name}" # 在进程中运行异步任务 def run_async_in_thread(name): # 创建一个新的事件循环 loop = asyncio.new_event_loop() asyncio.set_event_loop(loop) # 运行异步任务 result = loop.run_until_complete(async_task(name)) # 关闭事件循环 loop.close() return result # 线程函数 def thread_function(name): print(f"进程 {name} 开始执行") result = run_async_in_thread(f"Async-{name}") print(f"进程 {name} 执行结束，结果: {result}") # 主函数 def main(): start = time.time() # 创建并启动进程 processes: List[multiprocessing.Process] = [] for i in range(16): process = multiprocessing.Process( target=thread_function, args=(f"Process-{i+1}",) ) processes.append(process) process.start() # 等待所有进程完成 for process in processes: process.join() print(f"所有任务执行完毕, 耗时: {time.time() - start} s") if __name__ == "__main__": main()

运行时间对比

• 使用 No-GIL python3.13 耗时66s
• 使用 GIL python3.13 耗时375s
• 使用带GIL的多进程65s

有了multiprocessing，为什么还要No-GIL ？

因为multiprocessing是多进程， 每个进程都有自己的内存空间， 进程间通信成本较高

• 进程间通信手段: Queue, Pipe, Semaphore, Socket, File
• 线程间同步: Lock, RLock, Condition, Event, Queue, Barrier

NO-GIL的最大优势:

• 同一程序空间，线程间通信简单

[附] 多进程和多线程的区别:

• 多进程: 每个进程有自己的内存空间

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

  from multiprocessing import Process # 定义一个全局变量 counter = 0 def increment(): global counter for _ in range(1000000): counter += 1 if __name__ == "__main__": # 创建两个进程 p1 = Process(target=increment) p2 = Process(target=increment) # 启动进程 p1.start() p2.start() # 等待进程完成 p1.join() p2.join() # 打印最终的全局变量值 print(f"Final counter value: {counter}")

  运行结果:

  1 2 3 4

  $ python3.13 test_process.py counter: 1000000 counter: 1000000 Final counter value: 0

  因为主进程中的 counter没有改过, 所以最终的结果是0

• 多线程: 共享内存空间

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

  # from multiprocessing import Process from threading import Thread # 定义一个全局变量 counter = 0 def increment(): global counter for _ in range(1000000): counter += 1 if __name__ == "__main__": # 创建两个进程 p1 = Thread(target=increment) p2 = Thread(target=increment) # 启动进程 p1.start() p2.start() # 等待进程完成 p1.join() p2.join() # 打印最终的全局变量值 print(f"Final counter value: {counter}")

  • 使用 GIL版本运行结果:

    1 2	$ python3.13 -Xgil=1 test_thread.py Final counter value: 2000000

  • 使用 No-GIL版本运行结果:

    1 2 3 4 5 6 7 8

    $ python3.13 -Xgil=0 test_thread.py Final counter value: 1139283 $ python3.13 -Xgil=0 test_thread.py Final counter value: 1170427 $ python3.13 -Xgil=0 test_thread.py Final counter value: 1415999 $ python3.13 -Xgil=0 test_thread.py Final counter value: 1205918

    • 因为没有GIL的限制, 且没有加锁， 所以多线程的结果是不确定的

  • 对counter加锁

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29

  from threading import Thread, Lock # 定义一个全局变量 counter = 0 lock = Lock() def increment(): global counter for _ in range(1000000): lock.acquire() # 获取锁 counter += 1 lock.release() # 释放锁 if __name__ == "__main__": # 创建两个进程 p1 = Thread(target=increment) p2 = Thread(target=increment) # 启动进程 p1.start() p2.start() # 等待进程完成 p1.join() p2.join() # 打印最终的全局变量值 print(f"Final counter value: {counter}")

  使用无GIL python运行结果:

  1 2	$ python3.13 -Xgil=0 test_thread.py Final counter value: 2000000

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

from math import sqrt


def calc_market(market_cap_in_usd: float, sol_price_in_usd: float):

    # k = x * y      量纲 t*s  , s 为 sol ,  t 为 token
    k = 79 * (10_0000_0000 - 7_9310_0000)

    P = 0  # 量纲   s/t
    if True:
        # 量纲 u/s  , u为usd
        target_sol_price = sol_price_in_usd

        # 量纲 u/t  , u为usd
        target_token_price = market_cap_in_usd / 10_0000_0000

        # p = (u/t) / (u/s) , 目标量纲为 s/t
        P = target_token_price / target_sol_price
        # print(p)

    # y^2 = k / p       ,  量纲为 ts / (s/t) = t^2 , 因此 y的量纲为 t
    Y = sqrt(k / P)

    # x = p * y         , 量纲为 (s/t) * t = s , 因此 x 的量纲为 s
    X = P * Y

    return X, Y


target_market_cap_in_usd_lists = [1_0000_0000 * i for i in range(1, 11)]
sol_price_in_usd = 230

for target_market_cap in target_market_cap_in_usd_lists:
    ret = calc_market(target_market_cap, sol_price_in_usd)
    print(
        f"拉盘到{target_market_cap:0.0f}美金市值,  所需资金数量: {ret[0]:0.0f} 枚SOL , 约合 {ret[0] * sol_price_in_usd : 0.0f} USDT"
    )

计算结果：

1
2
3
4
5
6
7
8
9
10

拉盘到100000000美金市值,  所需资金数量: 2666 枚SOL , 约合  613137 USDT
拉盘到200000000美金市值,  所需资金数量: 3770 枚SOL , 约合  867107 USDT
拉盘到300000000美金市值,  所需资金数量: 4617 枚SOL , 约合  1061985 USDT
拉盘到400000000美金市值,  所需资金数量: 5332 枚SOL , 约合  1226275 USDT
拉盘到500000000美金市值,  所需资金数量: 5961 枚SOL , 约合  1371017 USDT
拉盘到600000000美金市值,  所需资金数量: 6530 枚SOL , 约合  1501873 USDT
拉盘到700000000美金市值,  所需资金数量: 7053 枚SOL , 约合  1622209 USDT
拉盘到800000000美金市值,  所需资金数量: 7540 枚SOL , 约合  1734214 USDT
拉盘到900000000美金市值,  所需资金数量: 7997 枚SOL , 约合  1839412 USDT
拉盘到1000000000美金市值,  所需资金数量: 8430 枚SOL , 约合  1938910 USDT