可以理解为工作之余开发的产品，通常是收费的服务，可作为工作之外额外收入的产品。

在目前经济下行、公司开源节流（裁员）、失业率上升的大环境下，每一个程序员都应该拥有自己的side projects来对冲未来的不可靠风险。

所以side project 不仅仅是多一种「被动收入」，他也是你未来的「筹码」——工作累了，不想干了、有小孩了、买房了、家人生病了等等这些事情发生的时候，你可以「任性」一下。

而不是一些不可靠的风险出现的时候，再来提高自己的「抗风险」能力。

上面把 side project 吹得有点高了……

写什么side project比较好？

对于大部分人来说，对于写什么其实是比较纠结的，以下是些思路：

• 基于解决自己生活中的问题

  • 自己持续用的产品是最重要的，因为你自己就是开发、测试、使用者，没人比你更懂需求了，除了解决自己的问题，产品化之后贩售变得是一件很自然的事情。

• 山寨一个你自己喜欢的产品

  • 比如你觉得Dash（文档搜索）这个Mac app不错，你可以山寨一个，加上 AI 的能力，缝合一个新的产品

  • 单纯的山寨我个人觉得没什么意思，但是开发一个满足自己需求，同时缝合一些特色功能，其实是不错的选择。

为什么说现在是做side project最好的时代

实际上随着行业发展，市面上出现了非常多PaaS产品，而且大部分都有入门级的套餐，价格低廉，甚至免费。

开发者前期可以薅一薅，当产品做大做强了，可以考虑升级套餐，满足用户需求了。

比如 https://bitbear.net 这个网站，我使用的paas产品有：

前后端错误收集：https://sentry.io/
行为分析：https://clarity.microsoft.com/
流量分析：https://dash.cloudflare.com/

后端：https://fly.io/
前端：https://dash.cloudflare.com/
数据库：https://planetscale.com/

对与这种简单的网站，前期几乎免费运行起来，而且大部分都是自动化的（github actions），不用自己维护linux服务器、部署产品了。

持续迭代 & 持续反馈

对于个人开发者来说，最大的风险反而不是卖出去，而是「做出来」。

把产品「做出来」又分很多种

1. 把产品做得尽善尽美而耗费大量的时间，最终产品出来，反响一般，导致信心受挫。

2. 持续迭代，持续发布。及时验证商业上可行性，避免时间投入

对于个人开发者来说，及时验证商业上的可行性，快速试错是比较节省时间的。当产品做得很完美了，结果发出来发现商业上不可行，造成浪费大量的时间。

一些原则和见解

• 产品不一定要十分完美才发布出去，能用就可以尝试推广给一部分用户使用了

  • 建群，保持沟通（其实也是一种「正反馈」）

• 持续开发 & 迭代 & 反馈

  • 与期望使用的客户保持沟通，收集意见

    • 包括产品对开发者的反馈，让开发者持续保持热情

  • 产品收入上的「持续反馈」是很重要的，这能让你保持对产品的信心

    • 前期产品可能仅仅是「能用」的状态时，建议还是避免收费（或者收很低的费用）

  • 持续开发并保持持续的发版

    • 随着上面与客户的沟通、身边人的反馈、自己的使用过程对产品做持续的改进既可以让客户和自己都对产品的未来提供良好的信心。

如何推广你的产品

• 你自己

• 你身边的人

• 博客、公众号、推特、油管、b站等互联网产品

• 广告

  • google ad等产品

咱们以后的新文章就放在 hashnode 吧， 更好的老文章就继续放在github吃灰吧～（导不进来）。

因为有更好的编辑器了～ 所以后应该会有更多的「流水账」。

之前有个很老的xbox游戏机，因为性能有点差劲了，所以卖了。 偶尔还是想玩玩游戏，但是老婆不让给买xbox的物理机（怀恋单身），所以含泪玩xbox cloud gaming（以下简称 xcg），xpg会员游戏还是很丰富的。

于是买了uu加速器，坦白说uu加速器不算便宜的，但是xcg在晚上高峰期，一样卡得怀疑人生，那种被马赛克糊满脸的感受，上一次这种体验还是看小姐姐的电影。

其实用uu加速器玩是ok的，就是国内的网络情况大家都知道，dddd（懂得都懂），晚上高峰期出口网络抖得怀疑人生。

于是我想自己建一个加速网络，会不会更好呢，趁着疫情被关在家里，做了一轮测试和体验，给需要的人做一些参考。

线路方案：

1. 直接买azure的韩国服务器，直连
2. 买联通、移动vps中转到韩国服务器，跳转

这里最大的问题其实高峰期出口会不会抖。

上面2个方案其实会有一些根据实际情况做一些调整，例如你本来就是联通，那可能不用中转了，直连。如果你是电信，晚上出口会抖成马赛克，可以考虑联通服务器中转。

了解Xbox会请求哪些服务器

xbox是限制区域的，还没对国内开放（未来估计也不太可能），亚洲基本只能使用 韩国、日本服务器，这俩服务器在国内服务器基本能做到50ms的延迟左右，玩非fps游戏是够用了。

于是浏览器开启开发者模式，截网络包，这里不复述了，直接给clash的规则：

rules:

• DOMAIN-SUFFIX,xbox.com,your-proxy
• DOMAIN-SUFFIX,live.com,your-proxy
• DOMAIN-SUFFIX,xboxlive.com,your-proxy
• DOMAIN-SUFFIX,microsoft.com,your-proxy
• DOMAIN-SUFFIX,visualstudio.com,your-proxy
• DOMAIN-SUFFIX,msn.com,your-proxy
• DOMAIN-SUFFIX,gamepass.com,your-proxy
• DOMAIN-SUFFIX,demdex.net,your-proxy
• DOMAIN-SUFFIX,microsoftonline.com,your-proxy

如果你自己有🪜，上面的规则配到你的 clash 中，也能实现加速了，不过速度嘛就看你的机场良心了～

测试

买了微软的azure，主要是其对国内宽带比较友好，当然还是要看高峰期表现。

可以尝试本地用 clash 配置，加上上面的 rules，应该就好啦。服务器和客户端的加密理论上越简单越好，这样实时性会更好一点。

搭建好了之后，直接上 xcg，没有提示「不可用区域」就ok啦。

开玩「杀手47」，很流畅，爱了爱了，心理甚至嘲讽了一波uu加速器，不过「开心不过3秒」，打脸总是非常及时。

晚上10点左右，高峰期，一样卡得满屏幕的马赛克。尝试用uu加速器，也卡哭了。

有钱还是上电信的精品网，没钱就老老实实买xbox物理机吧（并且你媳妇同意）。

当然后来还常识移动中转，发现我那台移动宽带到韩国的速度也不咋滴， 国内联通中转就没测了，晚点试试阿里云搞台上海到韩国的中转，之后再把结论同步到这篇blog。

总结

还是买个xbox的物理机吧，折腾。

放过自己，不要跟自己过不去，就像每次做核酸的时候：心理mmp，嘴张得比谁都大。

github codespaces 是github在被微软收购后，提供的一款在线web IDE，基本与vscode一致，只是运行在浏览器上而已。

而且非常土豪的提供了4核8G内存，微软就是壕。

so，通过ipad来使用codespaces就是一件比较顺其自然的事。

可是其实也没那么简单。。

IPad使用codespaces的快捷键问题

其实最大的问题就是快捷键的问题，不管你是用saferi，还是chrome，他们提供的快捷键或多或少会与你的vscode的快捷键冲突。

在ios中，浏览器就是一个webview控件，也就是本身其实没啥快捷键，快捷键都是浏览器厂商自己家的，所以，问题就变成，找一个没有快捷键的浏览器，或者webview控件只是用来打开网页的app。

筛选

于是筛了n个浏览器，火狐、chrome、oprea等等。以及各类非浏览器，但是有内置webview的app。

最终得出的结论如下：

最适合coodespace的浏览器竟然是美区的：yandex。也就是俄罗斯的搜索巨头推出的浏览器。

这个浏览器几乎没有快捷键，外接键盘时，几乎不会与codespaces的快捷键冲突。

如果你没有美区的账号，那么国区最合适的是微软的：bing。

这个app有一个简单的webview，但是有点太占屏幕空间。

完毕

so，大家可以参考这个思路去找相关的app，或者直接使用我筛选过的app。目前我的ipad mini6 使用yandex体验codespaces，还是挺棒的。

某个表的 status 「莫名其妙」变成 0 了

其实可以判断出是 status 没有被赋值，通常是结构体的 status 默认是 0 才会被插入数据库。

于是问题看起来就很简单了：只要检查相关的更新操作中的 status 字段有没有被赋值即可。

但是

这个表是用户表。

• 因为历史原因，源码中的更新函数很多
• 调用更新函数的地方也很多
• 无法复现该问题，测试人员也不知道做了什么操作状态变成 0 的

所以同事关注这个问题挺久了，也没看到问题原因（当然我也没看到……）

但是恰好我在做导出 binlog 日志，判断某行数据丢失的问题，于是顺手将该问题对应的数据库、表结构一并导出，查看 status=0 的 binlog 看看情况。

coding

因为我们内部对 https://github.com/go-mysql-org/go-mysql 这个库做了很多的封装。 所以下面我们在处理 binlog 时，仅展示事件部分，其他的数据库连接之类的暂且忽略。

func (f FileOutBound) OnEvent(event types.Event) error { if event.Database != "project" { return nil } mustTableSet := map[string]bool{ "invitation": true, "org_user": true, "team_member": true, }

, err := f.f.WriteString(event.Print()) if err != nil { panic(err) } , err = f.f.Write([]byte("\r\n")) if err != nil { panic(err) } return nil }

上面的代码就是响应 binlog 的 row 日志（原始的 row 已被解析成 Event 结构体）。 为了避免日志过多过大，所以仅处理 project 这个数据库，并且仅仅关注 invitaion 等 3 张表。

这里是直接将事件输出到文件，便于我们在电脑上直接处理。

分析日志文件

数据导出后，我们找到将某行数据的 status 改成 0 的 binlog row。 通常一行 row event 数据长这个样子：

{ "action": "UPDATE", "database": "project", "old_values": "('QmPCusvS','呀呀呀','yayaya','xxxx@yeah.net',1)", "pos": { "part": "mysql-bin.001591", "offset": 515629163 }, "table": "org_user", "values": "('QmPCusvS','呀呀呀','yayaya','xxxx@yeah.net',0)" }

可以看到数据结构大概是 action 操作方式；database 数据库；old_value 、values 旧新数据；pos 表示这行数据出现在哪个 binlog 文件以及对应的 offset 偏移。

上面的 json 中我们可以看到 旧数据中 stauts 还是 1（最后一个字段），新数据中 status 变成了 0。

因为我们知道了 pos 中这行数据的位置，所以我们可以看看这个 binlog 的上下文长什么样了。

在数据库中执行：

show binlog events in 'mysql-bin.001591' FROM 515629163 limit 100;

返回结果：

mysql-bin.001591 515629163 Anonymous_Gtid 1 515629228 SET @@SESSION.GTID_NEXT= 'ANONYMOUS' mysql-bin.001591 515629228 Query 1 515629309 BEGIN mysql-bin.001591 515629309 Table_map 1 515629403 table_id: 3407638 (project.team) mysql-bin.001591 515629403 Write_rows 1 515629521 table_id: 3407638 flags: STMT_END_F mysql-bin.001591 515629521 Table_map 1 515629593 table_id: 3411634 (project.team_config) mysql-bin.001591 515629593 Write_rows 1 515629665 table_id: 3411634 flags: STMT_END_F mysql-bin.001591 515629665 Table_map 1 515629771 table_id: 3407636 (project.org_user) mysql-bin.001591 515629771 Update_rows 1 515630301 table_id: 3407636 flags: STMT_END_F mysql-bin.001591 515630301 Table_map 1 515630372 table_id: 3407637 (project.team_member) mysql-bin.001591 515630372 Write_rows 1 515630435 table_id: 3407637 flags: STMT_END_F mysql-bin.001591 515630435 Table_map 1 515630513 table_id: 3411635 (project.dashboard) mysql-bin.001591 515630513 Write_rows 1 515630610 table_id: 3411635 flags: STMT_END_F mysql-bin.001591 515630610 Table_map 1 515630695 table_id: 3411637 (project.card)

可以看到上下文中有 BEGIN 开启事务（因为这个事务比较多，下面还有很多内容已删除忽略），所以我们看到事务中有 team、team_config、org_user 等等表。

因为这种上下午内容通常只有一个地方会有，所以我们锁定了「创建团队」这个操作，并且将操作定位到 team_config 表操作和 team_member 表 到中间操作。

那么在代码中缩小了范围之后，很快就定位到问题了：

插入到 org_user 数据在读取的适合，没有取 status 状态，所以默认是 0，于是被插入到了数据库中。

完

随着代码规模的变大，有些问题没那么好检查了，那么通过 binlog 的方式，还是能帮助定位这些问题的。

整个处理过程就完事了，最开始是想通过 https://github.com/zendesk/maxwell 这个 java 库来导出 binlog，并输出成 txt 文件。

结果这个库的 filter 功能并不好用，无法满足我的筛选功能，所以索性手写。

整个查处过程还是挺好玩的，自己踩的坑并没有在文中提及。

go-git 是 github 上一个 go 开发的开源项目。

go-git is a highly extensible git implementation library written in pure Go.

实现了大部分的 git 操作，可以对 git 仓库进行一些相关的操作。

为什么要实现 grpc 版

1. growerlab 项目需要，因为一开始就期望 growerlab 能实现将底层的 git 操作是一个分布式的微服务。
   1. 包括之后可能会支持 push/pull 操作
2. 感觉可能某些组织需要？那写一个出来可能能帮助大家
3. gitlab 也有类似的服务，不过是远程调用 git 命令，将 git 命令 grpc 化，我不觉得性能更高

其实主要是「贪玩」。

如何实现

其实还没啥难度，go-git 本身对仓库读写操作封装非常好，仅实现storage.Storer接口，并将其 grpc 化即可。

甚至一些流式的操作，grpc 也都支持了，所以接入还是比较简单的。

那么仓库在哪呢

github 地址：go-git-grpc

欢迎提供 pr

TODO & 测试

目前测试也不充分，并且还有一些功能并不完善，例如

• 中间件的支持
• push/pull 的实现

有空会加上更多测试 以及 完成上面的 todo（码农立的 todo，呵呵……）

有个哥们，有 5000G 数据需要去重。

这么大数据其实挺不好处理的，尤其是超不注意就内存/磁盘炸裂。

所以，如何做到性能、内存、磁盘之间的平衡，就是这个问题的难题……

其实这个问题让我想起「编程珠玑」中的一篇内容……

方案

刚开始大家觉得使用使用 redis 的 hash 能力来处理，set/hash 都可以，但是不管是直接丢字符串，还是将字符串 hash 计算后存储，其实都会比较耗费内存。并且 hash 后的数据还会存在一定概率 hash 碰撞，此时更不好处理了。

于是在我们小群里面进行了一些讨论……

于是大家纷纷出招：

• 磁盘换内存式的 kv 数据库（例如 leveldb、boltdb）
• redis 布隆过滤器（布隆过滤器内部也是用的 bitmap，关键）
• redis bitmap
• mapReduce

其实都会有一些优缺点吧。

• 磁盘式 kv db 性能不太行，同时读写磁盘可能会炸裂
• redis 布隆过滤器的话 存在误差，毕竟 「存在的不一定存在，不存在的一定不存在……」
• redis bitmap 如上，存在一定误差，毕竟还是会有撞库的可能
• mapReduce 好像有大炮打蚊子的感觉……

ok，最终因为忙工作，也没细想这个问题了，反正也是嘴炮一番，这事就过了。

几天之后……

过了几天看到哥们发了几篇布隆过滤器的文章，然后怎么还在研究这事。

此时刚好在上班的路上，又重新想了想这个方案。

因为之前公司的产品中有同事提出使用布隆过滤器的「存在则可能存在」的特性做一个减少检索范围的筛选器。

所以恰好好像可以反过来想想，此时方案流程可以是这样：

1. 利用布隆过滤器「不存在则一定不存在」的特性
2. 例如
   1. 传入「张三」
      1. 不存在
         1. 并标记到「存储器」中（如果为了省内存，其实也可以使用安全 hash 算法进行计算后存入）
      2. 存在
         1. 从「存储器」中拿到撞库的字符串列表
            1. 进行暴力匹配
            2. 并将「张三」存入布隆过滤器，也就是上面撞库的字符串列表中
3. 重复上面的步骤。

上面说的「存储器」是什么呢？

• 可以是磁盘 kvdb
• 可以是 redis 内存 set/hash
  • 如果重复字符串是低概率的事情才可以这么做，否内存炸裂

在「进行暴力匹配」这步骤中的问题

如果重复是大概率的事情，那么暴力匹配的耗时会非常多，变成一个 (O)n 的搜索，性能急剧下降。

此时有点像普通的二叉树，搜索匹配可能变成一个「链表」。

针对这种问题，可以做一些改进：

1. 直接存入磁盘 kvdb
2. 将字符串通过 安全 hash 算法计算成数字存入 redis bitmap/hash
   1. 对字符串进行 hash 的目的是降低内存占用

然而

然而哥们直接用了布隆过滤器的「不存在一定不存在」的特性直接「粗」过滤了。

所以……还是水一篇博客吧。

wiki 百科

Keycloak 是一个开源软件产品，旨在为现代的应用程序和服务，提供包含身份管理和访问管理功能的单点登录工具。

所以这个工具主要是为了解决账号的同步、身份管理与统一访问下的单点登录工具。

例如你可以将 github、google、facebook 等基于 OAuth2 的账号体系，以及基于 ldap 的账号管理体系集成到 keycloak。

我们并不需要关心账号的来源，只需要与 keycloak 进行通讯，即可解决多平台下不同账号体系的登录问题。

我这下载的版本是 keycloak v12.0.1

公司产品的解决方案

事实上在公司的产品中，我们需要提供类似 keycloak 的能力给客户，但是并不能给我们提供完整的解决方案。

但是致所有要看 keycloak 的源码，主要是有几点期望。

• 了解用户列表的拉取
  • ldap 拉取如何实现大规模用户的拉取
  • 如何合并用户

流程

Keycloak 主要做几件事

1. 将用户拉取下来
2. 将用户合并到系统中
3. 将用户通过协议（例如 OAuth2）暴露出来

因为我们的业务系统中，比较比较重「用户合并」这个能力，但是目前看起来，keycloak 解决的问题跟公司的业务不是很 match。

不过还是大概将 keycloak 的源码大概看了一下。

下面会主要关注 ldap 相关的实现，之所以关注 ldap 主要是因为我们的客户群体用 ldap 的较多，其次是 ldap 的用户量通常比较多，以及具有一定的代表性。

LDAP 的用户拉取

federation/ldap/src/main/java/org/keycloak/storage/ldap/idm/store/IdentityStore.java

public interface IdentityStore {

LDAPConfig getConfig();

void add(LDAPObject ldapObject);

void update(LDAPObject ldapObject);

void remove(LDAPObject ldapObject);

public void addMemberToGroup(String groupDn, String memberAttrName, String value);

public void removeMemberFromGroup(String groupDn, String memberAttrName, String value);

List fetchQueryResults(LDAPQuery LDAPQuery);

int countQueryResults(LDAPQuery LDAPQuery);

Set queryServerCapabilities();

void validatePassword(LDAPObject user, String password) throws AuthenticationException;

void updatePassword(LDAPObject user, String password, LDAPOperationDecorator passwordUpdateDecorator);

}

上面的代码删除了一些注释，ldap 的查询实现中主要实现了这个接口，诸如 拉取、验证、数量、配置等等。

具体的实现在

federation/ldap/src/main/java/org/keycloak/storage/ldap/idm/store/ldap/LDAPIdentityStore.java

public class LDAPIdentityStore implements IdentityStore { // …… }

然后在 LDAPQuery 中会进一步封装调用上面的代码，

federation/ldap/src/main/java/org/keycloak/storage/ldap/idm/query/internal/LDAPQuery.java

public class LDAPQuery implements AutoCloseable { }

当然，在往上找，就是各种工具类的封装了。

其实本身这些代码没有太多亮点，基本上都是业务上的逻辑（当然可能是我本身 java 接触不多，仅仅是 n 年前写过安卓的水平，海涵）。

用户的合并

keycloak 的用户的合并逻辑其实跟我们公司业务中的用户合并差别很大，几乎不 match……

但是还是看一下，当学习……

用户合并实现了很多的接口。

federation/ldap/src/main/java/org/keycloak/storage/ldap/LDAPStorageProvider.java

public class LDAPStorageProvider implements UserStorageProvider, CredentialInputValidator, CredentialInputUpdater.Streams, CredentialAuthentication, UserLookupProvider.Streams, UserRegistrationProvider, UserQueryProvider.Streams, ImportedUserValidation { }

federation/ldap/src/main/java/org/keycloak/storage/ldap/LDAPStorageProviderFactory.java

public class LDAPStorageProviderFactory implements UserStorageProviderFactory, ImportSynchronization {

public SynchronizationResult sync(KeycloakSessionFactory sessionFactory, String realmId, UserStorageProviderModel model) { }

protected SynchronizationResult importLdapUsers(KeycloakSessionFactory sessionFactory, final String realmId, final ComponentModel fedModel, List ldapUsers) { }

// …… }

上面的工厂类主要就是同步并导入用户到 keycloak 中。

后话

看到 keycloak 其实有地方也挺简单直接的，比如在 ldap 不管用户量的情况下，也是直接 fetch 加载到内存中的。

在我司的业务场景中，合并还是一个比较重的操作，并没有用流式方式来合并处理这些业务，当然跟业务场景有关。

其实 java 的代码比 go 的代码好看很多啊（可能是知名项目本身的质量较高…毕竟红帽出品…），基本上看到其名字就知道其他业务功能。

我司的代码质量还有提升空间～～～

由于 go1.5 之后官方的 go module 是默认强制开启的。

所以 gopls 在一些未使用 go module 的项目中会有一些坑。

比如公司的老项目还用的 govendor 这个依赖管理工具，官方早就未维护了。

其实迁移到新的 go module 也不麻烦，但是似乎并没人来推动这个事。

未使用 go module 的坑

一、gopls 无法启动，提示必须使用 go mod

解决方式：修改 vscode 的配置 settings.json 文件，新增配置

{ "go.toolsEnvVars": { "GO111MODULE": "auto" } }

gopls 似乎无法识别的系统环境变量中的 GO111MODULE 变量，但是在设置中修改，是有效的。

二、gopls 警告：依赖模块不对

The code in the workspace failed to compile (see the error message below). If you believe this is a mistake, please file an issue: https://github.com/golang/go/issues/new. unexpected directory layout: import path: /Users/me/go-project/src/github.com/compeny/compeny-api/app/models root: /Users/me/go-project/src dir: /Users/me/go-project/src/github.com/compeny/compeny-api/app/models expand root: /Users/me/go-project expand dir: /Users/me/go-project/src/github.com/compeny/compeny-api/app/models separator: / unexpected directory layout: import path: /Users/me/go-project/src/github.com/compeny/compeny-api/app/models root: /Users/me/go-project/src dir: /Users/me/go-project/src/github.com/compeny/compeny-api/app/models expand root: /Users/me/go-project expand dir: /Users/me/go-project/src/github.com/compeny/compeny-api/app/models separator: / : packages.Load error

解决方式：根据提示，删除 $GOPATH 中 pkg、src 中可能重复的代码即可

最近在写 git 的一个服务，也就是 growerlab 的一个组件。

mensa - https://github.com/growerlab/mensa

最近做的研究主要是用户的推送时以及推送到服务器的 hook 相关的功能。

推送时的权限验证时机

整个服务流程

• git push
• mensa - 调用 git-refs 权限权限
• mensa - 调用 git-receive-pack
• mensa - 调用 hooks 创建 events
  • hook 时机
  • 新分支的 commits

hook 时机的坑

最开始是想在创建仓库的时候，ln -s 软链一个 update 的 hook 到对应的钩子，这个是很久之前的 gitlab 的版本的方式。

后来查阅 gitlab 开发的 gitaly 代码，才发现 gitlab 这些年做了很多的改造，避开了很多 n 年前的坑。

比如 hook 的接入时机改成了调用 git 命令时

git xxxx -c core.hooksPath=hook path

这样其实还是非常方便的，避免了无避免的软链

新分支的 commits

hook 的功能之一就是创建 events。

普通的 commits 还好说，但是如果一个新的 分支，并且里面有几个新的 commits 时，这个问题倒是花了我一点时间研究测试。

后来发现，调用 update hook 时，还并不会在 refs 中创建对应的分支。

并且通过 go-git 试验发现，新提交的分支中的新 commit，查找他的 parents 时，只能拿到新提交的 commits。

所以当不管用户提交新的 branch 还是新的 tag，都是可以拿到新提交的 commit 的。

完

在做代码托管平台时，其实很多 git 的本身的很多问题都是可以通过测试发现的，有的坑必须踩呀。

又记一片流水账。。

没想到 2020 年过得真快，眼看进度条已经快 40%了。

2020 年发生了太多事，大到全球疫情，小到家庭矛盾，总体来说不太走运，但是人总要乐观一点，否则真的会不太好过。

偏题了，这篇文字是想写一些程序设计相关的一些感悟，观察，感慨。观察一些厉害的人，学习他人优点，补充一些自己的不足。

聪明人的自带天赋

如果一定要说聪明人之所以聪明，我一定会说：记忆力。

印象中物理界、数学界大佬，现实中认识的聪明人，无一例外记忆力都挺强。对曾经发生的事，甚至一些细节末梢依然描述得非常清晰。

有一次问个大佬一个代码问题，看 git 记录可能已经是 2 年前的代码，主要细节依然很清楚。

而「推理」跟大脑中的信息量是有直接关系的。

so~ 有些天赋得认命~

提高记忆力

• 好记性不如烂笔头
• 想更多，更深，持续改进
• 睡眠、睡眠、睡眠！

在程序开发中，厉害的程序员会想清楚方方面面，文字、UML、脑图、架构图、流程图，越细越好，这些东西本质上是在帮助记忆。

当然更重要的是，提前想好，规划好你要做的事。

良好的睡眠则是最好的大脑养护。

某大佬：程序设计=睡好觉

大脑的保养很重要。

问题的抽象汇总与方案输出

工作中，随着开发、迭代，我们总会碰到一系列的问题，这些问题可能会有一些联系，规律。

那么，对问题的 分类，归纳，总结，找出共同点，或本质的问题，最终输出一个合理的方案来解决问题。

这种能力需要经验以及丰富的知识，视野来提供支撑。

其实也需要一定的创造力。

程序设计是一门创造性的工作

上面说到程序设计中的一系列问题，工程师本质上就是一直在解决各类问题。

而各类解决方案的输出，本质上是一门创造性的工作，也许有一些方案已经存在了轮子，可以拿过来用，比如搜索功能 es。

但是某些没有的功能，是创造性的，需要权衡各种利弊的，甚至需要一些文献来提供支撑的，至少在逻辑上合情合理的。

普通程序员与高阶程序员一定程度上就是这种差异，这种差异往往是很难追赶的。

普通程序员如果想往上爬，做更厉害的程序员，需要思考更多。

与厉害的程序员交流是非常好的方式，当然你得提前将你的问题整理成问题，你的解决方案，你的思路，要解决的问题，这样更大佬交流才能更高效。

首先，在某些数据表中的字段，存着非常大的json数据。

并且有几十万行数据，需要更改json中的某个数组字段，追加一些元素。

常规方式

• 读取所有的行
• json反序列化
• 修改数据
• json序列号并保持到数据库

有几个问题

• 内存占用非常大，每行大概至少有8KB的数据，各种对象，内存申请，这个迁移程序可能会吃到数G的内存。
• 性能也不好，在读取数据库期间，其实是浪费了的

第二次优化

按每个团队划分，分别查询，内存降低了一点，因为golang中，使用过的对象并不会立即GC掉。

由于频繁的make对象，所以内存不会立即gc，内存还是比较高的。

第三次优化

使用golang中的Pool功能来复用对象：

var issueTypePool = sync.Pool{ New: func() interface{} { return make([]*IssueType, 0) }, }

数据库查询

issueTypes := issueTypePool.Get().([]*IssueType) _, err := tx.Select(&issueTypes, sql, teamUUID) if err != nil { return nil, err }

恢复对象到对象池：

defer issueTypePool.Put(issueTypes[:0])

这样已经不错了，对象能复用，内存占用取决于最大的团队的内存占用。。

第四次优化

使用golang中的游标方式。

下面的代码中有第二个参数就是channel缓冲区，并且在rows中边读边丢入channel

func AllObjects(tx sq.DB, issueTypeChan chan<- IssueType) error { // 。。。。 for rows.Next() { it := new(IssueType) err = rows.Scan(&it.UUID, &it.TeamUUID, &it.DefaultConfigs) if err != nil { return err } issueTypeChan <- it } return nil }

启动goroutine，并在持续从chan缓冲区读取数据，同时对数据修改迁移，并写入数据库。

issueTypeChan := make(chan IssueType, 1000) doneChan := make(chan bool) timer := time.NewTimer(5 time.Second) defer timer.Stop()

go func() { for { select { case <-timer.C: close(doneChan) fmt.Println("done...") return case it := <-issueTypeChan: timer.Reset(5 * time.Second) // TODO .... } } }()

这样就比较满意了，但是这种方式还没有经过测试，理论上读写分离之后，性能是更优的。

xxxxxxx/vendor/go4.org/reflectutil.typedmemmove: relocation target runtime.typedmemmove not defined for ABI0 (but is defined for ABIInternal)

解决方案：

删除 vendor 目录中的 go4.org 目录

执行：govendor update go4.org/reflectutil

总之就是更新这个包到新版

即可

\=========

奶一波我的一个网站：https://v2geek.com ，欢迎大家来贩卖自己的软件。

瞧了下十多年前写的博客，感觉好傻逼。。。🙄

感慨时光飞逝~~ 竟已是孩子他爹~~~~

\=========

奶一波我的一个网站：https://v2geek.com ，欢迎大家来贩卖自己的软件。

其实 2016 年就接触过，但是当时学得有点难受，于是放弃了，也没有目标性。

于是现在又学一下 rust~ 感觉还是有必要掌握一门高性能的语言，虽然 c/cpp 也可以，但是毕竟还是有点古老了。

而且比较看好 rust，哈哈。

而且最近想整一个小项目，需要一点高性能的东西，虽然理论上 golang 完全够用了，但是就当学一个新东西，顺便用起来，也挺好的。

完毕。。。

\=========== 8 月 7 号更新

rust 学习确实比较陡，估计学 1 个月才能上手~ 所以投入产出比太低了~ 先弃坑了~~~

奶一波我的一个网站：https://v2geek.com ，欢迎大家来贩卖自己的软件。

Synconfig 是什么

这个工具是基于 boltDB 开发的基于 http 协议的 配置同步工具。

这个的初衷是之前写一个你懂得工具，然后在分布在各地服务器，如果每次增加个新的服务器，那么就要重新同步配置，总之非常容易出错，是一个非常不可靠的设计。

于是就想整一个“配置中心”的功能，最开始想用 etcd，但是好像有点复杂了，所以感觉自己写了一个 服务端和客户端。

第三方的软件，直接集成客户端的功能，就实现配置的同步了。

实现 配置 与 服务的解耦。

当有新的配置更新时，所有的客户端能自动收到新的配置，自动更新自身。

造这个轮子不仅仅是为了“你懂得”的软件，未来我的任何新的一些服务，都可以直接集成客户端，并且快速上线

基本实现

“配置中心” 服务端需要运行在某个服务器的。我是在 vultr 上购买了一个最低配的服务器，每个月 3.5 刀，还可以，上面还跑了一些其他的服务。

“客户端” 配置好服务器端后，就会隔几秒通过自己的 stamp 来获取新的配置，从而更新自身的配置。

通讯上使用 token 来校验，并且可以配置 https 来通讯，避免 token 外泄，也建议使用 https 来与服务端通讯，避免 token 被检测到。

其他

通过写这么一个简单的“基础设施”，还是挺好玩的。

我设想的一些很多功能，都会集成这个服务端。

奶一波我的一个网站：https://v2geek.com ，欢迎大家来贩卖自己的软件。

golang函数级别的监控主要使用pprof包中的StartCPUProfile 函数与 StopCPUProfile

本报告主要是围绕这个监控来.

监控函数性能的目的

除了sql慢查询监控, 网络情况等监控, 我们应该也必须监控到函数的性能. 如果因为不合理的代码导致接口变慢, 内存变多等问题, 应能被监控并处理的.

• 提高接口响应速度
• 提前预知问题, 并尽早处理, 而不是等到大范围的客户感知被动响应(减少被动率, 提高主动率)
• 让程序员写出更好的代码
• 最终的目标是在性能问题被客户感知,放大之前, 将性能问题解决掉

PProf简单介绍

进程中的性能问题主要采用StartCPUProfile & StopCPUProfile函数.

这两个函数是golang自带的性能采集函数, 用于帮助开发者检查并分析进程中的性能问题.

• StartCPUProfile 开始采集运行栈, 并保存起来
• StopCPUProfile 停止采集

生产环境中使用PProf会有什么问题

那么直接在生产环境中会对主进程造成什么影响呢?

golang中的底层readProfile函数:

// readProfile, provided by the runtime, returns the next chunk of // binary CPU profiling stack trace data, blocking until data is available. // If profiling is turned off and all the profile data accumulated while it was // on has been returned, readProfile returns eof=true. // The caller must save the returned data and tags before calling readProfile again. func readProfile() (data []uint64, tags []unsafe.Pointer, eof bool)

目测不会对主城造成负担.

解决方案

分析prof数据

刚开始接触使用StartCPUProfile的时候, 感觉是一个本地使用的工具, 并不觉得可以用在生产环境(没看源码)

但是参考 http://github.com/stackimpact/stackimpact-go 的源码后, 发现其实StartCPUProfile是可以被集成到生产环境的性能监控的.

疑惑

• 如何解码StartCPUProfile产生的pprof数据
• 如何统计&量化profile数据

顺着这个思路, 开始研究golang中的go tool pprof 相关的命令源码, 并查阅 stackimpact 源码.

go tool pprof 的命令是基于 https://github.com/google/pprof/ 实现的.

• 数据通过 protocol-buffers 协议存储
• profile的数据结构: https://github.com/google/pprof/blob/master/proto/profile.proto
• 解码功能可以在 google/pprof 库里面找到.
  • google/pprof/profile.Parse()

查阅完上面的文档后可知道:

• StartCPUProfile输出的结果是用的google/pprof保存 + GZip方式压缩过的
• 输出的结果(xxx.prof) 文件是可以通过gzip.Reader 解码后, 通过google/pprof中的序列化成一个结构体的

• 结构体中内容如下:

  type Profile struct { SampleType []ValueType Sample []Sample Mapping []Mapping Location []Location Function []*Function

  DropFrames string KeepFrames string

  TimeNanos int64 DurationNanos int64 PeriodType *ValueType Period int64

  dropFramesX int64 keepFramesX int64 stringTable []string }

解码PProf数据:

// 将监控的结果写入内存 buff := bytes.Buffer{} w := bufio.NewWriter(buff) pprof.StartCPUProfile(w) defer pprof.StopCPUProfile()

// 解码数据(伪代码) import github.com/google/pprof/profile encodeBuff := gzip.Reader(buff) profile.Parse(encodeBuff)

通过上面的伪代码可以了解到这个搜集pprof的结果.

结论: 暂时只考虑 “定时监控” 的方式

func StartCPUProfile(w io.Writer) error { // cpu锁 cpu.Lock() defer cpu.Unlock() if cpu.done == nil { cpu.done = make(chan bool) } // 双重锁 if cpu.profiling { return fmt.Errorf("cpu profiling already in use") } cpu.profiling = true // ... return nil }

“定时监控” 实现

// ... func (f *TickerProfiler) tickerFunc() { // ... }

// 保持到队列 func (p *ProfilesData) AddNewProfile(newProfile map[string]int64) { // ... p.list.Push(profile) }

// 通过接口+时间戳获取队列中的增量数据

func GetProfiles(stamp int64) []*Profile { return profiles }

通过每隔一段时间执行 StartCPUProfile 进行采集并保持到队列列表中

定时监控”优点:

• 对主进程影响较低

缺点:

• 颗粒度较大, 不一定能实时命中到到较慢的函数(但理论上可以命大所有的函数)

“中间件” 实现

通过router.go中加入begin/done的方式监控各个接口请求的性能

// 伪代码 Use(StartCPUProfile) // 接口 Done(StopCPUProfile)

优点:

• 颗粒度够细

缺点

• StartCPUProfile 本身是全局锁, 同时只能运行一个该函数
• 在并发条件下, 依然可能会导致其他接口无法被监控到.

如何量化监控到的数据

采集到数据后, 可通过grafana将数据展示出来, 并提供预警等

开源库

根据这篇文章写一个golang的监控库:

[https://github.com/molizz/funcpprof](https://github.com/molizz/funcpprof)

今年年初加入 ONES 这家公司, 做了半年多 golang 后端开发.

1. 坦白说还是写编译型语言舒服.
2. 不喜欢 ruby 了,这种必测型语言很讨厌: 改一个地方, 必须要有个测试校验, 否则真不知道哪里会有坑. golang 没这么泛滥, 基本上编译器已经解决了不少问题, 测试也可以不用写那么复杂.
3. 现在能用 golang 写的, 绝不会用 ruby 了, 除非写网站. 写网站还是 ruby on rails 舒服啊.. 高效..

开发流程总结

1. 最近要改掉一些毛病: 思考不够深入, “将就”,”可以” 的想法要戒掉.
2. 开发某个功能前, 一定要画好流程图, 反复思考, 反复校验, 跟他人讨论, 一点思路直接开工会增加更多的工时, 浪费更多的脑细胞
3. 流程图之后, 接口的设计, 命名要更清晰
4. 功能要拆分, 越拆分越深入, 越能提前避免一些坑(但是坑总是避免不了的, 减少一点算一点咯

学习

1. 下班时间多记一记单词(已坚持 2 个月); 多记一些英文语句;
2. <算法 第四版=""> 必须要啃完.
3. <编程珠玑> 要啃完.

生活习惯

1. 坚持 12 点左右就睡觉, 熬夜这真的是一个烂习惯,因为第二天的无精打采会让你浪费一整天: 降低决策能力/逻辑能力/意志力. 之前尝试每天睡 7 小时, 似乎对于我的这幅身躯而已是不够的, 所以要延长至少每天能睡 8 小时.
2. 嗯, 最重要的, 之前 9 月份去体检, 结果不是太好, 所以锻炼身体这个事, 坦白说, 还没想好怎么安排; 深圳天气越来越糟, 户外的运动不太感冒. 比较感兴趣的是游泳, 羽毛球. 游泳一次 40, 羽毛球场地 80 一小时, 成本不低. 家里的公路自行车也一直荒废着, 坦白说, 附近没一个山可以爬一下, 平路骑行真的不费劲(达不到运动的效果, 可以考虑买一个骑行阻力架, 家里骑起来? 好像是不错的主意).

运动规律暂行方案:

1. 每周去一次游泳?
2. 骑行阻力架可以考虑买一个 达到每周运动 100 分钟(医生建议每周 150 分钟, 慢慢来).

暂时这样吧.

睡觉了.

最近用telegram, 发现bot这个玩意挺好玩的.

因为刚好觉得bing的翻译功能非常好用. 但是bing的翻译并没有接口,域名用读html的方式解析翻译结果.

做了一个telegram的机器人: @bingdict_bot

可以在telegram搜索体验一下~~~~

bing词典的解析是基于我之前写的另外一个开源项目https://github.com/molizz/bing-dict. 有需要的同学可以基于这个项目写api接口给第三方啥啥的.

保持telegram持续在线

telegram是被qiang了的. 所以为了让telegram一直保持在线,可以使用第三方的代理机器人申请代理.

通过测试,发现一个提供这个代理的机器人@getshadow_bot, 综合跟俄罗斯的几个代理机器人比起来, 速度快一些.

尤其是tg官方的MTProxy代理协议非常不错, 速度很快.

给tg加上代理后呢, 就不用设备一直翻墙了, 速度也还行.

最后

其实之所以写这篇文章，就是记流水账，然后体验一下 gitpages.io 这个网站，发现还是挺好用的，哈哈哈