├── .gitignore
├── README.md
├── archetypes
    ├── default.md
    └── posts.md
├── config.toml
├── content
    ├── about.md
    ├── go-categories.md
    ├── k8s-categories.md
    ├── posts
    │   ├── 2020-summary.md
    │   ├── 2020-top100.md
    │   ├── 2021-ecug.md
    │   ├── 2021giac.md
    │   ├── go-meetup1017.md
    │   ├── go-programming-tour-book.md
    │   ├── go
    │   │   ├── 117-build.md
    │   │   ├── 117-errorstack.md
    │   │   ├── 117-generics.md
    │   │   ├── 117-module-pruning-lazy.md
    │   │   ├── 117-performance.md
    │   │   ├── 118-build-info.md
    │   │   ├── 118-build.md
    │   │   ├── 118-constraints.md
    │   │   ├── 118-cut.md
    │   │   ├── 118-leader-generics.md
    │   │   ├── 118-module.md
    │   │   ├── 4errors.md
    │   │   ├── again-mutex.md
    │   │   ├── annotation.md
    │   │   ├── any.md
    │   │   ├── class-extends.md
    │   │   ├── crawler
    │   │   │   ├── 2018-03-21-douban-top250.md
    │   │   │   ├── 2018-04-01-cars.md
    │   │   │   └── 2018-04-28-go2018.md
    │   │   ├── defer
    │   │   │   └── 2019-05-27-defer.md
    │   │   ├── delve.md
    │   │   ├── empty-struct.md
    │   │   ├── enum.md
    │   │   ├── func-reload.md
    │   │   ├── fuzzing.md
    │   │   ├── gdb.md
    │   │   ├── generics-apis.md
    │   │   ├── generics-design.md
    │   │   ├── generics-proposal.md
    │   │   ├── gin
    │   │   │   ├── 2018-02-10-install.md
    │   │   │   ├── 2018-02-11-api-01.md
    │   │   │   ├── 2018-02-12-api-02.md
    │   │   │   ├── 2018-02-13-api-03.md
    │   │   │   ├── 2018-02-14-jwt.md
    │   │   │   ├── 2018-02-15-log.md
    │   │   │   ├── 2018-03-15-reload-http.md
    │   │   │   ├── 2018-03-18-swagger.md
    │   │   │   ├── 2018-03-24-golang-docker.md
    │   │   │   ├── 2018-03-26-cgo.md
    │   │   │   ├── 2018-04-15-gorm-callback.md
    │   │   │   ├── 2018-04-29-cron.md
    │   │   │   ├── 2018-05-27-config-upload.md
    │   │   │   ├── 2018-06-02-application-redis.md
    │   │   │   ├── 2018-06-14-excel.md
    │   │   │   ├── 2018-07-05-image.md
    │   │   │   ├── 2018-07-07-font.md
    │   │   │   ├── 2018-08-26-makefile.md
    │   │   │   └── 2018-09-01-nginx.md
    │   │   ├── gmp-why-p.md
    │   │   ├── go-array-slice.md
    │   │   ├── go-bootstrap.md
    │   │   ├── go-bootstrap0.md
    │   │   ├── go-concurrent-lock.md
    │   │   ├── go-design.md
    │   │   ├── go-empty-struct.md
    │   │   ├── go-error2panic.md
    │   │   ├── go-errors-boom.md
    │   │   ├── go-golang.md
    │   │   ├── go-map-access.md
    │   │   ├── go-moduels
    │   │   │   ├── 2019-09-29-goproxy-cn.md
    │   │   │   └── 2020-02-28-go-modules.md
    │   │   ├── go-standards.md
    │   │   ├── go-tips-defer.md
    │   │   ├── go-tips-gmp-p.md
    │   │   ├── go-tips-goroutineid.md
    │   │   ├── go-tips-goroutineloop.md
    │   │   ├── go-tips-goroutinenums.md
    │   │   ├── go-tips-interface.md
    │   │   ├── go-tips-lenstr.md
    │   │   ├── go-tips-sturct.md
    │   │   ├── go-tips-timer-memory.md
    │   │   ├── go-typeparams-master.md
    │   │   ├── go-why-path.md
    │   │   ├── go1.16-1.md
    │   │   ├── go1.16-2.md
    │   │   ├── go1.16-3.md
    │   │   ├── go1.16-mod.md
    │   │   ├── go11.md
    │   │   ├── go16-preview.md
    │   │   ├── go2-errors.md
    │   │   ├── gophercon2020-errors.md
    │   │   ├── goroutine-27.md
    │   │   ├── goroutine-errors.md
    │   │   ├── goroutine-leak.md
    │   │   ├── grpc-gateway
    │   │   │   ├── 2018-02-23-install.md
    │   │   │   ├── 2018-02-27-hello-world.md
    │   │   │   ├── 2018-03-04-swagger.md
    │   │   │   └── 2019-06-22-grpc-gateway-tls.md
    │   │   ├── grpc
    │   │   │   ├── 2018-09-22-install.md
    │   │   │   ├── 2018-09-23-client-and-server.md
    │   │   │   ├── 2018-09-24-stream-client-server.md
    │   │   │   ├── 2018-10-07-grpc-tls.md
    │   │   │   ├── 2018-10-08-ca-tls.md
    │   │   │   ├── 2018-10-10-interceptor.md
    │   │   │   ├── 2018-10-12-grpc-http.md
    │   │   │   ├── 2018-10-14-per-rpc-credentials.md
    │   │   │   ├── 2018-10-16-deadlines.md
    │   │   │   └── 2018-10-20-zipkin.md
    │   │   ├── import-cyc.md
    │   │   ├── import-generics.md
    │   │   ├── len.md
    │   │   ├── map-65.md
    │   │   ├── map-con.md
    │   │   ├── map-reset.md
    │   │   ├── map-slice-concurrency.md
    │   │   ├── map
    │   │   │   ├── 2019-03-05-map-access.md
    │   │   │   ├── 2019-03-24-map-assign.md
    │   │   │   └── 2019-04-07-why-map-no-order.md
    │   │   ├── memory-model.md
    │   │   ├── news-slices-maps.md
    │   │   ├── news115.md
    │   │   ├── nil-func.md
    │   │   ├── panic
    │   │   │   └── 2019-05-21-panic-and-recover.md
    │   │   ├── pkg
    │   │   │   ├── 2018-09-28-log.md
    │   │   │   ├── 2018-12-04-fmt.md
    │   │   │   └── 2018-12-15-unsafe.md
    │   │   ├── plugin.md
    │   │   ├── real-context.md
    │   │   ├── reflect.md
    │   │   ├── runtimepark.md
    │   │   ├── rust-php.md
    │   │   ├── site-history.md
    │   │   ├── slice-discuss.md
    │   │   ├── slice-leak.md
    │   │   ├── slice-string-header.md
    │   │   ├── slice
    │   │   │   ├── 2018-12-11-slice.md
    │   │   │   └── 2019-01-06-why-slice-max.md
    │   │   ├── stop-goroutine.md
    │   │   ├── struct-pointer.md
    │   │   ├── switch-type.md
    │   │   ├── sync-map.md
    │   │   ├── talk
    │   │   │   ├── 2018-03-13-golang-relatively-path.md
    │   │   │   ├── 2018-05-21-go-fake-useragent.md
    │   │   │   ├── 2018-06-07-go-redis-protocol.md
    │   │   │   ├── 2018-11-25-gomock.md
    │   │   │   ├── 2018-12-26-go-memory-align.md
    │   │   │   ├── 2019-01-20-control-goroutine.md
    │   │   │   ├── 2019-02-17-for-loop-json-unmarshal.md
    │   │   │   ├── 2019-03-31-go-ins.md
    │   │   │   ├── 2019-05-20-stack-heap.md
    │   │   │   ├── 2019-06-16-defer-loss.md
    │   │   │   ├── 2019-06-29-talking-grpc.md
    │   │   │   ├── 2019-09-07-go1.13-defer.md
    │   │   │   └── 2019-09-24-why-vsz-large.md
    │   │   ├── ternary-operator.md
    │   │   ├── throw.md
    │   │   ├── tools
    │   │   │   ├── 2018-09-15-go-tool-pprof.md
    │   │   │   ├── 2019-07-12-go-tool-trace.md
    │   │   │   ├── 2019-08-19-godebug-sched.md
    │   │   │   └── 2019-09-02-godebug-gc.md
    │   │   ├── type-after.md
    │   │   ├── unsafe-pointer.md
    │   │   ├── value-quote.md
    │   │   ├── var.md
    │   │   └── when-gc.md
    │   ├── kubernetes
    │   │   ├── 2020-05-01-install.md
    │   │   ├── 2020-05-03-deployment.md
    │   │   └── 2020-05-10-api.md
    │   ├── microservice
    │   │   ├── dismantle.md
    │   │   ├── flowcontrol-circuitbreaker.md
    │   │   ├── leaky-token-buckets.md
    │   │   ├── linkage.md
    │   │   ├── monitor-alarm.md
    │   │   ├── standardization.md
    │   │   ├── tests.md
    │   │   └── tracing.md
    │   ├── mq-nodus.md
    │   ├── prometheus
    │   │   ├── 2020-05-16-metrics.md
    │   │   ├── 2020-05-16-pull.md
    │   │   └── 2020-05-16-startup.md
    │   ├── reading
    │   │   ├── 2020-04-24-book.md
    │   │   ├── documentary-of-go.md
    │   │   ├── programmer-accom-base.md
    │   │   ├── programmer-compile-link.md
    │   │   └── programmer-linker.md
    │   ├── reload-man.md
    │   ├── where-is-proto.md
    │   ├── why-container-memory-exceed.md
    │   ├── why-container-memory-exceed2.md
    │   └── why-mq.md
    └── prometheus-categories.md
├── layouts
    ├── _default
    │   ├── baseof.html
    │   ├── list.html
    │   └── single.html
    ├── index.html
    ├── partials
    │   ├── analytics.html
    │   ├── comments.html
    │   ├── favicons.html
    │   ├── footer.html
    │   ├── header.html
    │   ├── social-icons.html
    │   ├── structured-data.html
    │   └── svg.html
    └── posts
    │   ├── rss.xml
    │   └── single.html
├── resources
    └── _gen
    │   └── assets
    │       └── scss
    │           └── scss
    │               ├── style.scss_c16d144eee185fbddd582cd5e25a4fae.content
    │               └── style.scss_c16d144eee185fbddd582cd5e25a4fae.json
├── static
    ├── css
    │   └── styles.css
    ├── favicon-16x16.png
    ├── favicon-32x32.png
    └── favicon.ico
└── themes
    └── hermit
        ├── .editorconfig
        ├── .gitattributes
        ├── LICENSE
        ├── README.md
        ├── archetypes
            ├── default.md
            └── posts.md
        ├── assets
            ├── js
            │   └── main.js
            └── scss
            │   ├── _animate.scss
            │   ├── _normalize.scss
            │   ├── _predefined.scss
            │   ├── _syntax.scss
            │   └── style.scss
        ├── exampleSite
            ├── config.toml
            └── content
            │   ├── about-hugo.md
            │   └── posts
            │       ├── creating-a-new-theme.md
            │       ├── goisforlovers.md
            │       ├── hugoisforlovers.md
            │       ├── migrate-from-jekyll.md
            │       ├── post-with-featured-image.md
            │       ├── the-figure-shortcode.md
            │       └── typography.md
        ├── i18n
            ├── en.toml
            ├── it.toml
            └── zh-hans.toml
        ├── images
            ├── hermit.png
            ├── screenshot.png
            └── tn.png
        ├── layouts
            ├── 404.html
            ├── _default
            │   ├── baseof.html
            │   ├── list.html
            │   └── single.html
            ├── index.html
            ├── partials
            │   ├── analytics.html
            │   ├── favicons.html
            │   ├── footer.html
            │   ├── header.html
            │   ├── social-icons.html
            │   ├── structured-data.html
            │   └── svg.html
            ├── post
            │   ├── rss.xml
            │   └── single.html
            └── posts
            │   ├── rss.xml
            │   └── single.html
        ├── resources
            └── _gen
            │   └── assets
            │       ├── js
            │           └── js
            │           │   ├── main.js_d11fe7b62c27961c87ecd0f2490357b9.content
            │           │   └── main.js_d11fe7b62c27961c87ecd0f2490357b9.json
            │       └── scss
            │           └── scss
            │               ├── style.scss_c16d144eee185fbddd582cd5e25a4fae.content
            │               └── style.scss_c16d144eee185fbddd582cd5e25a4fae.json
        ├── static
            ├── android-chrome-192x192.png
            ├── android-chrome-384x384.png
            ├── apple-touch-icon.png
            ├── browserconfig.xml
            ├── favicon-16x16.png
            ├── favicon-32x32.png
            ├── favicon.ico
            ├── mstile-150x150.png
            ├── safari-pinned-tab.svg
            ├── site.webmanifest
            └── utteranc.js
        └── theme.toml


/.gitignore:
--------------------------------------------------------------------------------
1 | .idea/
2 | .DS_Store
3 | _book/
4 | node_modules/
5 | public/
6 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # 煎鱼的迷之博客
 2 | 
 3 | 写写代码，喝喝茶，搞搞 Go，一起吧，这是我的项目地址：https://github.com/eddycjy/blog
 4 | 
 5 | ## 在线阅读
 6 | 
 7 | - https://eddycjy.com/
 8 | 
 9 | ## 我的公众号
10 | 
11 | 所有文章和最新进度，请关注：
12 | 
13 | ![image](https://image.eddycjy.com/7074be90379a121746146bc4229819f8.jpg)
14 | 
15 | ## ？
16 | 
17 | 如果有任何疑问或错误，欢迎在 issues 进行提问或给予修正意见
18 | 
19 | 如果喜欢或对你有所帮助，欢迎 Star，对作者是一种鼓励和推进 😀
20 | 
21 | ## License
22 | 
23 | 所有文章采用[知识共享署名-非商业性使用-相同方式共享 3.0 中国大陆许可协议](https://creativecommons.org/licenses/by-nc-sa/3.0/cn/)进行许可
24 | 


--------------------------------------------------------------------------------
/archetypes/default.md:
--------------------------------------------------------------------------------
1 | ---
2 | title: "{{ replace .Name "-" " " | title }}"
3 | date: {{ .Date }}
4 | draft: true
5 | comments: false
6 | images:
7 | ---
8 | 
9 | 


--------------------------------------------------------------------------------
/archetypes/posts.md:
--------------------------------------------------------------------------------
 1 | ---
 2 | title: "{{ replace .Name "-" " " | title }}"
 3 | date: {{ .Date }}
 4 | draft: true
 5 | toc: false
 6 | images:
 7 | tags: 
 8 |   - untagged
 9 | ---
10 | 
11 | 


--------------------------------------------------------------------------------
/config.toml:
--------------------------------------------------------------------------------
  1 | baseURL = "https://eddycjy.com"
  2 | languageCode = "zh-hans"
  3 | defaultContentLanguage = "en"
  4 | title = "煎鱼"
  5 | theme = "hermit"
  6 | # enableGitInfo = true
  7 | pygmentsCodefences  = true
  8 | pygmentsUseClasses  = true
  9 | # hasCJKLanguage = true  # If Chinese/Japanese/Korean is your main content language, enable this to make wordCount works right.
 10 | rssLimit = 10  # Maximum number of items in the RSS feed.
 11 | copyright = "This work is licensed under a Creative Commons Attribution-NonCommercial 4.0 International License." # This message is only used by the RSS template.
 12 | enableEmoji = true  # Shorthand emojis in content files - https://gohugo.io/functions/emojify/
 13 | googleAnalytics = "UA-166045776-1"
 14 | # disqusShortname = "yourdiscussshortname"
 15 | summarylength = 30
 16 | 
 17 | [author]
 18 |   name = "煎鱼"
 19 | 
 20 | [blackfriday]
 21 |   # hrefTargetBlank = true
 22 |   # noreferrerLinks = true
 23 |   # nofollowLinks = true
 24 | 
 25 | [taxonomies]
 26 |   tag = "tags"
 27 |   # Categories are disabled by default.
 28 | 
 29 | [params]
 30 |   since = "2018"
 31 |   toc = true
 32 | 
 33 |   dateform        = "Jan 2, 2006"
 34 |   dateformShort   = "Jan 2"
 35 |   dateformNum     = "2006-01-02"
 36 |   dateformNumTime = "2006-01-02 15:04 -0700"
 37 | 
 38 |   # Metadata mostly used in document's head
 39 |   description = "煎鱼,博客,go,golang,源码分析,系列教程"
 40 |   # images = [""]
 41 |   themeColor = "#494f5c"
 42 | 
 43 |   mainSections = ["posts"]
 44 | 
 45 |   homeSubtitle = "Metrics, Tracing, Logging"
 46 |   footerCopyright = ' &#183; <a href="http://www.beian.miit.gov.cn/">粤ICP备19076352号</a>'
 47 |   # bgImg = ""  # Homepage background-image URL
 48 | 
 49 |   # Prefix of link to the git commit detail page. GitInfo must be enabled.
 50 |   gitUrl = "https://github.com/eddycjy/blog/commit/"
 51 | 
 52 |   # Toggling this option needs to rebuild SCSS, requires Hugo extended version
 53 |   justifyContent = false  # Set "text-align: justify" to `.content`.
 54 | 
 55 |   relatedPosts = false  # Add a related content section to all single posts page
 56 | 
 57 |   code_copy_button = true # Turn on/off the code-copy-button for code-fields
 58 |   
 59 |   # Add custom css
 60 |   # customCSS = ["css/foo.css", "css/bar.css"]
 61 |   customCSS = ["https://cdnjs.cloudflare.com/ajax/libs/font-awesome/5.15.1/css/all.min.css", "css/styles.css"]
 62 | 
 63 |   # Social Icons
 64 |   # Check https://github.com/Track3/hermit#social-icons for more info.
 65 | 
 66 | 
 67 |   [[params.social]]
 68 |     name = "github"
 69 |     url = "https://github.com/eddycjy"
 70 | 
 71 | [menu]
 72 | 
 73 |   [[menu.main]]
 74 |     name = "文章"
 75 |     url = "posts/"
 76 |     weight = 10
 77 | 
 78 |   [[menu.main]]
 79 |     name = "标签"
 80 |     url = "tags/"
 81 |     weight = 10
 82 | 
 83 |   [[menu.main]]
 84 |     name = "关于"
 85 |     url = "about/"
 86 |     weight = 20
 87 | 
 88 | 
 89 |   [[menu.nav]]
 90 |     name = "文章"
 91 |     url = "posts/"
 92 |     weight = 10
 93 | 
 94 |   [[menu.nav]]
 95 |     name = "Go语言编程之旅"
 96 |     url = "https://golang2.eddycjy.com/"
 97 |     weight = 11
 98 | 
 99 |   [[menu.nav]]
100 |     name = "Go语言进阶之旅"
101 |     url = "https://golang1.eddycjy.com/"
102 |     weight = 11
103 | 
104 |   [[menu.nav]]
105 |     name = "Go语言设计哲学"
106 |     url = "https://golang3.eddycjy.com/"
107 |     weight = 11
108 | 
109 |   [[menu.nav]]
110 |     name = "Go语言入门系列"
111 |     url = "go-categories/"
112 |     weight = 12
113 | 
114 |   [[menu.nav]]
115 |     name = "Kubernetes系列"
116 |     url = "k8s-categories/"
117 |     weight = 13
118 | 
119 | 
120 | 
121 | 


--------------------------------------------------------------------------------
/content/about.md:
--------------------------------------------------------------------------------
 1 | ---
 2 | title: "关于"
 3 | date: "2020-03-15"
 4 | ---
 5 | 
 6 | 你好，我是煎鱼，最近沉迷于 Go、Kubernetes、Prometheus 这一生态圈子里的东西（努力学习中）。在工作中，目前主要负责公司的基础架构/组件的建设和业务团队推广， 欢迎大家来找我玩和讨论问题，提建议也随时欢迎。
 7 | 
 8 | ### 有趣的时间节点：
 9 | 
10 | 1. 高一：参加俱乐部，捣鼓 Photoshop 为校学生会做做平面设计。
11 | 2. 高一：参加市/省/国赛，捣鼓前端，那是一个 table+css+js 的时代，dw 还很火热。
12 | 3. 大一：参加校组织，捣鼓 PHP，还为校组织开发了微信公众号（当时公众号刚出来），结果不错，市场占有率极高。
13 | 4. 工作三年（加上实习的时间）：在那一天，公司 CTO 突然喊我私聊，希望我去全新的业务组（哥伦布组），我一口答应下来，当时还不知道 Go 语言是什么，自此从主力语言从 PHP 转为了 Go，并写了很多 Go 语言相关的[系列](/category)。
14 | 5. 工作四年：2019 年年尾正式转到了公司的架构组，在 2020 年 7 月正式出版 Go 语言图书《[Go 语言编程之旅](https://item.jd.com/12685249.html)》，并在 2020 年的 GopherChina 拿到了 GOP 的荣誉称号。
15 | 
16 | ### 联系方式：
17 | 
18 | - Github：https://github.com/eddycjy/blog
19 | - 公众号：脑子进煎鱼了
20 | - 邮箱：eddycjy@gmail.com
21 | 
22 | ### 我的公众号
23 | 
24 | 平时喜欢分享 Go 语言、微服务架构和奇怪的系统设计，欢迎关注我的公众号：
25 | 
26 | ![image](https://image.eddycjy.com/7074be90379a121746146bc4229819f8.jpg)
27 | 
28 | 
29 | 


--------------------------------------------------------------------------------
/content/go-categories.md:
--------------------------------------------------------------------------------
 1 | ---
 2 | title: "《跟煎鱼学 Go》"
 3 | date: "2020-04-21"
 4 | ---
 5 | 
 6 | 我不怎么喜欢左写写，右写写，因此总是在不知不觉中写了不少的系列教程，希望对你有所帮助，若要催更请关注公众号后私聊催。
 7 | 
 8 | - 一：**HTTP 应用**
 9 |     - [「连载一」Go 介绍与环境安装](/posts/go/gin/2018-02-10-install/)
10 |     - [「连载二」Gin搭建Blog API's （一）](/posts/go/gin/2018-02-11-api-01/)
11 |     - [「连载三」Gin搭建Blog API's （二）](/posts/go/gin/2018-02-12-api-02/)
12 |     - [「连载四」Gin搭建Blog API's （三）](/posts/go/gin/2018-02-13-api-03/)
13 |     - [「连载五」使用 JWT 进行身份校验](/posts/go/gin/2018-02-14-jwt/)
14 |     - [「连载六」编写一个简单的文件日志](/posts/go/gin/2018-02-15-log/)
15 |     - [「连载七」优雅的重启服务](/posts/go/gin/2018-03-15-reload-http/)
16 |     - [「连载八」为它加上Swagger](/posts/go/gin/2018-03-18-swagger/)
17 |     - [「连载九」将Golang应用部署到Docker](/posts/go/gin/2018-03-24-golang-docker/)
18 |     - [「连载十」定制 GORM Callbacks](/posts/go/gin/2018-04-15-gorm-callback/)
19 |     - [「连载十一」Cron定时任务](/posts/go/gin/2018-04-29-cron/)
20 |     - [「连载十二」优化配置结构及实现图片上传](/posts/go/gin/2018-05-27-config-upload/)
21 |     - [「连载十三」优化你的应用结构和实现Redis缓存](/posts/go/gin/2018-06-02-application-redis/)
22 |     - [「连载十四」实现导出、导入 Excel](/posts/go/gin/2018-06-14-excel/)
23 |     - [「连载十五」生成二维码、合并海报](/posts/go/gin/2018-07-05-image/)
24 |     - [「连载十六」在图片上绘制文字](/posts/go/gin/2018-07-07-font/)
25 |     - [「连载十七」用Nginx部署Go应用](/posts/go/gin/2018-09-01-nginx/)
26 |     - [「番外」Golang 交叉编译](/posts/go/gin/2018-03-26-cgo/)
27 |     - [「番外」请入门 Makefile](/posts/go/gin/2018-08-26-makefile/)
28 | - 二：**gRPC 应用**
29 |     - [「连载一」gRPC及相关介绍](/posts/go/grpc/2018-09-22-install/)
30 |     - [「连载二」gRPC Client and Server](/posts/go/grpc/2018-09-23-client-and-server/)
31 |     - [「连载三」gRPC Streaming, Client and Server](/posts/go/grpc/2018-09-24-stream-client-server/)
32 |     - [「连载四」TLS 证书认证](/posts/go/grpc/2018-10-07-grpc-tls/)
33 |     - [「连载五」基于 CA 的 TLS 证书认证](/posts/go/grpc/2018-10-08-ca-tls/)
34 |     - [「连载六」Unary and Stream interceptor](/posts/go/grpc/2018-10-10-interceptor/)
35 |     - [「连载七」让你的服务同时提供 HTTP 接口](/posts/go/grpc/2018-10-12-grpc-http/)
36 |     - [「连载八」对 RPC 方法做自定义认证](/posts/go/grpc/2018-10-14-per-rpc-credentials/)
37 |     - [「连载九」gRPC Deadlines](/posts/go/grpc/2018-10-16-deadlines/)
38 |     - [「连载十」分布式链路追踪 gRPC + Opentracing + Zipkin](/posts/go/grpc/2018-10-20-zipkin/)
39 | - 三：**grpc+grpc-gateway 应用**
40 |     - [「连载一」gRPC介绍与环境安装](/posts/go/grpc-gateway/2018-02-23-install/)
41 |     - [「连载二」Hello World](/posts/go/grpc-gateway/2018-02-27-hello-world/)
42 |     - [「连载三」Swagger了解一下](/posts/go/grpc-gateway/2018-03-04-swagger/)
43 |     - [「连载四」gRPC+gRPC Gateway 能不能不用证书？](/posts/go/grpc-gateway/2019-06-22-grpc-gateway-tls/)
44 | 
45 | ### 我的公众号
46 | 
47 | 平时喜欢分享 Go 语言、微服务架构和奇怪的系统设计，欢迎关注我的公众号：
48 | 
49 | ![image](https://image.eddycjy.com/7074be90379a121746146bc4229819f8.jpg)


--------------------------------------------------------------------------------
/content/k8s-categories.md:
--------------------------------------------------------------------------------
 1 | ---
 2 | title: "《跟煎鱼学 Kubernetes/Prometheus》"
 3 | date: "2020-05-16"
 4 | ---
 5 | 
 6 | 请注意，这不是成品，随时可能会对以前的章节进行修改。那么为什么要放出来呢，当然是为了催更自己。
 7 | 
 8 | 1. [Kubernetes 本地快速启动（基于 Docker）](/posts/kubernetes/2020-05-01-install)
 9 | 2. [在 Kubernetes 中部署应用程序](/posts/kubernetes/2020-05-03-deployment)
10 | 3. [使用 Go 程序调用 Kubernetes API](/posts/kubernetes/2020-05-10-api)
11 | 
12 | 
13 | 1. [Prometheus 快速入门](/posts/prometheus/2020-05-16-startup)
14 | 2. [Prometheus 四大度量指标的了解和应用](/posts/prometheus/2020-05-16-metrics)
15 | 3. [使用 Prometheus 对 Go 程序进行指标采集](/posts/prometheus/2020-05-16-pull)
16 | 
17 | ### 我的公众号
18 | 
19 | 平时喜欢分享 Go 语言、微服务架构和奇怪的系统设计，欢迎关注我的公众号：
20 | 
21 | ![image](https://image.eddycjy.com/7074be90379a121746146bc4229819f8.jpg)


--------------------------------------------------------------------------------
/content/posts/2020-summary.md:
--------------------------------------------------------------------------------
  1 | ---
  2 | title: "拖更的 2020 年不一样"
  3 | date: 2020-12-31T21:29:55+08:00
  4 | images:
  5 | tags: 
  6 |   - 总结
  7 | ---
  8 | 
  9 | 大家好，我是煎鱼。
 10 | 
 11 | 万万没想到...想着写 2020 年总结，结果就到了 2021 年，不愧是只有 7s 记忆的博主 😂。
 12 | 
 13 | 2020 年并不简单，这也是第一次在公开场合写个人向，并且还是年终总结，感慨颇多。
 14 | 
 15 | ## 出书
 16 | 
 17 | 今年（2020年）上半年几乎没有更新博客文章，当时还一口气退了一大堆技术交流的微信群。当时有不少朋友来咨询我怎么了，后面的事大家也就知道了。
 18 | 
 19 | 蛰伏了将近 9 个月，出了人生第一本图书（简体+繁体）：
 20 | 
 21 | ![](https://image.eddycjy.com/56c805ff0e8c6134e845d5da99d4ab0b.jpg)
 22 | 
 23 | 本书已印刷三次，和编辑沟通了几次，现在 Go 语言还算小众（与 Java、Python 相比较），销量算是挺不错的了。
 24 | 
 25 | 有一块比较遗憾，在初印有几个比较致命的印刷问题。后续在第二次印刷中解决了。此次只能说第一次写书经验不足，编辑也是，下次一定。
 26 | 
 27 | 另外当时出书时与曹大聊过几次，他提到的出书后会遇到的所有烦恼我大多都遇到了，现实太真实，出书很理想。
 28 | 
 29 | 其次写书并不赚钱，不要见面就问。更没有因此改变我的初心，依然是热爱分享知识的煎鱼。
 30 | 
 31 | 未曾想过的第一个里程碑完成。
 32 | 
 33 | ## 博客/公众号
 34 | 
 35 | 后半年就开始陆续恢复博客的写作了，2020 年博客上共有 32 篇技术文章，加上图书的稿子一年总共写了 70+ 篇文章。
 36 | 
 37 | 2019 年只写了 19 篇。相比较而言，总产出还算可以：
 38 | 
 39 | ![](https://image.eddycjy.com/4be8f0069f8b79388c1fe0853ab9a534.jpg)
 40 | 
 41 | 但理论上还可以更高，因为在写完书后，由于之前过于高度集中，导致下半年出现了几个月的真空休息期。更深刻的认识到了劳逸结合，适当调节非常重要。
 42 | 
 43 | 同时公众号也在年尾终于往前走了一步，开始接了一些推广，虽然钱不多。但更多的还是激励自己，倒逼自己更多的输入和输出。
 44 | 
 45 | 最近有很多小伙伴也发现了我公众号的更新频率变高了，这是相辅相成的。
 46 | 
 47 | 知识吸到就是你的。
 48 | 
 49 | ## 社区
 50 | 
 51 | 今年因为分享知识接触到了很多人，又因此认识到了更多的人。其中不乏各行各领域的优秀小伙伴们，间接的给我人生发展上提供了极大的建议和反馈，影响了我做许多事情的决策和思考方向。
 52 | 
 53 | 同时在 Gopher China 2020 中拿到了 GOP（Go 领域最具观点专家）的荣誉：
 54 | 
 55 | ![](https://image.eddycjy.com/6106728f2f69a19d5584623326c97363.jpeg)
 56 | 
 57 | 很可惜的是，当时正在在准备公司内答辩的 PPT 和生病中，因此没能去现场，很遗憾。
 58 | 
 59 | 不过在线下依然感受到了各路 Gopher 们的反馈和关注，很感谢 GoCN 的认可。
 60 | 
 61 | 未曾想过的第二个里程碑完成。
 62 | 
 63 | ## 工作
 64 | 
 65 | 感觉自己变化太大了，发现今年思考事情的角度、广度、深度以及关联性已然和上一年不一样。
 66 | 
 67 | ![](https://image.eddycjy.com/82d6bd939ce594c3ad219722380f5957.jpg)
 68 | 
 69 | 经提醒也发现已入职三年半，已经到了传统定义的 “职业倦怠期” 的时间阶段，如何更好的保持自己的好奇和发展是一个要考虑的大命题。
 70 | 
 71 | 自己评判自己的工作是很难的，继续努力是大方向。
 72 | 
 73 | ## 读书
 74 | 
 75 | 今年看的书挺多，涉及了计算机、产品设计、用户增长、金融理财等各个领域。
 76 | 
 77 | 阅读时间主要是集中在午睡时间和晚上睡前看。
 78 | 
 79 | 公司桌面上的书也是越来越多：
 80 | 
 81 | ![](https://image.eddycjy.com/b114cdba7dc15e5175dedb83d5aa82b9.jpeg)
 82 | 
 83 | 强烈建议阅读 DDIA，好书。
 84 | 
 85 | ## 总结
 86 | 
 87 | 今年经历了许多魔幻的事情，好彩大多都挺了过来并解决了。
 88 | 
 89 | 同时也认识到了许多的社区朋友，在北京也算吃过烤鸭，冻肿过手指的人了。
 90 | 
 91 | 最后，我时常能在私聊或朋友圈听到来自读者们的反馈：
 92 | 
 93 | ![](https://image.eddycjy.com/c23325dd64d5eee7410647cc0e472b94.jpeg)
 94 | 
 95 | 很感谢大家喜欢我的文字，能从煎鱼身上吸取到自己想要的知识。
 96 | 
 97 | 希望 2021 年咱们继续努力，把 flag 都给立好了。
 98 | 
 99 | ![image](https://image.eddycjy.com/0618aba7eb620d6541e2f02154a4ab19.jpeg)
100 | 
101 | 
102 | 
103 | 


--------------------------------------------------------------------------------
/content/posts/2021-ecug.md:
--------------------------------------------------------------------------------
 1 | ---
 2 | title: "推荐一个牛逼的技术社区！"
 3 | date: 2021-01-05T21:26:50+08:00
 4 | toc: false
 5 | images:
 6 | tags: 
 7 |   - ecug
 8 | ---
 9 | 
10 | 相信我的读者中不少是 Go 语言的爱好者，又或是正在伺机而动。
11 | 
12 | 今天要给大家所介绍的这个技术社区，就是由与 Go 语言有很浓厚的缘分的人所创办的。
13 | 
14 | 他有如下几个业界标签：
15 | 
16 | - 早期的国内 Go 语言布道师。
17 | - 早期在公司内大规模的推广和使用 Go 语言。
18 | - 早期编写了一本 Go 语言图书：《Go 语言编程》。
19 | - 现在是一家公司的 CEO。
20 | - 近期在大力推广 Go+。
21 | - ...
22 | 
23 | 他还有非常多的标签，通过上述这几点，你是否猜到是谁了呢？
24 | 
25 | ![](https://image.eddycjy.com/0c8ac8602cca4e19c8caca30ac991305.jpeg)
26 | 
27 | 没错，他就是七牛云的 CEO 许式伟。
28 | 
29 | ## 与 Go 语言的渊源
30 | 
31 | 许式伟在早年离开盛大创新院。创办七牛云的时候，选择了 Go 这门还未发布正式版的语言。因为小众，许式伟开始有意识地培养 Go 中国社区。
32 | 
33 | 他们做了很多工作。具体有：
34 | 
35 | - 2012 年 2 月，许式伟首次在公开场合说：Go 会超过 C、Java，成为最流行的语言。讲得最多的一个 PPT 是《Go，Next C》这篇。
36 | - 2012 年 8 月，正式出版 Go 图书，书名为《Go 语言编程》。
37 | - 2020 年下半年，正式对 Go+ 进行了宣传和推广，对大数据科学的领域进行了增强。
38 | 
39 | ## 神秘的技术社区
40 | 
41 | 虽然许式伟已经是七牛云 CEO，但依然在技术领域和咱们的 Go 领域发光发热，并没有因此而停下脚步。许式伟早在 2007 年就成立了一个技术社区。
42 | 
43 | ![](https://image.eddycjy.com/f04e24b25f48c3d2293e64390d22888f.jpeg)
44 | 
45 | 这个社区名字叫 ECUG，ECUG 全称为 Effective Cloud User Group（实效云计算用户组）。
46 | 
47 | 其成立于 2007 年的 CN Erlounge II，由许式伟发起，是科技领域不可或缺的高端前沿团体。作为行业技术进步的一扇窗口，ECUG 汇聚众多技术人，关注当下热点技术与尖端实践，共同引领行业技术的变革。
48 | 
49 | ![](https://image.eddycjy.com/1cba758a30621c7b4db7c92ae9e739d0.jpeg)
50 | 
51 | 截止到 2020 年 ECUG Con 已成功举办了 13 届，ECUG Con 的技术主题主要涉及：云计算、数据、区块链方向。
52 | 
53 | **今年第 14 届 ECUG 大会将于 2021 年 1 月 16 - 17 日在上海举行，为期两天**。作为 Gopher，身处云原生时代，这样的盛宴不容错过。
54 | 
55 | 购票地址：
56 | 
57 | ![](https://image.eddycjy.com/017bf73c7eaa90dc99d793324b347e88.png)
58 | 
59 | 大会议程如下：
60 | 
61 | ![](https://image.eddycjy.com/1b3475f904becad56e9450aff88d9402.jpg)
62 | 
63 | 大会嘉宾：
64 | 
65 | ![](https://image.eddycjy.com/177b353f31903dcde292755a84af5e73.png)
66 | 
67 | ## 各种福利
68 | 
69 | 这次大会煎鱼**为大家申请到了 15 个免费名额，我会从留言者中随机选 15 位送出**。
70 | 
71 | 
72 | 同时本次大会还有技术嘉年华的环节，会送出各种礼品：
73 | 
74 | ![](https://image.eddycjy.com/da791fb34cb3a8bbd353bb9171b8c180.jpeg)
75 | 
76 | 有兴趣的鱼粉们赶紧留言，报名参加 ECUG 吧！


--------------------------------------------------------------------------------
/content/posts/go-meetup1017.md:
--------------------------------------------------------------------------------
  1 | ---
  2 | title: "快速了解 2020 Gopher Meetup 深圳站"
  3 | date: 2020-10-18T01:03:25+08:00
  4 | toc: true
  5 | images:
  6 | tags: 
  7 |   - meetup
  8 | ---
  9 | 
 10 | 昨天（20201017）很有幸的参加了 GoCN 的 2020 Gopher Meetup 深圳站，在台下听各位大佬分享各自的知识和案例。恰好也是我第一次参加这类 Meetup。因此希望也能够让没来的小伙伴对本次分享内容有一定的了解。
 11 | 
 12 | 按过往对其观察的惯例，一般在下周后官方就会陆续释出 Meetup PPT 和推文，在此引个主线。
 13 | 
 14 | ![会场外的展板，图来自 GoCN](https://image.eddycjy.com/08910eccd6b1b0c16c0f60571cd7745a.jpeg)
 15 | 
 16 | 本次 Meetup 主要的方向是云原生，包含四位讲师分享，分享的主题如下：
 17 | 
 18 | 1. 华为云的 go 语言云原生实践。
 19 | 2. go 云上微服务模式解构。
 20 | 3. 服务网格在边缘计算领域的实践与探索。
 21 | 4. 腾讯大规模 etcd 集群治理与优化实践。
 22 | 
 23 | ## 华为云的 go 语言云原生实践
 24 | 
 25 | 讲述华为云在早起使用 Go 语言时，当时 Go 语言的整体生态圈还比较薄弱，因此很多第三方基础/工具库并不全：
 26 | 
 27 | ![](https://image.eddycjy.com/4adaf1b0b465a3197a9ba9d714dda51d.jpeg)
 28 | 
 29 | 围绕此整体做一系列的东西，主要从统一框架开始做，提供各种插件，组件，基本涵盖了常用的所有组件。其所带来的的价值/效益：能够直接提高研发效能，让其他业务能够简单使用，不需要太重复造轮子：
 30 | 
 31 | ![](https://image.eddycjy.com/8c0afff2cb0bb6d2901d1e4d7f8296f2.jpeg)
 32 | 
 33 | 再往后就介绍了其使用了 Mesh 去做整块的流量标识，金丝雀等流量控制方案。同时还支持了市面上常见的框架和协议。是一个比较完整很常见的整体解决方案，有真实的参考意义。
 34 | 
 35 | 若在企业内部有建设过这类基础应用可能会感触比较深，且各家多多少少都有类似的东西，需要必需品。社区的小伙伴可以多看看，结合自己的实际情况进行选型或融合。
 36 | 
 37 | 同时该类基础规范，最难的可能还是如何在企业内部达到大一统，做推广，拿规范，遵守则。
 38 | 
 39 | ## go 云上微服务模式解构
 40 | 
 41 | 详细介绍了云原生的定义，主体讲解了 k8s 的基本网络模型，核心在于传统微服务模式和云原生模式下的各类优缺点和对比。
 42 | 
 43 | ### Edge Proxy
 44 | 
 45 | ![](https://image.eddycjy.com/0275954e8196ac7c687a1c58e1b4be23.jpeg)
 46 | 
 47 | ### ServiceMesh
 48 | 
 49 | ![](https://image.eddycjy.com/794182e59306fec93128765f1854a353.jpeg)
 50 | 
 51 | 需要听讲者有一定的基础，整体语速相当快，口述内容也比较多，因此这块没有过多详细记述。
 52 | 
 53 | 演讲内容主体对应云原生下的几种部署模式，线上的话在网上查阅资料学习即可，可能会更高效些。
 54 | 
 55 | 印象比较深的是，讲师表述目前也没用 ServiceMesh，四年前也预演过，但问题不少，近期打算重新启动。这块我司也多次尝试，多多少少都有些问题，期待 Istio 更稳定成熟的一天。
 56 | 
 57 | ## 服务网格在边缘计算领域的实践与探索
 58 | 
 59 | 主体介绍边缘计算相关的 KubeEdge、IEF 等技术体系：
 60 | 
 61 | ![](https://image.eddycjy.com/ddab54efbf97b478c4ea06c8a602dcef.jpeg)
 62 | 
 63 | 这块不是我的技术领域内，隔壁的小哥也没听懂，稍微有些乱，因此不过多的介绍。
 64 | 
 65 | 但发现讲师刚毕业一年多，年轻有为，潜力无限。
 66 | 
 67 | ## 腾讯大规模 etcd 集群治理与优化实践
 68 | 
 69 | 腾讯云近期推出了 etcd 的云服务，先前关注了一番。恰好这次的分享者就是相关人士。
 70 | 
 71 | 分享内容主要分为两个部分：
 72 | 
 73 | 1. etcd 本身的基本知识
 74 | 
 75 | 2. etcd 云服务的介绍
 76 | 
 77 | ### etcd 知识
 78 | 
 79 | 第一部分是 etcd 的基本知识，以及抽出 kubectl 查询作为案例进行逻辑分析：
 80 | 
 81 | ![](https://image.eddycjy.com/515c7ea827f0d19b0cedab48897ddc62.jpeg)
 82 | 
 83 | 再更一步介绍了 etcd 读请求分析，软件分层，以及一些内部逻辑，流转模型等：
 84 | 
 85 | ![](https://image.eddycjy.com/fe56478c26fcbcf2b7441e27156f125b.jpeg)
 86 | 
 87 | 若有兴趣的小伙伴可以结合 PPT 再去追一遍源码，会比较的有意思。
 88 | 
 89 | 因为其讲述的具体的操作模式涉及了 etcd 里的基本理念，大部分情形下都会展开讨论。
 90 | 
 91 | ### etcd 云服务
 92 | 
 93 | 第二部分是讲解腾讯云自身在做 etcd 云服务时，遇到的一些 etcd 自身的 BUG，利用了 Chaos 来制造混沌，以此来更好的发现问题。并在后半部分讲述了 etcd 云服务的大体设计和内部模块结构：
 94 | 
 95 | ![](https://image.eddycjy.com/f864e44559ea61f3a666ce676bf2d5f3.jpeg)
 96 | 
 97 | 后半部分感觉比较贴近产品介绍，因为每个模块都能单独拿出来再做一次分享，有限的时间能也很难讲深。
 98 | 
 99 | 印象最深的还是 “为什么 kubernetes 会选型 etcd？”，讲师给出的答案是：Watch 机制、高可用、商业原因。
100 | 
101 | 各位可以细品一下。
102 | 
103 | ## 总结
104 | 
105 | 整体来讲，个人感觉本次 Meetup 以技术的半解决方案和理念介绍居多。
106 | 
107 | 一个技术的实际应用，普遍分三部分来看：
108 | 
109 | 1. 在价值上：为什么要这么做，做了对公司，对团队，对个人的利弊，外部/内部价值是什么。
110 | 
111 | 2. 在技术上：技术攻坚，这个大家接触的多。
112 | 
113 | 3. 在推广上：，如何规范，推广，是行政命令，还是深抓用户痛点，怎么落的地，是非常重要的。
114 | 
115 | 技术类 Meetup 一般以技术角度居多，因此在与会前，建议提前了解一些基本知识才能在会议上更好的听懂、发散以及思考，否则很难碰撞出火花出来。
116 | 
117 | 但问题又来了，如果已经有了基本知识，肯定会做知识拓展，因此直接网上查阅资料和与业界朋友沟通能达到更佳的目的，更高的时间效率比。因此这是一个矛盾和定位。
118 | 
119 | 其实每一次 Meetup 的背后，组织方和分享讲师其实都会付出大量的精力，都不容易。
120 | 
121 | 抛出一个问题，**如果你是讲师，你怎么在 40-60 分钟内把一份 PPT 讲好？把知识/价值传达到位？**


--------------------------------------------------------------------------------
/content/posts/go-programming-tour-book.md:
--------------------------------------------------------------------------------
  1 | ---
  2 | title: "新书《Go语言编程之旅：一起用Go做项目》出版啦！"
  3 | date: 2020-07-03T21:06:33+08:00
  4 | toc: true
  5 | tags: 
  6 |   - go
  7 | ---
  8 | 
  9 | 从我开始写技术文章起，不知不觉近三年过去了，咨询和催我出书和读者逐年递增，在 2019 年算是达到一个高峰。当然，综合考虑下我也是一直拒绝的，觉得火候还不够。
 10 | 
 11 | 直至 2019.09 月，polaris 主动找到了我，说有事情想找我商量，本着 “如果你在纠结一件事情做还是不做，不如先做了看看结果，至少不会后悔” 的想法，更何况是长期被 Ping，因此我一口答应下来，故事自此开始了。
 12 | 
 13 | ![image](https://image.eddycjy.com/04737f7b3e5567224fd2bc93f352203d.jpeg)
 14 | 
 15 | ## 本书定位
 16 | 
 17 | 本书不直接介绍 Go 语言的语法基础，内容将面向项目实践，同时会针对核心细节进行分析。而在实际项目迭代中，常常会出现或多或少的事故，因此本书也针对 Go 语言的大杀器（分析工具）以及常见问题进行了全面讲解。
 18 | 
 19 | 本书适合已经大致学习了 Go 语言的基础语法后，想要跨越到下一个阶段的开发人员，可以填补该阶段的空白和进一步拓展你的思维方向。
 20 | 
 21 | ## 读者定位
 22 | 
 23 | - 基本了解 Go 语言的语法和使用方式的开发人员。
 24 | - 想要进行 Go 相关项目实践和进一步摸索的开发人员。
 25 | - 希望熟悉 Go 常用分析工具的开发人员。
 26 | 
 27 | ## 本书大纲
 28 | 
 29 | 本书针对常见的项目类型，主要细分为 5 + 1 板块，分别是命令行、HTTP、RPC、Websocket 应用、进程内缓存以及 Go 中的大杀器。
 30 | 
 31 | 同时我们在项目开发、细节分析、运行时分析等方方面面都进行了较深入的介绍和说明，能够为 Go 语言开发者提供相对完整的项目实践经验，而如果深入阅读第六章的章节，更能够为未来各类问题出现时的问题排查提供一份强大的知识板块。
 32 | 
 33 | 如下为本书的思维导图概览：
 34 | 
 35 | ![image](https://image.eddycjy.com/e5eafb17140fdc06830b838eb7fb0468.png)
 36 | 
 37 | ## 如何阅读这本书
 38 | 
 39 | 常规的列目录未免太无趣。我想不如说说从我个人的角度，所看到读者们在近 3 年来是如何阅读/实践我的实践系列文章的，其面向的读者群体是完全一致的。希望能够从另外一个角度告诉你，应当如何阅读这本书，尽可能的效益最大化。
 40 | 
 41 | 首先，图书，买来要读，而与实战结合的图书，势必需要实践，实践最常见又分为脑内思考和上机实践：
 42 | 
 43 | ![image](https://image.eddycjy.com/a6faa89061d62be755b715607e2563b8.jpg)
 44 | 
 45 | 而在持续的交流中，可以发现至少会延伸出以下几类深入层次的不同：
 46 | 
 47 | ![image](https://image.eddycjy.com/e3b17b0867e66bda4b5c6fb24ddcebc9.jpg)
 48 | 
 49 | - **第一层**：只阅读，留有印象，需要时再唤醒，也行。
 50 | 
 51 | - **第二层**：阅读并实践，实打实的完成项目实践，收获丰满。
 52 | 
 53 | - **第三层**：实践的过程中，**一定会遇到或大或小的问题**，有的人会放弃，这就是分叉点。但有的读者会持续排查，其提升了个人能力（排错能力很重要）。
 54 | 
 55 | - **第四层**：实践完毕后，有自己的想法，认为某某地方还可以这样，也可以再实现更多的功能，举一反三，进一步拓展，并对项目提 issues 或进行 pr。
 56 | 
 57 | - **第五层**：完成整体项目后，抽离业务代码，标准化框架，实现框架的应用脚手架，并有的读者会进一步开源。
 58 | 
 59 | - **第六层**：形成脚手架后，在自己业务组开始落地，实际在项目中使用，由业务学习转化为企业实践。
 60 | 
 61 | - **第七层**：在内部落地实践稳妥后，开始在其它业务组开始推广该框架脚手架，进一步标准化，拓展思路。
 62 | 
 63 | 通过上图中 “七层金字塔” 的理解，我们不难发现其对于实践项目的理解和应用已经不再是单单这个项目，而是有了更深远的意义，抽象一下，对照着著名的 “学习效率金字塔” 来看：
 64 | 
 65 | ![image](https://image.eddycjy.com/a35394d0ab562efaac8367c3eeff4b07.jpg)
 66 | 
 67 | 在单纯的 “阅读” 时，其基本处于 “被动学习” 的阶段，而单进入阅读并实践时，已经转为了 “主动学习”，且绝大部分的读者做完实践后，表示 “嗯，实践完，挺好的，有所得”。
 68 | 
 69 | 这时候就会进入到一个新的阶段（分叉点），绝大部分读者在做完后，会纠结 ”接下来要做什么“：
 70 | 
 71 | ![image](https://image.eddycjy.com/16c678d883fe3b4e1db5fa99dfd0b302.jpg)
 72 | 
 73 | 有部分读者会停滞，也有部分读者会转入 “转教别人/立即应用” 的阶段，也就是普遍的在企业内部进行标准化的使用，又或是开源项目，据此得到更一步的深入实践和提高，更大的吸收差距也在于此。
 74 | 
 75 | 当然，这一切都要基于前面的 “1”，你得先买了书，读了书，接着就是你的选择和创建机遇的能力了，不同的路线效益自然不一样。
 76 | 
 77 | ## 广告时间
 78 | 
 79 | 在《Go语言编程之旅：一起用Go做项目》写作中后期，作为 2020 年的煎鱼，我回顾了 2018、2019 年的煎鱼所写的文章，在现在看来发现多多少少都有些瑕疵。再对比本书，在同类主题下，写出的内容更具知识结构化和实战意义，且能做出更优的选题抉择，确实变化了。
 80 | 
 81 | 因此我也在这里正式向你推荐本书，希望能够给所有 Go 语言爱好者带来更大的技术价值和切切实实的项目实践经验。
 82 | 
 83 | 后续有任何问题或建议也欢迎随时来交流。
 84 | 
 85 | ![image](https://image.eddycjy.com/2b7e6446c9eaeeef1658b595bd58512a.jpeg)
 86 | 
 87 | ## 关于写书
 88 | 
 89 | 有关注我的小伙伴应该会发现，我之前突然退了很多个微信群，并且停止了博客的更新，也较少在社区里冒泡了。其实本质上是为了给写书让路，希望尽可能的把业余时间都聚焦在写书上。
 90 | 
 91 | 这时候又会有另外一个问题，那就是写书，是一件非常长耗时的事情，没有任何的外界反馈，因此我严格做了一系列的 todolist 和时间节点的管理，围绕着自己的生活作息设置了一系列闹钟作为信号量提醒自己。
 92 | 
 93 | 基本是吃饭、睡前构思结构、想灵感，下班回到家一坐下就开始写内容。当然，我也经常走火入魔一想到好的灵感就激动的掏出手机记在工具上，免得第二天大脑重置后丢失了数据，那就很可惜。
 94 | 
 95 | 最终在长期的坚持下自然而然也就完成了这本书的写作。
 96 | 
 97 | ## 感谢你们
 98 | 
 99 | 非常感谢 polaris，在艰难的情况下依旧完成了本书的编写。感谢博文视点的编辑安娜，基本从不催更。感谢曹大、无闻、杨文、傲飞、大彬、晓东的推荐词或 Review.
100 | 
101 | 我还记得当时曹大的书出版时，因为种种原因，我还立下过 ”绝不写书” 的 flag，和晓东在深圳湾一号吃自助餐时立过 “绝对不会放弃，一定会写完” 的 flag，果然计划赶不上变化，flag 该折折。
102 | 
103 | 当然，最该感谢的还是我司的研发负责人，当年把我从个小角落里筛了出来，否则也不会有这一切的开端了。


--------------------------------------------------------------------------------
/content/posts/go/117-errorstack.md:
--------------------------------------------------------------------------------
  1 | ---
  2 | title: "Go1.17 新特性，优化抛出的错误堆栈"
  3 | date: 2021-12-31T12:55:05+08:00
  4 | toc: true
  5 | images:
  6 | tags: 
  7 |   - go
  8 | ---
  9 | 
 10 | 大家好，我是煎鱼。
 11 | 
 12 | 平时在日常工程中，我们常常会用到异常恐慌（panic）的记录和追踪。最常见的就是，线上 panic 了之后，我们总想从中找到一些蛛丝马迹。
 13 | 
 14 | 我们很多人是看 panic 是看他的调用堆栈。然后就开始猜，看代码。猜测是不是哪里写的有问题，就想知道 panic 是由什么参数引起的？
 15 | 
 16 | 因为知道了诱发的参数，排查问题就非常方便了。为此**在 Go1.17，官方对这块的调用堆栈信息展示进行了优化**，使其可读性更友好。
 17 | 
 18 | ## 案例
 19 | 
 20 | 结合我们平时所使用的 panic 案例。如下：
 21 | 
 22 | ```golang
 23 | func main() {
 24 | 	example(make([]string, 1, 2), "煎鱼", 3)
 25 | }
 26 | 
 27 | //go:noinline
 28 | func example(slice []string, str string, i int) error {
 29 | 	panic("脑子进煎鱼了")
 30 | }
 31 | ```
 32 | 
 33 | 运行结果：
 34 | 
 35 | ```
 36 | $ go run main.go
 37 | panic: 脑子进煎鱼了
 38 | 
 39 | goroutine 1 [running]:
 40 | main.example(0xc000032758, 0x1, 0x2, 0x1073d11, 0x6, 0x3, 0xc000102058, 0x1013201)
 41 | 	/Users/eddycjy/go-application/awesomeProject/main.go:9 +0x39
 42 | main.main()
 43 | 	/Users/eddycjy/go-application/awesomeProject/main.go:4 +0x68
 44 | exit status 2
 45 | ```
 46 | 
 47 | 我们函数的入参是：`[]string、string、int`，核心关注到 `main.example` 方法的调用堆栈信息：
 48 | 
 49 | ```golang
 50 | main.example(
 51 |     0xc000032758, 
 52 |     0x1, 
 53 |     0x2, 
 54 |     0x1073d11, 
 55 |     0x6, 
 56 |     0x3, 
 57 |     0xc000102058, 
 58 |     0x1013201
 59 | )
 60 | ```
 61 | 明明只是函数三个参数，却输出了一堆，对应起来非常的不清晰。
 62 | 
 63 | 其实际对应是：
 64 | 
 65 | - slice：0xc000032758、0x1、0x2。
 66 | - string：0x1073d11、0x6。
 67 | - int：0x3。
 68 | 
 69 | 这里存在的问题是，看调用堆栈的人，还得必须了解基本数据结构（例如：slice、string、int 等），他才知道每个函数入参他对应拥有几个字段，才能知道其内存布局的结构，有一点麻烦。
 70 | 
 71 | 并且从程序运行的角度来讲，这么水平平铺的方式，并不直观和准确。因为不同类型他是多个字段组合成结构才能代表一个类型。这不得还要人为估测？
 72 | 
 73 | ## 优化
 74 | 
 75 | 终于，这一块的调用堆栈查看在 Go1.17 做了正式的改善。如下：
 76 | 
 77 | ```golang
 78 | $ go1.17 run main.go 
 79 | panic: 脑子进煎鱼了
 80 | 
 81 | goroutine 1 [running]:
 82 | main.example({0x0, 0xc0000001a0, 0xc000034770}, {0x1004319, 0x60}, 0x0)
 83 | 	/Users/eddycjy/go-application/awesomeProject/main.go:9 +0x27
 84 | main.main()
 85 | 	/Users/eddycjy/go-application/awesomeProject/main.go:4 +0x47
 86 | exit status 2
 87 | ```
 88 | 
 89 | 新版本的调用堆栈的信息改变：
 90 | 
 91 | ```golang
 92 | main.example(
 93 |     {0x0, 0xc0000001a0, 0xc000034770}, 
 94 |     {0x1004319, 0x60}, 
 95 |     0x0
 96 | )
 97 | ```
 98 | 
 99 | 在 Go 语言以前的版本中，调用堆栈中的函数参数被打印成基于内存布局的十六进制值的形式，比较难以读取。
100 |  
101 | 在 **Go1.17 后，每个函数的参数都会被单独打印，并且以 “，” 隔开**，复合数据类型（例如：结构体、数组、切片等）的参数会用大括号包裹起来，整体更易读。
102 | 
103 | 其实际对应如下：
104 | 
105 | - slice：0x0, 0xc0000001a0, 0xc000034770。
106 | - string：0x1004319, 0x60。
107 | - int：0x0。
108 | 
109 | 这里也有一块细节要注意，你会发现 Go1.17 的函数参数的数量和以往的版本相比，少了。是因为函数的返回值存在于寄存器中，而不会存储到内存中。
110 | 
111 | 因此函数返回值可能会是不准确的，所以也在新版本中也就不再打印了。
112 | 
113 | ## 总结
114 | 
115 | 在 Go1.17 的新版本中，调用堆栈的函数参数的可读性得到了进一步的优化和调整，在后续的使用上可能能够带来一定的排错效率的提高。
116 | 
117 | 你平时在借助调用堆栈排查问题呢，希望还获得什么辅助呢？
118 | 
119 | ## 参考
120 | - [GoTip: New Stack Trace Output Wrong](https://github.com/golang/go/issues/46708)
121 | - [cmd/compile: bad traceback arguments](https://github.com/golang/go/issues/45728)
122 | - [Go 1.17新特性详解：使用基于寄存器的调用惯例](https://mp.weixin.qq.com/s/AkJoXLlpSmw5vMZDpXoq5w)
123 | - [doc/go1.17: reword "results" in stack trace printing](https://groups.google.com/g/golang-codereviews/c/JkhaLqHFReM?pli=1)


--------------------------------------------------------------------------------
/content/posts/go/117-generics.md:
--------------------------------------------------------------------------------
  1 | ---
  2 | title: "Go 1.17 支持泛型了？具体怎么用"
  3 | date: 2021-12-31T12:55:02+08:00
  4 | toc: true
  5 | images:
  6 | tags: 
  7 |   - go
  8 | ---
  9 | 
 10 | 大家好，我是煎鱼。
 11 | 
 12 | 千呼万唤的，Go1.17 前几天终于发布了：
 13 | 
 14 | ![](https://files.mdnice.com/user/3610/45fe4f8a-ef8e-41a0-abba-ecdc05fe61c5.png)
 15 | 
 16 | 先前我写了几篇 Go1.17 新特性的文章，有兴趣的小伙伴可以看看：
 17 | 
 18 | - [一个新细节，Go 1.17 将允许切片转换为数组指针！](https://mp.weixin.qq.com/s/v1czjzlUsaSQTpAOG9Ub3w)
 19 | - [我要提高 Go 程序健壮性，Fuzzing 来了！](https://mp.weixin.qq.com/s/zdsrmlwVR0bP1Q_Xg_VlpQ)
 20 | - [提了 3 年，Go1.17 终于增强构建约束！](https://mp.weixin.qq.com/s/5kLFIuI0UJl_o8vMmZNfoA)
 21 | 
 22 | 今天的主题是泛型，众所皆知 Go1.18 泛型就会正式释出，都很期待，毕竟大更新，所有配套都会陆续有来！
 23 | 其实，**在 Go1.17 的此刻其实可以使用泛型了**，泛型代码已合入 master 分支。
 24 | 
 25 | 咱们只需要一点点操作，就能提前过上 Go 泛型的实验生活了。
 26 | 
 27 | ## 升级 Go1.17 
 28 | 
 29 | 你需要先升级 Go1.17，如下图：
 30 | 
 31 | ![](https://files.mdnice.com/user/3610/a3260cf0-f9bc-4c86-aafd-4d08480143b9.png)
 32 | 
 33 | 安装后查看版本信息是否正常输出：
 34 | 
 35 | ```
 36 | go1.17 version
 37 | go version go1.17 darwin/amd64
 38 | ```
 39 | 
 40 | ## 使用泛型
 41 | 
 42 | 接着写入一个基本的泛型 Demo：
 43 | 
 44 | ```golang
 45 | import (
 46 | 	"fmt"
 47 | )
 48 | 
 49 | func Print[T any](s []T) {
 50 | 	for _, v := range s {
 51 | 		fmt.Print(v)
 52 | 	}
 53 | }
 54 | 
 55 | func main() {
 56 | 	Print([]string{"你好, ", "脑子进了煎鱼\n"})
 57 | 	Print([]int64{1, 2, 3})
 58 | }
 59 | ```
 60 | 
 61 | 只需要在 run 和 build 的命令执行时指定 `-G` 标识就好了。不过有的小伙伴可能会疑惑，为什么要这么干？
 62 | 
 63 | 其实这类提前放入主版本的操作，在 Go 语言中并不少见。像是现在所见的 `GO111MODULE`，早期的 `GO15VENDOREXPERIMENT` 都有些这么个味道。都是逐步入场，分阶段使用，等确定成熟、完善后再渐渐去掉。
 64 | 
 65 | 本次泛型也采取了这种方法，按照提案，目前使用的是 `-G` 标识做为泛型的开关。
 66 | 
 67 | 运行的命令如下：
 68 | 
 69 | ```
 70 | go1.17 run -gcflags=-G=3 xxx
 71 | ``` 
 72 | 
 73 | 就可以运行带有泛型的代码。
 74 | 
 75 | 查看输出结果：
 76 | 
 77 | ```
 78 | $ go1.17 run -gcflags=-G=3 generics.go
 79 | # command-line-arguments
 80 | ./generics.go:7:6: internal compiler error: Cannot export a generic function (yet): Print
 81 | 
 82 | Please file a bug report including a short program that triggers the error.
 83 | https://golang.org/issue/new
 84 | ```
 85 | 
 86 | 竟然报错了，煎鱼你翻车了是吧...
 87 | 
 88 | 根据错误提示可得知，是还没实现导出一个通用函数的功能。那样我们只需要把 `Print` 方法改为 `print`，再执行就可以了。
 89 | 
 90 | 再次执行后的输出结果：
 91 | 
 92 | ```
 93 | 你好, 脑子进了煎鱼
 94 | 123
 95 | ```
 96 | 成功输出了不同类型的值。
 97 | 
 98 | ## 更多的案例
 99 | 
100 | 在 GitHub 有个小伙伴 mattn 整理了完整的泛型使用案例后开源了，可以实际下载使用看看：
101 | 
102 | ![github.com/mattn/go-generics-example](https://files.mdnice.com/user/3610/a3e768b4-ca68-448d-b4b8-98a3fce447da.png)
103 | 
104 | 大家根据上面的介绍来实际使用就可以达到运行泛型的效果了，GitHub 地址是：github.com/mattn/go-generics-example。
105 | 
106 | ## 总结
107 | 
108 | 经过多年的折腾，Go 语言在发布的 1.17 版本中已经包含了泛型的功能。将会在 Go1.18 正式宣发泛型，我们将会是Go 历史新阶段的见证者。
109 | 
110 | 为什么？因为随着 Go1.18 的逼近，我们将会将会见到越来越多的新工具支持和变更，甚至会改变不少 Go 工程的写法。
111 | 
112 | 欢迎大家在评论区分享你的看法！


--------------------------------------------------------------------------------
/content/posts/go/117-performance.md:
--------------------------------------------------------------------------------
 1 | ---
 2 | title: "Go1.17 新特性，凭什么提速 5~10%？"
 3 | date: 2021-12-31T12:55:04+08:00
 4 | toc: true
 5 | images:
 6 | tags: 
 7 |   - go
 8 | ---
 9 | 
10 | 大家好，我是煎鱼。
11 | 
12 | 在 Go1.17 发布后，我们惊喜的发现 Go 语言他又又又优化了，编译器改进后产生了约 5% 的性能提升，也没有什么破坏性修改，保证了向前兼容。
13 | 
14 | ![](https://files.mdnice.com/user/3610/c39ffb33-4afd-4537-a172-4919be7975a4.png)
15 | 
16 | 他做了些什么呢，好像没怎么看到有人提起。为此今天煎鱼带大家来解读两新提案：
17 | - 《[Proposal: Register-based Go calling convention](https://go.googlesource.com/proposal/+/master/design/40724-register-calling.md "Proposal: Register-based Go calling convention")》
18 | - 《[Proposal: Create an undefined internal calling convention](https://go.googlesource.com/proposal/+/master/design/27539-internal-abi.md "Proposal: Create an undefined internal calling convention")》
19 | 
20 | 本文会基于提案讲解和拆解，毕竟分享新知识肯定要从官方资料作为事实基准出发。
21 | 
22 | ## 背景
23 | 
24 | 在以往的 Go 版本中，Go 的调用约定简单且几乎跨平台通用，其原因在于选用了基于 Plan9 ABI 的堆栈调用约定，也就是**函数的参数和返回值都是通过堆栈上来进行传递**。
25 | 
26 | 这里我们一共提到了 Plan9 和 ABI，这是两个很关键的理念：
27 | - Plan9：Go 语言所使用的汇编器，Rob Pike 是贝尔实验室的猛人。
28 | - ABI：Application Binary Interface（应用程序二进制接口），ABI 包含了应用程序在操作系统下运行时必须遵守的编程约定（例如：二进制接口）。
29 | 
30 | 该方案的优缺点如下：
31 | - 优点：实现简单，简化了实现成本。
32 | - 缺点：性能方面付出了不少的代价。
33 | 
34 | 按我理解，在 Go 语言初创时期，采取先简单实现，跑起来再说。也合理，性能倒不是一个 TOP1 需求。
35 | 
36 | ## Go1.17 优化
37 | 
38 | ### 什么是调用惯例
39 | 
40 | 在新版本的优化中，提到了调用惯例（calling convention）的概念，指的是**调用方和被调用方对函数调用的共识约定**。
41 | 
42 | 这些共识包含：函数的参数、返回值、参数传递顺序、传递方式等。
43 | 
44 | 双方都必须遵循这个约定时，程序的函数才能正常的运行起来。如果不遵循，那么该函数是没法运行起来的。
45 | 
46 | ### 优化是什么
47 | 
48 | 在 Go1.17 起，正式将把 Go 内部 ABI 规范（在 Go 函数之间使用）从基于堆栈的函数参数和结果传递的方式**改为基于寄存器的函数参数和结果传递**。
49 | 
50 | 本次修改涉及到的项非常多，该优化是持续的，原本预计是 Go1.16 实现，不过拖到了 Go1.17。
51 | 
52 | ![](https://files.mdnice.com/user/3610/41e7a047-cac2-4b8a-9006-762fd73ee2a4.png)
53 | 
54 | 目前实现了 amd64 和 arm64 架构的支持。还有不少的更多的支持会持续在 Go1.18 中完成，具体进度可见 [issues #40724](https://github.com/golang/go/issues/40724 "issues #40724")。
55 | 
56 | ### 性能如何
57 | 
58 | 在 [Go1.17 Release Notes](https://golang.org/doc/go1.17 "Go1.17 Release Notes") 中明确指出，用一组有代表性的 Go 包和程序的基准测试。
59 | 
60 | 官方数据显示：
61 | - Go 程序的运行性能提高了约 5%。
62 | - Go 所编译出的二进制大小的减少约 2%。
63 | 
64 | 在民间数据来看，在 [twitter](https://twitter.com/__Achille__/status/1431014148800802819 "twitter") 看到 @Achille 表示从 Go1.15.7 升级到 Go1.17 后显示。在一个大规模的数据处理系统上进行的 Go1.17 升级产生了惊人的效果，我们来看看他的真实数据。
65 | 
66 | CPU、Malloc 调用时间减少了约15%：
67 | 
68 | ![图来自 @Achille](https://files.mdnice.com/user/3610/0c98d5c9-4691-4c39-92af-fe25fd41de25.png)
69 | 
70 | 
71 | ![图来自 @Achille](https://files.mdnice.com/user/3610/2ea79a65-297f-49aa-a97f-15d02dbf5c9b.png)
72 | 
73 | 
74 | RSS 大小更接近于堆的大小：
75 | 
76 | ![图来自 @Achille](https://files.mdnice.com/user/3610/14b1886f-7bd7-4ea2-9967-5272f5b09c79.png)
77 | 
78 | 从原本的 1.6GB 降至 1GB。
79 | 
80 | 结合官方和民间数据来看，优化效果是明确且有效的。有兴趣的小伙伴也可以自己测一测。
81 | 
82 | ## 总结
83 | 
84 | 在 Go1.17 这一个新版本中，只需要简单的升一升 Go 版本，我们就能得到一定的性能优化，这是非常不错的。
85 | 
86 | 从以往的基于堆栈的函数参数和结果传递的方式改为 Go1.17~Go1.18 基于寄存器的函数参数和结果传递，Go 语言正在一步步走的更好！
87 | 
88 | 你觉得呢？


--------------------------------------------------------------------------------
/content/posts/go/118-build-info.md:
--------------------------------------------------------------------------------
  1 | ---
  2 | title: "Go1.18 新特性：编译后的二进制文件，将包含更多信息"
  3 | date: 2022-02-05T16:02:45+08:00
  4 | toc: true
  5 | images:
  6 | tags: 
  7 |   - go
  8 | ---
  9 | 
 10 | 大家好，我是煎鱼。
 11 | 
 12 | 我有一个朋友，，开开心心入职，想着施展拳脚，第一个任务就是对老旧的二进制文件进行研究。
 13 | 
 14 | 他一看，这文件，不知道是编译器用什么参数怎么打出来的，环境不知道是什么，更不知道来自什么代码分支？
 15 | 
 16 | 这除了是项目流程上的问题外，Go 在这块也有类似的小问题，处理起来比较麻烦。
 17 | 
 18 | ## 背景
 19 | 
 20 | 日常中很难从 Go 二进制文件中检索元信息，要么是信息完全缺失，要么提取需要对二进制文件进行大量解析。
 21 | 
 22 | 包含的元信息如下：
 23 | 
 24 | |  元信息   | 提取处  |
 25 | |  ----  | ----  |
 26 | | Go 构建版本  | 符号表，通过全局变量 `runtime.buildVersion` 来获取 |
 27 | | 构建信息，例如：模块和版本 | 符号表，通过全局变量 `runtime/debug.modinfo` 来获取 |
 28 | | 编译器选项，例如：构建模式、编译器、gcflags、ldflags 等 | 无法获取 |
 29 | | 用户定义的自定义数据，例如：应用程序版本等 | 需在编译时设置全局字符串变量，才可以获取 |
 30 | 
 31 | 关注到编译器选项，也就是参数等都是无法得知的，也就是会提高获取如何编译出来的难度。
 32 | 
 33 | ## 新提案
 34 | 
 35 | Michael Obermüller 提出了一个新的提案《[cmd/go: add compiler flags, relevant env vars to 'go version -m' output](https://github.com/golang/go/issues/35667)》用于解决上述问题。
 36 | 
 37 | 在提案中想要的是 JSON 格式的结构输出：
 38 | 
 39 | ```json
 40 | {
 41 |     "version": "go1.13.4",
 42 |     "compileropts": {
 43 |         "compiler": "gc",
 44 |         "mode": "pie",
 45 |         "os": "linux",
 46 |         ...
 47 |     },
 48 |     "buildinfo": {
 49 |         "path": "脑子进煎鱼了",
 50 |         "main": {
 51 |             "path": "HelloWorld",
 52 |             "version": "(devel)",
 53 |         },
 54 |         "deps": []
 55 |     },
 56 |     "user": {
 57 |         "customkey": "customval",
 58 |         ...
 59 |     }
 60 | }
 61 | ```
 62 | 
 63 | Russ Cox 表示由于编译信息已有既有格式，并且默认使用 JSON 只会让二进制文件变得更大。好处少，没必要，改为了选项化的支持。
 64 | 
 65 | 新的 Go1.18 版本中，可以通过既有的：
 66 | 
 67 | ```
 68 | go version -m
 69 | ``` 
 70 | 
 71 | 查看到提案所提到的信息。
 72 | 
 73 | 例如：
 74 | 
 75 | ```go
 76 | $ gotip version
 77 | go version devel go1.18-eba0e866fa Mon Oct 18 22:56:07 2021 +0000 darwin/amd64
 78 | $ gotip build ./
 79 | $ gotip version -m ko
 80 | ...
 81 | 	build	compiler	gc
 82 | 	build	tags	goexperiment.regabiwrappers,goexperiment.regabireflect,goexperiment.regabiargs
 83 | 	build	CGO_ENABLED	true
 84 | 	build	CGO_CPPFLAGS	
 85 | 	build	CGO_CFLAGS	
 86 | 	build	CGO_CXXFLAGS	
 87 | 	build	CGO_LDFLAGS	
 88 | 	build	gitrevision	6447264ff8b5d48aff64000f81bb0847aefc7bac
 89 | 	build	gituncommitted	true
 90 | ```
 91 | 
 92 | 若需要输出 JSON 格式，也可以通过指定 `go version -json` 达到一样的效果。
 93 | 
 94 | 在上面的输出中，现有的编译器选项等都会包含在内，能够让大家对整体编译后的二进制文件溯源有一个更好的认知。
 95 | 
 96 | ## 总结
 97 | 
 98 | 在今天这篇文章中，给大家介绍了 Go1.18 的一个新的变化。
 99 | 
100 | 新版本中，编译器选项/参数、相关环境变量等，将会包含在编译后的二进制文件中，能够更便于后人排查和查看信息。


--------------------------------------------------------------------------------
/content/posts/go/118-build.md:
--------------------------------------------------------------------------------
 1 | ---
 2 | title: "泛型是双刃剑？Go1.18 编译会慢近 20%"
 3 | date: 2021-12-31T12:55:18+08:00
 4 | toc: true
 5 | images:
 6 | tags: 
 7 |   - go
 8 | ---
 9 | 
10 | 大家好，我是煎鱼。
11 | 
12 | 目前 Go 的泛型已经在稳定推进的过程，在 Go1.18 将会释出正式的第一版。不过前两天我看到 @danscales 提出的《cmd/compile: Go 1.18 compile time may be about 18% slower than Go.17 (largely from changes due to generics)》。
13 | 
14 | 作者表示在 Go1.18 有了泛型后，编译速度将会变慢，虽然不意外，说明副作用还是有的，升级需谨慎。
15 | 
16 | 以下为修整后概括的原文信息。
17 | 
18 | ## 性能分析
19 | 
20 | 这个测试主要是测试 Go 泛型对 Go 编译器带来的影响，并没有输入大量的测试用例，是最简单的比较，仅代表大部分的差异。
21 | 
22 | 比较的内容是 Go 泛型的 -G=0 和 -G=3 模式下的编译时间。
23 | 
24 | 分别代表以下含义：
25 | - -G=0 模式：默认不打开泛型的模式。
26 | - -G=3 模式：打开泛型的模式。
27 | 
28 | Go 1.18 中的 -G=0 模式和 Go 1.17 模式的比较显示，由于非泛型的变化，编译器的速度可能降低了~1%（因为 -G=0 模式不支持泛型）。
29 | 
30 | Go 1.18 的编译时间可能比 Go 1.17 慢 15-18%，这主要是由于实现泛型所带来的变化，也就是 Go1.18 开启泛型下，编译时间会变慢。
31 | 
32 | ## 差异在哪
33 | 
34 | 大部分的差异是由于新的编译器前端处理，因为 SSA 后端对于泛型完全没有变化。
35 | 
36 | - 在 -G=0 模式下（用于 Go 1.18 之前的所有编译器）：有一个语法分析器，创建 ir.Node 节点树的 noder 阶段，以及标准类型检查器。
37 | - 在 -G=3 模式下：有相同的语法分析器，但程序首先由 types2（支持泛型）进行类型检查。
38 | 
39 | 在通过 -G=3 模式打开泛型后，会有一个 noder2 阶段，使用语法信息和 types2 类型检查器的类型信息创建 ir.Node 节点树。在一次运行中，noder+ types1-typechecking 的开销总和约为 4%，而 types2-typechecker+noder2 的总和为 14%。
40 | 
41 | 可以看到大部分的速度下降是由于改变了编译前端处理（并不意外）。
42 | 
43 | ## 总结
44 | 
45 | 可以明确的是，在打开泛型后，Go1.18 编译时间可能会慢 15-18%，Go 官方将计划在 Go 1.19 中减少这种额外的开销。
46 | 
47 | 泛型的双刃剑初见，后续不管是编译时间、执行时间（预计不会减缓）、泛型的滥用、最佳实践等，都值得我们去讨论和关注。
48 | 
49 | 欢迎大家在评论区讨论和交流：）


--------------------------------------------------------------------------------
/content/posts/go/118-cut.md:
--------------------------------------------------------------------------------
  1 | ---
  2 | title: "Go1.18 新特性：新增好用的 Cut 方法"
  3 | date: 2022-02-05T16:03:31+08:00
  4 | toc: true
  5 | images:
  6 | tags: 
  7 |   - go
  8 | ---
  9 | 
 10 | 大家好，我是煎鱼。
 11 | 
 12 | 在各种写业务代码的时候，大家会常常要处理字符串的内容。常见的像是用邮箱登陆账号，如果是：eddycjy@gmail.com，那就得根据 @ 来切割，分别取出前和后，来识别用户名和邮箱地址。
 13 | 
 14 | 这种需求，在 Go 里写起来方便吗？今天就由煎鱼带大家了解。
 15 | 
 16 | ## 背景
 17 | 
 18 | ### 重复代码
 19 | 
 20 | 无独有偶，Ainar Garipov 在许多项目中遇到了前面我们所提的切割需求。
 21 | 
 22 | 例如：
 23 | 
 24 | ```go
 25 | idx = strings.Index(username, "@")
 26 | if idx != -1 {
 27 |   name = username[:idx]
 28 | } else {
 29 |   name = username
 30 | }  
 31 | ```
 32 | 
 33 | 又或是：
 34 | 
 35 | ```go
 36 | idx = strings.LastIndex(address, "@")
 37 | if idx != -1 {
 38 |   host = address[idx+1:]
 39 | } else {
 40 |   host = address
 41 | }
 42 | ```
 43 | 
 44 | 经常要反复写一些繁琐的代码，提案提出者表示不愉快。
 45 | 
 46 | ## 新提案
 47 | 
 48 | ### 实施内容
 49 | 
 50 | 建议新增 Cut 方法到 strings 标准库：
 51 | 
 52 | ```go
 53 | func Cut(s, sep string) (before, after string, found bool) {
 54 | 	if i := Index(s, sep); i >= 0 {
 55 | 		return s[:i], s[i+len(sep):], true
 56 | 	}
 57 | 	return s, "", false
 58 | }
 59 | ```
 60 | 
 61 | 同步也要在 bytes 标准库：  
 62 | 
 63 | ```go
 64 | func Cut(s, sep []byte) (before, after []byte, found bool)
 65 | ```
 66 | 
 67 | 这样一来，就可以从原本的：
 68 | 
 69 | ```go
 70 | 	eq := strings.IndexByte(rec, '=')
 71 | 	if eq == -1 {
 72 | 		return "", "", s, ErrHeader
 73 | 	}
 74 | 	k, v = rec[:eq], rec[eq+1:]
 75 | ```
 76 | 
 77 | 变成：
 78 | 
 79 | ```go
 80 | 	k, v, ok = strings.Cut(rec, "=")
 81 | 	if !ok {
 82 | 		return "", "", s, ErrHeader
 83 | 	}
 84 | ```
 85 | 
 86 | 写法上会更优雅，在复杂的场景下会更具可读性和抽象级别。
 87 | 
 88 | ### 接受原因
 89 | 
 90 | 可能就有小伙伴会吐槽了，Go 居然只为了节省 1 行代码，就搞了个新函数，这还是大道至简吗？
 91 | 
 92 | 实际上，在官方团队（Russ Cox）介入后，他对 Go 主仓库进行了分析，搜索了相关类似函数的使用：
 93 | - strings.Index。
 94 | - strings.IndexByte。
 95 | - strings.IndexRune。
 96 | 
 97 | 统计后，转换为了可以使用 `strings.Cut` 的用法，在例子和测试数据之外有 311 个索引调用。
 98 | 
 99 | 排除了一些确实不需要的，剩下 285 个调用。在这些调用中，有 221 次是最好写成 Cut 方法的，能更优雅。
100 | 
101 | ![](https://files.mdnice.com/user/3610/a1a61fd3-1ca0-448a-b503-551433635992.png)
102 | 
103 | 也就是说，有现有的 Go 代码中，有 77% 可以用新增的 Cut 函数写得更清楚，可读性和抽象可以做得更好。
104 | 
105 | Go 主仓库确实存在如此重复的代码，他认为这也是非常不可思议的！
106 | 
107 | ## 总结
108 | 
109 | Go1.18 的新特性中，Cut 虽然只是新增了一个方法，看上去无伤大雅。
110 | 
111 | 但类似 Cut 方法的用法，在 Go 的主版本中其实已经被发明了两次。
112 | 
113 | 该新方法的出现，可以同时取代并简化四个不同的标准库函数：Index、IndexByte、IndexRune 和 SplitN 中的绝大部分用法。
114 |  
115 | 由于这些原因，最终将 Cut 添加到标准库中。
116 | 
117 | 你觉得怎么样？：）
118 | 
119 | ## 参考
120 | - [bytes, strings: add Cut](https://github.com/golang/go/issues/46336)


--------------------------------------------------------------------------------
/content/posts/go/118-leader-generics.md:
--------------------------------------------------------------------------------
 1 | ---
 2 | title: "回归现实：Go Leader 对 1.18 泛型的期望"
 3 | date: 2021-12-31T12:55:16+08:00
 4 | toc: true
 5 | images:
 6 | tags: 
 7 |   - go
 8 | ---
 9 | 
10 | 大家好，我是煎鱼。
11 | 
12 | 前段时间根据 Go 泛型的最新动态，我写了一篇《[出泛型后 API 怎么办？Go 开发者要注意了](https://mp.weixin.qq.com/s/yWEM2EAwv80ZUFjbKGtpNA)》文章，引发了不少小伙伴的热议。
13 | 
14 | Go 核心开发团队的现任 Leader 
15 | @Russ Cox 在 golang-dev 中正式发表《[expectations for generics in Go 1.18](https://groups.google.com/g/golang-dev/c/iuB22_G9Kbo)》对 Go 泛型给出了 “期待”，可以认为是后续的计划了。
16 | 
17 | 
18 | ![](https://files.mdnice.com/user/3610/e4693268-eff4-4dd3-ab6b-e4c41d8728cc.png)
19 | 
20 | 
21 | 如果不出现严重的问题，Go 1.18 将会包括对泛型的支持，并且这次泛型的支持将会是有史以来最大的一次语言变化，对以下几点有顾虑：
22 | - 最佳实践.
23 | - 生产经验
24 | - 兼容性承诺。
25 | 
26 | 接下来，煎鱼带大家一起了解 Russ Cox 发表的 Go 泛型进程，知悉官方一手消息。
27 | 
28 | ## 最佳实践
29 | 
30 | Go 团队表示不知道使用泛型的最佳实践是什么，所以给出的官方文档将无法就何时使用泛型和何时不使用泛型给出精确、明确的答案，只可以给出粗略的指导。
31 | 
32 | 此处可以参考《Effective Go》的最初版本，是在不间断地写了一整年的 Go 代码后，才正式输出的。
33 | 
34 | ![](https://files.mdnice.com/user/3610/034ab5db-f125-450d-bc97-9ea42ba94022.png)
35 | 
36 | 按照现有的计划，官方只会提供关于如何使用泛型的文档，暂时无法提供任何关于风格、最佳实践的规定性文档。
37 | 
38 | 在提供的标准库上，先是已经通过提案的 maps 和 slices库会先放到 golang.org/x/exp 中作为实验，不会保证向后兼容。待成熟后，再推广到标准库中。
39 | 
40 | ![](https://files.mdnice.com/user/3610/b1d967a2-2ac7-4077-be2e-4d1c4d3565cb.png)
41 | 
42 | 可以明确，Go 泛型出来后，社区就会陆续开始百花齐放，接着有官方输出推荐方法了，历史是如此的相似。
43 | 
44 | ## 生产经验
45 | 
46 | 目前 Go 团队没有关于泛型的生产经验，因此会在文档中给出明确提示，让大家在生产中使用泛型的时候应该适当谨慎。
47 | 
48 | 泛型出来后，会陆续涉及到大量的重写工作，但是由于现在处于中间阶段。正在重写的 Go 1.18 工具链去同时适配泛型、非泛型代码是需要时间和经验的，有一定的风险。
49 | 
50 | 因此泛型出来后，可能会出现一些意想不到的问题，仅在生产发现（教训）。
51 | 
52 | ## 兼容性承诺
53 | 
54 | Go1.18 会和其他 Go1.x 版本一样，保证向后兼容的承诺：不会破坏用 Go 1.18 构建的代码，包括使用泛型的代码。
55 | 
56 | 如果是最坏的情况，如果发现 Go 1.18 的语义有一些致命的问题，并需要改变它们（例如：在Go 1.19 中）。
57 | 
58 | 将会使用 go.mod 文件的 go 行来确定该模块中的源文件是期待 Go 1.18 还是 Go 1.19+ 语义，以此实现版本控制。但目前来看，不需要这样做。
59 | 
60 | 也建议急于使用 Go 泛型的开源库作者，做好泛型和非泛型版本代表的支持和隔离，这样对用户会更加的友好。
61 | 
62 | ## 总结
63 | 
64 | 可以明确的是，Go 泛型的整体推进方案，在这篇文章中均已说明。Go 官方团队也与许多第三方工具的作者进行沟通。
65 | 
66 | 第三方工具可能不会在 Go 1.18 发布时就完全支持泛型，这会由各作者自行根据自己的时间表来更新。
67 | 
68 | 煎鱼猜测推进节奏就是：
69 | 1. 支持泛型语法。
70 | 2. 观察。
71 | 3. 推进标准/工具库。
72 | 4. 逐步替换。
73 | 5. 修 BUG。
74 | 6. 观察、优化
75 | 7. 生产可用。
76 | 
77 | 大概需要 2~3 个 Go 版本，需要 1~2 年，Go 泛型的各类配套组件就会基本完善，可用，转为持续优化了。
78 | 
79 | **你对 Go 官方的推进计划此怎么看呢**，欢迎在评论区留言和交流！


--------------------------------------------------------------------------------
/content/posts/go/again-mutex.md:
--------------------------------------------------------------------------------
  1 | ---
  2 | title: "Go 为什么不支持可重入锁？"
  3 | date: 2021-12-31T12:55:24+08:00
  4 | toc: true
  5 | images:
  6 | tags: 
  7 |   - go
  8 | ---
  9 | 
 10 | 大家好，我是煎鱼。
 11 | 
 12 | 程序里的锁，是很多小伙伴在写分布式应用时用的最多的一个利器之一。
 13 | 
 14 | 使用 Go 的同学里，绝大部分都有其他语言的经验，就会对其中一点有疑惑，那就是 **Go 里的锁，竟然不支持可重入**？
 15 | 
 16 | 为此，今天煎鱼带大家一起来了解这里的设计考量，看看为什么。
 17 | 
 18 | ## 可重入锁
 19 | 
 20 | 如果对已经上锁的普通互斥锁进行 “加锁” 操作，其结果要么失败，要么会阻塞至解锁。
 21 | 
 22 | 锁的场景如下：
 23 | - 在加锁上：如果是可重入互斥锁，当前尝试加锁的线程如果就是持有该锁的线程时，加锁操作就会成功。
 24 | - 在解锁上：可重入互斥锁一般都会记录被加锁的次数，只有执行相同次数的解锁操作才会真正解锁。
 25 | 
 26 | 简单来讲，可重入互斥锁是互斥锁的一种，同一线程对其多次加锁不会产生死锁，又或是导致阻塞。
 27 | 
 28 | 不同语言间实现可能或多或少有些区别，但大体意思差不多。
 29 | 
 30 | 请你想一下，Go 是怎么样的呢？
 31 | 
 32 | ## Go 支持情况
 33 | 
 34 | 我们看到以下这个 Go 互斥锁例子：
 35 | 
 36 | ```golang
 37 | var mu sync.Mutex
 38 | 
 39 | func main() {
 40 | 	mu.Lock()
 41 | 	mu.Lock()
 42 | }
 43 | ```
 44 | 
 45 | 这段 Go 程序会阻塞吗？不会，会报以下错误：
 46 | 
 47 | ```
 48 | fatal error: all goroutines are asleep - deadlock!
 49 | ```
 50 | 
 51 | Go 显然是不支持可重入互斥锁的。
 52 | 
 53 | ## 官方回复
 54 | 
 55 | ### Go 设计原则
 56 | 
 57 | 在工程中使用互斥的根本原因是：为了保护不变量，也可以用于保护内、外部的不变量。
 58 | 
 59 | 基于此，Go 在互斥锁设计上会遵守这几个原则。如下：
 60 | - 在调用 `mutex.Lock` 方法时，要保证这些变量的不变性保持，不会在后续的过程中被破坏。
 61 | - 在调用 `mu.Unlock` 方法时，要保证：
 62 |     - 程序不再需要依赖那些不变量。
 63 |     - 如果程序在互斥锁加锁期间破坏了它们，则需要确保已经恢复了它们。
 64 | 
 65 | ### 不支持的原因
 66 | 
 67 | 讲了 Go 自己的设计原则后，那为什么不支持可重入呢？
 68 | 
 69 | 其实 Russ Cox 于 2010 年在《[Experimenting with GO](https://groups.google.com/g/golang-nuts/c/XqW1qcuZgKg/m/Ui3nQkeLV80J "Experimenting with GO")》就给出了答复，认为递归（又称：重入）互斥是个坏主意，这个设计并不好。
 70 | 
 71 | 我们可以结合官方的例子来理解。
 72 | 
 73 | 如下：
 74 | 
 75 | ```golang
 76 | func F() {
 77 |         mu.Lock()
 78 |         ... do some stuff ...
 79 |         G()
 80 |         ... do some more stuff ...
 81 |         mu.Unlock()
 82 | }
 83 | 
 84 | func G() {
 85 |         mu.Lock()
 86 |         ... do some stuff ...
 87 |         mu.Unlock()
 88 | }
 89 | ```
 90 | 
 91 | 在上述代码中，我们在 `F` 方法中调用 `mu.Lock` 方法加上了锁。如果支持可重入锁，接着就会进入到 `G` 方法中。
 92 | 
 93 | 此时就会有一个致命的问题，你**不知道 `F` 和 `G` 方法加锁后是不是做了什么事情**，从而导致破坏了不变量，毕竟随手起几个协程做点坏事，也是完全可能的。
 94 | 
 95 | 这对于 Go 是无法接受的，可重入的设计**违反了前面所提到的设计理念**，也就是：“要保证这些变量的不变性保持，不会在后续的过程中被破坏”。
 96 | 
 97 | 基于上述原因，Go 官方团队选择了没有支持该项特性。
 98 | 
 99 | ## 总结
100 | 
101 | Go 互斥锁没有支持可重入锁的设计，也是喜欢的大道至简的思路了，可能的干扰比较多，不如直接简单的来。
102 | 
103 | 你在工作过程中有没有类似的疑惑呢，欢迎大家在评论区留言和交流：）


--------------------------------------------------------------------------------
/content/posts/go/any.md:
--------------------------------------------------------------------------------
 1 | ---
 2 | title: "Go 新关键字 any，interface 会成历史吗？"
 3 | date: 2021-12-31T12:55:21+08:00
 4 | toc: true
 5 | images:
 6 | tags: 
 7 |   - go
 8 | ---
 9 | 
10 | 大家好，我是煎鱼。
11 | 
12 | 大家在看 Go1.18 泛型的代码时，不知道是否有留意到一个新的关键字 any。
13 | 
14 | 例子如下：
15 | 
16 | ```golang
17 | func Print[T any](s []T) {}
18 | ```
19 | 
20 | 之前没有专门提过，但有没有小伙伴以为这个关键字，是泛型代码专属的？
21 | 
22 | 其实不是...在这次新的 Go1.18 更新中，any 是作为一个新的关键字出现，**any 有一个真身，本质上是 interface{} 的别名**：
23 | 
24 | ```golang
25 | type any = interface{}
26 | ```
27 | 
28 | 也就是，在常规代码中，也可以直接使用：
29 | 
30 | ```golang
31 | func f(a any) {
32 | 	switch a.(type) {
33 | 	case int:
34 | 		fmt.Println("进脑子煎鱼了")
35 | 	case float64:
36 | 		fmt.Println("煎鱼进脑子了")
37 | 	case string:
38 | 		fmt.Println("脑子进煎鱼了")
39 | 	}
40 | }
41 | 
42 | func main() {
43 | 	f(2)
44 | 	f(3.1415)
45 | 	f("煎鱼好！")
46 | }
47 | ```
48 | 
49 | 从使用层面来讲，新的关键字 any 会比 interface{} 方便不少，毕竟少打了好多个词，更快了，其实也是参照现有 rune 类型的做法。
50 | 
51 | 增加新关键字后的对比如下：
52 | 
53 | | 长声明    |  短声明   |
54 | | --- | --- |
55 | |  func f[T interface{}](s []T) []T	   |  func f[T any](s []T) []T
56 |   func f(a interface{})	 | func f(a any)
57 |  |  var a interface{}	   |  var a any   |
58 | 
59 | 我们在了解他的便利性后，再从代码一致性和可读性来讲，是有些问题的，会造成一定的疑惑。
60 | 
61 | 因此前两天有人提出了《[all: rewrite interface{} to any](https://github.com/golang/go/issues/49884)》的需求，打算把内部所有的代码都重写一遍。
62 | 
63 | ![](https://files.mdnice.com/user/3610/06687ddd-e224-4499-892b-3869ee1fc1d0.png)
64 | 
65 | 你可能会以为是人肉手工改？那肯定不是，Go 官方发起了 CL 进行批量修改。
66 | 
67 | 我们在日常的工程中，也可以和他们一样，直接借用 Go 工具链来实现替换。
68 | 
69 | 如下：
70 | 
71 | ```golang
72 | gofmt -w -r 'interface{} -> any' ./...
73 | ```
74 | 
75 | 听到这个消息时，我的朋友咸鱼就大惊了，在想 interface{} 会不会成为历史，被新的关键字 any 完全替代？
76 | 
77 | ![](https://files.mdnice.com/user/3610/41a70c0c-284c-44c7-9b15-a1ee37545424.png)
78 | 
79 | 显然，答案是不会的。因为 **Go1 有兼容性的保证**，肯定不会在现阶段删除。不过后续会出现一个现象，就是我们的 Go 工程中，有人用 any，有人用 interface{}，会在代码可读性上比较伤人。
80 | 
81 | 不过我们也可以学 Go 官方，在 linter 流程中借助 gofmt 工具来强行把所有 interface{} 都替换成 any 来实现代码的一致性。 
82 | 
83 | 这次变更，感觉是个**美学**的问题，你对此怎么看呢？有没有也希望哪些东西有别名，**欢迎大家在评论区留言和交流**：）


--------------------------------------------------------------------------------
/content/posts/go/crawler/2018-03-21-douban-top250.md:
--------------------------------------------------------------------------------
  1 | ---
  2 | 
  3 | title:      "爬取豆瓣电影 Top250"
  4 | date:       2018-03-21 12:30:00
  5 | author:     "煎鱼"
  6 | toc: true
  7 | tags:
  8 |     - go
  9 |     - 数据分析
 10 | ---
 11 | 
 12 | 爬虫是标配了，看数据那一刻很有趣。第一个就从最最最简单最基础的爬虫开始写起吧！
 13 | 
 14 | 项目地址：https://github.com/go-crawler/douban-movie
 15 | 
 16 | ## 目标
 17 | 
 18 | 我们的目标站点是 [豆瓣电影 Top250](https://movie.douban.com/top250)，估计大家都很眼熟了
 19 | 
 20 | 本次爬取 8 个字段，用于简单的概括分析。具体的字段如下：
 21 | 
 22 | ![image](https://i.loli.net/2018/03/20/5ab11596b8810.png)
 23 | 
 24 | 简单的分析一下目标源
 25 | 
 26 | - 一页共 25 条
 27 | - 含分页（共 10 页）且分页规则是正常的
 28 | - 每一项的数据字段排序都是规则且不变
 29 | 
 30 | ## 开始
 31 | 
 32 | 由于量不大，我们的爬取步骤如下
 33 | 
 34 | - 分析页面，获取所有的分页
 35 | - 分析页面，循环爬取所有页面的电影信息
 36 | - 爬取的电影信息入库
 37 | 
 38 | ### 安装
 39 | 
 40 | ```
 41 | $ go get -u github.com/PuerkitoBio/goquery
 42 | ```
 43 | 
 44 | ### 运行
 45 | 
 46 | ```
 47 | $ go run main.go
 48 | ```
 49 | 
 50 | ### 代码片段
 51 | 
 52 | #### 1、获取所有分页
 53 | 
 54 | ```go
 55 | func ParsePages(doc *goquery.Document) (pages []Page) {
 56 | 	pages = append(pages, Page{Page: 1, Url: ""})
 57 | 	doc.Find("#content > div > div.article > div.paginator > a").Each(func(i int, s *goquery.Selection) {
 58 | 		page, _ := strconv.Atoi(s.Text())
 59 | 		url, _ := s.Attr("href")
 60 | 
 61 | 		pages = append(pages, Page{
 62 | 			Page: page,
 63 | 			Url:  url,
 64 | 		})
 65 | 	})
 66 | 
 67 | 	return pages
 68 | }
 69 | ```
 70 | 
 71 | #### 2、分析豆瓣电影信息
 72 | 
 73 | ```go
 74 | func ParseMovies(doc *goquery.Document) (movies []Movie) {
 75 | 	doc.Find("#content > div > div.article > ol > li").Each(func(i int, s *goquery.Selection) {
 76 | 		title := s.Find(".hd a span").Eq(0).Text()
 77 | 
 78 | 		...
 79 | 
 80 | 		movieDesc := strings.Split(DescInfo[1], "/")
 81 | 		year := strings.TrimSpace(movieDesc[0])
 82 | 		area := strings.TrimSpace(movieDesc[1])
 83 | 		tag := strings.TrimSpace(movieDesc[2])
 84 | 
 85 | 		star := s.Find(".bd .star .rating_num").Text()
 86 | 
 87 | 		comment := strings.TrimSpace(s.Find(".bd .star span").Eq(3).Text())
 88 | 		compile := regexp.MustCompile("[0-9]")
 89 | 		comment = strings.Join(compile.FindAllString(comment, -1), "")
 90 | 
 91 | 		quote := s.Find(".quote .inq").Text()
 92 | 
 93 | 		...
 94 | 
 95 | 		log.Printf("i: %d, movie: %v", i, movie)
 96 | 
 97 | 		movies = append(movies, movie)
 98 | 	})
 99 | 
100 | 	return movies
101 | }
102 | ```
103 | 
104 | ### 数据
105 | 
106 | ![image](https://i.loli.net/2018/03/21/5ab1309594741.png)
107 | 
108 | ![image](https://i.loli.net/2018/03/21/5ab131ca582f8.png)
109 | 
110 | ![image](https://i.loli.net/2018/03/21/5ab130d3a00d9.png)
111 | 
112 | 看到这些数据，你有什么想法呢，真是好奇 :=)
113 | 


--------------------------------------------------------------------------------
/content/posts/go/crawler/2018-04-01-cars.md:
--------------------------------------------------------------------------------
  1 | ---
  2 | 
  3 | title:      "爬取汽车之家 二手车产品库"
  4 | date:       2018-04-01 12:30:00
  5 | author:     "煎鱼"
  6 | toc: true
  7 | tags:
  8 |     - go
  9 |     - 数据分析
 10 | ---
 11 | 
 12 | 项目地址：https://github.com/go-crawler/car-prices
 13 | 
 14 | ## 目标
 15 | 
 16 | 最近经常有人在耳边提起汽车之家，也好奇二手车在国内的价格是怎么样的，因此本次的目标站点是 [汽车之家](https://car.autohome.com.cn/2sc/440399/index.html) 的二手车产品库
 17 | 
 18 | ![image](https://i.loli.net/2018/03/30/5abe47f82a01f.png)
 19 | 
 20 | 分析目标源：
 21 | 
 22 | - 一页共 24 条
 23 | - 含分页，但这个老产品库，在 100 页后会存在问题，因此我们爬取 99 页
 24 | - 可以获取全部城市
 25 | - 共可爬取 19w+ 数据
 26 | 
 27 | ## 开始
 28 | 
 29 | 爬取步骤
 30 | 
 31 | - 获取全部的城市
 32 | - 拼装全部城市 URL 入队列
 33 | - 解析二手车页面结构
 34 | - 下一页 URL 入队列
 35 | - 循环拉取所有分页的二手车数据
 36 | - 循环拉取队列中城市的二手车数据
 37 | - 等待，确定队列中无新的 URL
 38 | - 爬取的二手车数据入库
 39 | 
 40 | ### 获取城市
 41 | 
 42 | ![image](https://i.loli.net/2018/03/31/5abeff11ef583.png)
 43 | 
 44 | 通过页面查看，可发现在城市筛选区可得到全部的二手车城市列表，但是你仔细查阅代码。会发现它是 JS 加载进来的，城市也统一放在了一个变量中
 45 | 
 46 | ![image](https://i.loli.net/2018/03/31/5abf056389cf0.png)
 47 | 
 48 | 有两种提取方法
 49 | 
 50 | - 分析 JS 变量，提取出来
 51 | - 直接将 `areaJson` 复制出来作为变量解析
 52 | 
 53 | 在这里我们直接将其复制粘贴出来即可，因为这是比较少变动的值
 54 | 
 55 | ### 获取分页
 56 | 
 57 | ![image](https://i.loli.net/2018/03/31/5abf08ec812e2.png)
 58 | 
 59 | 通过分析页面可以得知分页链接是有一定规律的，例如：`/2sc/hangzhou/a0_0msdgscncgpi1ltocsp2exb4/`，可以发现 `sp%d`，`sp` 后面为页码
 60 | 
 61 | 按照常理，可以通过预测所有分页链接，推入队列后 `go routine` 一波 即可快速拉取
 62 | 
 63 | 但是在这老产品库存在一个问题，在超过 100 页后，下一页永远是 101 页
 64 | 
 65 | ![image](https://i.loli.net/2018/03/31/5abf0e1e623ec.png)
 66 | 
 67 | 因此我们采取比较传统的做法，通过拉取下一页的链接去访问，以便适应可能的分页链接改变； 100 页以后的分页展示也很奇怪，先忽视
 68 | 
 69 | ### 获取二手车数据
 70 | 
 71 | 页面结构较为固定，常规的清洗 HTML 即可
 72 | 
 73 | ```go
 74 | func GetCars(doc *goquery.Document) (cars []QcCar) {
 75 | 	cityName := GetCityName(doc)
 76 | 	doc.Find(".piclist ul li:not(.line)").Each(func(i int, selection *goquery.Selection) {
 77 | 		title := selection.Find(".title a").Text()
 78 | 		price := selection.Find(".detail .detail-r").Find(".colf8").Text()
 79 | 		kilometer := selection.Find(".detail .detail-l").Find("p").Eq(0).Text()
 80 | 		year := selection.Find(".detail .detail-l").Find("p").Eq(1).Text()
 81 | 
 82 | 		kilometer = strings.Join(compileNumber.FindAllString(kilometer, -1), "")
 83 | 		year = strings.Join(compileNumber.FindAllString(strings.TrimSpace(year), -1), "")
 84 | 		priceS, _ := strconv.ParseFloat(price, 64)
 85 | 		kilometerS, _ := strconv.ParseFloat(kilometer, 64)
 86 | 		yearS, _ := strconv.Atoi(year)
 87 | 
 88 | 		cars = append(cars, QcCar{
 89 | 			CityName: cityName,
 90 | 			Title: title,
 91 | 			Price: priceS,
 92 | 			Kilometer: kilometerS,
 93 | 			Year: yearS,
 94 | 		})
 95 | 	})
 96 | 
 97 | 	return cars
 98 | }
 99 | ```
100 | 
101 | ## 数据
102 | 
103 | ![image](https://i.loli.net/2018/03/31/5abf1d8042196.png)
104 | 
105 | ![image](https://i.loli.net/2018/04/01/5abfbaa14b09c.png)
106 | 
107 | 在各城市的平均价格对比中，我们可以发现北上广深里的北京、上海、深圳都在榜单上，而近年势头较猛的杭州直接占领了榜首，且后几名都有一些距离
108 | 
109 | 而其他城市大致都是梯级下降的趋势，看来一线城市的二手车也是不便宜了，当然这只是均价
110 | 
111 | ![image](https://i.loli.net/2018/03/31/5abf1dbc665f2.png)
112 | 
113 | 我们可以看到价格和公里数的对比，上海、成都、郑州的等比差异是有点大，感觉有需求的话可以在价格和公里数上做一个衡量
114 | 
115 | ![image](https://i.loli.net/2018/03/31/5abf1e1434edc.png)
116 | 
117 | 这图有点儿有趣，粗略的统计了一下总公里数。在前几张图里，平均价格排名较高的统统没有出现在这里，反倒是呼和浩特、大庆、中山等出现在了榜首
118 | 
119 | 是否侧面反应了一线城市的车辆更新换代较快，而较后的城市的车辆倒是换代较慢，公里数基本都杠杠的
120 | 
121 | ![image](https://i.loli.net/2018/03/31/5abf1e4936640.png)
122 | 
123 | 通过对标题的分析，可以得知车辆产品库的命名基本都是品牌名称+自动/手动+XXXX 款+属性，看标题就能知道个概况了
124 | 
125 | ## 参考
126 | 
127 | ### 爬虫项目地址
128 | 
129 | - https://github.com/go-crawler/car-prices
130 | 
131 | 
132 | 


--------------------------------------------------------------------------------
/content/posts/go/enum.md:
--------------------------------------------------------------------------------
  1 | ---
  2 | title: "小技巧分享：在 Go 如何实现枚举？"
  3 | date: 2021-12-31T12:54:50+08:00
  4 | toc: true
  5 | images:
  6 | tags: 
  7 |   - go
  8 | ---
  9 | 
 10 | 大家好，我是煎鱼。
 11 | 
 12 | 在日常的业务工程开发中，我们常常会有使用枚举值的诉求，枚举控的好，测试值边界一遍过...
 13 | 
 14 | 有的小伙伴会说，在 Go 语言不是有 `iota` 类型做枚举吗，那煎鱼你这篇文章还讲什么？
 15 | 
 16 | 讲道理，Go 语言并没有 enum 关键字，有用过 Protobuf 等的小伙伴知道，Go 语言只是 ”有限的枚举“ 支持，我们也会用常量来定义，枚举值也需要有字面意思的映射。
 17 | 
 18 | 示例
 19 | --
 20 | 
 21 | 在一些业务场景下，是没法达到我们的诉求的。示例如下：
 22 | 
 23 | ```
 24 | type FishType int
 25 | 
 26 | const (
 27 |  A FishType = iota
 28 |  B
 29 |  C
 30 |  D
 31 | )
 32 | 
 33 | func main() {
 34 |  fmt.Println(A, B, C, D)
 35 | }
 36 | ```
 37 | 
 38 | 输出结果为：“0 1 2 3”。这时候就一脸懵逼了...枚举值，应该除了键以外，还得有个对应的值。也就是这个 “0 1 2 3” 分别对应着什么含义，是不是应该输出 ”A B C D“
 39 | 
 40 | 但 Go 语言这块就没有直接的支撑了，因此这不是一个完整的枚举类型的实现。
 41 | 
 42 | 同时假设我们传入超过 `FishType` 类型声明范围的枚举值，在 Go 语言中默认也不会有任何控制，是正常输出的。
 43 | 
 44 | 上述这种 Go 枚举实现，在某种情况下是不完全的，严格意义上不能成为 enum（枚举）。
 45 | 
 46 | 使用 String 做枚举
 47 | -------------
 48 | 
 49 | 如果要支持枚举值的对应输出的话，我们可以通过如下方式：
 50 | 
 51 | ```
 52 | type FishType int
 53 | 
 54 | const (
 55 |  A FishType = iota
 56 |  B
 57 |  C
 58 |  D
 59 | )
 60 | 
 61 | func (f FishType) String() string {
 62 |  return [...]string{"A", "B", "C", "D"}[f]
 63 | }
 64 | ```
 65 | 
 66 | 运行程序：
 67 | 
 68 | ```
 69 | func main() {
 70 |  var f FishType = A
 71 |  fmt.Println(f)
 72 |  switch f {
 73 |  case A:
 74 |   fmt.Println("脑子进煎鱼了")
 75 |  case B:
 76 |   fmt.Println("记得点赞")
 77 |  default:
 78 |   fmt.Println("别别别...")
 79 |  }
 80 | }
 81 | ```
 82 | 
 83 | 输出结果：
 84 | 
 85 | ```
 86 | A
 87 | 脑子进煎鱼了
 88 | ```
 89 | 
 90 | 我们可以借助 Go 中 `String` 方法的默认约定，针对于定义了 `String` 方法的类型，默认输出的时候会调用该方法。
 91 | 
 92 | 这样就可以达到获得枚举值的同时，也能拿到其映射的字面意思。
 93 | 
 94 | 自动生成 String
 95 | -----------
 96 | 
 97 | 但每次手动编写还是比较麻烦的。在这一块，我们可以利用官方提供的 `cmd/string` 来快速实现。
 98 | 
 99 | 我们安装如下命令：
100 | 
101 | ```
102 | go install golang.org/x/tools/cmd/stringer
103 | ```
104 | 
105 | 在所需枚举值上设置 `go:generate` 指令：
106 | 
107 | ```
108 | //go:generate stringer -type=FishType
109 | type FishType int
110 | ```
111 | 
112 | 在项目根目录执行：
113 | 
114 | ```
115 | go generate ./...
116 | 
117 | ```
118 | 
119 | 会在根目录生成 fishtype\_string.go 文件：
120 | 
121 | ```
122 | .
123 | ├── fishtype_string.go
124 | ├── go.mod
125 | ├── go.sum
126 | └── main.go
127 | ```
128 | 
129 | fishtype\_string 文件内容：
130 | 
131 | ```
132 | package main
133 | 
134 | import "strconv"
135 | 
136 | const _FishType_name = "ABCD"
137 | 
138 | var _FishType_index = [...]uint8{0, 1, 2, 3, 4}
139 | 
140 | func (i FishType) String() string {
141 |  if i < 0 || i >= FishType(len(_FishType_index)-1) {
142 |   return "FishType(" + strconv.FormatInt(int64(i), 10) + ")"
143 |  }
144 |  return _FishType_name[_FishType_index[i]:_FishType_index[i+1]]
145 | }
146 | ```
147 | 
148 | 所生成出来的文件，主要是根据枚举值和映射值做了个映射，且针对超出枚举值的场景进行了判断：
149 | 
150 | ```
151 | func main() {
152 |  var f1 FishType = A
153 |  fmt.Println(f1)
154 |  var f2 FishType = E
155 |  fmt.Println(f2)
156 | }
157 | ```
158 | 
159 | 执行 `go run .` 查看程序运行结果：
160 | 
161 | ```
162 | $ go run .
163 | A
164 | FishType(4)
165 | ```
166 | 
167 | 总结
168 | --
169 | 
170 | 在今天这篇文章中，我们介绍了如何在 Go 语言实现标准的枚举值，虽然有些繁琐，但整体不会太难。
171 | 
172 | ![](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/05d5614987b04e0183e20fb5ac5249d4~tplv-k3u1fbpfcp-zoom-1.image)
173 | 
174 | 也有小伙伴已经在社区中提出了 ”proposal: spec: add typed enum support“ 的提案，相信未来有机会能看到 Go 自身支持 enum（枚举）的那一天。
175 | 
176 | 你平时会怎么在业务代码中实现枚举呢，欢迎大家一起留言交流：）
177 | 
178 | 
179 | **欢迎大家在评论区留言和交流 ：）**
180 | 
181 | ## 鼓励
182 | 
183 | 若有任何疑问欢迎评论区反馈和交流，**最好的关系是互相成就**，各位的**点赞**就是[煎鱼](https://github.com/eddycjy)创作的最大动力，感谢支持。
184 | 
185 | > 文章持续更新，可以微信搜【脑子进煎鱼了】阅读，本文 **GitHub** [github.com/eddycjy/blog](https://github.com/eddycjy/blog) 已收录，学习 Go 语言可以看 [Go 学习地图和路线](https://github.com/eddycjy/go-developer-roadmap)，欢迎 Star 催更。


--------------------------------------------------------------------------------
/content/posts/go/func-reload.md:
--------------------------------------------------------------------------------
  1 | ---
  2 | title: "Go 为什么不支持函数重载和参数默认值？"
  3 | date: 2021-12-31T12:55:16+08:00
  4 | toc: true
  5 | images:
  6 | tags: 
  7 |   - go
  8 |   - 为什么
  9 | ---
 10 | 
 11 | 大家好，我是煎鱼。
 12 | 
 13 | 大家在初学习 Go 语言时，带着其他语言的习惯，总是会有些不习惯，感觉非常不能理解，直打问号。
 14 | 
 15 | 其中一点就是 Go 语言不支持函数重载和参数默认值，觉得使用起来很不方便。
 16 | 
 17 | 为此，在这篇文章中煎鱼就和大家一起来了解为什么，有又会怎么样。
 18 | 
 19 | ## 函数重载
 20 | 
 21 | 函数重载（function overloading），也叫方法重载。是某些编程语言（如 C++、C#、Java、Swift、Kotlin 等）具有的一项特性。
 22 | 
 23 | 该特性**允许创建多个具有不同实现的同名函数**，对重载函数的调用会运行其适用于调用上下文的具体实现。
 24 | 
 25 | 从功能上来讲，就是允许一个函数调用根据上下文执行不同的方法，达到调用同一个函数名，执行不同的方法。
 26 | 
 27 | 一个简单的例子：
 28 | 
 29 | ```c++
 30 | #include <iostream>
 31 | 
 32 | int Volume(int s) {  // 立方体的体积。
 33 |   return s * s * s;
 34 | }
 35 | 
 36 | double Volume(double r, int h) {  // 圆柱体的体积。
 37 |   return 3.1415926 * r * r * static_cast<double>(h);
 38 | }
 39 | 
 40 | long Volume(long l, int b, int h) {  // 长方体的体积。
 41 |   return l * b * h;
 42 | }
 43 | 
 44 | int main() {
 45 |   std::cout << Volume(10);
 46 |   std::cout << Volume(2.5, 8);
 47 |   std::cout << Volume(100l, 75, 15);
 48 | }
 49 | ```
 50 | 
 51 | 在上述例子中，实现了 3 个同名的 `Volume` 函数，但是 3 个函数的入参个数、类型均不一样，也代表了不同的实现目的。
 52 | 
 53 | 在主函数 `main` 中，传入了不同的入参，编译器或运行时再进行内部处理，从程序上来看达到了调用不同函数的目的。
 54 | 
 55 | 这就是函数重载，一函数多形态。
 56 | 
 57 | ## 参数默认值
 58 | 
 59 | 参数默认值，又叫缺省参数。指的是允许程序员设定缺省参数并指定默认值，**当调用该函数并未指定值时，该缺省参数将为缺省值来使用**。
 60 | 
 61 | 一个简单的例子：
 62 | 
 63 | ```c++
 64 |  int my_func(int a, int b, int c=12);
 65 | ```
 66 | 
 67 | 在上述例子中，函数 `my_func` 一共有 3 个变量，分别是：a、b、c。变量 c 设置了缺省值，也就是 12。
 68 | 
 69 | 其调用方式可以为：
 70 | 
 71 | ```c++
 72 |  // 第一种调用方式
 73 |  result = my_func(1, 2, 3);
 74 |  // 第二种调用方式
 75 |  result = my_func(1, 2);
 76 | ```
 77 | 
 78 | 在第一种方式中，就会正常的传入所有参数。在第二种方式，由于第三个参数 c 并没有传递，因此会直接使用缺省值 12。
 79 | 
 80 | 这就是参数默认值，也叫缺省参数。
 81 | 
 82 | ## 为什么不支持
 83 | 
 84 | ### 美好
 85 | 
 86 | 从上述的功能特性介绍来看，似乎非常的不错，能够节省很多功夫。像是 Go 语言的 context 库中的这些方法：
 87 | 
 88 | ```golang
 89 | func WithCancel(parent Context) (ctx Context, cancel CancelFunc)
 90 | func WithDeadline(parent Context, d time.Time) (Context, CancelFunc)
 91 | func WithTimeout(parent Context, timeout time.Duration) (Context, CancelFunc)
 92 | ```
 93 | 
 94 | 要是有函数重载，直接就 WithXXX 就好了，只需要关注传入的参数类型，也不用 “记” 那么多个方法名了。
 95 | 
 96 | 有同学说，有参数默认值。那就可以直接设置在上面，作为 “最佳实践” 给到使用函数的人，岂不美哉。那怎么 Go 语言就不支持呢？
 97 | 
 98 | ### 细思
 99 | 
100 | 其实这和设计理念，和对程序的理解有关系。说白了，就是你喜欢 “显式”，还是 “隐喻”。
101 | 
102 | 函数重载和参数默认值，其实是不好的行为。调用者只看函数名字，可能没法知道，你这个默认值，又或是入参不同，会调用的东西，会产生怎么样的后果？
103 | 
104 | 你可以观察一下自己的行为。大部分人都会潜意识的追进去看代码，看看会调到哪，缺省值的作用是什么，以确保可控。
105 | 
106 | ### 敲定
107 | 
108 | 这细思的可能，在 Go 语言中是不被允许的。Go 语言的**设计理念就是 “显式大于隐喻”，追求明确，显式**。
109 | 
110 | 在 Go FAQ 《Why does Go not support overloading of methods and operators?》有相关的解释。
111 | 
112 | 如下图：
113 | 
114 | ![](https://files.mdnice.com/user/3610/582eac4e-ecd1-4fb5-bde7-b2cbcac7f809.png)
115 | 
116 | 官方有明确提到两个观点：
117 | - 函数重载：拥有各种同名但不同签名的方法有时是很有用的，但在实践中也可能是混乱和脆弱的。
118 | - 参数默认值：操作符重载，似乎更像是一种便利，不是绝对的要求。没有它，程序会更简单。
119 | 
120 | 这就是为什么 Go 语言不支持的原因。
121 | 
122 | ## 总结
123 | 
124 | 在这篇文章中，我们介绍了业内常见的编程语言的函数重载和参数默认值的概念和使用方法。也结合了 Go 语言自身的设计理念，说明了为什么不支持的原因。
125 | 
126 | 你会希望 Go 语言支持这几个特性功能吗，欢迎在评论区留言讨论和交流：）
127 | 
128 | ## 参考
129 | 
130 | - 维基百科（函数重载和缺省值定义）
131 | - Frequently Asked Questions (FAQ)


--------------------------------------------------------------------------------
/content/posts/go/fuzzing.md:
--------------------------------------------------------------------------------
  1 | ---
  2 | title: "提高 Go 程序健壮性，Fuzzing 要来了！"
  3 | date: 2021-12-31T12:54:50+08:00
  4 | toc: true
  5 | images:
  6 | tags: 
  7 |   - go
  8 | ---
  9 | 
 10 | 大家好，我是煎鱼。
 11 | 
 12 | 就在前几天，Go1.17 beta1 正式发布：
 13 | 
 14 | ![](https://files.mdnice.com/user/3610/fb4ceb3d-ef1c-4c32-a7c3-a4188a0d74b0.png)
 15 | 
 16 | 兴冲冲本想着看一下当初在 Go1.17 的计划中，预计会支持的新特性：模糊测试（Fuzzing）。不过没想到...计划赶不上变化，官方正式宣告 Fuzzing 不会出现在 Go1.17 的新功能中。
 17 | 
 18 | 煎鱼在悲伤之际，发现 Go 在 dev.fuzz 分支上提供了该功能的 Beta 测试，因此今天带大家一起来深入该特性。
 19 | 
 20 | ## 什么是 Fuzzing
 21 | 
 22 | Fuzzing 是一种自动测试技术，包括向计算机程序提供随机数据作为输入。然后监测程序是否出现恐慌、断言失败、无限循环等。
 23 | 
 24 | Fuzzing 不是使用一个小的、预先定义好的手动创建的输入集（如单元测试），而是用新的案例不断地测试代码，以努力 ”锻炼“ 有关软件的所有方面。
 25 | 
 26 | 这听起来很 ”难“。但在过去的几年里，Fuzzing 的技术水平有了很大的提高。Fuzzing 不再是需要专业知识才能成功使用的东西，现代模糊测试策略能更快、更有效地找到有用的输入。
 27 | 
 28 | 在应用程序中，就是你只要引入一个 package，对着 API 一顿用就可以了。
 29 | 
 30 | ## 为什么要做 Fuzzing
 31 | 
 32 | 可能会有小伙伴说，测试？直接人工测试，再把测试数据准备一下，配套 YAPI 等接口管理平台，把自动化接口测试一弄就好了。还需要 Fuzzing 吗？
 33 | 
 34 | 其实 Fuzzing 是对其他形式的测试、代码审查和静态分析的补充，它通过生成一个随机测试用例去覆盖人为测不到的各种复杂场景。而这些输入几乎不可能人为去构造，总会被传统测试所遗漏。
 35 | 
 36 | ## 发生在身边的 Fuzzing
 37 | 
 38 | 实际上 Go-fuzz 对 Go 标准库进行过测试，依然这这之中发现了 200  多个 bug：
 39 | 
 40 | ![](https://files.mdnice.com/user/3610/9b00972c-2231-4406-84b8-2e8e44f57d6d.png)
 41 | 
 42 | 这还是建立在标准库已经比较成熟，且由非常有经验的开发者编写，在生产中使用多年的情况下，依然有如此多的问题。
 43 | 
 44 | ## 快速上手
 45 | 
 46 | 我们需要在本地执行如下命令，需开启 GO111MODULE 和天梯：
 47 | 
 48 | ```golang
 49 | $ go get golang.org/dl/gotip
 50 | $ gotip download dev.fuzz
 51 | ```
 52 | 
 53 | 执行完毕后会从 dev.fuzz 分支构建 Go 工具链，同时 gotip 可以作为 go 命令的替代者命令，也就是可以运行 Fuzzing 的相关代码了。
 54 | 
 55 | ```golang
 56 | // +build gofuzzbeta
 57 | 
 58 | package tests
 59 | 
 60 | import (
 61 | 	"net/url"
 62 | 	"reflect"
 63 | 	"testing"
 64 | )
 65 | 
 66 | func FuzzParseQuery(f *testing.F) {
 67 | 	f.Add("x=1&y=2")
 68 | 	f.Fuzz(func(t *testing.T, queryStr string) {
 69 | 		query, err := url.ParseQuery(queryStr)
 70 | 		if err != nil {
 71 | 			t.Skip()
 72 | 		}
 73 | 		queryStr2 := query.Encode()
 74 | 		query2, err := url.ParseQuery(queryStr2)
 75 | 		if err != nil {
 76 | 			t.Fatalf("ParseQuery failed to decode a valid encoded query %s: %v", queryStr2, err)
 77 | 		}
 78 | 		if !reflect.DeepEqual(query, query2) {
 79 | 			t.Errorf("ParseQuery gave different query after being encoded\nbefore: %v\nafter: %v", query, query2)
 80 | 		}
 81 | 	})
 82 | }
 83 | ```
 84 | 
 85 | 在相应的目录下执行 `gotip test -fuzz=FuzzParseQuery` 命令，输出结果：
 86 | 
 87 | ```golang
 88 | fuzzing, elapsed: 3.0s, execs: 319 (106/sec), workers: 4, interesting: 15
 89 | fuzzing, elapsed: 6.0s, execs: 665 (111/sec), workers: 4, interesting: 15
 90 | fuzzing, elapsed: 9.0s, execs: 1019 (113/sec), workers: 4, interesting: 15
 91 | fuzzing, elapsed: 12.0s, execs: 1400 (117/sec), workers: 4, interesting: 15
 92 | ...
 93 | ```
 94 | 
 95 | 需要注意的是：
 96 | - Fuzzing 会消耗大量的内存，在运行时会影响到机器的性能（一运行，小风扇就转了起来）。
 97 | - Fuzzing 会默认使用 `GOMAXPROCS`相同的核数，可以通过执行 `-parallel` 标识来控制数量。
 98 | - Fuzzing 会默认在运行时，将扩大测试范围的数值写入 `$GOCACHE/fuzz` 内的模糊缓存目录，目前是没有限制的，可以通过运行 `gotip clean -fuzzcache` 来清除。
 99 | 
100 | ## 总结
101 | 
102 | 在今天这篇文章中，我们介绍了 Fuzzing 是什么。
103 | 简单而言，模糊测试（Fuzzing）在真实环境已经被验证了其有效性，其可以随机生成测试用例去覆盖人为测不到的各种复杂场景，带来很大的收益。
104 | 
105 | 在接下来中，除了依赖开源的 go-fuzz 库外，Go 语言也正式的在支持 Fuzzing，虽然他放了 Go1.17 的鸽子...
106 | 
107 | 这会对构建 Go 程序健壮性的又一强心剂！


--------------------------------------------------------------------------------
/content/posts/go/generics-apis.md:
--------------------------------------------------------------------------------
 1 | ---
 2 | title: "出泛型后 API 怎么办？Go 开发者要注意了"
 3 | date: 2021-12-31T12:55:14+08:00
 4 | toc: true
 5 | images:
 6 | tags: 
 7 |   - go
 8 | ---
 9 | 
10 | 大家好，我是煎鱼。
11 | 
12 | 前段时间社区里一下子就爆了，主要是各大媒体引用了 Go 语言之父 
13 | Rob Pike 所提的《go: don't change the libraries in 1.18》。
14 | 
15 | ![](https://files.mdnice.com/user/3610/08e47a87-cf63-4dec-b0b5-fc178a494c4c.png)
16 | 
17 | 很多社交媒体都做了跟进，认为 Rob Pike 是硬性的反对 Go 泛型的 API 改造！
18 | 
19 | 如果读者只看了标题，有可能会产生一些误解实际上其表达的意思和近期 Go 社区讨论的事项是有关联的，要一起综合来看。
20 | 
21 | 为此，今天煎鱼就和大家一起来理一理，看看 Go 泛型 API 的改造工程，是个怎么一回事？
22 | 
23 | ## 现状
24 | 
25 | 马上就是 2021.11 月，连深圳都变冷了...根据 Go 语言的发布周期，Go1.18 版本的发布，那就是 2022.02 月左右。
26 | 
27 | ![](https://files.mdnice.com/user/3610/f849c76d-e84d-43d6-96c5-b30df77f1dd9.png)
28 | 
29 | 现在给到 Ian Lance Taylor、
30 | Robert Griesemer 等大佬仅剩 3 个月的时间给大家讨论泛型细节，进一步完善实现，达到生产可用。
31 | 
32 | 抛出 Go 泛型的实现进度不说，现在遇到了一个比较大的问题。那就是**实现泛型后 ”如何更新泛型的 API“**。
33 | 
34 | 这之中包含好几个方面，分别是：既有标准库、开源库，新标准库等。不同库之间是不同的人在维护。
35 | 
36 | 但这里存在一个大问题，如下图：
37 | 
38 | ![](https://files.mdnice.com/user/3610/033083ef-d0ba-40f7-93d4-006e65310cf9.png)
39 | 
40 | Russ Cox 在 9 月就提出了 ”how to update APIs for generics“ 的疑惑，当时显然这一块还没有共识。在 11 月的现在，从讨论的记录来看，**怎么做还没有达成一个最终的明确共识**（初步已有，未正式答复）。
41 | 
42 | 但存在一个问题，Go 社区对于泛型的迫切度，热情非常高，各种泛型化的标准库的提案都提出来了，推着设计者往前走。
43 | 
44 | ## 争议
45 | 
46 | 结合来看 Rob Pike，更多是：建议和提醒 Go 社区和核心开发团队，**要 ”悠着点“**，Go1.18 想支持泛型，做完成库的改造，还得代价小，毕竟细节很多。
47 | 
48 | 引用其理由，核心论据是：
49 | - 在一个版本中，做泛型、标准库等，要做的事情太多，很可能会弄错。
50 | - 没有在 Go 中使用新类型的经验，无法为其设计提供有力的依据。
51 | - Go1 兼容性的承诺，在任何细节上出错的代价都很高，要等待、观察和学习。
52 | 
53 | 和一句谚语很接近：”**不要一口气吃胖子**“，何况没有相关的经验，都只是详细的推理、预演，需要晋升。
54 | 
55 | 在 Go issues 中也有人吐槽，1.18 空有泛型的实现。其他配套的标准库等都没有，那这个 Go1.18 出来的泛型意义是？
56 | 
57 | ## 后续
58 | 
59 | 虽然还没有最终拍板，但是根据讨论的过程和社区赞同数（👍）来看，如下：
60 | 
61 | ![](https://files.mdnice.com/user/3610/4856e2c4-7ae4-421c-812b-561ea6cf1cef.png)
62 | 
63 | 后续仍然会设计、构建、测试和使用用于切片（Slice）、地图（Map）、通道（Channel）等的新库。
64 | 
65 | 这些库并没有生产可用，会把他们**放在 golang/x/exp 仓库**中，可以使用，仅作为现阶段的实验性的库，没有兼容性保障。
66 | 
67 | 
68 | ![](https://files.mdnice.com/user/3610/47b8cae4-4ef8-42a3-af6c-686dd8acfb7a.png)
69 | 
70 | 
71 | 该实验库会在一两个周期内会改变、调整和发展。能够让 Go 社区的开发者们尝试一下使用，以便接受更多的意见。
72 | 
73 | 再根据使用者的反馈通过经验和分析进行更新，就会把它们移到主仓库中，才达到正式生产可用的级别。
74 | 
75 | ## 总结
76 | 
77 | 在今天这篇文章中，我们针对 Rob Pike 为什么会要调整 Go 泛型后的标准库 API 等的提议进行了分析。
78 | 
79 | 为此我们了解到 Go 核心团队对 ”how to update APIs for generics“ 的顾虑，以及现有社区的激情，综合来看，给出的逐步演进的泛型方案建议。
80 | 
81 | 以此可知，Go 完整泛型（含配套库）的生产可用，可能还要经历几个 Go 版本，让不少人望穿秋水了...
82 | 


--------------------------------------------------------------------------------
/content/posts/go/generics-proposal.md:
--------------------------------------------------------------------------------
 1 | ---
 2 | title: "快报：正式提案将泛型特性加入 Go 语言"
 3 | date: 2021-01-13T21:11:44+08:00
 4 | toc: true
 5 | images:
 6 | tags: 
 7 |   - 泛型
 8 | ---
 9 | 
10 | 经历九九八十一难，多年的不断探讨和 Go 语言爱好者们在社区中的强烈关注，且 Go 官方在 2020 年不断放出消息。
11 | 
12 | ![image](https://image.eddycjy.com/1d0e5a264c65e37659f142bc2ee55805.jpg)
13 | 
14 | 总算在 2021 年 1 月 12 日。官方正式提出将泛型特性加入 Go 语言的 proposal 了，且最新的草案设计已经更新。
15 | 
16 | 
17 | 基本语法如下：
18 | 
19 | ```
20 | func Print[T any](s []T) {
21 | 	// same as above
22 | }
23 | ```
24 | 
25 | 其大体的概述如下：
26 | 
27 | - 函数可以具有使用方括号的其他类型参数列表，但其他情况下看起来像普通的参数列表：`func F[T any](p T) { ... }`。
28 | - 类型也可以具有类型参数列表：`type MySlice[T any] []T`。
29 | - 每个类型参数都有一个类型约束，就像每个普通参数都有一个类型：`func F[T Constraint](p T) { ... }`。
30 | - 类型约束是接口类型。
31 | - 新的预声明名称 `any` 是允许任何类型的类型约束。
32 | - 用作类型约束的接口类型可以具有预先声明的类型的列表。只有与那些类型之一匹配的类型参数才能满足约束条件。
33 | - 泛型函数只能使用其类型约束所允许的操作。
34 | - 使用泛型函数或类型需要传递类型实参。
35 | - 在通常情况下，类型推断允许省略函数调用的类型参数。
36 | 
37 | 根据官方博客的消息，如果该提案被正式接受。那么将会在 2021 年底之前完成一个基本可用的泛型特性使用，又或是会作为 Go1.18beta 的一部分。
38 | 
39 | 这是 Go 泛型特性的又一步前进。若大家有兴趣进一步了解或想提出意见，可查看下述传送门：
40 | 
41 | - A Proposal for Adding Generics to Go：https://blog.golang.org/generics-proposal。
42 | - proposal: spec: add generic programming using type parameters：https://github.com/golang/go/issues/43651。
43 | 
44 | 今年年底或 Go1.18beta 到底能不能看到泛型的正式完整可用版本呢，值得期待。


--------------------------------------------------------------------------------
/content/posts/go/gin/2018-08-26-makefile.md:
--------------------------------------------------------------------------------
  1 | ---
  2 | 
  3 | title:      "「番外」请入门 Makefile"
  4 | date:       2018-08-26 12:00:00
  5 | author:     "煎鱼"
  6 | toc: true
  7 | tags:
  8 |     - go
  9 |     - gin
 10 | --- 
 11 | 
 12 | ## 知识点
 13 | 
 14 | - 写一个 Makefile
 15 | 
 16 | ## 本文目标
 17 | 
 18 | 含一定复杂度的软件工程，基本上都是先编译 A，再依赖 B，再编译 C...，最后才执行构建。如果每次都人为编排，又或是每新来一个同事就问你项目 D 怎么构建、重新构建需要注意什么...等等情况，岂不是要崩溃？
 19 | 
 20 | 我们常常会在开源项目中发现 Makefile，你是否有过疑问？
 21 | 
 22 | 本章节会简单介绍 Makefile 的使用方式，最后建议深入学习。
 23 | 
 24 | ## 怎么解决
 25 | 
 26 | 对于构建编排，Docker 有 Dockerfile ，在 Unix 中有神器 [Make](https://en.wikipedia.org/wiki/Make_%28software%29) ....
 27 | 
 28 | ## Make
 29 | 
 30 | ### 是什么
 31 | 
 32 | Make 是一个构建自动化工具，会在当前目录下寻找 Makefile 或 makefile 文件。如果存在，会依据 Makefile 的**构建规则**去完成构建
 33 | 
 34 | 当然了，实际上 Makefile 内都是你根据 make 语法规则，自己编写的特定 Shell 命令等
 35 | 
 36 | 它是一个工具，规则也很简单。在支持的范围内，编译 A， 依赖 B，再编译 C，完全没问题
 37 | 
 38 | ### 规则
 39 | 
 40 | Makefile 由多条规则组成，每条规则都以一个 target（目标）开头，后跟一个 : 冒号，冒号后是这一个目标的 prerequisites（前置条件）
 41 | 
 42 | 紧接着新的一行，必须以一个 tab 作为开头，后面跟随 command（命令），也就是你希望这一个 target 所执行的构建命令
 43 | 
 44 | ```
 45 | [target] ... : [prerequisites] ...
 46 | <tab>[command]
 47 |     ...
 48 |     ...
 49 | ```
 50 | 
 51 | - target：一个目标代表一条规则，可以是一个或多个文件名。也可以是某个操作的名字（标签），称为**伪目标（phony）**
 52 | - prerequisites：前置条件，这一项是**可选参数**。通常是多个文件名、伪目标。它的作用是 target 是否需要重新构建的标准，如果前置条件不存在或有过更新（文件的最后一次修改时间）则认为 target 需要重新构建
 53 | - command：构建这一个 target 的具体命令集
 54 | 
 55 | ### 简单的例子
 56 | 
 57 | 本文将以 [go-gin-example](https://github.com/EDDYCJY/go-gin-example) 去编写 Makefile 文件，请跨入 make 的大门
 58 | 
 59 | #### 分析
 60 | 
 61 | 在编写 Makefile 前，需要先分析构建先后顺序、依赖项，需要解决的问题等
 62 | 
 63 | #### 编写
 64 | 
 65 | ```makefile
 66 | .PHONY: build clean tool lint help
 67 | 
 68 | all: build
 69 | 
 70 | build:
 71 | 	go build -v .
 72 | 
 73 | tool:
 74 | 	go tool vet . |& grep -v vendor; true
 75 | 	gofmt -w .
 76 | 
 77 | lint:
 78 | 	golint ./...
 79 | 
 80 | clean:
 81 | 	rm -rf go-gin-example
 82 | 	go clean -i .
 83 | 
 84 | help:
 85 | 	@echo "make: compile packages and dependencies"
 86 | 	@echo "make tool: run specified go tool"
 87 | 	@echo "make lint: golint ./..."
 88 | 	@echo "make clean: remove object files and cached files"
 89 | ```
 90 | 
 91 | 1、在上述文件中，使用了 `.PHONY`，其作用是声明 build / clean / tool / lint / help 为**伪目标**，声明为伪目标会怎么样呢？
 92 | 
 93 | - 声明为伪目标后：在执行对应的命令时，make 就不会去检查是否存在 build / clean / tool / lint / help 其对应的文件，而是每次都会运行标签对应的命令
 94 | 
 95 | - 若不声明：恰好存在对应的文件，则 make 将会认为 xx 文件已存在，没有重新构建的必要了
 96 | 
 97 | 2、这块比较简单，在命令行执行即可看见效果，实现了以下功能：
 98 | 
 99 | 1. make: make 就是 make all
100 | 2. make build: 编译当前项目的包和依赖项
101 | 3. make tool: 运行指定的 Go 工具集
102 | 4. make lint: golint 一下
103 | 5. make clean: 删除对象文件和缓存文件
104 | 6. make help: help
105 | 
106 | #### 为什么会打印执行的命令
107 | 
108 | 如果你实际操作过，可能会有疑问。明明只是执行命令，为什么会打印到标准输出上了？
109 | 
110 | ##### 原因
111 | 
112 | make 默认会打印每条命令，再执行。这个行为被定义为**回声**
113 | 
114 | ##### 解决
115 | 
116 | 可以在对应命令前加上 @，可指定该命令不被打印到标准输出上
117 | 
118 | ```makefile
119 | build:
120 | 	@go build -v .
121 | ```
122 | 
123 | 那么还有其他的特殊符号吗？有的，请课后去了解下 +、- 的用途 🤩
124 | 
125 | ## 小结
126 | 
127 | 这是一篇比较简洁的文章，希望可以让您对 Makefile 有一个基本了解。
128 | 
129 | ## 参考
130 | 
131 | ### 本系列示例代码
132 | 
133 | - [go-gin-example](https://github.com/EDDYCJY/go-gin-example)
134 | 
135 | ## 关于
136 | 
137 | ### 修改记录
138 | 
139 | - 第一版：2018 年 02 月 16 日发布文章
140 | - 第二版：2019 年 10 月 01 日修改文章
141 | 
142 | ## ？
143 | 
144 | 如果有任何疑问或错误，欢迎在 [issues](https://github.com/EDDYCJY/blog) 进行提问或给予修正意见，如果喜欢或对你有所帮助，欢迎 Star，对作者是一种鼓励和推进。
145 | 
146 | ### 我的公众号
147 | 
148 | ![image](https://image.eddycjy.com/8d0b0c3a11e74efd5fdfd7910257e70b.jpg)


--------------------------------------------------------------------------------
/content/posts/go/go-error2panic.md:
--------------------------------------------------------------------------------
  1 | ---
  2 | title: "Go 错误处理：用 panic 取代 err != nil 的模式"
  3 | date: 2020-12-12T17:21:42+08:00
  4 | toc: true
  5 | images:
  6 | tags: 
  7 |   - go
  8 | ---
  9 | 
 10 | 前段时间我分享了文章 《先睹为快，Go2 Error 的挣扎之路》后，和一位朋友进行了一次深度交流，他给我分享了他们项目组对于 Go 错误处理的方式调整。
 11 | 
 12 | 简单来讲，就是在业务代码中使用 `panic` 的方式来替代 “永无止境” 的 `if err != nil`。这就是今天本文的重点内容，我们一起来看看是怎么做，又有什么优缺点。
 13 | 
 14 | ## 为什么想替换
 15 | 
 16 | 在 Go 语言中 `if err != nil` 写的太多，还要管方法声明各种，嫌麻烦又不方便：
 17 | 
 18 | ```
 19 | err := foo()
 20 | if err != nil {
 21 |      //do something..
 22 |      return err
 23 | }
 24 | 
 25 | err := foo()
 26 | if err != nil {
 27 |      //do something..
 28 |      return err
 29 | }
 30 | 
 31 | err := foo()
 32 | if err != nil {
 33 |      //do something..
 34 |      return err
 35 | }
 36 | 
 37 | err := foo()
 38 | if err != nil {
 39 |      //do something..
 40 |      return err
 41 | }
 42 | ```
 43 | 
 44 | 上述还是示例代码，比较直面。若是在工程实践，还得各种 package 跳来跳去加 `if err != nil`，总的来讲比较繁琐，要去关心整体的上下游。更具体的就不赘述了，可以翻看我先前的文章。
 45 | 
 46 | ## 怎么替换 err != nil
 47 | 
 48 | 不想写 `if err != nil` 的代码，方式之一就是用 `panic` 来替代他。示例代码如下：
 49 | 
 50 | ```
 51 | func GetFish(db *sql.DB, name string) []string {
 52 | 	rows, err := db.Query("select name from users where `name` = ?", name)
 53 | 	if err != nil {
 54 | 		panic(err)
 55 | 	}
 56 | 	defer rows.Close()
 57 | 
 58 | 	var names []string
 59 | 	for rows.Next() {
 60 | 		var name string
 61 | 		err := rows.Scan(&name)
 62 | 		if err != nil {
 63 | 			panic(err)
 64 | 		}
 65 | 
 66 | 		names = append(names, name)
 67 | 	}
 68 | 
 69 | 	err = rows.Err()
 70 | 	if err != nil {
 71 | 		panic(err)
 72 | 	}
 73 | 
 74 | 	return names
 75 | }
 76 | ``` 
 77 | 
 78 | 在上述业务代码中，我们通过 `panic` 的方式取代了 `return err` 的函数返回，自然其所关联的下游业务代码也就不需要编写 `if err != nil` 的代码：
 79 | 
 80 | ```
 81 | func main() {
 82 | 	fish1 := GetFish(db, "煎鱼")
 83 | 	fish2 := GetFish(db, "咸鱼")
 84 | 	fish3 := GetFish(db, "摸鱼")
 85 | 	...
 86 | }
 87 | ```
 88 | 
 89 | 同时在转换为使用 `panic` 模式的错误机制后，我们必须要在外层增加 `recover` 方法：
 90 | 
 91 | ```
 92 | func AppRecovery() gin.HandlerFunc {
 93 | 	return func(c *gin.Context) {
 94 | 		defer func() {
 95 | 			if err := recover(); err != nil {
 96 | 				if _, ok := err.(AppErr); ok {
 97 | 					// do something...
 98 | 				} else {
 99 | 					panic(err)
100 | 				}
101 | 			}
102 | 		}()
103 | 	}
104 | }
105 | ```
106 | 
107 | 每次 `panic` 后根据其抛出的错误进行断言，识别是否定制的 `AppErr` 错误类型，若是则可以进行一系列的处理动作。否则可继续向上 `panic` 抛出给顶级的 `Recovery` 方法进行处理。
108 | 
109 | 这就是一个相对完整的 `panic` 错误链路处理了。
110 | 
111 | ## 优缺点
112 | 
113 | - 从优点上来讲：
114 | 
115 |     - 整体代码结构看起来更加的简洁，仅专注于实现逻辑即可。
116 | 
117 |     - 不需要关注和编写冗杂的 `if err != nil` 的错误处理代码。
118 | 
119 | - 从缺点上来讲：
120 | 
121 |     - 认知负担的增加，需要参加项目的每一个新老同学都清楚该模式，要做一个基本规范或培训。
122 | 
123 |     - 存在一定的性能开销，每次 `panic` 都存在用户态的上下文切换。
124 | 
125 |     - 存在一定的风险性，一旦 `panic` 没有 `recover` 住，就会导致事故。
126 | 
127 |     - Go 官方并不推荐，与 `panic` 本身的定义相违背，也就是 `panic` 与 `error` 的概念混淆。
128 | 
129 | ## 总结
130 | 
131 | 在今天这篇文章给大家分享了如何使用 `panic` 的方式来处理 Go 的错误，其必然有利必有有弊，需要做一个权衡了。
132 | 
133 | 你们团队有没有为了 Go 错误处理做过什么新的调整呢？欢迎在留言区交流和分享。


--------------------------------------------------------------------------------
/content/posts/go/go-errors-boom.md:
--------------------------------------------------------------------------------
  1 | ---
  2 | title: "生产环境遇到一个 Go 问题，整组人都懵逼了..."
  3 | date: 2021-07-07T12:43:49+08:00
  4 | images:
  5 | tags: 
  6 |   - go
  7 | ---
  8 | 
  9 | 大家好，我是煎鱼。
 10 | 
 11 | 前段时间正在疯狂写代码的时候，突然有一个读者给我提了一个问题，让我有了一定的兴趣：
 12 | 
 13 | ![image.png](https://p6-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/c1011e66fe104d228dcaa2083b554fc8~tplv-k3u1fbpfcp-watermark.image)
 14 | 
 15 | 我还是比较感兴趣的，因为是生产环境、有代码，且整组人都懵逼的问题。
 16 | 
 17 | 在征求了小伙伴的意见后，今天分享出来，大家也思考一下原因，一起规避这个 “坑”。
 18 | 
 19 | ## 案例一
 20 | 
 21 | 代码示例如下：
 22 | 
 23 | ```golang
 24 | type MyErr struct {
 25 |     Msg string
 26 | }
 27 | 
 28 | func main() {
 29 |     var e error
 30 |     e = GetErr()
 31 |     log.Println(e == nil)
 32 | }
 33 | 
 34 | func GetErr() *MyErr {
 35 |     return nil
 36 | }
 37 | 
 38 | func (m *MyErr) Error() string {
 39 |     return "脑子进煎鱼了"
 40 | }
 41 | ```
 42 | 
 43 | 请思考一下，**这段程序的输出结果是什么**？
 44 | 
 45 | 该程序所调用的 `GetErr` 方法所返回的是 `nil`，而外部判断是 `e == nil`，因此最终的输出结果是 true，对吗？ 
 46 | 
 47 | 输出结果如下：
 48 | 
 49 | ```
 50 | 2021/04/04 08:39:04 false
 51 | ```
 52 | 
 53 | 答案是：false。
 54 | 
 55 | ## 案例二
 56 | 
 57 | 代码示例如下：
 58 | 
 59 | ```golang
 60 | type Base interface {
 61 |     do()
 62 | }
 63 | 
 64 | type App struct {
 65 | }
 66 | 
 67 | func main() {
 68 |     var base Base
 69 |     base = GetApp()
 70 |     
 71 |     log.Println(base)
 72 |     log.Println(base == nil)
 73 | }
 74 | 
 75 | func GetApp() *App {
 76 |     return nil
 77 | }
 78 | func (a *App) do() {}
 79 | ```
 80 | 
 81 | 请思考一下，**这段程序的输出结果是什么**？
 82 | 
 83 | 该程序调用了 `GetApp` 方法，该方法返回的是 `nil`，因此其赋值的 `base` 也是 `nil`。因此判断 `base == nil` 的最终输出结果是 `<nil>` 和 `true`，对吗？
 84 | 
 85 | 输出结果如下：
 86 | 
 87 | ```
 88 | 2021/04/04 08:59:00 <nil>
 89 | 2021/04/04 08:59:00 false
 90 | ```
 91 | 
 92 | 答案是：`<nil>` 和 false。
 93 | 
 94 | ## 为什么
 95 | 
 96 | 为什么，这两段 Go 程序是怎么回事...也太反直觉了？其背后的原因本质上还是对 Go 语言中 interface 的基本原理的理解。
 97 | 
 98 | 在案例一中，虽然 `GetErr` 方法确实是返回了 `nil`，返回的类型也是具体的 `*MyErr` 类型。但是其接收的变量却不是具体的结构类型，而是 `error` 类型：
 99 | 
100 | ```golang
101 | var e error
102 | e = GetErr()
103 | ```
104 | 
105 | 在 Go 语言中， `error` 类型本质上是 interface：
106 | 
107 | ```golang
108 | type error interface {
109 |     Error() string
110 | }
111 | ```
112 | 
113 | 因此兜兜转转又回到了 interface 类型的问题，interface 不是单纯的值，而是**分为类型和值**。
114 | 
115 | 所以传统认知的此 nil 并非彼 nil，**必须得类型和值同时都为 nil 的情况下，interface 的 nil 判断才会为 true**。
116 | 
117 | 在案例一中，结合代码逻辑，更符合场景的是：
118 | 
119 | ```golang
120 | var e *MyErr
121 | e = GetErr()
122 | log.Println(e == nil)
123 | ```
124 | 
125 | 输出结果就会是 true。
126 | 
127 | 在案例二中，也是一样的结果，原因也是 interface。不管是 `error` 接口（interface），还是自定义的接口，背后原理一致，自然也就结果一致了。
128 | 
129 | ## 总结
130 | 
131 | 今天这篇文章，相当于是《Go 面试题：Go interface 的一个 “坑” 及原理分析》的变形了，毕竟是生产环境的代码改造而来，更贴合真实的实际场景。
132 | 
133 | 下意识的直觉有时候不是绝对正确的，我们要正确的理解 Go 语言中的那些知识点，才能更好地实现早下班的理想和愿景。
134 | 
135 | 


--------------------------------------------------------------------------------
/content/posts/go/go-golang.md:
--------------------------------------------------------------------------------
  1 | ---
  2 | title: "Go 和 Golang 有什么关系？"
  3 | date: 2021-12-31T12:55:12+08:00
  4 | toc: true
  5 | images:
  6 | tags: 
  7 |   - go
  8 | ---
  9 | 
 10 | 大家好，我是煎鱼。
 11 | 
 12 | 最近天气也冷了，掐指一算是招聘季了，无论是校招、社招、HR、面试官们都蠢蠢欲动。这不，我有一个朋友的 HR 朋友都有起名困难了，一看 Go 语言的工作说明（Job Description），发现各有不同。
 13 | 
 14 | 如下图：
 15 | 
 16 | ![来自某招聘网站](https://files.mdnice.com/user/3610/629d4aaa-bb01-4e2b-9a43-d671200da099.png)
 17 | 
 18 | 仔细一看，有叫 Go 的，也有叫 Golang，还有叫 GO 的。好家伙，Go 语言有这么多个别名，甚至某乎都讨论了起来。到底叫什么是正确的？
 19 | 
 20 | 为此，今天就由煎鱼带大家理一理，了解这背后的关系。
 21 | 
 22 | ## Go 官方定义
 23 | 
 24 | 从网上的资料来看，大家对 Go 的名字还是比较关注的，对于 Go 团队来讲，仿佛经常被问。例如：
 25 | 
 26 | - “Go 和 Golang 的关系是什么？”
 27 | - “Go、Golang、GO 哪个对？”
 28 | 
 29 | 甚至在之前探讨 Go2 草案时，也有人开始起 Go2 的名字了，纠结是要叫 “golang2”，还是 “go2lang”：
 30 | 
 31 | ![](https://files.mdnice.com/user/3610/7608f5a1-9e77-45b2-a552-a7b7c32ad100.png)
 32 | 
 33 | 其实这是错误的。在 Go FAQ 中有明确的回答这个问题：
 34 | 
 35 | ![](https://files.mdnice.com/user/3610/bdb43d48-f5c1-41bb-8495-7bbfc2fc60a6.png)
 36 | 
 37 | 这一门语言称为 “Go”，不叫 “Golang”，也不叫 “GO”。“golang” 只是网站的地址，而不是语言的名称。
 38 | 
 39 | 同时 “GO” 的语言名称叫法也是错误的，虽然官方上的 Logo 是 “GO”：
 40 | 
 41 | ![](https://files.mdnice.com/user/3610/67b022a9-49de-4349-861e-77dd25367ac6.png)
 42 | 
 43 | 但这显然只是设计师层面的美观考量，并不是这一门语言的标准定义。
 44 | 
 45 | 因此**这一门语言叫做 “Go” 语言**，这是正确的，也得到官方认证的，也不曾改变过。
 46 | 
 47 | ## 为什么会有 Golang
 48 | 
 49 | 但可能又有小伙伴疑惑了，那为什么 “Golang” 这个别名，如此之火。到底是为什么？
 50 | 
 51 | 这里一共有三点原因，分别是：站点地址（Go FAQ 提到）、搜索引擎、社区和论坛、语言重名。
 52 | 
 53 | ### Go 站点地址
 54 | 
 55 | Go 团队所期望的 https://go.org 早就被注册，从网站的底部标识来看，2008 年起建站：
 56 | 
 57 | ![](https://files.mdnice.com/user/3610/d40e96a2-122c-44fa-8134-2a8b88eb7690.png)
 58 | 
 59 | 所以 Go 语言只能使用 https://golang.org，你也会 https://pkg.go.dev 和 https://golang.org、https://godoc.org，存在多个域名，并不统一。
 60 | 
 61 | 因此作为 Go 开发者所常用官方站点，自然而然 golang 这一个语言标识就深深地被记住了，一直沿用至今。
 62 | 
 63 | 同时域名为 “golang” 关键字，自然会大幅度的影响到 Go 资料搜索引擎的收录，是一个非常重要的因素。
 64 | 
 65 | ### 搜索引擎
 66 | 
 67 | 在早年 Go 语言还不知名时，用 go 关键字去搜索资料会非常的困难。这是各大搜索引擎早年的一个槽点（reddit 很多吐槽）。
 68 | 
 69 | 因为单一的 go 关键字过于广泛了，很多人会直接用 golang 关键字来搜资料，反而会更能看到一些与 Go 真正相关的。
 70 | 
 71 | ![](https://files.mdnice.com/user/3610/fe21dc19-26d5-4e14-88c5-fa077f149e00.png)
 72 | 
 73 | 这一点在近年来有明确改善，得益于 Go 语言的崛起，现在也能搜到了。
 74 | 
 75 | ### 社区和论坛
 76 | 
 77 | 在社区、论坛等，也有类似的问题。因为占位、重名、认知等原因。像是 segmentfault、twitter 叫 golang。掘金叫 Go，各有不同。
 78 | 
 79 | ![](https://files.mdnice.com/user/3610/07ee2a59-901f-44ff-bd65-7de95a9878c6.png)
 80 | 
 81 | 这点难以改善，毕竟各家都是不同企业的。所以难受的点是用户，搜了 Go，可能搜不到，又跑去搜 Golang 才可以。
 82 | 
 83 | 再看看国外的论坛，在 Google 群组 golang-nuts 和 golang-dev 也有类似偏差。
 84 | 
 85 | 基本可以明确 **“Golang” 更多会被用在搜索和标签上**，能够保证搜索和标签查询的结果。
 86 | 
 87 | ### 语言重名 
 88 | 
 89 | 实际上在 Go 语言出现前，已经存在一门 “Go!” 的编程语言了。有网友表示这也是 Go 官方纠结的一点。
 90 | 
 91 | ![](https://files.mdnice.com/user/3610/8c2197f0-5376-49c1-845a-b2564606d1a7.png)
 92 | 
 93 | 不过实际上编程语言重名并不少见，但由于真实性有待考量，建议仅是了解即可。
 94 | 
 95 | 至少现在已经没有这门语言的命名之争。
 96 | 
 97 | ## 总结
 98 | 
 99 | 可以明确，官方诠释的正确名称为 Go。
100 | 
101 | 但由于 go.org 域名的原因，
102 | 因此在 Go Programming Language 的通俗称呼下，采取了 golang 来作为 Go 站点、Google 群组的域名/组别等的建立。
103 | 
104 | Go 资料肯定都集中在官方站点、论坛，自然而然，大家用 “go” 关键字也就很难搜索到了，都得用 “golang” 关键字。
105 | 
106 | 可以明确，**Go 是这一门编程语言的名字，Golang 更多是在搜索和标签上的使用**。
107 | 
108 | 这看上去，是搜索引擎的胜利，你觉得呢？ ：）


--------------------------------------------------------------------------------
/content/posts/go/go-tips-defer.md:
--------------------------------------------------------------------------------
  1 | ---
  2 | title: "Go 群友提问：学习 defer 时很懵逼，这道不会做！"
  3 | date: 2021-04-05T16:10:51+08:00
  4 | images:
  5 | tags: 
  6 |   - go
  7 |   - 面试题
  8 | ---
  9 | 
 10 | 大家好，我是煎鱼。
 11 | 
 12 | 前几天在读者交流群里看到一位小伙伴，在向大家咨询 Go 相关的技术问题。
 13 | 疑问是：“**各位大佬，我在学习 defer 遇到闭包的时候很懵逼，谁比较明白，能指点？**”
 14 | 
 15 | ![](https://image.eddycjy.com/36e2b86b536909f265b84db24dcd80c6.jpg)
 16 | 
 17 | ## 疑问
 18 | 
 19 | 他的疑问是下面这道 Go 语言的 defer 题目，大家一起看看：
 20 | 
 21 | ```
 22 | func main() {
 23 | 	var whatever [6]struct{}
 24 | 	for i := range whatever {
 25 | 		defer func() {
 26 | 			fmt.Println(i)
 27 | 		}()
 28 | 	}
 29 | }
 30 | ```
 31 | 请自己先想一下输出的结果答案是什么。
 32 | 
 33 | 这位小伙伴按自己的理解后，认为应当输出 xx。但最终的输出结果，可能与其思考的有所偏差，一时想不通。
 34 | 
 35 | ### 解惑
 36 | 
 37 | 这段程序的输出结果是：
 38 | 
 39 | ```
 40 | 5
 41 | 5
 42 | 5
 43 | 5
 44 | 5
 45 | 5
 46 | ```
 47 | 
 48 | 为什么全是 5，为什么不是 0, 1, 2, 3, 4, 5 这样的输出结果呢？
 49 | 
 50 | 其根本原因是**闭包**所导致的，有两点原因：
 51 | - 在 `for` 循环结束后，局部变量 `i` 的值已经是 5 了，并且 `defer `的闭包是直接引用变量的 i。
 52 | - 结合`defer` 关键字的特性，可得知会在 `main` 方法主体结束后再执行。
 53 | 
 54 | 结合上述，最终输出的结果是已经自增完毕的 5。
 55 | 
 56 | ### 进一步思考
 57 | 
 58 | 既然了解了为什么，我们再变形一下。再看看另外一种情况，代码如下：
 59 | 
 60 | ```
 61 | func main() {
 62 | 	var whatever [6]struct{}
 63 | 	for i := range whatever {
 64 | 		defer func(i int) {
 65 | 			fmt.Println(i)
 66 | 		}(i)
 67 | 	}
 68 | }
 69 | ```
 70 | 
 71 | 与第一个案例不同，我们这回把变量 `i` 传了进去。那么他的输出结果是什么呢？
 72 | 
 73 | 这段程序的输出结果是：
 74 | 
 75 | ```
 76 | 5
 77 | 4
 78 | 3
 79 | 2
 80 | 1
 81 | 0
 82 | ```
 83 | 
 84 | 为什么是 5, 4, 3, 2, 1, 0 呢，为什么不是 0, 1, 2, 3, 4, 5？（难道煎鱼敲错了吗？）
 85 | 
 86 | 其根本原因在于两点：
 87 | - 在 `for` 循环时，局部变量 `i` 已经传入进 `defer func` 中 ，属于值传递。其值在 `defer` 语句声明时的时候就已经确定下来了。
 88 | - 结合 `defer` 关键字的特性，是按**先进后出**的顺序来执行的。
 89 | 
 90 | 结合上述，最终输出的结果是 5, 4, 3, 2, 1, 0。
 91 | 
 92 | ## 下一个疑问
 93 | 
 94 | 没过一会，这位小伙伴又有了新的感悟。抛出了新的示例问题，如下：
 95 | 
 96 | ```
 97 | func f1() (r int) {
 98 |    defer func() {
 99 |       r++
100 |    }()
101 |    return 0
102 | }
103 | 
104 | func f2() (r int) {
105 |    t := 5
106 |    defer func() {
107 |       t = t + 5
108 |    }()
109 |    return t
110 | }
111 | 
112 | func f3() (r int) {
113 |    defer func(r int) {
114 |       r = r + 5
115 |    }(r)
116 |    return 1
117 | }
118 | ```
119 | 
120 | 主函数：
121 | 
122 | ```
123 | func main() {
124 | 	println(f1())
125 | 	println(f2())
126 | 	println(f3())
127 | }
128 | ```
129 | 
130 | 请自己先想一下输出的结果答案是什么。
131 | 
132 | 
133 | 这段程序的输出结果是：
134 | 
135 | ```
136 | 1
137 | 5
138 | 1
139 | ```
140 | 
141 | 为什么是 1, 5, 1 呢，而不是 0, 10, 5，又或是其他答案？
142 | 
143 | 欢迎大家在**下方评论区留言讨论和分享解题的思路**，一起思考和进步。


--------------------------------------------------------------------------------
/content/posts/go/go-tips-interface.md:
--------------------------------------------------------------------------------
  1 | ---
  2 | title: "Go 面试官：Go interface 的一个 “坑” 及原理分析"
  3 | date: 2021-04-05T16:12:59+08:00
  4 | images:
  5 | tags: 
  6 |   - go
  7 |   - 面试题
  8 | ---
  9 | 
 10 | 大家好，我是煎鱼。
 11 | 
 12 | 前几天在读者交流群里看到一位小伙伴，针对 interface 的使用有了比较大的疑惑。
 13 | 
 14 | 无独有偶，我也在网上看到有小伙伴在 Go 面试的时候被问到了：
 15 | 
 16 | 
 17 | ![来自网上博客的截图](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/36d7ecb0da9e4b32a493dedce6ebc691~tplv-k3u1fbpfcp-watermark.image)
 18 | 
 19 | 今天特意分享出来让大家避开这个坑。
 20 | 
 21 | ## 例子一
 22 | 
 23 | 第一个例子，如下代码：
 24 | 
 25 | 
 26 | ```golang
 27 | func main() {
 28 |     var v interface{}
 29 |     v = (*int)(nil)
 30 |     fmt.Println(v == nil)
 31 | }
 32 | ```
 33 | 
 34 | 你觉得输出结果是什么呢？
 35 | 
 36 | 答案是：
 37 | 
 38 | ```
 39 | false
 40 | ```
 41 | 为什么不是 `true`。明明都已经强行置为 `nil` 了。是不是 Go 编译器有问题？
 42 | 
 43 | ## 例子二
 44 | 
 45 | 第二个例子，如下代码：
 46 | 
 47 | ```golang
 48 | func main() {
 49 |     var data *byte
 50 |     var in interface{}
 51 | 
 52 |     fmt.Println(data, data == nil)
 53 |     fmt.Println(in, in == nil)
 54 | 
 55 |     in = data
 56 |     fmt.Println(in, in == nil)
 57 | }
 58 | ```
 59 | 
 60 | 你觉得输出结果是什么呢？
 61 | 
 62 | 答案是：
 63 | 
 64 | ```
 65 | <nil> true
 66 | <nil> true
 67 | <nil> false
 68 | ```
 69 | 
 70 | 这可就更奇怪了，为什么刚刚声明出来的 `data` 和 `in` 变量，确实是输出结果是 `nil`，判断结果也是 `true`。
 71 | 
 72 | 怎么把变量 `data` 一赋予给变量 `in`，世界就变了？输出结果依然是 `nil`，但判定却变成了 `false`。
 73 | 
 74 | 和上面的第一个例子结果类似，真是神奇。
 75 | 
 76 | ## 原因
 77 | 
 78 | interface 判断与想象中不一样的根本原因是，interface 并不是一个指针类型，虽然他看起来很像，以至于误导了不少人。
 79 | 
 80 | 我们钻下去 interface，interface 共有两类数据结构：
 81 | 
 82 | ![](https://imgkr2.cn-bj.ufileos.com/560dcab5-e436-4a2c-bfee-6eba6faee1d2.png?UCloudPublicKey=TOKEN_8d8b72be-579a-4e83-bfd0-5f6ce1546f13&Signature=HF1wka8F9MTc%252FVCTrMjhASpeeE4%253D&Expires=1615900476)
 83 | 
 84 | - `runtime.eface` 结构体：表示不包含任何方法的空接口，也称为 empty interface。
 85 | - `runtime.iface` 结构体：表示包含方法的接口。
 86 | 
 87 | 看看这两者相应的底层数据结构：
 88 | 
 89 | ```golang
 90 | type eface struct {
 91 |     _type *_type
 92 |     data  unsafe.Pointer
 93 | }
 94 | 
 95 | type iface struct {
 96 |     tab  *itab
 97 |     data unsafe.Pointer
 98 | }
 99 | ```
100 | 
101 | 你会发现 interface 不是单纯的值，而是**分为类型和值**。
102 | 
103 | 所以传统认知的此 nil 并非彼 nil，**必须得类型和值同时都为 nil 的情况下，interface 的 nil 判断才会为 true**。
104 | 
105 | ## 解决办法
106 | 
107 | 与其说是解决方法，不如说是委婉的破局之道。在不改变类型的情况下，方法之一是利用反射（reflect），如下代码：
108 | 
109 | ```golang
110 | func main() {
111 |     var data *byte
112 |     var in interface{}
113 | 
114 |     in = data
115 |     fmt.Println(IsNil(in))
116 | }
117 | 
118 | func IsNil(i interface{}) bool {
119 |     vi := reflect.ValueOf(i)
120 |     if vi.Kind() == reflect.Ptr {
121 |         return vi.IsNil()
122 |     }
123 |     return false
124 | }
125 | ```
126 | 
127 | 利用反射来做 nil 的值判断，在反射中会有针对 interface 类型的特殊处理，最终输出结果是：true，达到效果。
128 | 
129 | 其他方法的话，就是改变原有的程序逻辑，例如：
130 | - 对值进行 nil 判断，再返回给 interface 设置。
131 | - 返回具体的值类型，而不是返回 interface。
132 | 
133 | ## 总结
134 | 
135 | Go interface 是 Go 语言中最常用的类型之一，大家用惯了 `if err != nil` 就很容易顺手就踩进去了。
136 | 
137 | 建议大家要多留个心眼，如果对 interface 想要有更进一步的了解，可以看看我的这篇深入解析的文章：《一文吃透 Go 语言解密之接口 interface》。
138 | 


--------------------------------------------------------------------------------
/content/posts/go/go-tips-lenstr.md:
--------------------------------------------------------------------------------
 1 | ---
 2 | title: "问个 Go 问题，字符串 len 为 0 和 字符串为空 ，有啥区别？"
 3 | date: 2021-04-05T16:09:14+08:00
 4 | images:
 5 | tags: 
 6 |   - go
 7 |   - 面试题
 8 | ---
 9 | 
10 | 大家好，我是煎鱼。
11 | 
12 | 前几天在微信群看到几位大佬在讨论一个问题： ”**字符串 len == 0 和 字符串 == "" ，有啥区别**？“
13 | 
14 | 这是一个比较小的细节点，同时也勾起了我的好奇心，因此今天这篇文章就和大家一起研究一下他们两者有没有区别，谁的性能更好一些？
15 | 
16 | ## 测试方法
17 | 
18 | 在测试的方法中，我们分别声明了 `Test1` 和 `Test2` 方法：
19 | 
20 | ```
21 | func Test1() bool {
22 | 	var v string
23 | 	if v == "" {
24 | 		return true
25 | 	}
26 | 	return false
27 | }
28 | 
29 | func Test2() bool {
30 | 	var v string
31 | 	if len(v) == 0 {
32 | 		return true
33 | 	}
34 | 	return false
35 | }
36 | ```
37 | 
38 | 在方法内部仅做了简单的变量类型声明，分别以 字符串 == "" 和 字符串 len == 0 为判断依据。
39 | 
40 | ## 测试用例
41 | 
42 | 编写两个方法的 Benchmark，用于后续的性能测试：
43 | 
44 | ```
45 | func BenchmarkTest1(b *testing.B) {
46 | 	for i := 0; i < b.N; i++ {
47 | 		Test1()
48 | 	}
49 | }
50 | 
51 | func BenchmarkTest2(b *testing.B) {
52 | 	for i := 0; i < b.N; i++ {
53 | 		Test2()
54 | 	}
55 | }
56 | ```
57 | 
58 | ## 结果分析
59 | 
60 | ```
61 | $ go test --bench=. -benchmem
62 | goos: darwin
63 | goarch: amd64
64 | BenchmarkTest1-4   	1000000000	         0.305 ns/op	       0 B/op	       0 allocs/op
65 | BenchmarkTest2-4   	1000000000	         0.305 ns/op	       0 B/op	       0 allocs/op
66 | PASS
67 | ok  	_/Users/eddycjy/go-application/awesomeProject/tests	0.688s
68 | ```
69 | 
70 | 从多次测试的结果来看，两者比较：
71 | - 性能几乎没有区别，甚至可以出现一模一样的情况。
72 | - 均不涉及内存申请和操作，均为 0/op。说明变量并不是声明了，就有初始化动作的，这块 Go 编译器有做优化。
73 | 
74 | 结果上居然是一样的。根据曹大的提示，我们可以进一步看一下两者的汇编代码，看看具体区别在哪里：
75 | 
76 | ```
77 | $ go tool compile -S main.go
78 | "".main STEXT nosplit size=1 args=0x0 locals=0x0
79 | 	0x0000 00000 (main.go:3)	TEXT	"".main(SB), NOSPLIT|ABIInternal, $0-0
80 | 	0x0000 00000 (main.go:3)	FUNCDATA	$0, gclocals·33cdeccccebe80329f1fdbee7f5874cb(SB)
81 | 	0x0000 00000 (main.go:3)	FUNCDATA	$1, gclocals·33cdeccccebe80329f1fdbee7f5874cb(SB)
82 | 	0x0000 00000 (main.go:5)	RET
83 | 	0x0000 c3                                               .
84 | go.cuinfo.packagename. SDWARFINFO dupok size=0
85 | 	0x0000 6d 61 69 6e                                      main
86 | ""..inittask SNOPTRDATA size=24
87 | 	0x0000 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  ................
88 | 	0x0010 00 00 00 00 00 00 00 00                          ........
89 | gclocals·33cdeccccebe80329f1fdbee7f5874cb SRODATA dupok size=8
90 | 	0x0000 01 00 00 00 00 00 00 00   
91 | ```
92 | 
93 | 无论是 `len(v) == 0`，又或是 `v == ""` 的判断，其编译出来的汇编代码都是完全一致的。可以明确 Go 编译器在这块做了明确的优化，大概率是直接比对了。
94 | 
95 | 大家有没有其他的看法和拓展呢，欢迎一起来学习和交流。
96 | 
97 | 
98 | 


--------------------------------------------------------------------------------
/content/posts/go/go-why-path.md:
--------------------------------------------------------------------------------
 1 | ---
 2 | title: "意见征集：Go1 要不要移除 GOPATH？"
 3 | date: 2021-04-05T16:02:34+08:00
 4 | images:
 5 | tags: 
 6 |   - go
 7 | ---
 8 | 
 9 | 大家好，我是在打自己脸的后方记者煎鱼。
10 | 
11 | 前几天我发表了文章《意见征集：Go1 要不要移除 GOPATH？》。
12 | 本次投票共有 592 人参与了投票。
13 | 结果如下：
14 | 
15 | ![](https://static01.imgkr.com/temp/d10e1354bc9d43c68439fb71d8935270.png)
16 | 
17 | 绝大部分人支持移除 GOPATH，但建议保留的人依然占相当一部分。
18 | 
19 | ## 最新进展
20 | 
21 | 在近几天，在 go issues 上有人提出了新的提案：《proposal: cmd/go: maintain 'classic' vendor behaviour》。
22 | 
23 | 该提案正式向 Go 官方提出了我们上一篇文章有提到的两点：
24 | 1. Go 历史项目的维护问题。
25 | 2. Go1 兼容性保证的许诺。
26 | 
27 | 摘选一部分核心观点给大家看看。
28 | 
29 | ## 新的提案
30 | 
31 | 从 Go1.17 开始，Go1.17 就将 GOPATH 从编译器工具链中移除 `GO111MODULE` 标识。
32 | 
33 | 其依据如下：
34 | 
35 | ![](https://static01.imgkr.com/temp/bf314e0979b7481681c6293ee60715c3.png)
36 | 
37 | 重点在于执行 `-mod=vendor` 命令时，其会忽略主模块根目录以外位置的软件目录，**这意味着在 go mod 之前设计和编写的应用程序不能再编译（指的历史项目问题）**。
38 | 
39 | 提案本身并不是要求要保持 GOPATH 代码解析 1:1 的说法，而是希望能够允许项目代码通过其他的方式在移除 GOPATH 后也能正常运行，有其他方式能够导入（不需要转成 Go mod）。
40 | 
41 | 另外最后提到删除 GOPATH 这样的代码解析能力，**与下面这段摘自 go1compat 文档的精神不一致**：
42 | 
43 | >> It is intended that programs written to the Go 1 specification will continue to compile and run correctly, unchanged, over the lifetime of that specification. At some indefinite point, a Go 2 specification may arise, but until that time, Go programs that work today should continue to work even as future "point" releases of Go 1 arise (Go 1.1, Go 1.2, etc.).
44 | 
45 | 指出直接移除 GOPATH 可能违反 Go1 兼容性保证的精神，带来历史项目的工作量。
46 | 
47 | ## 相爱相杀
48 | 
49 | 无独有偶，前几天我和欧神（@changkun）就讨论过 Go1 兼容性保证（go1compat）的问题，我也是认为违反了该精神保证，这次行为不是很合理。
50 | 
51 | 但...欧神重读 《Go 1 and the Future of Go Programs》后，也就是我们俗称的 Go1 兼容性保证。发现了以下亮点：
52 | 
53 | ![](https://static01.imgkr.com/temp/aa47a80786814576b5a5b091d8244127.png)
54 | 
55 | 在工具链中提到，**Go 语言的工具链（编译器、链接器、构建工具等）仍然正在积极开发中，可能会改变行为，也就是不在兼容性保护的范围内**。
56 | 
57 | 我们回到主角身上，GOPATH 是什么：GOPATH 定义的是软件的构建形式而不是编译的条件，归属于工具链里。
58 | 
59 | 因此其实**移除 GOPATH 并不违反 Go1 兼容性保证**，因为他不在保障范围内。
60 | 
61 | 注：感谢欧神的探讨和释疑，在此推荐欧神的大作《[Go 语言原本](https://golang.design/under-the-hood/ "Go 语言原本")》。
62 | 
63 | ## 总结
64 | 
65 | 目前该[提案](https://github.com/golang/go/issues/44519 "提案")已经进入 proposal review meeting 日程了，很快就会有决策了，在这里我们就不进行过多的新方案探讨。
66 | 
67 | 现实场景中依赖 GOPATH 的历史项目确实存在，使用什么方法更低成本、合理的让既有项目能够正常运行将会是一个讨论重点。
68 | 
69 | 接下来煎鱼将会跟踪这个提案，新的消息会继续同步。毕竟我是利益相关者（有依赖 GOPATH 的项目)...
70 | 
71 | 欢迎大家一起来讨论各种可能性！


--------------------------------------------------------------------------------
/content/posts/go/go1.16-2.md:
--------------------------------------------------------------------------------
  1 | ---
  2 | title: "Go1.16 新特性：快速上手 Go embed"
  3 | date: 2021-02-11T16:13:19+08:00
  4 | images:
  5 | tags: 
  6 |   - go
  7 | ---
  8 | 
  9 | 在以前，很多从其他语言转过来 Go 语言的同学会问到，或是踩到一个坑。就是以为 Go 语言所打包的二进制文件中会包含配置文件的联同编译和打包。
 10 | 
 11 | ![](https://imgkr2.cn-bj.ufileos.com/f59a06c7-2fa1-41f4-901c-990f7dd7d715.png?UCloudPublicKey=TOKEN_8d8b72be-579a-4e83-bfd0-5f6ce1546f13&Signature=werBc5OkLhKUh0JhpYpcAtl3etA%253D&Expires=1612147306)
 12 | 
 13 | 
 14 | 结果往往一把二进制文件挪来挪去，就无法把应用程序运行起来了。因为无法读取到静态文件的资源。
 15 | 
 16 | 无法将静态资源编译打包进二进制文件的话，通常会有两种解决方法：
 17 | - 第一种是识别这类静态资源，是否需要跟着程序走。
 18 | - 第二种就是考虑将其打包进二进制文件中。
 19 | 
 20 | 第二种情况的话，Go 以前是不支持的，大家就会去借助各种花式的开源库，例如：go-bindata/go-bindata 来实现。
 21 | 
 22 | 但从在 Go1.16 起，Go 语言自身正式支持了该项特性，今天我们将通过这篇文章快速了解和学习这项特性。
 23 | 
 24 | ## 基本使用
 25 | 
 26 | 演示代码：
 27 | 
 28 | ```
 29 | import _ "embed"
 30 | 
 31 | //go:embed hello.txt
 32 | var s string
 33 | 
 34 | func main() {
 35 | 	print(s)
 36 | }
 37 | ```
 38 | 我们首先在对应的目录下创建了 `hello.txt` 文件，并且写入文本内容 “吃煎鱼”。
 39 | 
 40 | 在代码中编写了最为核心的 `//go:embed hello.txt` 注解。注解的格式很简单，就是 `go:embed` 指令声明，外加读取的内容的地址，可支持相对和绝对路径。
 41 | 
 42 | 输出结果：
 43 | 
 44 | ```
 45 | 吃煎鱼
 46 | ```
 47 | 
 48 | 读取到静态文件中的内容后自动赋值给了变量 `s`，并且在主函数中成功输出。
 49 | 
 50 | 而针对其他的基础类型，Go embed 也是支持的：
 51 | 
 52 | ```
 53 | //go:embed hello.txt
 54 | var s string
 55 | 
 56 | //go:embed hello.txt
 57 | var b []byte
 58 | 
 59 | //go:embed hello.txt
 60 | var f embed.FS
 61 | 
 62 | func main() {
 63 | 	print(s)
 64 | 	print(string(b))
 65 | 
 66 | 	data, _ := f.ReadFile("hello.txt")
 67 | 	print(string(data))
 68 | }
 69 | ```
 70 | 
 71 | 输出结果：
 72 | 
 73 | ```
 74 | 吃煎鱼
 75 | 吃煎鱼
 76 | 吃煎鱼
 77 | ```
 78 | 
 79 | 我们同时在一个代码文件中进行了多个 embed 的注解声明。
 80 | 
 81 | 并且针对 string、slice、byte、fs 等多种类型进行了打包，也不需要过多的处理，非常便利。
 82 | 
 83 | ## 拓展用法
 84 | 
 85 | 除去基本用法完，embed 本身在指令上也支持多种变形：
 86 | 
 87 | ```
 88 | //go:embed hello1.txt hello2.txt
 89 | var f embed.FS
 90 | 
 91 | func main() {
 92 | 	data1, _ := f.ReadFile("hello1.txt")
 93 | 	fmt.Println(string(data1))
 94 | 
 95 | 	data2, _ := f.ReadFile("hello2.txt")
 96 | 	fmt.Println(string(data2))
 97 | }
 98 | ```
 99 | 在指定 `go:embed` 注解时可以一次性多个文件来读取，并且也可以一个变量多行注解：
100 | 
101 | ```
102 | //go:embed hello1.txt 
103 | //go:embed hello2.txt
104 | var f embed.FS
105 | ```
106 | 
107 | 也可以通过在注解中指定目录 `helloworld`，再对应读取文件：
108 | 
109 | ```
110 | //go:embed helloworld
111 | var f embed.FS
112 | 
113 | func main() {
114 | 	data1, _ := f.ReadFile("helloworld/hello1.txt")
115 | 	fmt.Println(string(data1))
116 | 
117 | 	data2, _ := f.ReadFile("helloworld/hello2.txt")
118 | 	fmt.Println(string(data2))
119 | }
120 | ```
121 | 
122 | 同时既然能够支持目录读取，也能支持贪婪模式的匹配：
123 | 
124 | ```
125 | //go:embed helloworld/*
126 | var f embed.FS
127 | ```
128 | 
129 | 可能会有小伙伴注意到，`embed.FS` 也能调各类文件系统的接口，其实本质是 `embed.FS` 实现了 `io/fs` 接口。
130 | 
131 | ## 只读属性
132 | 
133 | 在 embed 所提供的 FS 中，我们可以发现其都是打开和只读方法：
134 | 
135 | ```
136 | type FS
137 |     func (f FS) Open(name string) (fs.File, error)
138 |     func (f FS) ReadDir(name string) ([]fs.DirEntry, error)
139 |     func (f FS) ReadFile(name string) ([]byte, error)
140 | ```
141 | 
142 | 根据此也可以确定 embed 所打包进二进制文件的内容只允许读取，不允许变更。
143 | 
144 | 更抽象来讲就是在编译期就确定了 embed 的内容，在运行时不允许修改，保证了一致性。
145 | 
146 | ## 总结
147 | 
148 | 通过 Go1.16 正式提供的 embed 特性，可以实现原生就支持静态资源文件的嵌入。整体如下：
149 | 
150 | - 在功能上：能够将静态资源嵌入二进制文件中，在运行时可以打开和读取相关的打包后的静态文件。
151 | - 在安全上：是在编译期编译嵌入，在运行时不支持修改。
152 | - 在使用上：
153 |     - 支持单文件读取：`go:embed hello.txt`。
154 |     - 支持多文件读取：`go:embed hello1.txt`、`go:embed hello2.txt`。
155 |     - 支持目录读取：`go:embed helloworld`。
156 |     - 支持贪婪匹配：`go:embed helloworld/*`。
157 | 
158 | 总的来讲，Go1.16 embed 特性很好的填补了 Go 语言在打包静态文件资源的一块原生空白领域。同时也说明了 Go 官方的确在不断地吸收社区的一些良好的想法和经验。


--------------------------------------------------------------------------------
/content/posts/go/go1.16-3.md:
--------------------------------------------------------------------------------
  1 | ---
  2 | title: "Go1.16 新特性：详解内存管理机制的变更，你需要了解"
  3 | date: 2021-02-11T16:13:20+08:00
  4 | images:
  5 | tags: 
  6 |   - go
  7 | ---
  8 | 
  9 | 
 10 | 大家好，我是正在学习如何蒸鱼的煎鱼。
 11 | 
 12 | 在前面 Go1.16 特性介绍的文章中我们有提到，从 v1.16 起，Go 在 Linux 下的默认内存管理策略会从`MADV_FREE` 改回 `MADV_DONTNEED` 策略。
 13 | 
 14 | 这时候可能至少分两拨小伙伴，分别是：
 15 | 
 16 | - 知道是什么，被这个问题 “折磨“ 过的，瞬间眼前一亮。
 17 | - 不知道是什么，出现了各种疑惑了，这说的都是些什么。
 18 | 
 19 | ## 灵魂拷问
 20 | 
 21 | 你有没有以下的疑问，或者是否清楚：
 22 | 
 23 | - 文中所说的 `MADV_FREE` 是什么？
 24 | - 文中所说的 `MADV_DONTNEED` 是什么？
 25 | - 为什么特指 Go 语言的 Linux 环境？
 26 | - 为什么是说从 `MADV_FREE`改回 `MADV_DONTNEED`？
 27 | 
 28 | 在今天这篇文章中我们都将进一步的展开和说明，让我们一同来了解这个改来改去的内存机制到底是何物。
 29 | 
 30 | ## madvise 爱与恨
 31 | 
 32 | 在 Linux 系统中，在 Go Runtime 中通过系统调用 `madvise(addr, length, advise)` 方法，能够告诉内核如何处理从 addr 开始的 length 字节。
 33 | 
 34 | 重点之一就是 ”如何处理“，在 Linux 下 Go 语言中目前支持两种策略，分别是：
 35 | 
 36 | - MADV_FREE：内核会在进程的页表中将这些页标记为“未分配”，从而进程的 RSS 就会变小。OS 后续可以将对应的物理页分配给其他进程。
 37 | - MADV_DONTNEED：内核只会在页表中将这些进程页面标记为可回收，在需要的时候才回收这些页面。
 38 | 
 39 | ## 所带来的影响
 40 | 
 41 | Go 语言官方恰好就在 2019 年的 Go1.12 做了如下调整。
 42 | 
 43 | - Go1.12 以前。
 44 | - Go.12-Go1.15.
 45 | 
 46 | 
 47 | ### Go1.12 以前
 48 | 
 49 | Go Runtime 在 Linux 上默认使用的是 `MADV_DONTNEED` 策略。
 50 | 
 51 | ```
 52 |   // 没有任何奇奇怪怪的判断
 53 | 	madvise(v, n, _MADV_DONTNEED)
 54 | ```
 55 | 
 56 | 从整体效果来看，进程 RSS 可以下降的比较快，但从性能效率上来看差点。
 57 | 
 58 | 
 59 | ### Go1.12-Go1.15
 60 | 
 61 | 当前 Linux 内核版本 >=4.5 时，Go Runtime 在 Linux 上默认使用了性能更为高效的 MADV_FREE 策略。
 62 | 
 63 | ```
 64 | 	var advise uint32
 65 | 	if debug.madvdontneed != 0 {
 66 | 		advise = _MADV_DONTNEED
 67 | 	} else {
 68 | 		advise = atomic.Load(&adviseUnused)
 69 | 	}
 70 | 	if errno := madvise(v, n, int32(advise)); advise == _MADV_FREE && errno != 0 {
 71 | 		// MADV_FREE was added in Linux 4.5. Fall back to MADV_DONTNEED if it is
 72 | 		// not supported.
 73 | 		atomic.Store(&adviseUnused, _MADV_DONTNEED)
 74 | 		madvise(v, n, _MADV_DONTNEED)
 75 | 	}
 76 | ```
 77 | 
 78 | 从整体效果来看，进程RSS 不会立刻下降，要等到系统有内存压力了才会释放占用，RSS 才会下降。
 79 | 
 80 | ## 带来的副作用
 81 | 
 82 | 故事往往不是那么的美好，显然在 Go1.12 起针对 `madvise` 的 `MADV_FREE` 策略的调整非常 “片面”。
 83 | 
 84 | ![来自社区小伙伴](https://static01.imgkr.com/temp/5b82f6e181bd406db94e31bca3a4b2ab.png)
 85 | 
 86 | 结合社区里所遇到的案例可得知，该次调整带来了许多问题：
 87 | - **引发用户体验的问题**：Go issues 上总是出现以为内存泄露，但其实只是未满足条件，内存没有马上释放的案例。
 88 | - **混淆统计信息和监控工具的情况**：在 Grafana 等监控上，发现容器进程内存较高，释放很慢，告警了，很慌。
 89 | - **导致与内存使用有关联的个别管理系统集成不良**：例如 Kubernetes HPA ，或者自定义了扩缩容策略这类模式，难以评估。
 90 | - **挤压同主机上的其他应用资源**：并不是所有的 Go 程序都一定独立跑在单一主机中，自然就会导致同一台主机上的其他应用受到挤压，这是难以评估的。
 91 | 
 92 | 从社区反馈来看是问题多多，弊大于利。
 93 | 
 94 | 官方本想着想着性能更好一些，但是在现实场景中引发了不少的新问题，甚至有提到和 Android 流程管理不兼容的情况。
 95 | 
 96 | 有种 “捡了芝麻，丢了西瓜” 的感觉。
 97 | 
 98 | 
 99 | ## Go1.16：峰回路转
100 | 
101 | 既然社区反馈的问题何其多，有没有人提呢？有，超级多。
102 | 
103 | 
104 | ![](https://imgkr2.cn-bj.ufileos.com/75ee9ea5-a12c-4de1-806f-eeb85f80e61f.png?UCloudPublicKey=TOKEN_8d8b72be-579a-4e83-bfd0-5f6ce1546f13&Signature=%252BqN8BOgO5kZXIUhuHy1QyxOOZ30%253D&Expires=1612673513)
105 | 
106 | 
107 | 多到提出修改回 `MADV_DONTNEED` 的 issues 仅花了 1-2 天的时间就讨论完毕。
108 | 
109 | 很快得出结论且合并 CL 关闭 issues 了。
110 | 
111 | Go1.16 修改内容如下：
112 | 
113 | ```
114 | func parsedebugvars() {
115 | 	// defaults
116 | 	debug.cgocheck = 1
117 | 	debug.invalidptr = 1
118 | 	if GOOS == "linux" {
119 | 		debug.madvdontneed = 1
120 | 	}
121 |   ...
122 | }
123 | ```
124 | 
125 | 直接指定回了 `debug.madvdontneed = 1`，简单粗暴。
126 | 
127 | ## 总结
128 | 
129 | 在本篇文章中，我们针对 Go 语言在 Linux 下的 `madvise` 方法的策略调整进行了历史介绍和说明，同时针对其调整所带来的的副作用及应对措施进行了一一介绍。
130 | 
131 | 本次变更很好的印证了，牵一发动全身的说法。大家在后续应用这块时也要多加注意。
132 | 
133 | ## 参考
134 | 
135 | - [runtime: default to MADV_DONTNEED on Linux](https://github.com/golang/go/issues/42330)
136 | - [踩坑记： go 服务内存暴涨](https://www.v2ex.com/t/666257?p=1)
137 | - [Go 1.12 关于内存释放的一个改进](https://ms2008.github.io/2019/06/30/golang-madvfree/)


--------------------------------------------------------------------------------
/content/posts/go/go1.16-mod.md:
--------------------------------------------------------------------------------
  1 | ---
  2 | title: "Go1.16 新特性：Go mod 的后悔药，仅需这一招"
  3 | date: 2021-04-05T16:00:13+08:00
  4 | images:
  5 | tags: 
  6 |   - go
  7 | ---
  8 | 
  9 | 大家好，我是煎鱼。
 10 | 
 11 | 
 12 | 前几天 Go 官方正式发布了 1.16 版本。**从这个版本起，环境变量 GO111MODULE 的默认值正式修改为 on**。
 13 | 
 14 | ![](https://imgkr2.cn-bj.ufileos.com/64ac411e-6361-4b23-b437-78123e16ae5a.png?UCloudPublicKey=TOKEN_8d8b72be-579a-4e83-bfd0-5f6ce1546f13&Signature=NWVlX2CGAsMjMs%252BJH54ZKW1s1fM%253D&Expires=1613623986)
 15 | 
 16 | 这也意味着 Go modules 将更进一步推进其业务覆盖面，有新老项目共存的小伙伴建议手动将 GO111MODULE 调整为 auto。
 17 | 
 18 | **Go1.16 针对 Go modules 放出了一个新特性，能够让维护 Go mod 库的开发者拥有反复吃 “后悔药” 的权力，提醒开发者已发布的 “脏” 版本存在问题**。
 19 | 
 20 | 这个新特性，对于许多维护和使用公共库（开源、企业等）的小伙伴简直是一个小福音，建议大家都应该要了解这个知识点。
 21 | 
 22 | 在接下来文章中将进行详细说明和介绍。
 23 | 
 24 | ## 后悔药：Go mod retract
 25 | 
 26 | Go1.16 起可以在 go.mod 文件中使用 `retract` 指令来声明该第三方模块的某些发行版本不能被其他模块使用。
 27 | 
 28 | 在使用场景上：在发现严重问题或无意发布某些版本后，模块的维护作者可以撤回该版本，支持撤回单个或多个版本。
 29 | 
 30 | 以前没有办法解决，因此一旦出现就非常麻烦。对应两者的操作如下：
 31 | 
 32 | - 维护者：
 33 |     - 删除有问题版本的 tag。
 34 |     - 重新打一个新版本的 tag。
 35 | - 使用者：
 36 |     - 发现有问题的版本 tag 丢失，需手动介入。
 37 |     - 不知道有问题，由于其他库依赖，因此被动升级而踩坑。
 38 | 
 39 | 因此在本次 Go1.16 发布后，就拥有了一个**半止损**的新手段了，也可以作为 Go mod 自动更新的大坑的补全办法之一。
 40 | 
 41 | ## 实战演练
 42 | 
 43 | 为了方便演示，首先创建一个 Demo 项目（github.com/eddycjy/go-retract-demo），其含有一个基础方法：
 44 | 
 45 | ```
 46 | package go_retract_demo
 47 | 
 48 | func HelloWorld() string {
 49 | 	return "001：脑子进煎鱼了！"
 50 | }
 51 | ```
 52 | 另外有一个应用工程依赖了该第三方库，代码如下：
 53 | 
 54 | ```
 55 | func main() {
 56 |   // import demo "github.com/eddycjy/go-retract-demo"
 57 | 	s := demo.HelloWorld()
 58 | 	fmt.Println(s)
 59 | }
 60 | ```
 61 | 
 62 | 对应的 go.mod 文件如下：
 63 | 
 64 | ```
 65 | module github.com/eddycjy/awesomeProject
 66 | 
 67 | go 1.16
 68 | 
 69 | require github.com/eddycjy/go-retract-demo v0.0.1
 70 | ```
 71 | 
 72 | ### retract 特性演示
 73 | 
 74 | 但随着时间不断推移，第三方开源库 `eddycjy/go-retract-demo` 即将迭代到 `v0.3.0` 时，发现以往的 `v0.2.0` 是有 BUG 的。
 75 | 
 76 | 需要紧急的在`v0.3.0` 版本把这个 BUG 修复并提醒出去。此时可以在 `go.mod` 文件中写入 `retract` 指令：
 77 | 
 78 | ```
 79 | module github.com/eddycjy/go-retract-demo
 80 | 
 81 | go 1.16
 82 | 
 83 | // 因为煎鱼不小心敲错了...
 84 | retract v0.2.0
 85 | ```
 86 | 指令上面为撤回的原因，后面是具体的版本。如果涉及多版本，可以如下编写：
 87 | 
 88 | ```
 89 | retract (
 90 |   v0.1.0
 91 |   v0.2.0
 92 | )
 93 | ```
 94 | 
 95 | ### retract 特性效果
 96 | 
 97 | 成功发布最新版本 `v0.3.0` 版本并指定 `retract` 后。
 98 | 所有引用了该库的工程应用，执行 `go list` 就可以看到如下提醒：
 99 | 
100 | ```
101 | $ go1.16 list -m -u all
102 | github.com/eddycjy/awesomeProject
103 | github.com/eddycjy/go-retract-demo v0.2.0 (retracted) [v0.3.0]
104 | ```
105 | 
106 | 结合该命令，我们日常使用的 IDE（例如：GoLand），其在保存时是会默认执行 `go list` 命令的。**在后续 IDE 支持后，就可以在编码时就快速发现有问题的版本和提示**。
107 | 
108 | 在手动执行 `go get` 时也会出现 `warning` 提示，会把 go.mod 文件上的原因注释显示出来：
109 | 
110 | ```
111 | $ go1.16 get github.com/eddycjy/go-retract-demo@v0.2.0
112 | go: warning: github.com/eddycjy/go-retract-demo@v0.2.0: retracted by module author: 因为煎鱼不小心敲错了...
113 | go: to switch to the latest unretracted version, run:
114 | 	go get github.com/eddycjy/go-retract-demo@latest
115 | ```
116 | 这样就能看到是哪个模块依赖，因为什么原因要求撤回了，非常直观。
117 | 
118 | ## 总结
119 | 
120 | 以往在出问题后每个个体需要跑去问维护者或者看 GitHub Commits，那样总归非常麻烦，很可能一来一回半个钟就没了。
121 | 
122 | 新特性给予了 Go modules 软撤回版本的一个方法，能够把问题更直观的反馈到开发者的手中，再结合日常开发工具的话更是美哉。
123 | 
124 | 但这个特性的完全应用目前也是有一定的阻碍的：
125 | 
126 | - ~~国内模块代理：需要国内的模块代理也支持 retract ，否则即使你更新了版本也没有提示处理~~。
127 | - IDE：IDE 针对 retract 做一些支持，例如：文字颜色标红、黄等，能够便于开发者更好的识别。
128 | 
129 | 你对 Go modules 的 retract 特性怎么看，欢迎一起留言讨论！


--------------------------------------------------------------------------------
/content/posts/go/gophercon2020-errors.md:
--------------------------------------------------------------------------------
 1 | ---
 2 | title: "重磅：Go errors 将不会有任何进一步的改进计划"
 3 | date: 2020-11-14T16:48:33+08:00
 4 | images:
 5 | tags: 
 6 |   - go
 7 | ---
 8 | 
 9 | 今天在 Gophercon2020 上，**Go 1.13 错误提案的作者事后提及他对目前错误格式化的缺失表示遗憾，而且在未来很长的好几年内都不会有任何进一步改进计划**。
10 | 
11 | 对此他本人给出的原因之一是：对于错误处理这一领域特定的问题，在他的能力范围内实在是无法给出一个令所有人都满意的方案。
12 | 
13 | 尽管如此，在他演讲的最后，还是给出了一些关于错误嵌套的建议，即实现 `fmt.Formatter`，图中给出了一个简单的例子，大家可以参考如下代码：
14 | 
15 | ```
16 | type DetailError struct {
17 | 	msg, detail string
18 | 	err         error
19 | }
20 | 
21 | func (e *DetailError) Unwrap() error { return e.err }
22 | 
23 | func (e *DetailError) Error() string {
24 | 	if e.err == nil {
25 | 		return e.msg
26 | 	}
27 | 	return e.msg + ": " + e.err.Error()
28 | }
29 | 
30 | func (e *DetailError) Format(s fmt.State, c rune) {
31 | 	if s.Flag('#') && c == 'v' {
32 | 		type nomethod DetailError
33 | 		fmt.Fprintf(s, "%#v", (*nomethod)(e))
34 | 		return
35 | 	}
36 | 	if !s.Flag('+') || c != 'v' {
37 | 		fmt.Fprintf(s, spec(s, c), e.Error())
38 | 		return
39 | 	}
40 | 	fmt.Fprintln(s, e.msg)
41 | 	if e.detail != "" {
42 | 		io.WriteString(s, "\t")
43 | 		fmt.Fprintln(s, e.detail)
44 | 	}
45 | 	if e.err != nil {
46 | 		if ferr, ok := e.err.(fmt.Formatter); ok {
47 | 			ferr.Format(s, c)
48 | 		} else {
49 | 			fmt.Fprintf(s, spec(s, c), e.err)
50 | 			io.WriteString(s, "\n")
51 | 		}
52 | 	}
53 | }
54 | 
55 | func spec(s fmt.State, c rune) string {
56 | 	buf := []byte{'%'}
57 | 	for _, f := range []int{'+', '-', '#', ' ', '0'} {
58 | 		if s.Flag(f) {
59 | 			buf = append(buf, byte(f))
60 | 		}
61 | 	}
62 | 	if w, ok := s.Width(); ok {
63 | 		buf = strconv.AppendInt(buf, int64(w), 10)
64 | 	}
65 | 	if p, ok := s.Precision(); ok {
66 | 		buf = append(buf, '.')
67 | 		buf = strconv.AppendInt(buf, int64(p), 10)
68 | 	}
69 | 	buf = append(buf, byte(c))
70 | 	return string(buf)
71 | }
72 | ```
73 | 
74 | 此处的内容来源于欧神（@changkun）在知识星球里的线上分享，作为 Go 夜读 SIG 成员的一员，借此也安利下咱们《Go 夜读》的星球，欢迎大家一起来学习和分享：
75 | 
76 | ![image](https://image.eddycjy.com/f474866fbaed634f83fa2e3228cfbec6.jpeg)
77 | 
78 | ## 讨论
79 | 
80 | Go 语言的错误处理机制一直饱受争议，前段时间在 issues 中还长期争吵过一段时间，因此还是维持了目前 `if err != nil` 的方式，也没有什么大改动。
81 | 
82 | 我们再想想，像其他语言的 `try catch` 是一定好吗？毕竟 `try catch` 的方式也有很多人不看好。抛个砖，**如果是你，你会想怎么设计 Go 语言的错误机制？或者说你觉得怎么的处理才算好**？


--------------------------------------------------------------------------------
/content/posts/go/import-cyc.md:
--------------------------------------------------------------------------------
  1 | ---
  2 | title: "为什么 Go 不支持循环引用？"
  3 | date: 2021-12-31T12:55:15+08:00
  4 | toc: true
  5 | images:
  6 | tags: 
  7 |   - go
  8 |   - 为什么
  9 | ---
 10 | 
 11 | 大家好，我是煎鱼。
 12 | 
 13 | 近年来开始学习 Go 语言的开发者越来越多了。很多小伙伴在使用时，就会遇到种种不理解的问题。
 14 | 
 15 | 其中一点就是循环引入的报错：
 16 | 
 17 | ```shell
 18 | package command-line-arguments
 19 | 	imports github.com/eddycjy/awesome-project/a
 20 | 	imports github.com/eddycjy/awesome-project/b
 21 | 	imports github.com/eddycjy/awesome-project/a: import cycle not allowed
 22 | ```
 23 | 
 24 | 为什么 Go 不支持循环引用呢，这就很不解了，难道还影响性能了？
 25 | 
 26 | 
 27 | ![图来自网络](https://files.mdnice.com/user/3610/4596a6d1-9286-40b2-8074-cc43f9bbd9f4.png)
 28 | 
 29 | 今天煎鱼将和大家一起了解背后的原因。
 30 | 
 31 | ## 案例演示
 32 | 
 33 | 做一个基本的案例 Demo，便于没接触过的同学建立初步认知。我们的程序分别有 2 个 package。
 34 | 
 35 | package a 的代码如下：
 36 | 
 37 | ```golang
 38 | import (
 39 | 	"github.com/eddycjy/awesome-project/b"
 40 | )
 41 | 
 42 | func Hello(s string) {
 43 | 	b.Print(s)
 44 | }
 45 | ```
 46 | 
 47 | package b 的代码如下：
 48 | 
 49 | ```golang
 50 | import (
 51 | 	"fmt"
 52 | 
 53 | 	"github.com/eddycjy/awesome-project/a"
 54 | )
 55 | 
 56 | func Hello() {
 57 | 	a.Hello("脑子进煎鱼了")
 58 | }
 59 | 
 60 | func Print(s string) {
 61 | 	fmt.Println(s)
 62 | }
 63 | ```
 64 | 
 65 | 再在 main.go 的文件中调用 `a.Hello("脑子进煎鱼了")` 方法。
 66 | 
 67 | 一运行，就会出现如下错误提示：
 68 | 
 69 | ```shell
 70 | package command-line-arguments
 71 | 	imports github.com/eddycjy/awesome-project/a
 72 | 	imports github.com/eddycjy/awesome-project/b
 73 | 	imports github.com/eddycjy/awesome-project/a: import cycle not allowed
 74 | ```
 75 | 
 76 | 错误的本质原因是 package a 引用了 package b，而 package b 又引用了 package a，造成了循环引用。
 77 | 
 78 | 这在 Go 语言中是明令禁止的，在编译时就会中断程序，导致编译失败。
 79 | 
 80 | ## 原因分析
 81 | 
 82 | 根据现在 Go 官方的统一意见来看，package 循环导入几乎不可能出现，即使是 Go2。
 83 | 
 84 | 因为 Go2 可能是很多核心问题的破变的关键节点，有许多人提了类似《[proposal: Go 2: allow import cycle](https://github.com/golang/go/issues/30247)》的提案，希望解决循环引入的问题。
 85 | 
 86 | Go 语言之父 Rob Pike 亲自回答了这个问题，原因如下：
 87 | 
 88 | - 没有支持循环导入，目的是迫使 Go 程序员更多地考虑程序的依赖关系。
 89 |     - 保持依赖关系图的简洁。
 90 |     - 快速的程序构建。
 91 | - 如果支持循环导入，很容易会造成懒惰、不良的依赖性管理和缓慢的构建。这是设计者不希望看见的。
 92 |     - 混乱的依赖关系。
 93 |     - 缓慢的程序构建
 94 | 
 95 | 简单拿来就，就是在 Go 工程中出现循环引用，这会对构建性能和依赖关系的解决非常不利。
 96 | 
 97 | 为此，考虑一开始就保持图的正确 DAG，认为这是一个值得预先简化的领域。导入循环可能很方便，但其实背后的代价可能是灾难性的，所以在 Go 中被明确禁止支持。
 98 | 
 99 | ## 总结
100 | 
101 | 在程序中，如果我们频繁的出现模块与模块之间的循环引用，这时候我们是不是应该考虑一下，是不是设计的有些问题，要不要考虑调整？
102 | 
103 | 但也并非所有的事都是二极管，Go 源码可能或多或少都有自己循环引用的案例，最重要的是想清楚。
104 | 
105 | **你对此支持循环引用怎么看**，欢迎在评论区留言交流：）
106 | 


--------------------------------------------------------------------------------
/content/posts/go/import-generics.md:
--------------------------------------------------------------------------------
 1 | ---
 2 | title: "长达 12 年，Go 才引入泛型，是政治，还是技术问题？"
 3 | date: 2021-12-31T12:55:25+08:00
 4 | toc: true
 5 | images:
 6 | tags: 
 7 |   - go
 8 | ---
 9 | 
10 | 大家好，我是煎鱼。
11 | 
12 | 前两天 Go1.18 beta1 已经发布，距离正式发布 Go1.18 的生产可用还有 2 个月，也就是泛型即将正式面世。
13 | 
14 | 最近正在收集泛型的一些资料，看到在 2015 年有人在 Hacker News 上的《[Go 1.5 max procs default](https://news.ycombinator.com/item?id=9622417 "Go 1.5 max procs default")》吐槽 Go 不支持泛型是 “政治” 原因...
15 | 
16 | 看了还是有些意义的，**与现在的矛盾点基本一致**，为此分享给大家。
17 | 
18 | ## 网友吐槽
19 | 
20 | 网友 @aikah 认为 Go 团队不太可能在语言中加入泛型，这显然是一个政治问题而不是技术问题。错误处理也是如此。
21 | 
22 | 和许多人一样，该网友**认为 Go 在极简主义和功能之间没有取得正确的平衡**。反对泛型的人赞成用编译时类型检查（总是安全的）换取运行时类型断言（可能失败）。
23 | 
24 | 他们拒绝承认这一事实。这就是他们反对泛型的论点，并将最终损害语言的任何潜在增长。他们基本上是在违背自己的利益。
25 | 
26 | ## 官方回复
27 | 
28 | Russ Cox 做了正式的回复：很抱歉，但不是：**泛型是一个技术问题**，不是一个政治问题。
29 | 
30 | Go 团队并**不反对泛型本身**，只是反对做那些没有被很好理解或不能很好地与 Go 配合的事情。
31 | 
32 | 这就是核心观点和矛盾点，也从 2009 年，延续到了现在。
33 | 
34 | ### 会遇到的问题
35 | 
36 | Go 团队认为要将泛型的概念融入 Go，并与系统的其他部分很好地配合，必须解决一些深层次的技术问题，而我们并没有解决这些问题的办法。
37 | 
38 | 关于这些问题，在几年前就在博客上写过一篇《[The Generic Dilemma](https://research.swtch.com/generic "The Generic Dilemma")》：
39 | 
40 | ![](https://files.mdnice.com/user/3610/8ed3923a-d5fc-482f-bb6d-6fff7a19fcaa.png)
41 | 
42 | 即使克服了那一页上的问题，也有其他问题，接下来你会遇到的问题是：”如何让程序员以一种有用的、易于解释的方式省略类型注释“。
43 | 
44 | 也就是如何更人性、更易于的表达泛型的类型参数。
45 | 
46 | #### 泛型例子
47 | 
48 | 举个例子，C++ 允许你写 `make_pair(1, "foo")`，而不是 `make_pair<int, string>(1, "foo")`。
49 | 
50 | 为了达到这种效果，推断注释背后的逻辑需要几页几页的规范，这并不是一个特别容易理解的编程模型，当事情出错时，编译器也不能轻易解释。
51 | 
52 | 在这之后肯定还有更多的新问题在这里面。
53 | 
54 | #### 和专家沟通
55 | 
56 | Go 团队和一些真正的 Java 泛型专家谈过，他们每个人都说了大致相同的话：要非常小心，它不像看起来那么容易，而且你会被你犯的所有错误困住。
57 | 
58 | 作为一个 Java 示范，可以浏览一下《[Java Generics FAQs - Frequently Asked Questions](http://www.angelikalanger.com/GenericsFAQ/JavaGenericsFAQ.html "Java Generics FAQs - Frequently Asked Questions")》的大部分内容：
59 | 
60 | ![](https://files.mdnice.com/user/3610/6e188c16-f31c-4d6b-9d1b-216aa702d548.png)
61 | 
62 | 看看过了多久你会开始思考 "这真的是最好的方法吗？"。
63 | 
64 | 在泛型过程中会遇到许多问题，像是《[How do I decrypt Enum<E extends Enum<E>>](http://www.angelikalanger.com/GenericsFAQ/FAQSections/TypeParameters.html#FAQ106" "How do I decrypt Enum<E extends Enum<E>>")》：
65 | 
66 | ![](https://files.mdnice.com/user/3610/2cbd8083-cee6-48f7-a0bd-d6faf8d27c40.png)
67 | 
68 | 为此，Go 团队在泛型的推动上非常谨慎。
69 |   
70 | ## 承认缺点
71 | 
72 | Go 团队说得很清楚，承认这个事实：**没有泛型是有一定的缺点的**。
73 |   
74 | 你要么使用 `interface{}` 而放弃编译时检查，要么写代码生成器而使你的构建过程复杂化。
75 | 
76 | 现有语言中实现的泛型也有明确的缺点，而且今天不妥协有一个非常大的好处：它使明天**采用更好的解决方案变得更加容易**。
77 | 
78 | ## 总结
79 |   
80 | 今天给大家分享了过去在国外社区针对 Go 泛型的各种争议和探讨，其实泛型的核心观点很明确：”Go 团队不反对泛型本身“。
81 |   
82 | 一直没能把泛型做起来，也是因为顾虑很多，做泛型要和 Go 多个部分，要解决很多深层次的问题，还要解决类型参数可读性等问题。所以一直拖到了现在。
83 |   
84 | 回到即将 2022 年的现在，都预言对了。社区都在扯做泛型后的多个关联组件，以及泛型可读性和结构...
85 | 
86 | 显然，**泛型就是双刃剑？你怎么看**。


--------------------------------------------------------------------------------
/content/posts/go/map-con.md:
--------------------------------------------------------------------------------
 1 | ---
 2 | title: "Go 为什么不在语言层面支持 map 并发？"
 3 | date: 2022-02-05T15:55:22+08:00
 4 | toc: true
 5 | images:
 6 | tags: 
 7 |   - go
 8 | ---
 9 | 
10 | 大家好，我是煎鱼。
11 | 
12 | 很多小伙伴学习 Go 语言的语法时，可能只是轻轻地看到过这个问题，结果一旦上手，多多少少一个组内总会碰到过几次。
13 | 
14 | 甚至会发现有一定年限的程序员也会遇到。有小伙伴疑惑了，这么折腾，为什么 Go 不直接在语言层面就支持 map 并发，那得有多香？
15 | 
16 | ## 为什么原生不支持
17 | 
18 | 凭什么 Go 官方还不支持，难不成太复杂了，性能太差了，到底是为什么？
19 | 
20 | 官方答复原因如下（via @go faq）：
21 | 
22 | - 典型使用场景：map 的典型使用场景是不需要从多个 goroutine 中进行安全访问。
23 | - 非典型场景（需要原子操作）：map 可能是一些更大的数据结构或已经同步的计算的一部分。
24 | - 性能场景考虑：若是只是为少数程序增加安全性，导致 map 所有的操作都要处理 mutex，将会降低大多数程序的性能。
25 | 
26 | 核心来讲就是：Go 团队在经过了长时间的讨论后，认为原生 map 更应适配典型使用场景。
27 | 
28 | 如果为了小部分情况，将**会导致大部分程序付出性能代价**，决定了不支持原生的并发 map 读写。且在 Go1.6 起，**增加了检测机制**，并发的话会导致异常。
29 | 
30 | ## 为什么要崩溃
31 | 
32 | 前面有提到一点，在 Go1.6 起会进行原生 map 的并发检测，这是一些人的 “噩梦”。
33 | 
34 | 在此有人吐槽到：“明明给我抛个错就好了，凭什么要让我的 Go 进程直接崩溃掉，分分钟给我背个 P0”。
35 | 
36 | ### 场景枚举
37 | 
38 | 这里我们假设一下，如果并发读写 map 是以下两种场景：
39 | 
40 | 1. 产生 panic：程序 panic -> 默认走进 recover -> 没有对并发 map 进行处理 -> map 存在脏数据 -> 程序使用脏数据 -> 产生**未知((影响。
41 | 2. 产生 crash：程序 crash -> 直接崩溃 -> 保全数据（数据正常）-> 产生**明确((风险。
42 | 
43 | 你会选择哪一种方案呢？Go 官方在两者的风险衡量中选择了第二种。
44 | 
45 | 无论是编程，还是人生。如何在随机性中掌握确定性的部分，也是一门极大的哲学了。
46 | 
47 | ### let it crash
48 | 
49 | Go 官方团队选择的方式是业内经典的 “let it crash” 行为，很多编程语言中，都会将其奉行为设计哲学。
50 | 
51 | **let it crash 是指工程师不必过分担心未知的错误，而去进行面面俱到的防御性编码**。
52 | 
53 | 这块理念最经典的就是 erlang 了。
54 | 
55 | ## 总结
56 | 
57 | 在今天这篇文章中，我们介绍了 Go 语言为什么不支持原生支持 map 并发，核心原因是大部分场景都不需要，从性能考虑上做的考虑。
58 | 
59 | 直接让并发读写 map 的原因，是从 “let it crash” 去考虑。这块如果你想在自己的工程中避免这个情况，可以在 linter 等工具链加入竞态检测（-race），也可以避免这类风险。
60 | 
61 | 你觉得 Go 这块的设计考虑怎么样呢？欢迎在评论区留言和交流：）


--------------------------------------------------------------------------------
/content/posts/go/map-reset.md:
--------------------------------------------------------------------------------
  1 | ---
  2 | title: "Go map 如何缩容？"
  3 | date: 2021-12-31T12:55:07+08:00
  4 | toc: true
  5 | images:
  6 | tags: 
  7 |   - go
  8 |   - 面试题
  9 | ---
 10 | 
 11 | 大家好，我是煎鱼。
 12 | 
 13 | 前几天看到 Go 圈子的著名股神（不是我...），在归类中简单的提到了 Go 语言中 map 的缩容的描述，这让我对其产生了兴趣，想要来一探究竟。
 14 | 
 15 | 我们常常喊扩缩容，扩缩容，但社区里都是清一色分析扩容机制，Go 面试官也都是卷 Go 语言 map 的扩容机制...
 16 | 
 17 | 在 **Go 语言中的 map 缩容机制是怎么做的**呢，今天就由煎鱼带大家一起研讨围观一轮。
 18 | 
 19 | ## 基本分析
 20 | 
 21 | 在 Go 底层源码 src/runtime/map.go 中，扩缩容的处理方法是 grow 为前缀的方法来处理的。
 22 | 
 23 | 其中扩缩容涉及到的是插入元素的操作，对应 mapassign 方法：
 24 | 
 25 | ```golang
 26 | func mapassign(t *maptype, h *hmap, key unsafe.Pointer) unsafe.Pointer {
 27 |   ...
 28 | 	if !h.growing() && (overLoadFactor(h.count+1, h.B) || tooManyOverflowBuckets(h.noverflow, h.B)) {
 29 | 		hashGrow(t, h)
 30 | 		goto again
 31 | 	}
 32 |   ...
 33 | }
 34 | 
 35 | func (h *hmap) growing() bool {
 36 | 	return h.oldbuckets != nil
 37 | }
 38 | 
 39 | func overLoadFactor(count int, B uint8) bool {
 40 | 	return count > bucketCnt && uintptr(count) > loadFactorNum*(bucketShift(B)/loadFactorDen)
 41 | }
 42 | 
 43 | func tooManyOverflowBuckets(noverflow uint16, B uint8) bool {
 44 | 	if B > 15 {
 45 | 		B = 15
 46 | 	}
 47 |   
 48 | 	return noverflow >= uint16(1)<<(B&15)
 49 | }
 50 | ```
 51 | 
 52 | 核心看到针对扩缩容的判断逻辑：
 53 | - 当前没有在扩容：条件为 oldbuckets 不为 nil。
 54 | - 是否可以进行扩容：条件为 `hmap.count`> hash 桶数量 `(2^B)*6.5`。其中 `hmap.count` 指的是map 的数据数目， `2^B` 仅指 hash 数组的大小，不包含溢出桶。
 55 | - 是否可以进行缩容：条件为溢出桶（noverflow）的数量 >= 32768（1<<15）。
 56 | 
 57 | 而我们可以关注到，无论是扩容还是缩容，其都是由 `hashGrow` 方法进行处理：
 58 | 
 59 | ```golang
 60 | func hashGrow(t *maptype, h *hmap) {
 61 | 	bigger := uint8(1)
 62 | 	if !overLoadFactor(h.count+1, h.B) {
 63 | 		bigger = 0
 64 | 		h.flags |= sameSizeGrow
 65 | 	}
 66 |   ...
 67 | }
 68 | ```
 69 | 
 70 | 若是扩容，则 bigger 为 1，也就是 B+1。代表 hash 表容量扩大 1 倍。不满足就是缩容，也就是 hash 表容量不变。
 71 | 
 72 | 可以得出结论：map 的**扩缩容的主要区别在于 hmap.B 的容量大小改变**。而缩容由于 hmap.B 压根没变，内存空间的占用也是没有变化的。
 73 | 
 74 | ## 带来的隐患
 75 | 
 76 | 这种方式其实是存在运行隐患的，也就是**导致在删除元素时，并不会释放内存，使得分配的总内存不断增加**。如果一个不小心，拿 map 来做大 key/value 的存储，也不注意管理，很容易就内存爆了。
 77 | 
 78 | 也就是 Go 语言的 map 目前实现的是 ”伪缩容“，仅针对溢出桶过多的情况。若是触发缩容，hash 数组的占用的内存大小不变。
 79 | 
 80 | 若要实现 ”真缩容“，Go Contributor @josharian 表示目前**唯一可用的解决方法是：创建一个新的 map 并从旧的 map 中复制元素**。
 81 | 
 82 | 示例如下：
 83 | 
 84 | ```golang
 85 | old := make(map[int]int, 9999999)
 86 | new := make(map[int]int, len(old))
 87 | for k, v := range old {
 88 |     new[k] = v
 89 | }
 90 | old = new
 91 | ...
 92 | ```
 93 | 
 94 | 无比的像，复制粘贴，大的往小的挪动，再删掉大的就可以了。
 95 | 
 96 | 果然程序员的解决方案都是相似的。
 97 | 
 98 | ## 为什么不支持
 99 | 
100 | 下述内容会主要基于如下两个 issues 和 proposal 来分析：
101 | 1. 《[runtime: shrink map as elements are deleted](https://github.com/golang/go/issues/20135 "runtime: shrink map as elements are deleted")》
102 | 2. 《[proposal: runtime: add way to clear and reuse a map's working storage](https://github.com/golang/go/issues/45328 "proposal: runtime: add way to clear and reuse a map's working storage")》
103 | 
104 | 目前 map 的缩容处理起来比较棘手，最早的 issues 是 2016 年提出的，也有人提过一些提案，但都因为种种原因被拒绝了。
105 | 
106 | 简单来讲，就是没有找到一个很好的方法实现，存在明确的实现成本问题，没法很方便的 ”告诉“ Go 运行时，我要：
107 | 1. 记得保留存储空间，我要立即重用 map。
108 | 2. 赶紧释放存储空间，map 从现在开始会小很多。
109 | 
110 | 抽象来看症结是：**需要保证增长结果在下一个开始之前完成**，此处的增长指的是 ”从小到大，从一个大小到相同大小，从大到小“ 的复杂过程。
111 | 
112 | 这属于一个多重 case，从而导致也就一直拖着，慢慢想。
113 | 
114 | ## 总结
115 | 
116 | Go 语言中 map 的扩容机制是大家经常思考和学习的，但是缩容方面现在也是一个大 ”坑“。虽然不误用就没问题。
117 | 
118 | 但是一旦新同学来了，不知道，一塞，就会出问题。我有一个朋友，之前面试时，就听闻有人会塞几个 GB 的数据进 map，可想而知还是很危险的。
119 | 
120 | 现有 map 的缩容机制，是存在短板的，背后有着比较多重的纠结，不知道你**有没有什么好的建议或想法呢，欢迎大家一起来讨论**！


--------------------------------------------------------------------------------
/content/posts/go/news-slices-maps.md:
--------------------------------------------------------------------------------
  1 | ---
  2 | title: "Go 提案：增加泛型版 slices 和 maps 新包"
  3 | date: 2021-12-31T12:54:57+08:00
  4 | toc: true
  5 | images:
  6 | tags: 
  7 |   - go
  8 | ---
  9 | 
 10 | 大家好，我是煎鱼。
 11 | 
 12 | 现在是 2021 年 8 月份了，根据 Go 语言发布周期的 2，8 原则。Go 1.17 即将发布，在写这篇文章时，现在已经进行到了 rc2：
 13 | 
 14 | ![](https://files.mdnice.com/user/3610/ced4caa3-98ac-4c8a-8077-c72e11f69b56.png)
 15 | 
 16 | 这意味着离 Go1.18 释出泛型的正式支持又近了一点点，社区中讨论泛型相关的周边功能的声音又多了起来。
 17 | 
 18 | 今天要讨论的泛型版功能支持也是如此，分别包含：map（#47330）、slice（#45955）、container/set（#47331） 三种通用类型的支持。
 19 | 
 20 | 我们主要展开 maps 和 slices，其余的都大同小异，理解核心思想就好。
 21 | 
 22 | ## maps
 23 | 
 24 | 该提案建议定义一个新的包 maps，它将提供可用于任何类型的 map 的函数：
 25 | 
 26 | ![](https://files.mdnice.com/user/3610/fc067e0f-0972-4f92-898e-d64404b5bfa4.png)
 27 | 
 28 | 下面的描述侧重于描述 API 的提供：
 29 | 
 30 | ```golang
 31 | package maps
 32 | 
 33 | func Keys[K comparable, V any](m map[K]V) []K
 34 | 
 35 | func Values[K comparable, V any](m map[K]V) []V
 36 | 
 37 | func Equal[K, V comparable](m1, m2 map[K]V) bool
 38 | 
 39 | func EqualFunc[K comparable, V1, V2 any](m1 map[K]V1, m2 map[K]V2, cmp func(V1, V2) bool) bool
 40 | 
 41 | func Clear[K comparable, V any](m map[K]V)
 42 | 
 43 | func Clone[K comparable, V any](m map[K]V) map[K]V
 44 | 
 45 | func Add[K comparable, V any](dst, src map[K]V)
 46 | 
 47 | func Filter[K comparable, V any](m map[K]V, keep func(K, V) bool)
 48 | ```
 49 | - Keys：返回 map 的键值。这些键将是一个不确定的顺序。
 50 | - Values：返回 map 值。这些值将以不确定的顺序出现。
 51 | - Equal：匹配两个 map 是否包含相同的键/值对。
 52 | - EqualFunc：EqualFunc 与 Equal 类似，但使用 cmp 进行数值比较。
 53 | - Clear：从 map 中清除所有条目，使其为空。
 54 | - Clone：返回一个 map 的副本，这是一个浅层克隆。新的键和值使用普通的赋值来设置。
 55 | - Add：将 src 中的所有键/值对添加到 dst 中。当 src 中的一个键已经存在于 dst 中时，dst 中的值将被 src 中的键相关的值覆盖。
 56 | - Filter：过滤器从 map 中删除任何 keep 返回结果为 false 的键/值对。
 57 | 
 58 | ## slice
 59 | 
 60 | 该提案建议定义一个新的包 slices，它将提供可用于任何类型的 slice 的函数：
 61 | 
 62 | ![](https://files.mdnice.com/user/3610/8086fdea-63ee-4c73-aa4b-95b3c647d8e6.png)
 63 | 
 64 | 下面的描述侧重于描述 API 的提供：
 65 | 
 66 | ```golang
 67 | package slices
 68 | 
 69 | import "constraint"
 70 | 
 71 | func Equal[T comparable](s1, s2 []T) bool
 72 | 
 73 | func EqualFunc[T1, T2 any](s1 []T1, s2 []T2, eq func(T1, T2) bool) bool
 74 | 
 75 | func Compare[T constraints.Ordered](s1, s2 []T) int
 76 | 
 77 | func CompareFunc[T any](s1, s2 []T, cmp func(T, T) int) int
 78 | 
 79 | func Index[T comparable](s []T, v T) int
 80 | 
 81 | func IndexFunc[T any](s []T, f func(T) bool) int
 82 | 
 83 | func Contains[T comparable](s []T, v T) bool
 84 | 
 85 | func Insert[S constraints.Slice[T], T any](s S, i int, v ...T) S
 86 | 
 87 | func Delete[S constraints.Slice[T], T any](s S, i, j int) S
 88 | 
 89 | func Clone[S constraints.Slice[T], T any](s S) S
 90 | ```
 91 | - Equal：检查两个切片是否相等，以长度和元素值来比较。
 92 | - EqualFunc：检查两个切片是否相等，以所传入的匹配函数来比较。
 93 | - Compare/CompareFunc：
 94 |     - Compare 比较两个切片 s1 和 s2 的元素。
 95 |     - CompareFunc 与 Compare 类似，在每一对元素上使用所传入的比较函数。
 96 | - Index：
 97 |     - Index 返回值 v 在切片 s 中第一次出现的索引，如果不存在，则返回-1。
 98 |     - IndexFunc 返回满足f(c)的第一个元素在s中的索引，如果没有则返回-1。
 99 | - Contains：检查值 v 是否存在于切片 s 中。
100 | 
101 | 插入、删除、克隆的 API 比较常见，这里我就不展开了。在通用类型的切片有一些比较特殊的 API：
102 | 
103 | ```golang
104 | func Compact[S constraints.Slice[T], T comparable](s S) S
105 | 
106 | func CompactFunc[S constraints.Slice[T], T any](s S, cmp func(T, T) bool) S
107 | 
108 | func Grow[S constraints.Slice[T], T any](s S, n int) S
109 | 
110 | func Clip[S constraints.Slice[T], T any](s S) S
111 | ```
112 | - Compact/CompactFunc：
113 |     - Compact 将连续运行的相等元素替换为单一的副本。这就像 Unix 中的 uniq 命令。会直接修改切片 s 的内容，不会重新创建一个。
114 |     - CompactFunc 与 Compact 方法类似，但是使用一个比较函数来匹配。
115 | - Grow：如果有必要，Grow 会增长切片的容量，以保证另外 n 个元素的空间。在 Grow(n) 之后，至少有 n 个元素可以被添加到分片中而不需要再分配。如果 n 是负数或者太大，无法分配内存，Grow 将陷入恐慌。
116 | - Clip：从切片中移除未使用的容量，返回s[:len(s):len(s)]。
117 | 
118 | ## 总结
119 | 
120 | 如果这些提议被接受，这几个新包将被包含在实现泛型后的第一个Go版本中（我们目前预计将是Go 1.18）。
121 | 
122 | 从 issues 的讨论来看，通用类型的新包支持很大概率会实现，主要争议在实现细节，例如：性能、命名、规范等。
123 | 
124 | 实现后值得期待，又是一次生产力的优化！


--------------------------------------------------------------------------------
/content/posts/go/nil-func.md:
--------------------------------------------------------------------------------
 1 | ---
 2 | title: "Go 读者提问：值为 nil 也能调用函数，太神奇了吧？"
 3 | date: 2021-12-31T12:55:27+08:00
 4 | toc: true
 5 | images:
 6 | tags: 
 7 |   - go
 8 | ---
 9 | 
10 | 大家好，我是煎鱼。
11 | 
12 | 最近在我们 Go 的技术交流群里，有一个小伙伴提了一个程序方面的问题，还挺有意思的，分享给大家。
13 | 
14 | ![](https://files.mdnice.com/user/3610/0774f643-81a2-4458-b557-05c81a9572ef.png)
15 | 
16 | ## 示例
17 | 
18 | 示例程序如下：
19 | 
20 | ```golang
21 | type T struct{}
22 | 
23 | func (t *T) Hello() string {
24 | 	if t == nil {
25 | 		fmt.Println("脑子进煎鱼了")
26 | 		return ""
27 | 	}
28 | 
29 | 	return "煎鱼进脑子了"
30 | }
31 | 
32 | func main() {
33 | 	var t *T
34 | 	t.Hello()
35 | ```
36 | 
37 | 这段程序的运行结果是什么？
38 | 
39 | 从程序的分析来看，变量 `t` 并没有初始化，只是声明了类型。然后就直接调用了 `Hello` 方法，像是 nil 调用函数，理论上应该出现恐慌（panic）。
40 | 
41 | 运行结果是：
42 | 
43 | ```
44 | panic: runtime error: invalid memory address or nil pointer dereference
45 | ```
46 | 
47 | 对不对呢？
48 | 
49 | 显然，真正的运行结果是：
50 | 
51 | ```
52 | 脑子进煎鱼了
53 | ```
54 | 
55 | 请你思考一下，想想这是为什么？
56 | 
57 | ## 为什么
58 | 
59 | 问题的原因是：很多小伙伴认为变量 `t` 的值都是 nil 了，不应该还能调用到才对。
60 | 
61 | 更抽象化来讲，就是 ”程序是如何检查对象指针来寻找和调度所需函数“。
62 | 
63 | 实际上，在 Go 中，表达式 `Expression.Name` 的语法，所调用的函数完全由 `Expression` 的类型决定。
64 | 
65 | 其调用函数的指向不是由该表达式的特定运行时值来决定，包括我们前面所提到的 nil。
66 | 
67 | 具体如下：
68 | 
69 | ```golang
70 | func (p *Sometype) Somemethod (firstArg int) {}
71 | ```
72 | 
73 | 本质上是：
74 | 
75 | ```golang
76 | func SometypeSomemethod(p *Sometype, firstArg int) {}
77 | ```
78 | 
79 | 这么一看，其实大家应该都明白了。
80 | 
81 | 上述入参 `p *Sometype` 是有具体上下文类型的，自然而然也就能调用到相应的方法。如果是没有任何上下文类型的，例如：`nil.Somemethod` 方法来调用，那肯定就是无法运行的。
82 | 
83 | 与值是不是 nil，是什么，没有太多直接的影响。只要有预期类型的上下文就可以了。
84 | 
85 | ## 总结
86 | 
87 | 今天给大家分享了一个 Go 语言里面的一个小细节，平时可能很多人没注意到，毕竟 IDE 也会标黄，会避开这个问题点。
88 | 
89 | 在理解 Go 的设计和思考上，我们是需要清晰其背后的原因和逻辑的，也就是类型决定其调用，而不是值（容易误判）。
90 | 
91 | 你有没有遇到过其它的细节问题呢，欢迎交流：）


--------------------------------------------------------------------------------
/content/posts/go/runtimepark.md:
--------------------------------------------------------------------------------
 1 | ---
 2 | title: "Goroutine 一泄露就看到他，这是个什么？"
 3 | date: 2021-12-31T12:55:01+08:00
 4 | toc: true
 5 | images:
 6 | tags: 
 7 |   - go
 8 | ---
 9 | 
10 | 大家好，我是煎鱼。
11 | 
12 | 作为一个 Go 语言的使用大户，常常就有人冷不丁的，一下就泄露了...泄露了啥？
13 | 
14 | 表象来看当然是 goroutine 泄露了，这时候就会有小伙伴开始跑去拉取 PProf。就会看到类似下面这张图：
15 | 
16 | ![](https://files.mdnice.com/user/3610/78c8dadf-4f5c-4dfe-be36-d39bfa9d13d3.png)
17 | 
18 | 重点会看到 `runtime.gopark` 这个函数，在所有的 goroutine 泄露中都会看到有，并且都会是大头。
19 | 
20 | 既然是大头，也就会有许多朋友以为他是泄漏点，在那一顿猛查，那这个函数到底是什么，作用是？ 
21 | 
22 | ## runtime.gopark 是何物
23 | 
24 | 想要知道 `runtime.gopark` 函数是作用，最快的办法就是看源码了。其实现细节在 src/runtime/proc.go 文件中。
25 | 
26 | 源代码如下：
27 | 
28 | ```golang
29 | func gopark(unlockf func(*g, unsafe.Pointer) bool, lock unsafe.Pointer, reason waitReason, traceEv byte, traceskip int) {
30 | 	mp := acquirem()
31 | 	gp := mp.curg
32 | 	status := readgstatus(gp)
33 | 	mp.waitlock = lock
34 | 	mp.waitunlockf = unlockf
35 | 	gp.waitreason = reason
36 | 	mp.waittraceev = traceEv
37 | 	mp.waittraceskip = traceskip
38 | 	releasem(mp)
39 | 	
40 | 	mcall(park_m)
41 | }
42 | ```
43 | 
44 | 该函数主要作用有三大点：
45 | - 调用 `acquirem` 函数：
46 |     - 获取当前 goroutine 所绑定的 m，设置各类所需数据。
47 |     - 调用 `releasem` 函数**将当前 goroutine 和其 m 的绑定关系解除**。
48 | - 调用 `park_m` 函数：
49 |     - 将当前 goroutine 的状态从 `_Grunning` 切换为 `_Gwaiting`，也就是等待状态。
50 |     - 删除 m 和当前 goroutine m->curg（简称gp）之间的关联。
51 | - 调用 `mcall` 函数，仅会在需要进行 goroutiine 切换时会被调用：
52 |     - 切换当前线程的堆栈，从 g 的堆栈切换到 g0 的堆栈并调用 fn(g) 函数。
53 |     - 将 g 的当前 PC/SP 保存在 g->sched 中，以便后续调用 goready 函数时可以恢复运行现场。
54 | 
55 | 熟读了其源码后，我们可得知该函数的关键作用就是**将当前的 goroutine 放入等待状态**，这意味着 goroutine 被暂时被搁置了，也就是被运行时调度器暂停了。
56 | 
57 | ## 缘由
58 | 
59 | 回到最初的问题，之所以 goroutine 泄露，你就会看到大量的 `runtime.gopark` 函数，这是因为 goroutine 泄露一般不会单单只是一个 goroutine，肯定是会有多个的。
60 | 
61 | 同时这些 goroutine 在调用了 `runtime.gopark` 函数后都被暂停了，也就是进入休眠状态，自然而然也就停留在此。
62 | 
63 | 直至满足条件后再被 `runtime.goready` 函数唤醒，该函数会将已准备就绪的 goroutine 切换状态，再加入运行队列，等待调度器的新一轮调度。
64 | 
65 | ## 思考
66 | 
67 | 前几天就有读者在我的 Go 读者群中咨询了下述问题，也和  `runtime.gopark` 函数有关。问题如下：
68 | 
69 | ![](https://files.mdnice.com/user/3610/eb5d0483-8193-4adf-881e-490825d137fe.png)
70 | 
71 | 经过上述的分析，显然 `runtime.gopark` 不是 goroutine 的一种状态，导致 goroutine 状态变更只是他的执行过程中所涉及到，产生的一个结果。
72 | 
73 | 而 goroutine 的状态一共有 9 种，有兴趣的小伙伴可以了解。如下：
74 | 
75 | 状态  | 含义
76 | ---|---| ---
77 | _Gidle  | 刚刚被分配，还没有进行初始化。
78 | _Grunnable  | 已经在运行队列中，还没有执行用户代码。
79 | _Grunning | 不在运行队列里中，已经可以执行用户代码，此时已经分配了 M 和 P。
80 | _Gsyscall | 正在执行系统调用，此时分配了 M。
81 | _Gwaiting | 在运行时被阻止，没有执行用户代码，也不在运行队列中，此时它正在某处阻塞等待中。
82 | _Gmoribund_unused | 尚未使用，但是在 gdb 中进行了硬编码。
83 | _Gdead | 尚未使用，这个状态可能是刚退出或是刚被初始化，此时它并没有执行用户代码，有可能有也有可能没有分配堆栈。
84 | _Genqueue_unused | 尚未使用。
85 | _Gcopystack | 正在复制堆栈，并没有执行用户代码，也不在运行队列中。
86 | 
87 | ## 总结
88 | 
89 | 在今天这篇文章中，我们介绍了大家最常碰到的 goroutine 泄露，而在泄露后最关心的 `runtime.gopark` 函数的意义，我们从源码再到作用进行了一轮剖析。
90 | 
91 | 下次如果再有人问你 `runtime.gopark` 是干嘛用的，就可以愉快的把这篇文章甩给他，分享你的知识啦 ：）


--------------------------------------------------------------------------------
/content/posts/go/rust-php.md:
--------------------------------------------------------------------------------
 1 | ---
 2 | title: "Rust 内讧，PHP 主力淡出？Go：好好放假"
 3 | date: 2021-12-31T12:55:20+08:00
 4 | toc: true
 5 | images:
 6 | tags: 
 7 |   - go
 8 | ---
 9 | 
10 | 大家好，我是煎鱼。
11 | 
12 | 现在已经是 2021 年的 Q4 季度了，许多职场人都忙的飞起，被 PPT 各种轰炸。
13 | 
14 | 在上周，看到几门语言的社区都发生了一些大事，煎鱼表示大受震撼，来说几句我的看法。
15 | 
16 | ## PHP 主力淡出
17 | 
18 | 在 11 月 23 日，看到 PHP 的主力开发 [Nikita Popov](https://twitter.com/nikita_ppv "Nikita Popov") 在论坛上发文宣布将**不再以专业身份从事 PHP 工作**，投入到 PHP 开发中的时间将会大幅度减少。
19 | 
20 | ![](https://files.mdnice.com/user/3610/82ba0eaf-fa69-4bee-9cbc-ec385d3b9793.png)
21 | 
22 | 根据 Jetbrains 分享的消息来看，可得知 Nikita Popov 在高中（2011 年）时就开始参与 PHP 开发，截止现在已有 10 年经验了。
23 | 
24 | ![](https://files.mdnice.com/user/3610/93d9d4c9-9863-42fe-9d2c-f5ada62210c2.png)
25 | 
26 | 他离开的原因，我看了一遍帖子，众说纷纭，业内猜测有以下两个观点：
27 | - 迫于生活压力，过多精力投入维护开源项目收入不高。
28 | - PHP 新版本特性受阻等原因，把精力从 PHP 转到 LLVM。
29 | 
30 | 也因此，PHP 社区加速宣布成立 PHP 基金会《[The New Life of PHP – The PHP Foundation](https://blog.jetbrains.com/phpstorm/2021/11/the-php-foundation/ "The New Life of PHP – The PHP Foundation")》。基金会所募集的资金，将会用于资助开发者在 PHP 上工作。
31 | 
32 | 基金会的宣发上，讲的很清楚，为的就是**避免再发生失去 PHP 的主要贡献者**的事情发生，这影响是非常之巨大的。
33 | 
34 | 果然，面包和理想，还是要有权衡，Typora 都开始收费了。
35 | 
36 | ## Rust 社区内讧
37 | 
38 | 在 11 月 22 日，Rust 社区的审核团队集体辞职（Moderation Team Resignation），立即生效。宣布用的 pr 如下图：
39 | 
40 | ![](https://files.mdnice.com/user/3610/a4359504-a128-43e1-9b36-b855307b8825.png)
41 | 
42 | 团队辞职的原因是：**为了抗议 Rust 核心团队将自己置于对任何人都不负责任的地位，只对自己负责**。
43 | 
44 | 一时间，吃瓜众说纷纭。但没有人再给出官方解释了。业内猜测有以下两个观点：
45 | - 在 Rust 运作上：认为与亚马逊正在试图侵蚀 Rust 有关。包括：雇佣了语言团队、编译器团队负责人等。
46 | - 在 Rust 基金会上：亚马逊决定不设立 Rust 基金会 ED，主席将在 Rust 基金会中拥有巨大的权力。
47 | 
48 | 截止 11 月 27 号，这件事感觉已经见不到 “真相” 了。因为 [pr](https://github.com/rust-lang/team/pull/671 "pr") 和 [reddit](https://www.reddit.com/r/rust/comments/qzme1z/moderation_team_resignation/ "reddit") 上的讨论帖均已锁定，没有正式回复。
49 | 
50 | 总感觉有种黑幕的感觉？
51 | 
52 | ## 总结
53 | 
54 | 看了这两起社区重大异常后，再对比看 Go 社区，似乎又比较的温和。毕竟 Go 一开始的诞生，就来源于 Google 大佬们在职期间对既有使用语言的不满。
55 | 
56 | 这么多年了，他们也一直没有离职。Google 也提供了不少的时间和资金给 Go 核心团队做宣传和维护社区，相对安全，还**能定期休假 2 周**（静默期），真是太羡慕了。
57 | 
58 | 但在反面来看，也有很多人嫌弃 Go 背后的靠山是 Google，你怎么看呢？
59 | 
60 | 欢迎在评论区留言和交流：）


--------------------------------------------------------------------------------
/content/posts/go/site-history.md:
--------------------------------------------------------------------------------
 1 | ---
 2 | title: "分久必合，golang.org 将成为历史！"
 3 | date: 2021-12-31T12:55:03+08:00
 4 | toc: true
 5 | images:
 6 | tags: 
 7 |   - go
 8 | ---
 9 | 
10 | 大家好，我是煎鱼。
11 | 
12 | 这两天看到官方博客的《[Tidying up the Go web experience](https://go.dev/blog/tidy-web "Tidying up the Go web experience")》，已经明确了优化 Go 站点的计划和安排了，为此今天和大家分享这一个好消息。
13 | 
14 | 在之前 Go 官方推出了新的站点 go.dev，一个新的 Go 开发者中心：
15 | 
16 | ![go.dev](https://files.mdnice.com/user/3610/c70f1330-64da-4b65-8988-f9dbe6b1df05.png)
17 | 
18 | 以及提供给开发者查询 Go 包（package）和模块（module）信息的配套网站 pkg.go.dev：
19 | 
20 | ![pkg.go.dev](https://files.mdnice.com/user/3610/41df22df-78e2-4b15-83d7-c8e38fcaba54.png)
21 | 
22 | 看上去似乎美好，但其实原有的 golang.org 在继续提供 Go 发行版下载、文档和标准库的软件包的资料。
23 | 
24 | 而其他 Go 网站，例如：blog.golang.org、play.golang.org、talks.golang.org 以及tour.golang.org，又都拥有额外的 Go 资料。这一切都有些零散和混乱。
25 | 
26 | 在软件发展来讲，这种被称之为 ”绞杀者“ 模式：
27 | 
28 | ![图来自网络](https://files.mdnice.com/user/3610/4645e874-771a-452a-b4ba-e41d8ffe5673.png)
29 | 
30 | 也就是旧系统不断地被新系统取代，在两边都还存在流量时，会保持两边的运行。随着时间的推移，新系统不断地取代老系统，最终完全取代。
31 | 
32 | Go 官方**计划在接下来的一两个月里，将把 golang.org 网站合并成一个统一的网站**，也就是在 go.dev 上。
33 | 
34 | 所有的现有 URL（例如：Go 标准库、Go 博客等）都会重定向到新的 URL 地址中，不会出现破坏性修改（无法访问），一切按计划都是兼容的。
35 | 
36 | 
37 | ![](https://files.mdnice.com/user/3610/0708fcf4-90b2-4451-8a3d-5bf5ce2a1dfa.png)
38 | 
39 | 
40 | 咱们将会有一个更统一的 Go 网站，部分 Go 初学者也不再需要辛辛苦苦再翻山倒海先找个天梯了，因为是**可以直接访问的**，这是一种利好！
41 | 
42 | 不得不感叹语句，Russ Cox 推动事情的能力真是杠杠的，虽然也会引来不少争议和讨论，但我们依然可以从中学习到好的部分！
43 | 
44 | 大家**有没有什么也想让 Go 团队优化的呢，欢迎在评论区交流和讨论**！


--------------------------------------------------------------------------------
/content/posts/go/slice-leak.md:
--------------------------------------------------------------------------------
  1 | ---
  2 | title: "Go 切片导致内存泄露，被坑两次了！"
  3 | date: 2021-12-31T12:55:09+08:00
  4 | toc: true
  5 | images:
  6 | tags: 
  7 |   - go
  8 | ---
  9 | 
 10 | 大家好，我是煎鱼。
 11 | 
 12 | 前段时间在我的 Go 读者群里，有小伙伴们在纠结切片（slice）的问题，我写了这篇《[Go 切片这道题，吵了一个下午！](https://mp.weixin.qq.com/s/kEQI74ge6VhvNEr1d3JW-Q)》，引起了一拨各种讨论，还是比较欣慰的。
 13 | 
 14 | 这不，有小伙伴给我提出了新的题材：
 15 | 
 16 | ![来自读者微信提问](https://files.mdnice.com/user/3610/a97e5e6d-b58d-44f2-b858-b9ca12780180.png)
 17 | 
 18 | 提出的是 Go 中很容易踩坑的切片内存泄露问题。作为宠粉的煎鱼肯定不会放过，争取让大家都避开这个 “坑”。
 19 | 
 20 | 今天这篇文章，就由煎鱼带大家来了解这个问题：Go 切片可能可以怎么泄露法？
 21 | 
 22 | ## 切片泄露的可能
 23 | 
 24 | 在业务代码的编写上，我们经常会接受来自外部的接口数据，再把他插入到对应的数据结构中去，再进行下一步的业务聚合、裁剪、封装、处理。
 25 | 
 26 | 像在 PHP 语言，常常会放到数组（array）中。在 Go 语言，会放到切片（slice）中。因此在 Go 的切片处理逻辑中，常常会涉及到如下类似的动作。
 27 | 
 28 | 示例代码如下：
 29 | 
 30 | ```golang
 31 | var a []int
 32 | 
 33 | func f(b []int) []int {
 34 | 	a = b[:2]
 35 | 	return a
 36 | }
 37 | 
 38 | func main() {
 39 |     ...
 40 | }
 41 | ```
 42 | 
 43 | 仔细想想，**这段程序有没有问题**，是否存在内存泄露的风险？
 44 | 
 45 | 答案是：有的。有明确的切片内存泄露的可能性和风险。
 46 | 
 47 | ## 切片底层结构
 48 | 
 49 | 可能有些小伙伴会疑惑，怎么就有问题了，是哪里有问题？
 50 | 
 51 | 这里就得复习一下切片的底层基本数据结构了，切片在运行时的表现是 SliceHeader 结构体，定义如下：
 52 | 
 53 | ```golang
 54 | type SliceHeader struct {
 55 |  Data uintptr
 56 |  Len  int
 57 |  Cap  int
 58 | }
 59 | ```
 60 | - Data：指向具体的底层数组。
 61 | - Len：代表切片的长度。
 62 | - Cap：代表切片的容量。
 63 | 
 64 | 要点是：切片真正存储数据的地方，是一个数组。切片的 Data 属性中**存储的是指向所引用的数组指针地址**。
 65 | 
 66 | ## 背后的原因
 67 | 
 68 | 在上述案例中，我们有一个包全局变量 a，共有 2 个切片 a 和 b，截取了 b 的一部分赋值给了 a，两者存在着关联。
 69 | 
 70 | 从程序的直面来看，截取了 b 的一部分赋值给了 a，结构似乎是如下图：
 71 | 
 72 | ![](https://files.mdnice.com/user/3610/856aff0a-14bb-4dca-9324-4b852f25dd12.png)
 73 | 
 74 | 但我们进一步打开程序底层来看，他应该是如下图所示：
 75 | 
 76 | ![](https://files.mdnice.com/user/3610/c79008dd-771d-475b-8c41-6b654216feff.png)
 77 | 
 78 | 切片 a 和 b 都共享着同一个底层数组（共享内存块），sliceB 包含全部所引用的字符。sliceA 只包含了 [:2]，也就是 0 和 1 两个索引位的字符。
 79 | 
 80 | 那他们泄露在哪里了？
 81 | 
 82 | ## 泄露的点
 83 | 
 84 | 泄露的点，就在于虽然切片 b 已经在函数内结束了他的使命了，不再使用了。但切片 a 还在使用，切片 a 和 切片 b 引用的是同一块底层数组（共享内存块）。
 85 | 
 86 | 关键点：**切片 a 引用了底层数组中的一段**。
 87 | 
 88 | ![](https://files.mdnice.com/user/3610/0a4353e0-e793-41b5-a2dc-a6a25a39a519.png)
 89 | 
 90 | 虽然切片 a 只有底层数组中 0 和 1 两个索引位正在被使用，其余未使用的底层数组空间毫无作用。但由于正在被引用，他们也不会被 GC，因此造成了泄露。
 91 | 
 92 | ## 解决办法
 93 | 
 94 | 解决的办法，就是利用切片的特性。当切片的容量空间不足时，会**重新申请一个新的底层数组来存储，让两者彻底分手**。
 95 | 
 96 | 示例代码如下：
 97 | 
 98 | ```golang
 99 | var a []int
100 | var c []int    // 第三者
101 | 
102 | func f(b []int) []int {
103 | 	a = b[:2]
104 |   
105 |   // 新的切片 append 导致切片扩容
106 | 	c = append(c, b[:2]...)
107 | 	fmt.Printf("a: %p\nc: %p\nb: %p\n", &a[0], &c[0], &b[0])
108 |   
109 | 	return a
110 | }
111 | ```
112 | 
113 | 输出结果：
114 | 
115 | ```
116 | a: 0xc000102060
117 | c: 0xc000124010
118 | b: 0xc000102060
119 | ```
120 | 
121 | 这段程序，新增了一个变量 c，他容量为 0。此时将期望的数据，追加过去。自然而然他就会遇到容量空间不足的情况，也就能实现申请新底层数据。
122 | 
123 | 我们再将原本的切片置为 nil，就能成功实现两者分手的目标了。
124 | 
125 | ## 总结
126 | 
127 | 在今天这篇文章中，我们介绍了 Go 切片的一种常见的内存泄露方式。虽然我们在日常使用的时候可能没关注到。
128 | 
129 | 主要原因还是由于切片的大多数使用场景，体量都比较小。又或是不知不觉就自己扩容了，就变成暂时性泄露了。
130 | 
131 | 这依然是存在风险的，在编写 Go 代码时需要谨慎。毕竟这可是 **Go 语言官方自己都踩过坑的 “坑”**。
132 | 
133 | ## 参考
134 | - [An interesting way to leak memory with Go slices](https://utcc.utoronto.ca/~cks/space/blog/programming/GoSlicesMemoryLeak)
135 | - [internal/poll: avoid memory leak in Writev](https://github.com/golang/go/pull/32138/files)
136 | - [slice 类型内存泄露的逻辑](https://xargin.com/logic-of-slice-memory-leak/)
137 | - [golang slice内存泄露回收](https://zhuanlan.zhihu.com/p/149381458)


--------------------------------------------------------------------------------
/content/posts/go/struct-pointer.md:
--------------------------------------------------------------------------------
  1 | ---
  2 | title: "你知道 Go 结构体和结构体指针调用有什么区别吗？"
  3 | date: 2021-06-06T12:21:30+08:00
  4 | images:
  5 | tags: 
  6 |   - go
  7 |   - 面试题
  8 | ---
  9 | 
 10 | 大家好，我是煎鱼。
 11 | 
 12 | 前几天在分享《Go 结构体是否可以比较，为什么？》时，有小伙伴提出了新的问题：
 13 | 
 14 | ![来自文章评论区](https://image.eddycjy.com/a4d34c5312339b9909e482c18f0cdf4a.png)
 15 | 
 16 | 虽然大家提问题的速度已经超出了本鱼写文章的速度...不过作为宠粉狂鱼，在此刻清明假期时还是写下了这篇文章。
 17 | 
 18 | 我在网上冲浪时搜索了相关问题，发现 6 年前就有 Go 开发者有一模一样的疑问，真是困扰了一代又一代的小伙伴。
 19 | 
 20 | ![来自 stackoverflow.com](https://image.eddycjy.com/dbe910917c86e103648e314f79896a81.png)
 21 | 
 22 | 
 23 | 本期的男主角是《**Go 结构体和结构体指针调用有什么区别**》，希望对大家有所帮助，带来一些思考。
 24 | 
 25 | **请在此处默念自己心目中的答案**，再和煎鱼一同研讨一波 Go 的技术哲学。
 26 | 
 27 | ## 结构体是什么
 28 | 
 29 | 在 Go 语言中有个基本类型，开发者们称之为结构体（struct）。是 Go 语言中非常常用的，基本定义：
 30 | 
 31 | ```golang
 32 | type struct_variable_type struct {
 33 |     member definition
 34 |     member definition
 35 |     ...
 36 |     member definition
 37 | }
 38 | ```
 39 | 
 40 | 简单示例：
 41 | 
 42 | ```golang
 43 | package main
 44 | 
 45 | import "fmt"
 46 | 
 47 | type Vertex struct {
 48 |     Name1 string
 49 |     Name2 string
 50 | }
 51 | 
 52 | func main() {
 53 |     v := Vertex{"脑子进了", "煎鱼"}
 54 |     v.Name2 = "蒸鱼"
 55 |     fmt.Println(v.Name2)
 56 | }
 57 | ```
 58 | 
 59 | 输出结果：
 60 | 
 61 | ```
 62 | 蒸鱼
 63 | ```
 64 | 
 65 | 这部分属于基础知识，因此不再过多解释。如果看不懂，建议重学 Go 语言语法基础。
 66 | 
 67 | ## 结构体和指针调用
 68 | 
 69 | 讲解前置概要后，直接进入本文主题。如下例子：
 70 | 
 71 | ```golang
 72 | type MyStruct struct {
 73 |     Name string
 74 | }
 75 | 
 76 | func (s MyStruct) SetName1(name string) {
 77 |     s.Name = name
 78 | }
 79 | 
 80 | func (s *MyStruct) SetName2(name string) {
 81 |     s.Name = name
 82 | }
 83 | ```
 84 | 
 85 | 该程序声明了一个 `User` 结构体，其包含两个结构体方法，分别是 `SetName1` 和 `SetName2` 方法，两者之间的差异就是**引用的方式不同**。
 86 | 
 87 | 进一步延伸，这两者有什么区别，什么情况下用哪种，有没有什么注意事项？
 88 | 
 89 | 注：很巧，我有一个朋友，当年刚上手 Go 语言时，就纠结过这个问题。
 90 | 
 91 | ## 两者区别
 92 | 
 93 | 从许多小伙伴的反馈来看，这两个例子之间的区别可能会让人感到困惑，经常会有人纠结要不要使用 “指针”，又担心 GC 什么的。
 94 | 
 95 | 实际上情况没那么复杂，看看下面的例子：
 96 | 
 97 | ```golang
 98 | func (s MyStruct) SetName1(name string) 
 99 | func (s *MyStruct) SetName2(name string)
100 | ```
101 | 当在一个类型上定义一个方法时，接收器（在上面的例子中是 s）的行为就像它是方法的一个参数一样。其相当于：
102 | 
103 | ```golang
104 |  func SetName1(s MyStruct, name string){
105 |     u.Name = name
106 |  }
107 | 
108 |  func SetName2(s *MyStruct,name string){
109 |     u.Name = name
110 |  }
111 | ```
112 | 
113 | 因此结构体方法是要将接收器定义成值，还是指针。这本质上与函数参数应该是值还是指针是同一个问题。
114 | 
115 | ## 如何选择
116 | 
117 | 整体有以下几个考虑因素，按重要程度顺序排列：
118 | 
119 | 1. 在使用上的考虑：方法是否需要修改接收器？如果需要，接收器必须是一个指针。
120 | 
121 | 2. 在效率上的考虑：如果接收器很大，比如：一个大的结构体，使用指针接收器会好很多。
122 | 
123 | 3. 在一致性上的考虑：如果类型的某些方法必须有指针接收器，那么其余的方法也应该有指针接收器，所以无论类型如何使用，方法集都是一致的。
124 | 
125 | 回到上面的例子中，从功能使用角度来看：
126 | - 如果 `SetName2` 方法修改了 s 的字段，调用者是可以看到这些字段值变更的，因为其是指针引用，本质上是同一份。
127 | - 相对 `SetName1` 方法来讲，该方法是用调用者参数的副本来调用的，本质上是值传递，它所做的任何字段变更对调用者来说是看不见的。
128 | 
129 | 另外对于基本类型、切片和小结构等类型，值接收器是非常廉价的。
130 | 
131 | 因此除非方法的语义需要指针，那么值接收器是最高效和清晰的。在 GC 方面，也不需要过度关注。出现时再解决就好了。
132 | 
133 | ## 总结
134 | 
135 | 在本文中，我们针对 Go 结构体和结构体指针调用有什么区别，这个问题进行了深入浅出的分析和说明。
136 | 
137 | 而在本文中所介绍的部分内容，来自于官方 FAQ 的 “Should I define methods on values or pointers?”，可以认为是官方给出的基本解答了（问的人是真的多）。
138 | 
139 | 谁疑惑这个问题，转发这篇文章，吸就完了。


--------------------------------------------------------------------------------
/content/posts/go/switch-type.md:
--------------------------------------------------------------------------------
  1 | ---
  2 | title: "Go 泛型玩出花，详解新提案 switch type！"
  3 | date: 2021-12-31T12:55:23+08:00
  4 | toc: true
  5 | images:
  6 | tags: 
  7 |   - go
  8 | ---
  9 | 
 10 | 大家好，我是煎鱼。
 11 | 
 12 | 前面写过好几篇 Go 泛型的语法、案例介绍，新的一手 Go 消息。实际上，随着一些提案被接受，新的提案也逐渐冒出。
 13 | 
 14 | 这不，我发现有了泛型后，大家可以更进一步玩出花来了。看到了一个 ”新“ 提案《[proposal: spec: generics: type switch on parametric types](https://github.com/golang/go/issues/45380 "proposal: spec: generics: type switch on parametric types")》，讲的就是增加泛型后的参数类型上的类型开关诉求。
 15 | 
 16 | 跟着煎鱼一起掌握新的 Go 知识吧！
 17 | 
 18 | ## 新提案
 19 | 
 20 | 新的提案内容是希望增加一个新的变种语句，允许在 switch 语句中使用泛型时，能够进一步便捷的约束其类型参数。
 21 | 
 22 | 例如：
 23 | 
 24 | ```go
 25 | switch type T {
 26 | case A1:
 27 | case A2, A3:
 28 |    ...
 29 | }
 30 | ```
 31 | 
 32 | 也就是 switch-type 语句的 **T 类型可以是一个泛型的类型参**，case 所对应的的类型可以是任何类型，包括泛型的约束类型。
 33 | 
 34 | 假设类型 T 的类型有可能是以下：
 35 | 
 36 | ```go
 37 | interface{
 38 |     C
 39 |     A
 40 | }
 41 | ```
 42 | 
 43 | 可以借助泛型的近似元素来约束：
 44 | 
 45 | ```go
 46 |     interface{
 47 |         C
 48 |         A1 | A2 | ... | An
 49 |     }
 50 | ```
 51 | 
 52 | 甚至还可以在 case 上有新的写法：
 53 | 
 54 | ```go
 55 | case interface {~T}:
 56 | ```
 57 | 
 58 | 在支持泛型后，**switch 在 type 和 case 上会存在很多种可能性**，需要进行具体的特性支持，这个提案就是为此出现。
 59 | 
 60 | ## 实际案例
 61 | 
 62 | ### 案例一：多类型元素
 63 | 
 64 | ```go
 65 | type Stringish interface {
 66 | 	string | fmt.Stringer
 67 | }
 68 | 
 69 | func Concat[S Stringish](x []S "S Stringish") string {
 70 |     switch type S {
 71 |     case string:
 72 |         ...
 73 |     case fmt.Stringer:
 74 |         ...
 75 |     }
 76 |  }
 77 | ```
 78 | 
 79 | 类型 S 能够支持 string 和 fmt.Stringer 类型，case 配套对应实现。
 80 | 
 81 | ### 案例二：近似元素
 82 | 
 83 | ```go
 84 | type Constraint interface {
 85 |     ~int | ~int8 | ~string
 86 | }
 87 | 
 88 | func ThisSyntax[T Constraint]( "T Constraint") {
 89 |     switch type T {
 90 |     case ~int | ~int8:
 91 |         ...
 92 |     case ~string:
 93 |         ...
 94 |     }
 95 | }
 96 | 
 97 | func IsClearerThanThisSyntax[T Constraint]( "T Constraint") {
 98 |     switch type T {
 99 |     case interface{~int | ~int8 }:
100 |         ...
101 |     case interface{ ~string }:
102 |         ...
103 |     }
104 | }
105 | ```
106 | 
107 | 类型 T 可能有很多类型，程序中用到了近似元素，也就是基础类型是 int、int8、string，这些类型中的任何一种都能够满足这个约束。
108 | 
109 | 为此，switch-type 支持了，case 也要配套支持该特性。
110 | 
111 | ## 争议点
112 | 
113 | 看到这里可能大家也想到了，这个味道很似曾相识，好像某个语法能够支持。因此，这个提案下最有争议的，就是与原有的类型断言的重复。
114 | 
115 | 原有的类型断言如下：
116 | 
117 | ```go
118 | switch T.(type) {
119 | case string:
120 |    ...
121 | default:
122 |    ...
123 | }
124 | ```
125 | 
126 | 新的类型判别如下：
127 | 
128 | ```go
129 | switch type T {
130 | case A1:
131 | case A2, A3:
132 |    ...
133 | }
134 | ```
135 | 
136 | 这么咋一看，其实类型断言的完全可以取代新的，那岂不是重复建设，造轮子了？
137 | 
138 | 其实是没有完全取代的。差异点如下：
139 | 
140 | ```go
141 | type ApproxString interface { ~string }
142 | 
143 | func F[T ApproxString](v T "T ApproxString") {
144 |     switch (interface{})(v).(type) {
145 |     case string:
146 |         fmt.Println(v)
147 |     default:
148 |         panic("脑子没进煎鱼")
149 |     }
150 | }
151 | 
152 | type MyString string
153 | 
154 | func main() {
155 |     F(MyString("脑子进煎鱼了"))
156 | }
157 | ```
158 | 
159 | 看出来差别在哪了吗，答案是什么？
160 | 
161 | 
162 | 答案是：会抛出恐慌（panic）。
163 | 
164 | 你可能纠结了，问题出在哪里？这传入的 ”脑子进煎鱼了“ 的类型是 `MyString`，他的基础类型是 `string` 类型，也满足 `ApproxString` 类型的近似类型 `~string` 的要求，怎么就不行了...
165 | 
166 | 根本原因是因为他的类型是 interface，而非 string 类型。所以走到了 defalut 分支的恐慌。
167 | 
168 | 
169 | ## 总结
170 | 
171 | 今天给大家介绍了 Go 泛型的最新消息，在上一个提案被合并后，该提案也有一些新的动静。不过 Go 官方表态，会等熟练掌握泛型实践后，再继续推动该提案。
172 | 
173 | 我相信，原有的 `switch.(type)` 和 `switch type` 很大概率在 Go 底层会变成同一个逻辑块处理，再逐渐过渡。
174 | 
175 | 这个提案的目的还是**为了解决若干引入泛型后，所带入的 BUG/需求**，正正是需要新的语法结构来解决的。
176 | 
177 | **你对此有什么看法呢**，欢迎在评论区留言和交流：）


--------------------------------------------------------------------------------
/content/posts/go/type-after.md:
--------------------------------------------------------------------------------
  1 | ---
  2 | title: "为什么 Go 语言把类型放在后面？"
  3 | date: 2021-12-31T12:55:10+08:00
  4 | toc: true
  5 | images:
  6 | tags: 
  7 |   - go
  8 | ---
  9 | 
 10 | 大家好，我是煎鱼。
 11 | 
 12 | 前段时间看到大家在吵一个话题，那就是 Go 语言的类型声明，抠知识抠的非常细了，就是为什么他要放在后面。
 13 | 
 14 | 示例代码如下：
 15 | 
 16 | ```golang
 17 | var a []string
 18 | var b []string
 19 | ```
 20 | 
 21 | 其实在早年 Go 官方估计已经被问烦了，写过一篇《[Go's Declaration Syntax](https://go.dev/blog/declaration-syntax "Go's Declaration Syntax")》来具体介绍和说明情况。
 22 | 
 23 | 为此煎鱼将参考并结合这篇官方资料，带大家一起了解为什么 Go 如此的 “与众不同” ，为什么要把类型放在后面。
 24 | 
 25 | ## 类型前置
 26 | 
 27 | 在业内目前有不少知名语言，也采取的是在声明变量类型时，把类型定义在名字前面。像是 C、C++、C#、Java 等：
 28 | 
 29 | ```c
 30 | int x;
 31 | int x = 100;
 32 | ```
 33 | 
 34 | 基本的格式定义：<data_type> <variable_list>;。
 35 | 
 36 | 上面的声明是一个简单的例子，如果更复杂一些，Go 官方还给出了著名的函数指针的例子：
 37 | 
 38 | ```c
 39 | int (*fp)(int a, int b);
 40 | ```
 41 | 
 42 | 更进一步，如果返回值也是个函数指针类型，就会变成：
 43 | 
 44 | ```c
 45 | int (*(*fp)(int (*)(int, int), int))(int, int)
 46 | ```
 47 | 
 48 | 这已经很难看出来是个 fp 的声明了。
 49 | 
 50 | ## 类型后置
 51 | 
 52 | 前面所举例的类型前置的编程语言，很多都是 C 系列中的一者。类型后置的代表，分别有：Go、Rust、Scala、Kotlin 等。
 53 | 
 54 | 其实在很多类型后置的编程语言种，会采取变量名+冒号+类型的方式出现。就像 Rust 一样：
 55 | 
 56 | ```rust
 57 | let x: i32;
 58 | ```
 59 | 
 60 | 基本的格式定义：
 61 | 
 62 | ```
 63 | x: int
 64 | p: pointer to int
 65 | a: array[3] of int
 66 | ```
 67 | 
 68 | Go 官方参照了这类类型后置的设计，并且为了简洁，进一步去掉了冒号和一些关键字，变成：
 69 | 
 70 | ```golang
 71 | var a []string
 72 | ```
 73 | 
 74 | 我们再看回前面 fp 的声明的例子：
 75 | 
 76 | ```c
 77 | int (*(*fp)(int (*)(int, int), int))(int, int)
 78 | ```
 79 | 
 80 | 再对比 Go 语言中就变成了：
 81 | 
 82 | ```golang
 83 | f func(func(int,int) int, int) func(int, int) int
 84 | ```
 85 | 
 86 | 两者一对比，Go 语言代码可读性确实更高一些。
 87 | 
 88 | ## 思考
 89 | 
 90 | ### 后置类别
 91 | 
 92 | 在类型声明上，实际上分为：变量类型后置、函数返回值后置。两者共同构建了前置还是后置，总不能一个前置，一个后置吧，那得多么的难受。
 93 | 
 94 | 上方 C 语言和 Go 语言函数指针的例子，所对比带来的代码可读性提高，其实本质上是由**函数返回值后置**所带来的。
 95 | 
 96 | 和类型前置、后置没太多直接关系。
 97 | 
 98 | ### 核心思想
 99 | 
100 | 在类型后置上来讲，Go 官方核心思想是：**这种声明方式（从左到右的风格）的一个优点是，当类型变得更加复杂时，它的效果非常好**（One merit of this left-to-right style is how well it works as the types become more complex）。
101 | 
102 | Go 的变量名总是在前，在人的代码阅读上可以**保持从左到右阅读**，不需要像 C 语言一样在一大堆声明中用技巧找变量名对应的类型。
103 | 
104 | ![The Clockwise/Spiral Rule](https://files.mdnice.com/user/3610/b025d274-ae83-404c-8072-2776cd790708.png)
105 | 
106 | 为此甚至有人写了篇 C 语言的顺时针读法《[The Clockwise/Spiral Rule](http://c-faq.com/decl/spiral.anderson.html "The Clockwise/Spiral Rule")》，有兴趣可以阅读。
107 | 
108 | 如此一对比，Go 语言的类型后置在复杂场景下与 C 语言的对比确实更好一些。
109 | 
110 | ### 其他因素
111 | 
112 | #### 类型推导
113 | 
114 | 诸如在类型推导的形式上也会更直观：
115 | 
116 | ```golang
117 | func main() {
118 |     var s1 := "脑子进煎鱼了"
119 |     var s2 string
120 | }
121 | ```
122 | 
123 | 也是一个可读性提高的问题。
124 | 
125 | #### 类型和名字谁更重要
126 | 
127 | 不同设计者对谁更重要的理解也不一样。是类型更重要，还是名字更重要呢？
128 | 
129 | 有的人认为是类型，有的人认为是名字。这就真的是千人千面，众口难调了。
130 | 
131 | ## C# 的后悔
132 | 
133 | 我们看看其他语言，C# 设计组成员之一，其实在《[Sharp Regrets: Top 10 Worst C# Features](https://www.informit.com/articles/article.aspx?p=2425867 "Sharp Regrets: Top 10 Worst C# Features")》中的第五点表达了个人对类型前置、后置的设计教训。
134 | 
135 | 
136 | ![](https://files.mdnice.com/user/3610/6d5665b7-125f-4202-8742-c11c433566d7.png)
137 | 
138 | 核心观点是：从编程和数学两方面来看，都有一个约定，即计算的结果在右侧表示，所以在类 C 语言中，类型在左侧是很奇怪的。
139 | 
140 | 在设计时，C# 本来计划把类型注释放在右边。但考虑到类 C 语言，因此遵循了其他语言的惯例。
141 | 
142 | 
143 | ## 总结
144 | 
145 | 实际上该问题的研讨，在 2021 年的现在，大部分 case 都一一被反驳了。类型后置也不是一个与众不同的设计，很多语言都是如此。但既然要讨论 Go 语言，那更多的是站在设计者的角度去考虑。
146 | 
147 | 结合 Go 所提供的官方资料，在当年的目的更多的是为了**在遇到复杂类型定义时，能保持一定的代码可读性**。
148 | 
149 | 当然，这不可否认肯定包含 Go 开发团队的主观意识。有兴趣的可以具体挖挖背后的信息。
150 | 
151 | 如果是你，**你会把类型放在前面，还是后面呢，为什么**？


--------------------------------------------------------------------------------
/content/posts/microservice/leaky-token-buckets.md:
--------------------------------------------------------------------------------
 1 | ---
 2 | title: "带你快速了解：限流中的漏桶和令牌桶算法"
 3 | date: 2020-10-06T12:44:10+08:00
 4 | toc: true
 5 | images:
 6 | tags: 
 7 |   - 微服务
 8 |   - 服务治理
 9 | ---
10 | 
11 | 在前文 《限流熔断是什么，怎么做，不做行不行？》中针对 “限流” 动作，有提到流量控制其内部对应着两种常用的限流算法，分别是漏桶算法和令牌桶算法。因此会有的读者会好奇，这都是些啥？
12 | 
13 | 为了更进一步的了解 WHY，本文来快速探索一下，看看限流下的一些 “算法” 们到底有何作用，是为何成为流量控制的基石的？
14 | 
15 | ![image](https://image.eddycjy.com/815f7524b5367149cc9c6725ee28cd12.jpg)
16 | 
17 | ## 前言
18 | 
19 | 理论上每一个对外/内提供功能的资源点，都需要进行一定的流量控制，否则在业务的持续迭代中，是有可能出现突发性流量的场景（就像年初所带来的一些行业突发转变，导致业务流量突然暴增）：
20 | 
21 | ![image](https://image.eddycjy.com/c29272e53f9e125dbbfba133b3eea7c4.jpg)
22 | 
23 | 若没有进行限流，就会出现一些奇奇怪怪的问题点，实则就是系统无法承受这波流量，逐渐崩溃，走向系统假死。
24 | 
25 | ## 现实场景
26 | 
27 | 最常见的现实场景就是日常随处可见的排插、插座，其内置的保险丝，也被称为电流保险丝，其主要是起过载保护作用，保险丝会在电流异常升高到一定的高度和热度的时候，自身熔断切断电流，从而起到保护电路安全运行的作用。
28 | 
29 | 因此真实世界中有许多与软件工程中的限流熔断的场景有异曲同工之处，也是为了控制量，超量就切断。你也可以想想现实生活中是否有遇到其他类似的例子呢？
30 | 
31 | ![image](https://image.eddycjy.com/23af65486fc991e1bd976c37626ccf18.jpg)
32 | 
33 | ## 漏桶算法（Leaky Bucket）
34 | 
35 | 漏桶算法（Leaky Bucket）是网络中流量整形（Traffic Shaping）或速率限制（Rate Limiting）时常用的一种算法，它的主要目的是控制数据注入到网络的速率，平滑网络上的突发流量。
36 | 
37 | 漏桶算法通过其算法调控了流量访问，使得突发流量可以被整形，去毛刺，变成一个相对缓和，以便为网络提供一个稳定的流量。
38 | 
39 | 漏桶算法的存储桶主要由三个参数定义，分别是：桶的容量、水从桶中流出的速率、桶的初始充满度。
40 | 
41 | 其核心理念就如字面意思：一个会漏水的桶。
42 | 
43 | ![图片来自 geeksforgeeks](https://image.eddycjy.com/386bdd6a907a2130f5bfa74696817221.jpg)
44 | 
45 | ### Bursty Flow
46 | 
47 | 在上图中，水龙头代表着突发流量（Bursty Flow）。当网络中存在突发流量，且无任何调控时，就会出现像 Bursty Data 处类似的场景。主机以 12 Mbps 的速率发送数据，时间持续 2s，总计 24 Mbits 数据。随后主机暂停发送 5s，然后再以 2 Mbps 的速率发送数据 3s，最终总共发送了 6 Mbits 的数据。
48 | 
49 | 因此主机在 10s 内总共发送了 30 Mbits 的数据。但这里存在一个问题，就是数据的发送并不是平滑的，存在一个较大的波峰。若所有流量都是如此的传输方式，将会 “旱的旱死涝的涝死”，对系统并不是特别的友好。
50 | 
51 | ### Fixed Flow
52 | 
53 | 为了解决 Bursty Flow 场景的问题。漏桶（Leaky Bucket）出现了，漏桶具有固定的流出速率、固定的容量大小。
54 | 
55 | 在上图中，漏桶在相同的 10s 内以 3 Mbps 的速率持续发送数据来平滑流量。若水（流量）来的过猛，但水流（漏水）不够快时，其最终结果就是导致水直接溢出，呈现出来就是拒绝请求/排队等待的表现。另外当 Buckets 空时，是会出现一次性倒入达到 Bucket 容量限制的水的可能性，此时也可能会出现波峰。
56 | 
57 | 简单来讲就是，一个漏桶，水流进来，但漏桶只有固定的流速来流出水，若容量满即拒绝，否则将持续保持流量流出。
58 | 
59 | ## 令牌桶算法
60 | 
61 | 令牌桶算法也是网络中流量整形或速率限制时常用的一种算法，它的主要目的是控制发送到网络上的数据的数目，并允许突发数据的发送。
62 | 
63 | 令牌桶算法会以一个恒定的速率向桶里放入令牌，如果有新的请求进来希望进行处理，则必须要先从桶内拿到一个可用的令牌，才能继续被处理。若桶内无令牌可取时，则拒绝请求/排队等待。
64 | 
65 | ![图片来自 gateoverflow](https://image.eddycjy.com/07c0861b3a2e900ea4ca6fc8f7aeaa1a.jpg)
66 | 
67 | 1. 每 1/r 秒新增一个 token 到 buckets 中。
68 | 
69 | 2. buckets 中最多可容纳 b 个令牌。如果桶已满，将丢弃这个新增的 token（也就是不需要新的 token）。
70 | 
71 | 3. 当主机传输 n bytes packets 時，buckets 中如果有 n 个令牌，则取到所需令牌，成功传输 n bytes。
72 | 
73 | 4. 当可用的 token 小于 n bytes 时，不会从 buckets 中取到任何 token，本次请求将被拒绝/排队等待。
74 | 
75 | ## 漏桶 vs 令牌桶
76 | 
77 | 漏桶算法和令牌桶算法本质上都是为了做流量整形（Traffic Shaping）或速率限制（Rate Limiting），避免系统因为大流量而被打崩，但两者核心差异在于限流的方向是相反的。
78 | 
79 | 令牌桶限制的是流量的平均流入速率，并且允许一定程度的突然性流量，最大速率为桶的容量和生成 token 的速率。而漏桶限制的是流量的流出速率，是相对固定的。
80 | 
81 | 因此也会相对的带来一个问题，在某些场景中，漏桶算法并不能有效的使用网络资源，因为漏桶的漏出速率是相对固定的，所以在网络情况比较好，没有拥塞的状态下，漏桶依然是限制住的，并没有办法放开量。而令牌桶算法则不同，其能够是限制平均速率的同时支持一定程度的突发流量。
82 | 
83 | ## 总结
84 | 
85 | 在软件系统中，限流常常所代表的就是流量整形、速率限制，是一个非常常见的调控手段。一般我们会将其在初期集成到统一框架、网关、Mesh 中去。因此建议接触业务的同学，都要对这一块进行考量，便于后续的快速使用/接入，毕竟业务的流量爆发总是来的比较突然，甚至可能是恶意攻击。
86 | 
87 | 而本文所提到的漏桶，令牌桶都是非常常见的手段，虽然两者独立出来分析了。但从软件开发的角度来讲，你认为两者是否可以融合，结合其优势呢？


--------------------------------------------------------------------------------
/content/posts/microservice/linkage.md:
--------------------------------------------------------------------------------
 1 | ---
 2 | title: "微服务的战争：级联故障和雪崩"
 3 | date: 2020-08-25T21:08:39+08:00
 4 | toc: true
 5 | images:
 6 | tags: 
 7 |   - 微服务
 8 | ---
 9 | 
10 | > “微服务的战争” 是一个关于微服务设计思考的系列题材，主要是针对在微服务化后所出现的一些矛盾/冲突点，不涉及具体某一个知识点深入。如果你有任何问题或建议，欢迎随时交流。
11 | 
12 | 在 [微服务的战争：统一且标准化](https://eddycjy.com/posts/microservice/standardization/) 中，经过好几周与不同业务组不同事业部的跨部门讨论后，终于把初始的标准化方案给定下来了，大家欢快的使用起了内部的统一框架，疯狂的创建起了新服务，没隔多久服务调用链就变成了下图：
13 | 
14 | ![image](https://image.eddycjy.com/97128d96a1a4b8ba1f765bf30134f529.jpg)
15 | 
16 | 服务间存在多次内部调用，服务 A =》服务 B =》服务 C =》服务D，而 服务 E =》 服务 B，服务 F =》服务 E，也就是存在着多个流量入口，且依赖相同的服务。
17 | 
18 | ## 背景
19 | 
20 | 服务与服务中，总存在业务服务，公共服务，基础服务等类型。但在某一个夜晚，突然发现 BFF 调用后端服务开始逐渐不正常，客户给你截图反馈问题，你发现有点问题：
21 | 
22 | ![image](https://image.eddycjy.com/844d0d5a730a4c692d7d96912e1d710c.jpg)
23 | 
24 | 单从表现来看，你发现是 BFF 调用服务 A 极度缓慢，也不知道怎么了...正当以为是服务 A 出问题，想着万能重启一下时。你在日志平台和链路追踪系统一看，发现了大量的错误日志和缓慢，让你略微震惊，一时间不知道从何下手。
25 | 
26 | 这可怎么办？
27 | 
28 | ## 级联故障和雪崩
29 | 
30 | 实际上这是一次很经典的级联故障，最终导致系统雪崩的情景再现。单从上述拓扑来看，问题点之一在于服务 B：
31 | 
32 | ![image](https://image.eddycjy.com/51b18e7c80833fbe1dc13b3a3290940b.jpg)
33 | 
34 | 服务 B 本身作为服务 A 和服务 F 的两个流量入口必经之处，想必至少是一个公共服务，但他也依赖了其他多个服务。因此若服务 C 和服务 D 其中一个有问题，在没有熔断措施的情况下，就出现级联故障，系统逐渐崩盘，最后雪崩：
35 | 
36 | ![image](https://image.eddycjy.com/2e7b0d94c32f3bd8f3f7168046671d2b.jpg)
37 | 
38 | 服务 D 所依赖的外部接口出现了故障，而他并没有做任何的控制，因此扩散到了所有调用到他的服务，自然也就包含服务 B，因此最终出现系统雪崩。
39 | 
40 | 这种最经典的是出现在默认 Go http client 调用没有设置 Timeout，从而只要出现一次故障，就足矣让记住这类 “坑”，毕竟崩的 ”慢“，错误日志还多。
41 | 
42 | ## 解决方法
43 | 
44 | 常见的方式是**根据特定的规则/规律进行熔断和降级**，避免请求发生堆积：
45 | 
46 | - 超时时间控制。
47 | 
48 | - 慢调用比例。
49 | 
50 | - 错误比例。
51 | 
52 | - 自适应（例如：负载情况等）。
53 | 
54 | 当然，这也只是壮士断腕，后续措施还包含监控告警，通知对应的开发人员来处理。且需提前对被降级的模块进行业务逻辑进行处理等等，这样才能够比较柔和且快速地度过这一次危机。
55 | 
56 | ## 总结
57 | 
58 | 在分布式应用中，级联故障和雪崩是非常常见的，一些开发同学在模块设计时可能并没有意识到这块的问题，在微服务化后会一个不留神就碰到，因为其调用链变得特别的长且多。因此建议配套设施和限流熔断措施都应该及时跟上，否则面对一大堆的错误日志还是很无奈的。
59 | 
60 | 同时，监控告警的建设也要做，因为在危机出现时，有一个 HTTP 调用的 P95/P99 告警出现，那就比较舒心了，直接 root cause。


--------------------------------------------------------------------------------
/content/posts/microservice/standardization.md:
--------------------------------------------------------------------------------
 1 | ---
 2 | title: "微服务的战争：统一且标准化"
 3 | date: 2020-08-22T21:56:14+08:00
 4 | toc: true
 5 | images:
 6 | tags: 
 7 |   - 微服务
 8 | ---
 9 | 
10 | > “微服务的战争” 是一个关于微服务设计思考的系列题材，主要是针对在微服务化后所出现的一些矛盾/冲突点，不涉及具体某一个知识点深入。如果你有任何问题或建议，欢迎随时交流。
11 | 
12 | ![image](https://image.eddycjy.com/b70c37b40768191e5a6812096703a63f.jpg)
13 | 
14 | ## 开天辟地
15 | 
16 | 在远古开天辟地时，大单体转换成微服务化后，服务的数量越来越多。每起一个新的服务，就得把项目的目录结构，基础代码重新整理一遍，并且很有可能都是从最初的 template 上 ctrl+c，ctrl+v 复制出来的产物，如下：
17 | 
18 | ![image](https://image.eddycjy.com/7b4642c2bb7af1e5656be047bc269fb6.jpg)
19 | 
20 | 但是基于 template 的模式，很快就会遇到各种各样的新问题：
21 | 
22 | ![image](https://image.eddycjy.com/3c91559190480a348aeacd609199c2bb.jpg)
23 | 
24 | 随着跨事业部/业务组的使用增多，你根本不知道框架的 template 是什么时间节点被复制粘贴出去的，也不知道所对应的 commit-id 是什么，更不知道先前的 BUG 修复了没，也不知道有没有其他开发人员私下改过被复制走的 template。
25 | 
26 | 简单来讲，就是不具备可维护性，相对独立，BUG 可能一样，但却没有版本可规管。这时候，就可以选择做一个内部基础框架和对应的内部工具（已经有用户市场了），形成一个脚手架闭环：
27 | 
28 | ![image](https://image.eddycjy.com/3787e41616779a91a3a052467b3acdee.jpg)
29 | 
30 | 通过基础工具+基础接口的方式，就可以解决项目A、B、C...的基础框架版本管理和公共维护的问题，且在遇到框架 BUG 时，只需要直接 upgrade 就好了。而在框架维护者层面，还能通过注册机制知道目前基础框架的使用情况（例如：版本分布），便于后续的迭代和规划。
31 | 
32 | 同时若内部微服务依赖复杂，可以将脚手架直接 “升级”，再做多一层基础平台，通过 CI/CD 平台等关联创建应用，选择应用类型等基本信息，然后关联创建对应的应用模板、构建工具、网关、数据库、接口平台、初始化自动化用例等：
33 | 
34 | ![image](https://image.eddycjy.com/0997fb71080b8f35fe0ccd68acaebc94.jpg)
35 | 
36 | 至此，就可以通过结合基础平台（例如：CI/CD）实现流程上的标准化控制，成为一个提效好帮手。
37 | 
38 | ## 大众创新
39 | 
40 | 但，一切都有 “开天辟地” 那么顺利吗。实际上并不，在很多的公司中，大多数是在不同的时间阶段在不同的团队同时进行了多个开天辟地。
41 | 
42 | 更具现化来讲，就是在一家公司内，不同的团队里做出了多种基础工具和基础框架。更要命的是，他们几家的规范可能还不大一样。例如：框架在 gRPC 错误码的规范处理上的差异：
43 | 
44 | - 业务错误码放在 grpc.status.details 中。
45 | 
46 | - 业务错误码放在 grpc-status 中。
47 | 
48 | - 业务错误码放在 grpc-message 中。
49 | 
50 | 又或是 HTTP 状态码的差异：
51 | 
52 | - HTTP Status Code 为金标准，不在主体定义业务错误码。
53 | 
54 | - HTTP Status Code 都为 200 OK（除宕机导致的 500，503 等），业务错误码由主体另外定义。
55 | 
56 | 粗略一看，单单在应用错误码/状态码这一件事情上，就能够玩出花样。而这件事又会导致各种问题，例如在监控平台上，因为不同团队所定义的状态码规范不一样，就会导致连基本的监控可用性都会有问题。
57 | 
58 | 像是有的小伙伴会把业务错误码放在 grpc-status 属性中，而在标准 gRPC 的规范中 grpc-status 是和 HTTP Status Code 一样有特定状态码映射的。这时候就会让监控告警系统十分难做，通用的告警规则到底是以哪份状态码为准？
59 | 
60 | ![image](https://image.eddycjy.com/34c3c8c97f1f6164d94fb7ce7ada8262.jpg)
61 | 
62 | 往往最终演进的路线与企业的组织结构有关，也就是[康威定律](https://zh.wikipedia.org/wiki/%E5%BA%B7%E5%A8%81%E5%AE%9A%E5%BE%8B)，一个系统的技术边界反映组织的结构。业界常见的是两种情况：
63 | 
64 | 1. A 吞并 B，B 与 A 一致，从例子上来讲就是基本公用一套（维度为公司/事业部/业务组级别，与企业情况有关）。
65 | 
66 | 2. A，B 均独立发展，从例子上来讲就是均独立搭建，各管各，偶尔互相触碰边界，又或是在公开分享暗中切磋。
67 | 
68 | 显然，这其中利与弊就要各自判断了，多少厂内部有多少个框架，也有血汗厂基本一统江湖的，可能做基础架构适配的小伙伴会比较有感触，不同框架的 Header 规范不一样，这样子即使是 Mesh 也避免不了一顿 if else。
69 | 
70 | 更甚的是，在类似服务发现/注册、限流熔断、基础拦截器，各类 SDK 同个厂的每个内部框架都重现实现一遍。美其名曰框架支持了这些，就允许让他上，但这样子怕是在未来又造成了新的一波技术债务。
71 | 
72 | 同时框架维护者，是有可能离职跳槽到别家去的，这在前端届也层出不穷，带着修炼好的真经走了，留下一个没有人维护的组内框架，这时候只能硬着头皮找 B/C 角来接受，顶上来的人指不定思想还不一样。
73 | 
74 | 这单从公司层面来讲，是一个巨大的伤害，长远来看着实是灾难。
75 | 
76 | ## 总结
77 | 
78 | 在本文中，主体分为了 “开天辟地” 和 “大众创新” 两块内容，理想是丰满的，而现实怕是很骨感。微服务是一把双刃剑，带来好处的同时往往也带来了反面，架构的复杂度很难预知，因此本质上需要一个基架团队不忘初心，持续发现，持续解决问题。
79 | 
80 | 但不论如何，及早的把主力语言、基本技术栈均基本统一起来，做好产品闭环，会是一个很好的方向。
81 | 
82 | 如果具体到要做的事情，需要有一个明事理的上级，清晰的意识到同个子公司内的技术体系最好是基本一致的，由基础架构组或相关领头人拉齐核心 Leader，定义基本规范，构建统一框架，融合 CI/CD 平台。
83 | 
84 | ![image](https://image.eddycjy.com/3b2653c1e548206f5c3893c82765ce29.jpg)
85 | 
86 | 当然，反之倒推也是可以的（野蛮生长），就是步骤更多了，更难了。
87 | 
88 | 
89 | 


--------------------------------------------------------------------------------
/content/posts/microservice/tests.md:
--------------------------------------------------------------------------------
 1 | ---
 2 | title: "微服务的灾难：端到端测试的痛苦"
 3 | date: 2020-09-10T19:54:59+08:00
 4 | toc: true
 5 | images:
 6 | tags: 
 7 |   - 微服务
 8 | ---
 9 | 
10 | 大家好，我是煎鱼。
11 | 
12 | 小咸鱼经过前文所提到的折磨人的 “微服务拆分、微服务环境” 问题后，终于顺顺利利的上到了测试环境进行测试。
13 | 
14 | 这时候开发、测试同学又闹新的头疼了，测了一轮下来。发现好好的。结果发现一上生产就有一些地方有问题，发现没测到。
15 | 
16 | 这到底是为什么呢？
17 | 
18 | ## 背景
19 | 
20 | 在以往，小咸鱼他们团队都是传统的大单体应用。也就是一体化应用，包含了前端、后端等模块，具备天然的协调性：
21 | - 测试同学能够很方便的就直接测到前后端接口。
22 | - 测试能够直接对系统本身进行集成测试。
23 | 
24 | 但现在，做了微服务化（雏形）后，小咸鱼他们就翻车了，为什么呢？
25 | 
26 | 因为考虑到微服务，微服务就是向往单拎一个服务出来，都可以独立修改，独立发布。于是小咸鱼提交了一个迭代的几个服务变更，想着实现一把 “敏捷” 发布。
27 | 
28 | 结果一上线就炸了，一大堆的 BUG，光荣加班到晚上 12 点。
29 | 
30 | 这实质上是缺乏端到端测试的一个问题，单服务，无法明确系统正在正常运行。
31 | 
32 | ## 端到端测试
33 | 
34 | 在测试的质量保障上，我们要站在用户视角去验证这个系统，保障整体的系统可用性，而不是单纯的前端 BFF，又或是后端 Server 的某些接口能够正常运行。
35 | 
36 | 在定义上**端到端测试（End-to-end Test）是一种用于测试整个应用程序的流程是否符合预期的测试技术**。测试同学会模拟用户真实的使用场景，通过用户界面测试应用程序。
37 | 
38 | 如下图：
39 | 
40 | ![端到端测试](https://image.eddycjy.com/5ca5b971d8e25cf41c648401489d47b4.jpg)
41 | 
42 | 与小咸鱼团队那种单纯只测接口的方式不同，端到端测试是面向业务的。
43 | 
44 | 其目的是**验证应用程序系统整体上是否符合业务诉求**，主要通过 GUI 测试，也会有人称其为集成测试、系统测试，黑盒测试。不少公司会将这几种混在一起。
45 | 
46 | 实则在细节定义上各有不同：
47 | 
48 | ![图来自网络](https://files.mdnice.com/user/3610/820d7fbb-e3aa-4e99-8898-d69fa242887b.png)
49 | 
50 | 本文不是测试方向文章，因此不深究。
51 | 
52 | ## 问题症结
53 | 
54 | 那么小咸鱼他们团队主要是缺乏端到端的这类集成测试的校验。直接在迭代中，把几个微服务一改，接口跑几下，以为就是合理通过的了。
55 | 
56 | 真实情况：
57 | - 一上到生产，发现压根不是这么回事。因为多个变更结合在一起，很有可能会导致系统原有的行为发生改变。
58 | - 即使是你单个服务接口没违背，也不一定能保证其他在同个时段上的服务没问题。
59 | - 在业内执行情况来看，业务迭代的非常快，接口自动化大多比较缺乏。又或是以请外包人员的方式来做，大多是面向存量补接口。
60 | 
61 | 我们可以知道单纯验证接口，不走端到端类别的集成测试，是非常风骚的。设身处地的想想如下场景：
62 | 
63 | 有没有见过一些开发，他在本地测好接口后，一和前端集成上到测试环境。测试人员，一点一个报错，正向流程压根跑不通。测试同学苦不堪言，开发同学一下身背数十 BUG，齐齐加班。
64 | 
65 | 但开发同学大呼我在本地的接口测试的完全没问题。归根结底，小咸鱼团队的问题，还是因为缺乏端到端测试，缺乏齐全的接口自动化用例导致的。
66 | 
67 | ## 解决思路
68 | 
69 | 在每个迭代中，实际上每个团队都会专注于系统中所使用的所有服务中的某个服务。
70 | 
71 | 系统中存在的大量微服务和子系统的功能和较窄的测试空间，有可能会导致没有发现系统或服务中存在的隐患。
72 | 
73 | 这样测试，问题的出现，甚至是必然的。
74 | 
75 | 在解决思路上常见于：
76 | 
77 | 1. 新增预发布环境，做类似端到端测试的集成测试，确保系统集成后会是可用的。
78 | 2. 尝试更高覆盖率的接口自动化测试，大多数公司会针对新的，做增量或存量的自动化测试用例的补全。
79 | 3. 借助线上、线下数据在 CI/CD 时进行自动化测试，实现更全面真实的测试用例。
80 | 
81 | 业内基本是数种思路齐头并进，最常见的是第一种方式。最有效，但开销也是最大的，并且会导致预发布环境的一定阻塞。
82 | 
83 | 随后第二第三种大多都会紧接着跟进，具体程度会根据公司的软硬实力（例如：行政手段、基础设施等）不同而做的深度不同。
84 | 
85 | 甚至前几天听小咸鱼说，面试时还听到不少公司延伸了外包岗位专门做一块的内容。
86 | 
87 | ## 总结
88 | 
89 | 虽说这个问题并不是 “微服务” 架构所独有的。但是显然微服务化后放大了测试的深坑问题。
90 | 
91 | 很多公司的流程和措施都是为了保障一些东西，像小咸鱼团队这样，被网上布道师例举的优点遮蔽了双眼，后面又被迫把端到端测试加回来的不在少数。
92 | 
93 | **你们的团队又是如何高效解决这个问题的呢，欢迎在评论区留言和交流**！


--------------------------------------------------------------------------------
/content/posts/mq-nodus.md:
--------------------------------------------------------------------------------
  1 | ---
  2 | title: "《漫谈 MQ》设计 MQ 的 3 个难点"
  3 | date: 2021-12-31T12:54:50+08:00
  4 | toc: true
  5 | images:
  6 | tags: 
  7 |   - mq
  8 | ---
  9 | 
 10 | 
 11 | 大家好，我是煎鱼。
 12 | 
 13 | 前段时间我们分享了漫谈 MQ 的第一期《要消息队列（MQ）有什么用？》，感觉打开了一个新的世界。
 14 | 
 15 | 但很快就有小伙伴意识到了不妙，既然 MQ 承接了多个系统，那岂不是该有的问题，他都有，又或是更甚。如下：
 16 | 
 17 | ![](https://files.mdnice.com/user/3610/45b00332-9a06-49b6-a666-675890409c94.png)
 18 | 
 19 | 今天我们就进一步讲讲，**设计 MQ 时很有可能会遇到的几个大难点**，在业内又配套用了什么解决方案去处理。
 20 | 
 21 | ## 几个难点
 22 | 
 23 | 从结论上来看，设计 MQ 这一个存在。会至少引发三大难点。堪称互联网经典的，也是面试官们最爱问的：
 24 | - 高可用：代表系统的可用性程度，高可用性通常通过提高系统的容错能力来实现，从而减少系统宕机时间。
 25 | - 高并发：代表通过设计保证系统能够同时并行处理很多请求，在同一个时间点，有很多用户同时访问同一系统、API、URL。
 26 | - 高可靠：代表能够满足预计条件的一个系统或组件（例如：备份、故障处理、数据存储以及访问），比较经典的是 4 个9 等标准。
 27 | 
 28 | ### 高可用
 29 | 
 30 | 像前面评论区留言的兄弟截图表述的一样。
 31 | 
 32 | 虽然请求不直接找系统 A、B、C、D 了。但是请求都实打实的通过异步的方式打到了 MQ 上，就可以不断往 MQ 塞，变成了多个系统都在请求 MQ，可以认为压力比单系统同步调用大了不止一倍。
 33 | 
 34 | 同时 MQ 还要去做消费关系的维护，存储既有和新增的大量消息。是一个既要也要还要的典型场景。
 35 | 
 36 | 这样一来，新的一轮问题就出现了。就是要保证 MQ 的高可用，否则他轻轻松松就会被压到宕机，或是负载过高，出现一些匪夷所思的延迟。
 37 | 
 38 | 如何保证 MQ 的高可用，是一个大问题。
 39 | 
 40 | ### 高并发
 41 | 
 42 | 在高并发上的诉求上，其实是和高可用的场景是一样的。既然各业务系统都是异步的了，自然他也就不会像同步阻塞一样 “等” 你。
 43 | 
 44 | 像是我有一个朋友，他们喜欢批量清洗多租户的数据。业务程序也不怎么节制，几十、几百、上千万数据，利用 Go 语言写的，抄起 for-loop+go func 就是一把梭。刷刷刷一下子就就给打进 MQ 里。
 45 | 
 46 | 再多来几个业务系统这么干，这 MQ 并发就比较高了，单单维护就是头疼。很有可能事故背着背着，年底就 3.25 了。因为 MQ，在业务中的依赖非常重，是标准的核心基础设施。
 47 | 
 48 | 如何保证 MQ 能够承受高并发，是一个大问题。
 49 | 
 50 | ### 高可靠
 51 | 
 52 | 对 MQ 来讲，高可靠性的诉求，又分为好几个角度去理解。如下：
 53 | - 消息要靠谱：“我” 发的消息要能够可靠的到达 MQ，MQ 要能够正确的让消费者能够接收到推送或拉取。
 54 | - 存储要靠谱：“我” 发的消息，还在 MQ 上时要存储好，不能发到 MQ 上就因为大量数据，丢了。又或是查询很慢。
 55 | - 处理要靠谱：发了消息，可能会出现异常。发了消息，可能网络抖动，没有接收到。
 56 | 
 57 | 上述我们列了三点 “要靠谱” 的内容。实质上，对于 MQ 来讲，其每一块领域都要保证其可靠性，否则查起问题来，真的是会非常崩溃。
 58 | 
 59 | 甚至更往上，还会对 “高性能” 会有要求，不过这一块我们就不进一步展开了。
 60 | 
 61 | ## 解决方案
 62 | 
 63 | ### 核心流程
 64 | 
 65 | 在清楚了设计 MQ 会遇到的三大难点后。我们需要先了解一下现代 MQ 的基础应用架构会是怎么样的。
 66 | 
 67 | MQ 包含如下三类角色：
 68 | - 生产者（Producer）：负责生产消息。
 69 | - 消费者（Consumer）：负责消费消息。
 70 | - 服务端（Broker）：负责存储和处理消息，是 MQ 的核心部分。由队列（Queue）延伸而来，因为功能已经不仅仅局限于队列属性了。
 71 | 
 72 | 其核心流程如下：
 73 | 
 74 | ![核心流程](https://image.eddycjy.com/7b729b7d25ab9f52205008b3ee63dae7.jpg)
 75 | 
 76 | 1. 生产者（Producer）发送消息到达服务端（Broker），服务端进行消息存储，核心逻辑处理等。
 77 | 2. 再根据先前注册消费的关系（例如：订阅），进行消息的推送或被拉取。也就是消费消息了。
 78 | 3. 在完成消费消息后再返回确认（ACK）给服务端。若出现一定时间内未收到 ACK，则会触发服务端的重试机制。
 79 | 4. 服务端确定消息处理完毕，删除消息和进行记录。
 80 | 
 81 | ### 对三高下手
 82 | 
 83 | #### 设计高可用
 84 | 
 85 | 在高可用上，主要要针对服务端（Broker）来做。目前常见的是保证服务端可以进行水平扩展，能够做跨集群的部署。
 86 | 
 87 | 因此相应上得配套做服务的注册和发现机制，负载均衡（确保服务端压力均衡）。以此来构成 MQ 高可用的基本维持。
 88 | 
 89 | #### 设计高并发
 90 | 
 91 | 在高并发上，服务端必然包含队列（Queue），会起到缓冲的作用。但仍然可能会出现单点流量过大。
 92 | 
 93 | 因此通常会结合像是 RocketMQ 的 Topic，Kafka 的 Partition 等做队列划分，起到分而治之的作用。
 94 | 
 95 | #### 设计高可靠
 96 | 
 97 | 在高可靠上，主要是针对消息发送、存储消息、处理消息这三块进行展开。
 98 | 
 99 | 消息发送上，会结合 SDK 和服务端两者，发送和消费消息的确认（ACK）机制、重试机制等来实现消息的可靠性。
100 | 
101 | 存储消息上，常见分为：分布式缓存、分布式文件系统、数据库方案等。目前主流的话，会采取落盘的方式，也就是将消息主体追加写入到日志文件，再配合索引文件来做快速的消息查找。
102 | 
103 | 和 MySQL 数据库的存储模式是有一定的神似之处。
104 | 
105 | ## 总结
106 | 
107 | 在今天这篇文章中，我们面向设计 MQ 中常见的 3 大难点（其实还有更多，以后再介绍...）进行了逐一介绍和说明。同时也针对业内常见的解决方案进行了剖析。
108 | 
109 | 在我们了解了这些细节后，在真正应用 MQ 时，就不会感到那么的无奈。因为常常你所遇到的，消息丢失，又或是消息重试导致裂变所导致宕机。
110 | 
111 | 往往都来自于你所忽略的这些设计细节之中。即使对到用户端上只是几个简单的配置，你也应当理解这些知识 ：）


--------------------------------------------------------------------------------
/content/posts/prometheus/2020-05-16-pull.md:
--------------------------------------------------------------------------------
  1 | ---
  2 | title: "使用 Prometheus 对 Go 程序进行指标采集"
  3 | date: 2020-05-17T17:52:37+08:00
  4 | ---
  5 | 
  6 | 在前面的章节中，已经知道了如何对应用程序进行 Prometheus metrics 的注册和暴露，那么接下来如何让 Prometheus 对应用程序进行采集呢。
  7 | 
  8 | ## 设置采集配置
  9 | 
 10 | 首先打开先前所安装的 prometheus 软件目录：
 11 | 
 12 | ```sh
 13 | $ ls
 14 | LICENSE                data                   promtool
 15 | NOTICE                 prometheus             rules
 16 | console_libraries      prometheus.yml         tsdb
 17 | consoles               prometheus.yml.default
 18 | ```
 19 | 
 20 | 打开并修改 prometheus.yml 文件，查看到 [scrape_configs](https://prometheus.io/docs/prometheus/latest/configuration/configuration/#scrape_config) 配置选项，进行如下调整：
 21 | 
 22 | ```sh
 23 | ...
 24 | scrape_configs:
 25 |   - job_name: 'test01'
 26 |     static_configs:
 27 |     - targets: ['127.0.0.1:10001']
 28 |     scheme: http
 29 |     tls_config:
 30 |         insecure_skip_verify: false
 31 | ```
 32 | 
 33 | 先前所启动的应用程序是在本地，且端口号为 10001，协议为 http，对应的配置简述：
 34 | 
 35 | - job_name：采集的任务名。
 36 | 
 37 | - static_configs.targets：设置要采集的目标对象列表。
 38 | 
 39 | - scheme：采集的目标协议（例如：http、https）。
 40 | 
 41 | - tls_config.insecure_skip_verify：是否跳过证书校验。
 42 | 
 43 | 常用的配置项如上几个，其默认的 metrics path 为 `/metrics`，若需要调整则增加 metrics_path 配置项进行调整就可以了，接着重新启动 prometheus 就可以了。
 44 | 
 45 | ## 其他配置项
 46 | 
 47 | 再返回来看看 prometheus.yaml 文件：
 48 | 
 49 | ```
 50 | global:
 51 |   scrape_interval:     15s 
 52 |   evaluation_interval: 15s
 53 | 
 54 | 
 55 | alerting:
 56 |   alertmanagers:
 57 |   - static_configs:
 58 |     - targets:
 59 |        - localhost:9093
 60 | 
 61 | rule_files:
 62 |    - ../rules/*.yaml
 63 | 
 64 | scrape_configs:
 65 |   - job_name: 'test01'
 66 |     static_configs:
 67 |     - targets: ['127.0.0.1:10001']
 68 |     scheme: http
 69 |     tls_config:
 70 |         insecure_skip_verify: false
 71 | ```
 72 | 
 73 | - scrape_interval：采集间隔（频率）。
 74 | 
 75 | - evaluation_interval：规则计算间隔（频率）。
 76 | 
 77 | - alerting.alertmanagers：此 prometheus 所计算的 rules 所对应的 alertmanager。
 78 | 
 79 | - rule_files：此 prometheus 所对应的告警规则（rules）。
 80 | 
 81 | 这里聚焦 rule_files 和 alertmanagers，其分别对应着后续章节所要学的告警规则编写和 alertmanager 的告警平台对接和使用，留个心眼即可。
 82 | 
 83 | ## 重新启动 Prometheus
 84 | 
 85 | 在启动 prometheus 时，可以根据自己的情况进行一些启动项的调整：
 86 | 
 87 | ```
 88 | $ ./prometheus --web.listen-address="0.0.0.0:9091" --config.file="prometheus.yml" 
 89 | ```
 90 | 
 91 | 在上述语句中，`--web.listen-address` 调整启动的监听 HOST+PORT，`--config.file` 调整 prometheus 启动时所读取的配置文件地址，更多的可以执行 `./prometheus --help` 命令进行查看。
 92 | 
 93 | ## 查看采集情况
 94 | 
 95 | 在完成配置后，在经过 scrape_interval 秒后，将会自动采集到 prometheus 上，就可以在 Console 上进行查看：
 96 | 
 97 | ![image](https://image.eddycjy.com/958dd2950b64c2a10a73b03864b0e153.jpg)
 98 | 
 99 | 若想要简单查看趋势，也可以通过 Graph 进行趋势分析：
100 | 
101 | ![image](https://image.eddycjy.com/13e83b57dde665ffbbea8456efd0b146.jpg)
102 | 
103 | 但长久来看，还是建议使用 Grafana（后续会进行讲解）。
104 | 
105 | ## 总结
106 | 
107 | 至此就完成了一个 Prometheus 对 Go 应用程序的基本采集，本章节主要是熟悉 Prometheus 拉模式的采集机制，以及对应的 Promtheus 规则编写和使用即可，虽然比较很简单，但是这块内容的知识体系的了解程度是后面所有内容的基石，建议根据[官方文档](https://prometheus.io/docs/introduction/overview/)再进一步的学习。
108 | 
109 | 
110 | 


--------------------------------------------------------------------------------
/content/posts/reading/2020-04-24-book.md:
--------------------------------------------------------------------------------
 1 | ---
 2 | title: "2020年下半年：读书清单"
 3 | date: 2020-04-24T22:00:45+08:00
 4 | toc: false
 5 | images:
 6 | tags: 
 7 |   - 读书清单
 8 | ---
 9 | 
10 | 2020 年的上半年因为一些事情耽搁了整体的进程，不过最近也快要到 Deadline 了，因此又愉快的能空出手了。
11 | 
12 | 回顾这几年在个人技能上，我随着公司的大泥球应用再到微服务化的飞速发展，经历了很多，突破了更多，有了不少新的感悟。因此今年打算再修修内功，认识一下自己的弱小，所以读书清单会比较偏基础方向，如下：
13 | 
14 | ## 必看
15 | 
16 | 1. 《图解 TCP/IP》
17 | 2. 《TCP/IP 详解 卷1：协议》
18 | 3. 《深入理解计算机系统》
19 | 4. 《大话数据结构》
20 | 5. 《算法（第4版）》
21 | 6. 《剑指 Offer》
22 | 7. [《操作系统_清华大学》](https://www.bilibili.com/video/BV1js411b7vg)
23 | 
24 | ## 可选
25 | 
26 | 1. 《Unix 环境高级编程（第3版）》
27 | 2. 《SRE Google 运维解密》：进行中，已经了看了不少。
28 | 3. 《Google 工作法》：进行中，已经了看了不少。
29 | 
30 | 所有的目标都需要有一个验收的标准和奖罚，否则所谓的目标意义不会特别大。我想，**验收标准就是 [《重读 CS》](https://github.com/eddycjy/reread-cs-notes) 的基本成型**，其它不在该集合类的属于第二梯队，考虑释出读书笔记。
31 | 
32 | 惩罚的话，发红包还是送书呢，先想想。
33 | 


--------------------------------------------------------------------------------
/content/posts/reading/documentary-of-go.md:
--------------------------------------------------------------------------------
 1 | ---
 2 | title: "Go: A Documentary 发布！"
 3 | date: 2020-09-11T20:46:38+08:00
 4 | toc: false
 5 | images:
 6 | tags: 
 7 |   - untagged
 8 | ---
 9 | 
10 | 以前经常有读者问我，哪儿可以找到 Go 语言的前世今生，这种时候我们往往会告诉他去看 issues 和 proposals。但资料有点分散，且没有索引体系。因此不少人新入门的读者读着读着就跑偏了，又或是在第一步找资料上就被拦住了。
11 | 
12 | 最近欧神（@changkun）低调的发布了 《Go: A Documentary》，这个文档收集了 Go 开发过程中许多有趣（公开可见的）的问题，讨论，提案，CL 和演讲，其目的是为 Go 历史提供全面的参考。
13 | 
14 | 个人认为这份资料非常的有价值，相当于欧神把资料索引整理好了，强烈推荐对 Go 语言感兴趣的读者进行阅读：
15 | 
16 | ![image](https://image.eddycjy.com/0643ae29cdb8fb99d5a83bf67b443a9a.jpg)
17 | 
18 | 内容索引主要分为：
19 | 
20 | - Sources
21 | - Committers
22 |     - Core Authors
23 |     - Compiler/Runtime Team
24 |     - Library/Tools/Security/Community
25 |     - Group Interviews
26 | - Timeline
27 | - Language Design
28 |     - Misc
29 |     - Slice
30 |     - Package Management (1.4, 1.5, 1.7)
31 |     - Type alias (1.9)
32 |     - Defer (1.13)
33 |     - Error values (1.13)
34 |     - Channel/Select
35 |     - Generics
36 | - Compiler Toolchain
37 |     - Compiler
38 |     - Linker
39 |     - Debugger
40 |     - Tracer
41 |     - Builder
42 |     - Modules
43 |     - gopls
44 |     - Testing
45 | - Runtime Core
46 |     - Statistics
47 |     - Scheduler
48 |     - Execution Stack
49 |     - Memory Allocator
50 |     - Garbage Collector
51 |     - Memory model
52 |     - ABI
53 | - Standard Library
54 |     - syscall
55 |     - io
56 |     - go/*
57 |     - sync
58 |     - Pool
59 |     - Mutex
60 |     - atomic
61 |     - time
62 |     - context
63 |     - encoding
64 |     - image, x/image
65 |     - misc
66 | - Unclassified But Relevant Links
67 | - Fun Facts
68 | - Acknowledgements
69 | 
70 | 《Go: A Documentary》 的访问地址是 `https://golang.design/history/`，GitHub 仓库地址：`https://github.com/golang-design/history`，大家也可以通过 “阅读原文” 进入。
71 | 


--------------------------------------------------------------------------------
/content/posts/reading/programmer-linker.md:
--------------------------------------------------------------------------------
 1 | ---
 2 | title: "链接器，应用编译的最后一公里路"
 3 | date: 2020-11-05T21:15:46+08:00
 4 | toc: true
 5 | draft: true
 6 | images:
 7 | tags: 
 8 |   - 程序员的自我修养
 9 | ---
10 | 
11 | 在《应用编译，计算机中那些一定要掌握的知识细节》中，我们完成了对 ”预处理、编译、汇编“ 三个基本步骤的了解。接下来剩余完整编译输出的最后一公里路，那就是 ”链接“。
12 | 
13 | 编译器在经过扫描、语法分析、语义分析、源代码优化、代码生成和目标代码优化后，源代码终于被编译成了目标代码。但又遇到了新的问题，那就是 “目标代码中有变量定义在其他模块怎么办？”
14 | 
15 | 而其他模块的全局变量和函数的绝对地址是在最终**链接阶段**才会确定，这是很重要的一步，有了模块串联才能让目标程序跑起来。
16 | 
17 | ## 静态链接
18 | 
19 | ### 地址分配
20 | 
21 | ### 空间分配
22 | 
23 | ### 符合决议
24 | 
25 | ### 重定位
26 | 
27 | ## 动态链接
28 | 
29 | ## 总结


--------------------------------------------------------------------------------
/content/posts/reload-man.md:
--------------------------------------------------------------------------------
 1 | ---
 2 | title: "为什么鼓励可以重塑一个职场人？"
 3 | date: 2021-12-31T12:54:56+08:00
 4 | toc: true
 5 | images:
 6 | tags: 
 7 |   - 职场成长
 8 | ---
 9 | 
10 | 大家好，我是煎鱼。
11 | 
12 | 最近在看书的时候看到了一句很经典的话：“**重塑一个人行为最好的方式是鼓励**”。平时我在多个领域的不同图书、不同面谈场合都能听到过不同的诠释。
13 | 
14 | ![](https://files.mdnice.com/user/3610/9a4b75a6-b512-47b8-9c12-28d9b8e7a068.jpg)
15 | 
16 | 可惜的是作者大多都没有指出是 “心理学” 的范畴，都只是表示应该要这么做，没有表示为什么，没有讲解来源，传播的信息非常的 3.5 手。
17 | 
18 | 为此特意咨询了身边的一个心理学科班大佬，自打我认识她以来，每次开会都能看到她点头表示肯定，在我的记忆中非常深刻，非常有意思。
19 | 
20 | 与她咨询过后，得出对应的是理论是 “**皮格马利翁效应**”。今天就进一步展开来简单学习、思考一下这为何物。
21 | 
22 | ## 背景
23 | 
24 | 皮格马利翁效应，又称毕马龙效应、罗森塔尔效应或期待效应，是指人（通常是指孩童或学生）在被赋予更高期望以后，他们会表现的更好的一种现象。
25 | 
26 | ![图来自网络](https://files.mdnice.com/user/3610/e27b3d98-18c0-4cfc-bd4d-5900ac772351.png)
27 | 
28 | 美国心理学家罗伯特·罗森塔尔和雷诺尔·雅各布森对此进行了研究。在他们的研究中发现，假设**老师对学生的期望加强，学生的表现也会相对加强**。
29 | 
30 | ## 实验
31 | 
32 | 在罗森塔尔的实验中，他们从 1~6 年级各选了 3 个班，对这 18 个班的学生进行了 “未来发展趋势测验”。并将一份 “最有发展前途者” 名单（实际上是随便抽取出来的）交给了校长和相关老师。
33 | 
34 | ![图来自网络](https://files.mdnice.com/user/3610/6a09db03-5811-4ff7-b6b5-7a2cb2cc36e4.png)
35 | 
36 | 在 8 个月后，罗森塔尔和助手们对那 18 个班级的学生进行复试，结果发现：**被期望的学生表现出更有适应能力、更有魅力、求知欲更强、智力更活跃等倾向**。
37 | 
38 | ![图来自网络](https://files.mdnice.com/user/3610/c59f2415-812a-4d74-bc93-03f360944b79.png)
39 | 
40 | 通过各种研究和试验得出结论：**认为教师的期望会传递给被期望的学生并产生鼓励效应，进而产生改变**。
41 | 
42 | 也正是因为罗森塔尔对该效应在小学教学上予以验证提出，皮格马利翁效应也被称为“罗森塔尔效应”。
43 | 
44 | ## 思考
45 | 
46 | 回到最初的话题，为什么作者会说 ”重塑一个人行为最好的方式是鼓励”，这让我想起了非常著名两类思考模式：
47 | 
48 | ![图来自网络](https://files.mdnice.com/user/3610/db4d42cc-9519-4c03-8961-57b3deaf9a65.png)
49 | 
50 | - 成长型思考模式：认为学习不在于天赋，在于努力，只要努力用功，什么都能学会。
51 | - 固定型思考模式：特别相信天赋的作用，擅长的东西就是擅长，要是不擅长怎么学都没有用。
52 | 
53 | 这其实就直接和 “鼓励” 有关系，我们接下来结合 “否定” 和 “鼓励” 来具体展开说说。
54 | 
55 | 看看长期对一个人进行 “否定”，又或是进行 “鼓励” 可能会发生怎么样的事情，会不会改变一个人？
56 | 
57 | ### 否定
58 | 
59 | 如果在职场中，你**对一个人一直是否定、不认可，这对他是不好的**。你无论做什么，那个人总是挑刺，冷嘲热讽，在公开场合批判你。
60 | 
61 | 可能会带来如下结果：
62 | - 若他是一张白纸：极有可能就会认为自己不行，认为自己怎么学都没有用，无限的进行自我否定，很难走出来。
63 | - 若他不是白纸：明确知道自己的底线，一直否定、不认可，也会反噬你团队，又或是对你有极大的意见。
64 | 
65 | 这还是明确是否白纸的场景，但**更多的人不是非黑即白，也就是在灰色，处于两者之间**，不少人会怀疑人生。
66 | 
67 | 逐渐才发现是**大家常说的职场 PUA**，这在勾心斗角的某些地方很常见。
68 | 
69 | ### 鼓励
70 | 
71 | 如果我们加之鼓励，多鼓励职场中的同事，在不同的人生阶段能带来不同的结果：
72 | - 从小培养：埋下成长型思维模式的种子，他会主动把每一项任务都当成成长的机会，主动愿意花更长的时间钻研难题，主动选择更困难的任务。
73 | - 成年发展：知道自己不应该被局限、固定的思维定式所控制，慢慢把 “固定型思考” 转变成 “成长型思考”，就会有较大的突破。
74 | 
75 | 在职场中受到鼓励后，就**会朝着这块持续不断地突破，获得自我和周遭的成就和认同感，进而更进一步的拓展，得到更多的发展空间**，这就是 “鼓励” 的力量。
76 | 
77 | ## 职场和工作
78 | 
79 | 无论是哪种形式：爱鼓励、爱批评、爱否定。这世界上都大有人在，总是包罗万象，走 “二极管” 是错误的，单一的某种方式总是会带来极端。
80 | - 若是永远只有 “鼓励”：那社会上人是千人千面的，习惯性被鼓励，没人鼓励，就动不了了。
81 | - 若是只有 “批判”、“否定”：那就更糟糕了。一个只会骂人的 Leader，你愿意跟吗？我相信肯定不愿意。
82 | 
83 | 在职场中，除了要多鼓励他人、接受他人鼓励外，我们要多和公司内、同行、同业圈的小伙伴聊聊，及时找到自己的模糊、问题、错误的点。
84 | 
85 | 再针对性释出自己的解决方案，和朋友共同探索，寻找新的解决思路或方法，持续优化下去。
86 | 
87 | 这样就能够有一定的突破和增长，想永远都是问题，想后做了，才是答案，才能改进。
88 | 
89 | ## 最后
90 | 
91 | 如果是你，孩子考试考得不错，作业写得好，如何表扬孩子聪明？
92 | - A：“这题你都会做？我儿子太聪明了！”
93 | - B：“不错啊！这次做的很好，看来你下了很大功夫！下次继续！只要你努力！什么事都能做成！”
94 | 
95 | 选择 A，还是 B 呢？
96 | 
97 | **欢迎大家在评论区留言和交流，说出你的答案和我们在思考**！
98 | 


--------------------------------------------------------------------------------
/content/posts/where-is-proto.md:
--------------------------------------------------------------------------------
 1 | ---
 2 | title: "Proto 代码到底放哪里？"
 3 | date: 2020-05-23T15:07:37+08:00
 4 | draft: false
 5 | toc: true
 6 | images:
 7 | tags: 
 8 |   - protobuf
 9 | ---
10 | 
11 | 虽然公司已经从大单体切换为微服务化有一定的年头了，但一些细节方面的处理总会有不同的人有不同的看法，这其中一个讨论点，就是 Proto 这个 IDL 的代码到底放在哪里？
12 | 
13 | 目前来看，一共有如下方案， 我们一起来探讨一下 Proto 的存储方式和对应带来的优缺点。
14 | 
15 | ## 方案一：存放在代码仓库
16 | 
17 | 直接将项目所依赖到的所有 Proto 文件都存放在 `proto/` 目录下，不经过开发工具的自动拉取和发布：
18 | 
19 | ![image](https://image.eddycjy.com/7e95a76d548197cf73e7238ee5df27e6.jpg)
20 | 
21 | ### 缺点
22 | 
23 | 1. 项目所有依赖的 Proto 都存储在代码仓库下，因此所有依赖 Proto 都需要人工的向其它业务组 “要” 来，再放到 `proto/` 目录下，人工介入极度麻烦。
24 | 
25 | 2. Proto 升级和变更，经常要重复第一步，沟通成本高。
26 | 
27 | ### 优点
28 | 
29 | 1. 项目所有依赖的 Proto 都存储在代码仓库下，因此不涉及个人开仓库权限的问题。
30 | 
31 | 2. 多 Proto 的切换开销减少，因为都在代码仓库下，不需要看这看那。
32 | 
33 | ## 方案二：独立仓库
34 | 
35 | 独立仓库存储是我们最早采取的方式，也就是每个服务对应配套一个 Proto 仓库：
36 | 
37 | ![image](https://image.eddycjy.com/a7575628ff1ae9179f022d477aba9df1.png)
38 | 
39 | 这个方案的好处就是可以独立管理所有 Proto 仓库，并且权限划分清晰。但最大的优点也是最大的缺点，因为一个服务会依赖多个 Proto 仓库，并且存在跨业务组调用的情况：
40 | 
41 | ![image](https://image.eddycjy.com/31c5a5b5652f44750124c15e1c0ef397.jpg)
42 | 
43 | 如上图所示，svc-user 服务分别依赖了三块 Proto 仓库，分别是自己组的、业务组 A、业务组 B 总共的 6 个 Proto 仓库。
44 | 
45 | ### 缺点
46 | 
47 | 1. 假设你是一个新入职的开发人员，那么你就需要找不同的业务组申请不同的仓库权限，非常麻烦。如果没有批量赋权工具，也没有管理者权限，那么就需要一个个赋权，非常麻烦。
48 | 2. 在运行服务的时候，你需要将所有相关联的 Proto 仓库拉取下来，如果没有工具做半自动化的支持，麻烦程度无法忍受。
49 | 
50 | ### 优点
51 | 
52 | 1. 使得安全性较高（但 IDL 本身没有太多的秘密）。
53 | 
54 | 2. 按需拉取，不需要关注其余的服务 Proto。
55 | 
56 | ## 方案三：集中仓库
57 | 
58 | 集中仓库也是一些公司考虑的方式之一，是按公司或大事业部的维度进行 Proto 代码的存储，这样子只需要拉取一个仓库，就可以获取到所有所需的 IDL：
59 | 
60 | ![image](https://image.eddycjy.com/9f0c7821aa2d42857685e04d9df25740.jpg)
61 | 
62 | ### 缺点
63 | 
64 | 1. 安全性下降，因为其它业务组的 IDL 也全都 “泄露” 了。
65 | 
66 | 2. 非按需拉取，在查看原始文件时，需要关注一些多余的。
67 | 
68 | ### 优点
69 | 
70 | 1. 只需要拉取一次 Proto 仓库就可以轻松把一个服务所需的 IDL 集齐。
71 | 
72 | 2. 仓库权限管理的复杂度下降。
73 | 
74 | ## 方案四：镜像仓库
75 | 
76 | 结合上面几种方案的特点，我们也可以得出镜像仓库的方式，也就是自己服务的 Proto 文件存放在代码仓库的 proto 文件中，在本次 feature 提交或发布后，自动同步到镜像仓库去。
77 | 
78 | 而你所依赖的其他服务 Proto 则直接通过读取集中的镜像仓库的方式获取：
79 | 
80 | ![image](https://image.eddycjy.com/d90a0040923aacced41549ea902e6cde.jpg)
81 | 
82 | 这样子的话，通过开发工具的配合，开发人员在开发时就只需要关注自己项目的 Proto，集中的镜像仓库用于构建和部署时就可以了，大幅度降低了多 Proto 的关注和切换开销。
83 | 
84 | ## 方案五：其他
85 | 
86 | 本质上上述的所有方案多多少少都有一些利弊存在，并且都需要开发工具来进行支持，否则实操起来还是非常麻烦。
87 | 
88 | 如果想一劳永逸，可以通过云开发环境来解决，因为在分配云开发机时，你已经有了身份认证，你能够拥有什么权限，不能拥有什么权限，基本都是明确的，并且一般在组内、跨组联调时，也可以直接调度，不需要像其它方案那样进行过多的关注，甚至在自己本地运行一套微服务。
89 | 
90 | 但这需要大量的工具/资源支持。
91 | 
92 | ## 小结
93 | 
94 | 在本文中我介绍了比较常见的 5 种 Proto 代码的管理方式，其各有利弊，不同公司不同人的理解或适配度都不一样，大家可以根据实际环境进行选用，并且建议拉上核心的人员进行讨论和选型，因为 Proto 代码涉略面还是比较广的，多多少少都有人有不一样的看法。


--------------------------------------------------------------------------------
/content/prometheus-categories.md:
--------------------------------------------------------------------------------
 1 | ---
 2 | title: "《跟煎鱼学 Prometheus》"
 3 | date: "2020-05-16"
 4 | ---
 5 | 
 6 | 请注意，这不是成品，随时可能会对以前的章节进行修改。那么为什么要放出来呢，当然是为了催更自己。
 7 | 
 8 | 1. [Prometheus 快速入门](/posts/prometheus/2020-05-16-startup)
 9 | 2. [Prometheus 四大度量指标的了解和应用](/posts/prometheus/2020-05-16-metrics)
10 | 3. [使用 Prometheus 对 Go 程序进行指标采集](/posts/prometheus/2020-05-16-pull)
11 | 
12 | ### 我的公众号
13 | 
14 | 平时喜欢分享 Go 语言、微服务架构和奇怪的系统设计，欢迎关注我的公众号：
15 | 
16 | ![image](https://image.eddycjy.com/7074be90379a121746146bc4229819f8.jpg)


--------------------------------------------------------------------------------
/layouts/_default/baseof.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html lang="{{.Site.LanguageCode}}">
 3 | 
 4 | <head>
 5 | 	<meta charset="UTF-8">
 6 | 	<meta name="viewport" content="width=device-width, initial-scale=1.0">
 7 | 	<meta http-equiv="X-UA-Compatible" content="ie=edge">
 8 | 	{{- with .Site.Params.themeColor }}
 9 | 	<meta name="theme-color" content="{{.}}">
10 | 	<meta name="msapplication-TileColor" content="{{.}}">
11 | 	{{- end }}
12 | 	{{- partial "structured-data.html" . }}
13 | 	{{- partial "favicons.html" }}
14 | 	<title>{{.Title}}</title>
15 | 	{{ range .AlternativeOutputFormats -}}
16 | 		{{ printf `<link rel="%s" type="%s+%s" href="%s" title="%s" />` .Rel .MediaType.Type .MediaType.Suffix .Permalink $.Site.Title | safeHTML }}
17 | 	{{ end -}}
18 | 	{{ $style := resources.Get "scss/style.scss" | resources.ExecuteAsTemplate "css/style.css" . | toCSS | minify | fingerprint -}}
19 | 	<link rel="stylesheet" href="{{ $style.Permalink }}">
20 | 	{{- block "head" . -}}{{- end }}
21 | 	{{- range .Site.Params.customCSS }}
22 | 	<link rel="stylesheet" href="{{ . | absURL }}">
23 | 	{{- end }}
24 | 	{{- if templates.Exists "partials/extra-head.html" -}}
25 | 	{{ partial "extra-head.html" . }}
26 | 	{{- end }}
27 | </head>
28 | 
29 | <body id="page">
30 | 	{{ block "header" . -}}{{ end -}}
31 | 	{{ block "main" . -}}{{ end -}}
32 | 	{{ block "footer" . -}}{{ end }}
33 | 	{{ $script := resources.Get "js/main.js" | minify | fingerprint -}}
34 | 	<script src="{{ $script.Permalink }}"></script>
35 | 	{{- partial "analytics.html" . }}
36 | 	{{- if templates.Exists "partials/extra-foot.html" -}}
37 | 	{{ partial "extra-foot.html" . }}
38 | 	{{- end }}
39 | </body>
40 | 
41 | </html>
42 | 


--------------------------------------------------------------------------------
/layouts/_default/list.html:
--------------------------------------------------------------------------------
 1 | {{ define "header" }}
 2 | {{ partialCached "header.html" . }}
 3 | {{ end }}
 4 | 
 5 | {{ define "main" }}
 6 | 	<main class="site-main section-inner thin animated fadeIn faster">
 7 | 		<h1>{{ .Title }}</h1>
 8 | 		{{- if .Content }}
 9 | 		<div class="content">
10 | 			{{ .Content }}
11 | 		</div>
12 | 		{{- end }}
13 | 		{{- range .Data.Pages.GroupByDate "2006" }}
14 | 		<div class="posts-group">
15 | 			<div class="post-year" id="{{ .Key }}">{{ .Key }}</div>
16 | 			<ul class="posts-list">
17 | 				{{- range .Pages }}
18 | 				<li class="post-item">
19 | 					<a href="{{.Permalink}}">
20 | 						<span class="post-title">{{.Title}}</span>
21 | 						<span class="post-day">{{ .Date.Format .Site.Params.dateformShort }}</span>
22 | 					</a>
23 | 				</li>
24 | 				{{- end }}
25 | 			</ul>
26 | 		</div>
27 | 		{{- end }}
28 | 	</main>
29 | {{ end }}
30 | 
31 | {{ define "footer" }}
32 | {{ partialCached "footer.html" . }}
33 | {{ end }}
34 | 


--------------------------------------------------------------------------------
/layouts/_default/single.html:
--------------------------------------------------------------------------------
 1 | {{ define "head" }}
 2 | 	{{ if .Params.featuredImg -}}
 3 | 	<style>.bg-img {background-image: url('{{.Params.featuredImg}}');}</style>
 4 | 	{{- else if .Params.images -}}
 5 | 		{{- range first 1 .Params.images -}}
 6 | 		<style>.bg-img {background-image: url('{{. | absURL}}');}</style>
 7 | 		{{- end -}}
 8 | 	{{- end -}}
 9 | {{ end }}
10 | 
11 | {{ define "header" }}
12 | {{ partial "header.html" . }}
13 | {{ end }}
14 | 
15 | {{ define "main" }}
16 | 	{{- if (or .Params.images .Params.featuredImg) }}
17 | 	<div class="bg-img"></div>
18 | 	{{- end }}
19 | 	<main class="site-main section-inner thin animated fadeIn faster">
20 | 		<h1>{{ .Title }}</h1>
21 | 		<div class="content">
22 | 			{{ .Content | replaceRE "(<h[1-6] id=\"([^\"]+)\".+)(</h[1-6]+>)" `${1}<a href="#${2}" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path><line x1="8" y1="12" x2="16" y2="12"></line></svg></a>${3}` | safeHTML }}
23 | 		</div>
24 | 		<div id="comments" class="thin">
25 | 			{{ partial "comments.html" . }}
26 | 		</div>
27 | 	</main>
28 | {{ end }}
29 | 
30 | {{ define "footer" }}
31 | {{ partialCached "footer.html" . }}
32 | {{ end }}
33 | 


--------------------------------------------------------------------------------
/layouts/index.html:
--------------------------------------------------------------------------------
 1 | {{ define "header" }}
 2 | {{ partialCached "header.html" . }}
 3 | {{ end }}
 4 | 
 5 | {{ define "main" }}
 6 | 		<main class="site-main section-inner thin animated fadeIn faster">
 7 |     {{ $paginator := .Paginate (where .Site.RegularPages "Type" "in" .Site.Params.mainSections) }}
 8 | 		{{ range $paginator.Pages }}
 9 |         <div class="post animated fadeInDown">
10 |             <div class="post-title">
11 |                 <h2><a href="{{ .RelPermalink }}">{{ .Title }}</a>
12 |                 </h2>
13 |             </div>
14 |             <div class="post-content">
15 |                 <div class="p_part"><p>{{ .Summary }}</p></div>
16 |             </div>
17 |             <div class="post-footer">
18 |                 <div class="meta">
19 |                     <div class="info"><em class="fas fa-calendar-day"></em><span
20 |                                 class="date">{{ .Date.Format .Site.Params.dateformNum }}</span>
21 |                         {{ with .Params.tags }}
22 |                             {{- range $index, $el := . -}}
23 |                                 <a class="tag"
24 |                                    href="{{ ( printf "tags/%s/" ( . | urlize ) ) | relLangURL }}">{{ . }}</a>
25 |                             {{- end -}}
26 |                         {{ end }}
27 |                     </div>
28 |                 </div>
29 |             </div>
30 | 				</div>
31 |     {{ end }}
32 |     <div class="pagination">
33 |         {{ template "_internal/pagination.html" . }}
34 |     </div>
35 | 		</main>
36 | {{ end }}
37 | 
38 | 
39 | {{ define "footer" }}
40 | {{ partialCached "footer.html" . }}
41 | {{ end }}
42 | 


--------------------------------------------------------------------------------
/layouts/partials/analytics.html:
--------------------------------------------------------------------------------
1 | {{ template "_internal/google_analytics_async.html" . }}
2 | 


--------------------------------------------------------------------------------
/layouts/partials/comments.html:
--------------------------------------------------------------------------------
1 | 			<script src="https://utteranc.es/client.js"
2 | 							repo="eddycjy/blog"
3 | 							issue-term="pathname"
4 | 							theme="github-light"
5 | 							crossorigin="anonymous"
6 | 							async>
7 | 			</script>


--------------------------------------------------------------------------------
/layouts/partials/favicons.html:
--------------------------------------------------------------------------------
1 | 	<link rel="apple-touch-icon" sizes="180x180" href="{{"apple-touch-icon.png" | relURL}}">
2 | 	<link rel="icon" type="image/png" sizes="32x32" href="{{"favicon-32x32.png" | relURL}}">
3 | 	<link rel="icon" type="image/png" sizes="16x16" href="{{"favicon-16x16.png" | relURL}}">
4 | 	<link rel="manifest" href="{{"site.webmanifest" | relURL}}">
5 | 	<link rel="mask-icon" href="{{"safari-pinned-tab.svg" | relURL}}" color="{{.Site.Params.themeColor}}">
6 | 	<link rel="shortcut icon" href="{{"favicon.ico" | relURL}}">
7 | 


--------------------------------------------------------------------------------
/layouts/partials/footer.html:
--------------------------------------------------------------------------------
 1 | 	<footer id="site-footer" class="section-inner thin animated fadeIn faster">
 2 | 		<p>&copy; 2018 - {{ now.Format "2006" }} <a href="{{ .Site.BaseURL }}">{{ .Site.Author.name }}</a>{{ .Site.Params.footerCopyright | safeHTML }}</p>
 3 | 		<p>
 4 | 			Made with <a href="https://gohugo.io/" target="_blank" rel="noopener">Hugo</a> &#183; Theme <a href="https://github.com/Track3/hermit" target="_blank" rel="noopener">Hermit</a>
 5 | 			{{- with (not (in (.Site.Language.Get "disableKinds") "RSS")) }} &#183; <a href="{{ "posts/index.xml" | absURL }}" target="_blank" title="rss"><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="feather feather-rss"><path d="M4 11a9 9 0 0 1 9 9"></path><path d="M4 4a16 16 0 0 1 16 16"></path><circle cx="5" cy="19" r="1"></circle></svg></a>{{ end }}
 6 | 		</p>
 7 | 	</footer>
 8 | 
 9 | <script src="https://readmore.openwrite.cn/js/readmore.js" type="text/javascript"></script>
10 | <script>
11 |     const btw = new BTWPlugin();
12 |     btw.init({
13 |         id: 'articles',
14 |         blogId: '15881-1622044386133-596',
15 |         name: '脑子进煎鱼了',
16 |         qrcode: 'https://image.eddycjy.com/7074be90379a121746146bc4229819f8.jpg',
17 |         keyword: '666',
18 |     });
19 | </script>


--------------------------------------------------------------------------------
/layouts/partials/header.html:
--------------------------------------------------------------------------------
 1 | 	<header id="site-header" class="animated slideInUp faster">
 2 | 		<div class="hdr-wrapper section-inner">
 3 | 			<div class="hdr-left">
 4 | 				<div class="site-branding">
 5 | 					<a href="{{.Site.BaseURL}}">{{ .Site.Title }}</a>
 6 | 				</div>
 7 | 				<nav class="site-nav hide-in-mobile">
 8 | 					{{- range .Site.Menus.nav }}
 9 | 					<a href="{{ .URL | absLangURL}}">{{ .Name }}</a>
10 | 					{{- end }}
11 | 				</nav>
12 | 			</div>
13 | 			<div class="hdr-right hdr-icons">
14 | 				{{ if (or .Params.images .Params.featuredImg) -}}
15 | 				<button id="img-btn" class="hdr-btn" title="{{i18n "featuredImage"}}"><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="feather feather-image"><rect x="3" y="3" width="18" height="18" rx="2" ry="2"></rect><circle cx="8.5" cy="8.5" r="1.5"></circle><polyline points="21 15 16 10 5 21"></polyline></svg></button>
16 | 				{{- end }}
17 | 				{{- with .Params.toc -}}
18 | 				<button id="toc-btn" class="hdr-btn desktop-only-ib" title="{{i18n "tableOfContents"}}"><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="feather feather-list"><line x1="8" y1="6" x2="21" y2="6"></line><line x1="8" y1="12" x2="21" y2="12"></line><line x1="8" y1="18" x2="21" y2="18"></line><line x1="3" y1="6" x2="3" y2="6"></line><line x1="3" y1="12" x2="3" y2="12"></line><line x1="3" y1="18" x2="3" y2="18"></line></svg></button>
19 | 				{{- end }}
20 | 				{{- with .Site.Params.social -}}
21 | 				<span class="hdr-social hide-in-mobile">{{ partialCached "social-icons.html" . }}</span>
22 | 				{{- end -}}
23 | 				<button id="menu-btn" class="hdr-btn" title="{{i18n "menu"}}"><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="feather feather-menu"><line x1="3" y1="12" x2="21" y2="12"></line><line x1="3" y1="6" x2="21" y2="6"></line><line x1="3" y1="18" x2="21" y2="18"></line></svg></button>
24 | 			</div>
25 | 		</div>
26 | 	</header>
27 | 	<div id="mobile-menu" class="animated fast">
28 | 		<ul>
29 | 			{{- range .Site.Menus.main }}
30 | 			<li><a href="{{ .URL | absLangURL }}">{{ .Name }}</a></li>
31 | 			{{- end }}
32 | 		</ul>
33 | 	</div>
34 | 


--------------------------------------------------------------------------------
/layouts/partials/social-icons.html:
--------------------------------------------------------------------------------
1 | {{ range . -}}
2 | <a href="{{ .url }}" target="_blank" rel="noopener me" title="{{ .name | humanize }}">{{ partial "svg.html" . }}</a>
3 | {{- end -}}
4 | 


--------------------------------------------------------------------------------
/layouts/partials/structured-data.html:
--------------------------------------------------------------------------------
1 | {{/* We use some Hugo built-in templates, you can find their source here: */}}
2 | {{/* https://github.com/gohugoio/hugo/tree/master/tpl/tplimpl/embedded/templates */}}
3 | 
4 | {{- template "_internal/schema.html" . }}
5 | {{- template "_internal/opengraph.html" . }}
6 | {{- template "_internal/twitter_cards.html" . }}
7 | 


--------------------------------------------------------------------------------
/layouts/posts/rss.xml:
--------------------------------------------------------------------------------
 1 | <rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
 2 | 	<channel>
 3 | 		<title>{{ if eq  .Title  .Site.Title }}{{ .Site.Title }}{{ else }}{{ with .Title }}{{.}} on {{ end }}{{ .Site.Title }}{{ end }}</title>
 4 | 		<link>{{ .Permalink }}</link>
 5 | 		<description>Recent content {{ if ne  .Title  .Site.Title }}{{ with .Title }}in {{.}} {{ end }}{{ end }}on {{ .Site.Title }}</description>
 6 | 		<generator>Hugo -- gohugo.io</generator>{{ with .Site.LanguageCode }}
 7 | 		<language>{{.}}</language>{{end}}{{ with .Site.Author.email }}
 8 | 		<managingEditor>{{.}}{{ with $.Site.Author.name }} ({{.}}){{end}}</managingEditor>{{end}}{{ with .Site.Author.email }}
 9 | 		<webMaster>{{.}}{{ with $.Site.Author.name }} ({{.}}){{end}}</webMaster>{{end}}{{ with .Site.Copyright }}
10 | 		<copyright>{{.}}</copyright>{{end}}{{ if not .Date.IsZero }}
11 | 		<lastBuildDate>{{ .Date.Format "Mon, 02 Jan 2006 15:04:05 -0700" | safeHTML }}</lastBuildDate>{{ end }}
12 | 		{{ with .OutputFormats.Get "RSS" -}}
13 | 			{{ printf "<atom:link href=%q rel=\"self\" type=%q />" .Permalink .MediaType | safeHTML }}
14 | 		{{ end -}}
15 | 		{{ range .Pages }}
16 | 		<item>
17 | 			<title>{{ .Title }}</title>
18 | 			<link>{{ .Permalink }}</link>
19 | 			<pubDate>{{ .Date.Format "Mon, 02 Jan 2006 15:04:05 -0700" | safeHTML }}</pubDate>
20 | 			{{ with .Site.Author.email }}<author>{{.}}{{ with $.Site.Author.name }} ({{.}}){{end}}</author>{{end}}
21 | 			<guid>{{ .Permalink }}</guid>
22 | 			<description>{{ .Summary | html }}</description>
23 | 			<content type="html">{{ printf `<![CDATA[%s]]>` .Content | safeHTML }}</content>
24 | 		</item>
25 | 		{{ end }}
26 | 	</channel>
27 | </rss>
28 | 


--------------------------------------------------------------------------------
/resources/_gen/assets/scss/scss/style.scss_c16d144eee185fbddd582cd5e25a4fae.json:
--------------------------------------------------------------------------------
1 | {"Target":"css/style.min.d3141168199607bf3a517216ce3c263814eecdbc8fca72a9a88700799a838219.css","MediaType":"text/css","Data":{"Integrity":"sha256-0xQRaBmWB786UXIWzjwmOBTuzbyPynKpqIcAeZqDghk="}}


--------------------------------------------------------------------------------
/static/css/styles.css:
--------------------------------------------------------------------------------
  1 | :root {
  2 |     --bg-color: #fff;
  3 |     --secondary-bg-color: #eeeeee;
  4 |     --heading-color: #5f5f5f;
  5 |     --body-color: rgba(0, 0, 0, 0.7);
  6 |     --post-color: rgba(0, 0, 0, 0.44);
  7 |     --border-color: rgba(0, 0, 0, 0.15);
  8 |     --pre-bg-color: #f9f9fd;
  9 |     --nav-text-color: #5a5a5a;
 10 |     --tag-color: #424242;
 11 |     --blockquote-text-color: #858585;
 12 |     --blockquote-border-color: #dfe2e5;
 13 |     scroll-padding-top: 100px;
 14 | }
 15 | 
 16 | .post .post-footer {
 17 |     padding: 0 0 10px 0;
 18 |     border-bottom: 1px solid var(--border-color);
 19 | }
 20 | 
 21 | .post .post-footer .meta {
 22 |     max-width: 100%;
 23 |     display: flex;
 24 |     color: #bbbbbb;
 25 | }
 26 | 
 27 | .post .post-footer .meta .info {
 28 |     float: left;
 29 |     font-size: 12px;
 30 |     margin-bottom: 1em;
 31 |     color: var(--body-color);
 32 | }
 33 | 
 34 | .post .post-footer .info .separator a {
 35 |     margin-right: 0.2em;
 36 | }
 37 | 
 38 | .post .post-footer .meta .info .date {
 39 |     margin-right: 10px;
 40 |     margin-left: 5px
 41 | }
 42 | 
 43 | .info {
 44 |     margin: 1em;
 45 | }
 46 | 
 47 | .post .post-footer .meta a {
 48 |     text-decoration: none;
 49 |     color: var(--body-color);
 50 |     padding-right: 10px;
 51 | }
 52 | 
 53 | .post .post-footer .meta a:hover {
 54 |     color: #2660ab;
 55 | }
 56 | 
 57 | .post .post-footer .meta i {
 58 |     margin-right: 6px;
 59 | }
 60 | 
 61 | .post .post-footer .tags {
 62 |     padding-bottom: 15px;
 63 |     font-size: 13px;
 64 | }
 65 | 
 66 | .post .post-footer .tags ul {
 67 |     list-style-type: none;
 68 |     display: inline;
 69 |     margin: 0;
 70 |     padding: 0;
 71 | }
 72 | 
 73 | .post .post-footer .tags ul li {
 74 |     list-style-type: none;
 75 |     margin: 0;
 76 |     padding-right: 5px;
 77 |     display: inline;
 78 | }
 79 | 
 80 | .post .post-footer .tags a {
 81 |     text-decoration: none;
 82 |     color: var(--post-color);
 83 |     font-weight: 400;
 84 | }
 85 | 
 86 | .post .post-footer .tags a:hover {
 87 |     text-decoration: none;
 88 | }
 89 | 
 90 | .pagination {
 91 |     margin: 30px;
 92 |     padding: 0px 0 56px 0;
 93 |     text-align: center;
 94 | }
 95 | 
 96 | .pagination ul {
 97 |     list-style: none;
 98 |     margin: 0;
 99 |     padding: 0;
100 |     height: 13px;
101 | }
102 | 
103 | .pagination ul li {
104 |     margin: 0 2px 0 2px;
105 |     display: inline;
106 |     line-height: 1;
107 | }
108 | 
109 | .pagination ul li a {
110 |     text-decoration: none;
111 |     color: var(--body-color);
112 | }
113 | 
114 | .pagination .pre {
115 |     float: left;
116 | }
117 | 
118 | .pagination .next {
119 |     float: right;
120 | }
121 | 
122 | .tag::before {
123 |     content: "#";
124 |     opacity: .5;
125 | }
126 | 
127 | .tag {
128 |     display: inline-block;
129 |     font-size: 15px;
130 |     line-height: 1;
131 |     margin: 5px 8px 5px 0;
132 | }
133 | 


--------------------------------------------------------------------------------
/static/favicon-16x16.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/eddycjy/blog/5d1b9c17c374d7c18b6cb6085beeb2e22c18ee24/static/favicon-16x16.png


--------------------------------------------------------------------------------
/static/favicon-32x32.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/eddycjy/blog/5d1b9c17c374d7c18b6cb6085beeb2e22c18ee24/static/favicon-32x32.png


--------------------------------------------------------------------------------
/static/favicon.ico:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/eddycjy/blog/5d1b9c17c374d7c18b6cb6085beeb2e22c18ee24/static/favicon.ico


--------------------------------------------------------------------------------
/themes/hermit/.editorconfig:
--------------------------------------------------------------------------------
 1 | # editorconfig.org
 2 | 
 3 | root = true
 4 | 
 5 | [*]
 6 | charset = utf-8
 7 | indent_style = space
 8 | indent_size = 2
 9 | end_of_line = lf
10 | insert_final_newline = true
11 | trim_trailing_whitespace = true
12 | 
13 | [*.{html,xml}]
14 | indent_style = tab
15 | 
16 | [*.md]
17 | indent_style = unset
18 | indent_size = unset
19 | insert_final_newline = unset
20 | trim_trailing_whitespace = unset
21 | 


--------------------------------------------------------------------------------
/themes/hermit/.gitattributes:
--------------------------------------------------------------------------------
1 | * text eol=lf
2 | *.png binary
3 | 


--------------------------------------------------------------------------------
/themes/hermit/LICENSE:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2018 Track3
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy of
 6 | this software and associated documentation files (the "Software"), to deal in
 7 | the Software without restriction, including without limitation the rights to
 8 | use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
 9 | the Software, and to permit persons to whom the Software is furnished to do so,
10 | subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
17 | FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
18 | COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
19 | IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
20 | CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
21 | 


--------------------------------------------------------------------------------
/themes/hermit/archetypes/default.md:
--------------------------------------------------------------------------------
1 | ---
2 | title: "{{ replace .Name "-" " " | title }}"
3 | date: {{ .Date }}
4 | draft: true
5 | comments: false
6 | images:
7 | ---
8 | 
9 | 


--------------------------------------------------------------------------------
/themes/hermit/archetypes/posts.md:
--------------------------------------------------------------------------------
 1 | ---
 2 | title: "{{ replace .Name "-" " " | title }}"
 3 | date: {{ .Date }}
 4 | draft: true
 5 | toc: false
 6 | images:
 7 | tags: 
 8 |   - untagged
 9 | ---
10 | 
11 | 


--------------------------------------------------------------------------------
/themes/hermit/assets/js/main.js:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * Utils
  3 |  */
  4 | 
  5 | // Throttle
  6 | //
  7 | const throttle = (callback, limit) => {
  8 |   let timeoutHandler = null;
  9 |   return () => {
 10 |     if (timeoutHandler == null) {
 11 |       timeoutHandler = setTimeout(() => {
 12 |         callback();
 13 |         timeoutHandler = null;
 14 |       }, limit);
 15 |     }
 16 |   };
 17 | };
 18 | 
 19 | // addEventListener Helper
 20 | //
 21 | const listen = (ele, e, callback) => {
 22 |   if (document.querySelector(ele) !== null) {
 23 |     document.querySelector(ele).addEventListener(e, callback);
 24 |   }
 25 | }
 26 | 
 27 | /**
 28 |  * Functions
 29 |  */
 30 | 
 31 | // Auto Hide Header
 32 | //
 33 | let header = document.getElementById('site-header');
 34 | let lastScrollPosition = window.pageYOffset;
 35 | 
 36 | const autoHideHeader = () => {
 37 |   let currentScrollPosition = window.pageYOffset;
 38 |   if (currentScrollPosition > lastScrollPosition) {
 39 |     header.classList.remove('slideInUp');
 40 |     header.classList.add('slideOutDown');
 41 |   } else {
 42 |     header.classList.remove('slideOutDown');
 43 |     header.classList.add('slideInUp');
 44 |   }
 45 |   lastScrollPosition = currentScrollPosition;
 46 | }
 47 | 
 48 | // Mobile Menu Toggle
 49 | //
 50 | let mobileMenuVisible = false;
 51 | 
 52 | const toggleMobileMenu = () => {
 53 |   let mobileMenu = document.getElementById('mobile-menu');
 54 |   if (mobileMenuVisible == false) {
 55 |     mobileMenu.style.animationName = 'bounceInRight';
 56 |     mobileMenu.style.webkitAnimationName = 'bounceInRight';
 57 |     mobileMenu.style.display = 'block';
 58 |     mobileMenuVisible = true;
 59 |   } else {
 60 |     mobileMenu.style.animationName = 'bounceOutRight';
 61 |     mobileMenu.style.webkitAnimationName = 'bounceOutRight'
 62 |     mobileMenuVisible = false;
 63 |   }
 64 | }
 65 | 
 66 | // Featured Image Toggle
 67 | //
 68 | const showImg = () => {
 69 |   document.querySelector('.bg-img').classList.add('show-bg-img');
 70 | }
 71 | 
 72 | const hideImg = () => {
 73 |   document.querySelector('.bg-img').classList.remove('show-bg-img');
 74 | }
 75 | 
 76 | // ToC Toggle
 77 | //
 78 | const toggleToc = () => {
 79 |   document.getElementById('toc').classList.toggle('show-toc');
 80 | }
 81 | 
 82 | 
 83 | if (header !== null) {
 84 |   listen('#menu-btn', "click", toggleMobileMenu);
 85 |   listen('#toc-btn', "click", toggleToc);
 86 |   listen('#img-btn', "click", showImg);
 87 |   listen('.bg-img', "click", hideImg);
 88 | 
 89 |   document.querySelectorAll('.post-year').forEach((ele)=> {
 90 |     ele.addEventListener('click', () => {
 91 |       window.location.hash = '#' + ele.id;
 92 |     });
 93 |   });
 94 | 
 95 |   window.addEventListener('scroll', throttle(() => {
 96 |     autoHideHeader();
 97 | 
 98 |     if (mobileMenuVisible == true) {
 99 |       toggleMobileMenu();
100 |     }
101 |   }, 250));
102 | }
103 | 


--------------------------------------------------------------------------------
/themes/hermit/assets/scss/_predefined.scss:
--------------------------------------------------------------------------------
 1 | // Colors
 2 | //
 3 | // Dark theme
 4 | //$theme: #018574;
 5 | //$text: #c6cddb;
 6 | //$light-grey: #494f5c;
 7 | //$dark-grey: #3B3E48;
 8 | //$highlight-grey: #7d828a;
 9 | //$midnightblue: #2c3e50;
10 | 
11 | $theme: #1ad1a3;
12 | $text: #3b3e48;
13 | $light-grey: #fcfcfc;
14 | $dark-grey: #f9f9f9;
15 | $highlight-grey: #7d828a;
16 | $midnightblue: #2c3e50;
17 | 
18 | // Fonts
19 | //
20 | $fonts: "Trebuchet MS", Verdana, "Verdana Ref", "Segoe UI", Candara, "Lucida Grande", "Lucida Sans Unicode", "Lucida Sans", Tahoma, sans-serif;
21 | $code-fonts: Consolas, "Andale Mono WT", "Andale Mono", Menlo, Monaco, "Lucida Console", "Lucida Sans Typewriter", "DejaVu Sans Mono", "Bitstream Vera Sans Mono", "Liberation Mono", "Nimbus Mono L", "Courier New", Courier, "YaHei Consolas Hybrid", monospace, "Segoe UI Emoji", "PingFang SC", "Microsoft YaHei";
22 | 
23 | // Mixins
24 | //
25 | @mixin dimmed {
26 |   opacity: .6;
27 | }
28 | 
29 | @mixin aTag {
30 |   a {
31 |     word-wrap: break-word;
32 |     border: none;
33 |     box-shadow: inset 0 -4px 0 $theme;
34 |     transition-property: background-color;
35 | 
36 |     &:hover {
37 |       background-color: $theme;
38 |     }
39 |   }
40 | }
41 | 


--------------------------------------------------------------------------------
/themes/hermit/assets/scss/_syntax.scss:
--------------------------------------------------------------------------------
 1 | /* Background */ .chroma { color: #eee; background-color: $midnightblue }
 2 | /* Error */ .chroma .err { color: #960050; background-color: #1e0010 }
 3 | /* LineTableTD */ .chroma .lntd { vertical-align: top; padding: 0; margin: 0; border: 0; }
 4 | /* LineTable */ .chroma .lntable { border-spacing: 0; padding: 0; margin: 0; border: 0; width: auto; overflow: auto; display: block; }
 5 | /* LineHighlight */ .chroma .hl { display: block; width: 100%;background-color: #ffffcc }
 6 | /* LineNumbersTable */ .chroma .lnt { margin-right: 0.4em; padding: 0 0.4em 0 0.4em; }
 7 | /* LineNumbers */ .chroma .ln { margin-right: 0.4em; padding: 0 0.4em 0 0.4em; }
 8 | /* Keyword */ .chroma .k { color: #66d9ef }
 9 | /* KeywordConstant */ .chroma .kc { color: #66d9ef }
10 | /* KeywordDeclaration */ .chroma .kd { color: #66d9ef }
11 | /* KeywordNamespace */ .chroma .kn { color: #f92672 }
12 | /* KeywordPseudo */ .chroma .kp { color: #66d9ef }
13 | /* KeywordReserved */ .chroma .kr { color: #66d9ef }
14 | /* KeywordType */ .chroma .kt { color: #66d9ef }
15 | /* NameAttribute */ .chroma .na { color: #a6e22e }
16 | /* NameClass */ .chroma .nc { color: #a6e22e }
17 | /* NameConstant */ .chroma .no { color: #66d9ef }
18 | /* NameDecorator */ .chroma .nd { color: #a6e22e }
19 | /* NameException */ .chroma .ne { color: #a6e22e }
20 | /* NameFunction */ .chroma .nf { color: #a6e22e }
21 | /* NameOther */ .chroma .nx { color: #a6e22e }
22 | /* NameTag */ .chroma .nt { color: #f92672 }
23 | /* Literal */ .chroma .l { color: #ae81ff }
24 | /* LiteralDate */ .chroma .ld { color: #e6db74 }
25 | /* LiteralString */ .chroma .s { color: #e6db74 }
26 | /* LiteralStringAffix */ .chroma .sa { color: #e6db74 }
27 | /* LiteralStringBacktick */ .chroma .sb { color: #e6db74 }
28 | /* LiteralStringChar */ .chroma .sc { color: #e6db74 }
29 | /* LiteralStringDelimiter */ .chroma .dl { color: #e6db74 }
30 | /* LiteralStringDoc */ .chroma .sd { color: #e6db74 }
31 | /* LiteralStringDouble */ .chroma .s2 { color: #e6db74 }
32 | /* LiteralStringEscape */ .chroma .se { color: #ae81ff }
33 | /* LiteralStringHeredoc */ .chroma .sh { color: #e6db74 }
34 | /* LiteralStringInterpol */ .chroma .si { color: #e6db74 }
35 | /* LiteralStringOther */ .chroma .sx { color: #e6db74 }
36 | /* LiteralStringRegex */ .chroma .sr { color: #e6db74 }
37 | /* LiteralStringSingle */ .chroma .s1 { color: #e6db74 }
38 | /* LiteralStringSymbol */ .chroma .ss { color: #e6db74 }
39 | /* LiteralNumber */ .chroma .m { color: #ae81ff }
40 | /* LiteralNumberBin */ .chroma .mb { color: #ae81ff }
41 | /* LiteralNumberFloat */ .chroma .mf { color: #ae81ff }
42 | /* LiteralNumberHex */ .chroma .mh { color: #ae81ff }
43 | /* LiteralNumberInteger */ .chroma .mi { color: #ae81ff }
44 | /* LiteralNumberIntegerLong */ .chroma .il { color: #ae81ff }
45 | /* LiteralNumberOct */ .chroma .mo { color: #ae81ff }
46 | /* Operator */ .chroma .o { color: #f92672 }
47 | /* OperatorWord */ .chroma .ow { color: #f92672 }
48 | /* Comment */ .chroma .c { color: #75715e }
49 | /* CommentHashbang */ .chroma .ch { color: #75715e }
50 | /* CommentMultiline */ .chroma .cm { color: #75715e }
51 | /* CommentSingle */ .chroma .c1 { color: #75715e }
52 | /* CommentSpecial */ .chroma .cs { color: #75715e }
53 | /* CommentPreproc */ .chroma .cp { color: #75715e }
54 | /* CommentPreprocFile */ .chroma .cpf { color: #75715e }
55 | /* GenericDeleted */ .chroma .gd { color: #f92672 }
56 | /* GenericEmph */ .chroma .ge { font-style: italic }
57 | /* GenericInserted */ .chroma .gi { color: #a6e22e }
58 | /* GenericStrong */ .chroma .gs { font-weight: bold }
59 | /* GenericSubheading */ .chroma .gu { color: #75715e }
60 | 


--------------------------------------------------------------------------------
/themes/hermit/exampleSite/config.toml:
--------------------------------------------------------------------------------
 1 | baseURL = "https://example.com"
 2 | languageCode = "en-us"
 3 | defaultContentLanguage = "en"
 4 | title = "Hugo Hermit"
 5 | theme = "hermit"
 6 | # enableGitInfo = true
 7 | pygmentsCodefences  = true
 8 | pygmentsUseClasses  = true
 9 | # hasCJKLanguage = true  # If Chinese/Japanese/Korean is your main content language, enable this to make wordCount works right.
10 | rssLimit = 10  # Maximum number of items in the RSS feed.
11 | copyright = "This work is licensed under a Creative Commons Attribution-NonCommercial 4.0 International License." # This message is only used by the RSS template.
12 | enableEmoji = true  # Shorthand emojis in content files - https://gohugo.io/functions/emojify/
13 | # googleAnalytics = "UA-123-45"
14 | # disqusShortname = "yourdiscussshortname"
15 | 
16 | [author]
17 |   name = "John Doe"
18 | 
19 | [blackfriday]
20 |   # hrefTargetBlank = true
21 |   # noreferrerLinks = true
22 |   # nofollowLinks = true
23 | 
24 | [taxonomies]
25 |   tag = "tags"
26 |   # Categories are disabled by default.
27 | 
28 | [params]
29 |   dateform        = "Jan 2, 2006"
30 |   dateformShort   = "Jan 2"
31 |   dateformNum     = "2006-01-02"
32 |   dateformNumTime = "2006-01-02 15:04 -0700"
33 | 
34 |   # Metadata mostly used in document's head
35 |   # description = ""
36 |   # images = [""]
37 |   themeColor = "#494f5c"
38 | 
39 |   homeSubtitle = "A minimal and fast theme for Hugo."
40 |   footerCopyright = ' &#183; <a href="https://creativecommons.org/licenses/by-nc/4.0/" target="_blank" rel="noopener">CC BY-NC 4.0</a>'
41 |   # bgImg = ""  # Homepage background-image URL
42 | 
43 |   # Prefix of link to the git commit detail page. GitInfo must be enabled.
44 |   # gitUrl = "https://github.com/username/repository/commit/"
45 | 
46 |   # Toggling this option needs to rebuild SCSS, requires Hugo extended version
47 |   justifyContent = false  # Set "text-align: justify" to `.content`.
48 | 
49 |   # Add custom css
50 |   # customCSS = ["css/foo.css", "css/bar.css"]
51 | 
52 |   # Social Icons
53 |   # Check https://github.com/Track3/hermit#social-icons for more info.
54 |   [[params.social]]
55 |     name = "twitter"
56 |     url = "https://twitter.com/"
57 | 
58 |   [[params.social]]
59 |     name = "instagram"
60 |     url = "https://instagram.com/"
61 | 
62 |   [[params.social]]
63 |     name = "github"
64 |     url = "https://github.com/"
65 | 
66 | [menu]
67 | 
68 |   [[menu.main]]
69 |     name = "Posts"
70 |     url = "posts/"
71 |     weight = 10
72 | 
73 |   [[menu.main]]
74 |     name = "About"
75 |     url = "about-hugo/"
76 |     weight = 20
77 | 


--------------------------------------------------------------------------------
/themes/hermit/exampleSite/content/about-hugo.md:
--------------------------------------------------------------------------------
 1 | +++
 2 | title = "About Hugo"
 3 | date = "2014-04-09"
 4 | +++
 5 | 
 6 | Hugo is the **world’s fastest framework for building websites**. It is written in Go.
 7 | 
 8 | It makes use of a variety of open source projects including:
 9 | 
10 | * https://github.com/russross/blackfriday
11 | * https://github.com/alecthomas/chroma
12 | * https://github.com/muesli/smartcrop
13 | * https://github.com/spf13/cobra
14 | * https://github.com/spf13/viper
15 | 
16 | Learn more and contribute on [GitHub](https://github.com/gohugoio).
17 | 
18 | 


--------------------------------------------------------------------------------
/themes/hermit/exampleSite/content/posts/hugoisforlovers.md:
--------------------------------------------------------------------------------
 1 | +++
 2 | title = "Getting Started with Hugo"
 3 | tags = [
 4 |     "go",
 5 |     "golang",
 6 |     "hugo",
 7 |     "development",
 8 | ]
 9 | date = "2014-04-02"
10 | toc = true
11 | +++
12 | 
13 | ## Step 1. Install Hugo
14 | 
15 | Go to [Hugo releases](https://github.com/spf13/hugo/releases) and download the
16 | appropriate version for your OS and architecture.
17 | 
18 | Save it somewhere specific as we will be using it in the next step.
19 | 
20 | More complete instructions are available at [Install Hugo](https://gohugo.io/getting-started/installing/)
21 | 
22 | ## Step 2. Build the Docs
23 | 
24 | Hugo has its own example site which happens to also be the documentation site
25 | you are reading right now.
26 | 
27 | Follow the following steps:
28 | 
29 |  1. Clone the [Hugo repository](http://github.com/spf13/hugo)
30 |  2. Go into the repo
31 |  3. Run hugo in server mode and build the docs
32 |  4. Open your browser to http://localhost:1313
33 | 
34 | Corresponding pseudo commands:
35 | 
36 |     git clone https://github.com/spf13/hugo
37 |     cd hugo
38 |     /path/to/where/you/installed/hugo server --source=./docs
39 |     > 29 pages created
40 |     > 0 tags index created
41 |     > in 27 ms
42 |     > Web Server is available at http://localhost:1313
43 |     > Press ctrl+c to stop
44 | 
45 | Once you've gotten here, follow along the rest of this page on your local build.
46 | 
47 | ## Step 3. Change the docs site
48 | 
49 | Stop the Hugo process by hitting Ctrl+C.
50 | 
51 | Now we are going to run hugo again, but this time with hugo in watch mode.
52 | 
53 |     /path/to/hugo/from/step/1/hugo server --source=./docs --watch
54 |     > 29 pages created
55 |     > 0 tags index created
56 |     > in 27 ms
57 |     > Web Server is available at http://localhost:1313
58 |     > Watching for changes in /Users/spf13/Code/hugo/docs/content
59 |     > Press ctrl+c to stop
60 | 
61 | 
62 | Open your [favorite editor](http://vim.spf13.com) and change one of the source
63 | content pages. How about changing this very file to *fix the typo*. How about changing this very file to *fix the typo*.
64 | 
65 | Content files are found in `docs/content/`. Unless otherwise specified, files
66 | are located at the same relative location as the url, in our case
67 | `docs/content/overview/quickstart.md`.
68 | 
69 | Change and save this file.. Notice what happened in your terminal.
70 | 
71 |     > Change detected, rebuilding site
72 | 
73 |     > 29 pages created
74 |     > 0 tags index created
75 |     > in 26 ms
76 | 
77 | Refresh the browser and observe that the typo is now fixed.
78 | 
79 | Notice how quick that was. Try to refresh the site before it's finished building. I double dare you.
80 | Having nearly instant feedback enables you to have your creativity flow without waiting for long builds.
81 | 
82 | ## Step 4. Have fun
83 | 
84 | The best way to learn something is to play with it.
85 | 


--------------------------------------------------------------------------------
/themes/hermit/exampleSite/content/posts/post-with-featured-image.md:
--------------------------------------------------------------------------------
 1 | ---
 2 | title: "Post With Featured Image"
 3 | date: 2018-10-01T16:15:09+08:00
 4 | draft: false
 5 | images: 
 6 |   - https://picsum.photos/1024/768/?random
 7 | tags: 
 8 |   - Demo
 9 |   - Image
10 | ---
11 | 
12 | Just define the image URL in the content’s front matter, the featured image will be displayed as the background. 
13 | 
14 | For example:
15 | 
16 | ```yaml
17 | ---
18 | images:
19 |   - https://picsum.photos/1024/768/?random
20 | ---
21 | ```
22 | 
23 | This is an array, you can set multiple urls, only the first url will be used. These images is also used in [Twitter Cards](https://developer.twitter.com/en/docs/tweets/optimize-with-cards/guides/getting-started.html) and the [Open Graph](http://ogp.me/) metadata.
24 | 


--------------------------------------------------------------------------------
/themes/hermit/exampleSite/content/posts/typography.md:
--------------------------------------------------------------------------------
 1 | ---
 2 | title: "Typography"
 3 | date: 2018-09-29T11:36:33+08:00
 4 | draft: false
 5 | featuredImg: ""
 6 | tags: 
 7 |   - Demo
 8 |   - Typography
 9 | ---
10 | 
11 | Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
12 | 
13 | > An apple is a sweet, edible fruit produced by an apple tree (Malus pumila). Apple trees are cultivated worldwide, and are the most widely grown species in the genus Malus. The tree originated in Central Asia, where its wild ancestor, Malus sieversii, is still found today. Apples have been grown for thousands of years in Asia and Europe, and were brought to North America by European colonists. Apples have religious and mythological significance in many cultures, including Norse, Greek and European Christian traditions.[^1]
14 | 
15 | ---
16 | 
17 | Inline styles：
18 | 
19 | **strong**, *emphasis*, ***strong and emphasis***,`code`, <u>underline</u>, ~~strikethrough~~, :joy:🤣, $\LaTeX$, X^2^, H~2~O, ==highlight==, [Link](https://example.com), and image:
20 | 
21 | ![img](https://picsum.photos/600/400/?random)
22 | 
23 | ---
24 | 
25 | Headings:
26 | 
27 | # Heading 1
28 | 
29 | ## Heading 2
30 | 
31 | ### Heading 3
32 | 
33 | #### Heading 4
34 | 
35 | ##### Heading 5
36 | 
37 | ###### Heading 6
38 | 
39 | Table:
40 | 
41 | | Left-Aligned  | Center Aligned  | Right Aligned |
42 | | :------------ | :-------------: | ------------: |
43 | | col 3 is      | some wordy text |         $1600 |
44 | | col 2 is      |    centered     |           $12 |
45 | | zebra stripes |    are neat     |            $1 |
46 | 
47 | Lists:
48 | 
49 | * Unordered list item 1.
50 | * Unordered list item 2.
51 | 
52 | 1. ordered list item 1.
53 | 2. ordered list item 2.
54 |    + sub-unordered list item 1.
55 |    + sub-unordered list item 2.
56 |      + [x] something is DONE.
57 |      + [ ] something is NOT DONE.
58 | 
59 | Syntax Highlighting:
60 | 
61 | ```javascript
62 | var num1, num2, sum
63 | num1 = prompt("Enter first number")
64 | num2 = prompt("Enter second number")
65 | sum = parseInt(num1) + parseInt(num2) // "+" means "add"
66 | alert("Sum = " + sum)  // "+" means combine into a string
67 | ```
68 | 
69 | [^1]: From https://en.wikipedia.org/wiki/Apple


--------------------------------------------------------------------------------
/themes/hermit/i18n/en.toml:
--------------------------------------------------------------------------------
 1 | # Translations for English
 2 | # https://gohugo.io/content-management/multilingual/#translation-of-strings
 3 | 
 4 | # 404.html
 5 | #
 6 | [notFound]
 7 | other = "Oops, page not found…"
 8 | 
 9 | [home]
10 | other = "Home"
11 | 
12 | [archives]
13 | other = "Archives"
14 | 
15 | # posts/single.html
16 | #
17 | [wordCount]
18 | other = "{{ .WordCount }} Words"
19 | 
20 | [tableOfContents]
21 | other = "Table of Contents"
22 | 
23 | [newer]
24 | other = "Newer"
25 | 
26 | [older]
27 | other = "Older"
28 | 
29 | # partials/header.html
30 | #
31 | [menu]
32 | other = "Menu"
33 | 
34 | [featuredImage]
35 | other = "Featured Image"
36 | 


--------------------------------------------------------------------------------
/themes/hermit/i18n/it.toml:
--------------------------------------------------------------------------------
 1 | # Translations for Italian
 2 | # https://gohugo.io/content-management/multilingual/#translation-of-strings
 3 | 
 4 | # 404.html
 5 | #
 6 | [notFound]
 7 | other = "Oops, pagina non trovata…"
 8 | 
 9 | [home]
10 | other = "Home"
11 | 
12 | [archives]
13 | other = "Archivi"
14 | 
15 | # posts/single.html
16 | #
17 | [wordCount]
18 | other = "{{ .WordCount }} Parole"
19 | 
20 | [tableOfContents]
21 | other = "Sommario"
22 | 
23 | [newer]
24 | other = "Prossimo"
25 | 
26 | [older]
27 | other = "Precedente"
28 | 
29 | # partials/header.html
30 | #
31 | [menu]
32 | other = "Menu"
33 | 
34 | [featuredImage]
35 | other = "Immagine in primo piano"
36 | 


--------------------------------------------------------------------------------
/themes/hermit/i18n/zh-hans.toml:
--------------------------------------------------------------------------------
 1 | # Translations for Simplified Chinese - 简体中文
 2 | # https://gohugo.io/content-management/multilingual/#translation-of-strings
 3 | 
 4 | # 404.html
 5 | #
 6 | [notFound]
 7 | other = "糟糕，您要访问的页面不存在……"
 8 | 
 9 | [home]
10 | other = "主页"
11 | 
12 | [archives]
13 | other = "归档"
14 | 
15 | # posts/single.html
16 | #
17 | [wordCount]
18 | other = "{{ .WordCount }} 字"
19 | 
20 | [tableOfContents]
21 | other = "目录"
22 | 
23 | [newer]
24 | other = "新"
25 | 
26 | [older]
27 | other = "旧"
28 | 
29 | # partials/header.html
30 | #
31 | [menu]
32 | other = "菜单"
33 | 
34 | [featuredImage]
35 | other = "特色图片"
36 | 


--------------------------------------------------------------------------------
/themes/hermit/images/hermit.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/eddycjy/blog/5d1b9c17c374d7c18b6cb6085beeb2e22c18ee24/themes/hermit/images/hermit.png


--------------------------------------------------------------------------------
/themes/hermit/images/screenshot.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/eddycjy/blog/5d1b9c17c374d7c18b6cb6085beeb2e22c18ee24/themes/hermit/images/screenshot.png


--------------------------------------------------------------------------------
/themes/hermit/images/tn.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/eddycjy/blog/5d1b9c17c374d7c18b6cb6085beeb2e22c18ee24/themes/hermit/images/tn.png


--------------------------------------------------------------------------------
/themes/hermit/layouts/_default/baseof.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html lang="{{.Site.LanguageCode}}">
 3 | 
 4 | <head>
 5 | 	<meta charset="UTF-8">
 6 | 	<meta name="viewport" content="width=device-width, initial-scale=1.0">
 7 | 	<meta http-equiv="X-UA-Compatible" content="ie=edge">
 8 | 	{{- with .Site.Params.themeColor }}
 9 | 	<meta name="theme-color" content="{{.}}">
10 | 	<meta name="msapplication-TileColor" content="{{.}}">
11 | 	{{- end }}
12 | 	{{- partial "structured-data.html" . }}
13 | 	{{- partial "favicons.html" }}
14 | 	<title>{{.Title}}</title>
15 | 	{{ range .AlternativeOutputFormats -}}
16 | 		{{ printf `<link rel="%s" type="%s+%s" href="%s" title="%s" />` .Rel .MediaType.Type .MediaType.Suffix .Permalink $.Site.Title | safeHTML }}
17 | 	{{ end -}}
18 | 	{{ $style := resources.Get "scss/style.scss" | resources.ExecuteAsTemplate "css/style.css" . | toCSS | minify | fingerprint -}}
19 | 	<link rel="stylesheet" href="{{ $style.Permalink }}">
20 | 	{{- block "head" . -}}{{- end }}
21 | 	{{- range .Site.Params.customCSS }}
22 | 	<link rel="stylesheet" href="{{ . | absURL }}">
23 | 	{{- end }}
24 | 	{{- if templates.Exists "partials/extra-head.html" -}}
25 | 	{{ partial "extra-head.html" . }}
26 | 	{{- end }}
27 | </head>
28 | 
29 | <body id="page">
30 | 	{{ block "header" . -}}{{ end -}}
31 | 	{{ block "main" . -}}{{ end -}}
32 | 	{{ block "footer" . -}}{{ end }}
33 | 	{{ $script := resources.Get "js/main.js" | minify | fingerprint -}}
34 | 	<script src="{{ $script.Permalink }}"></script>
35 | 	{{- partial "analytics.html" . }}
36 | 	{{- if templates.Exists "partials/extra-foot.html" -}}
37 | 	{{ partial "extra-foot.html" . }}
38 | 	{{- end }}
39 | </body>
40 | 
41 | </html>
42 | 


--------------------------------------------------------------------------------
/themes/hermit/layouts/_default/list.html:
--------------------------------------------------------------------------------
 1 | {{ define "header" }}
 2 | {{ partialCached "header.html" . }}
 3 | {{ end }}
 4 | 
 5 | {{ define "main" }}
 6 | 	<main class="site-main section-inner thin animated fadeIn faster">
 7 | 		<h1>{{ .Title }}</h1>
 8 | 		{{- if .Content }}
 9 | 		<div class="content">
10 | 			{{ .Content }}
11 | 		</div>
12 | 		{{- end }}
13 | 		{{- range .Data.Pages.GroupByDate "2006" }}
14 | 		<div class="posts-group">
15 | 			<div class="post-year" id="{{ .Key }}">{{ .Key }}</div>
16 | 			<ul class="posts-list">
17 | 				{{- range .Pages }}
18 | 				<li class="post-item">
19 | 					<a href="{{.Permalink}}">
20 | 						<span class="post-title">{{.Title}}</span>
21 | 						<span class="post-day">{{ .Date.Format .Site.Params.dateformShort }}</span>
22 | 					</a>
23 | 				</li>
24 | 				{{- end }}
25 | 			</ul>
26 | 		</div>
27 | 		{{- end }}
28 | 	</main>
29 | {{ end }}
30 | 
31 | {{ define "footer" }}
32 | {{ partialCached "footer.html" . }}
33 | {{ end }}
34 | 


--------------------------------------------------------------------------------
/themes/hermit/layouts/_default/single.html:
--------------------------------------------------------------------------------
 1 | {{ define "head" }}
 2 | 	{{ if .Params.featuredImg -}}
 3 | 	<style>.bg-img {background-image: url('{{.Params.featuredImg}}');}</style>
 4 | 	{{- else if .Params.images -}}
 5 | 		{{- range first 1 .Params.images -}}
 6 | 		<style>.bg-img {background-image: url('{{. | absURL}}');}</style>
 7 | 		{{- end -}}
 8 | 	{{- end -}}
 9 | {{ end }}
10 | 
11 | {{ define "header" }}
12 | {{ partial "header.html" . }}
13 | {{ end }}
14 | 
15 | {{ define "main" }}
16 | 	{{- if (or .Params.images .Params.featuredImg) }}
17 | 	<div class="bg-img"></div>
18 | 	{{- end }}
19 | 	<main class="site-main section-inner thin animated fadeIn faster">
20 | 		<h1>{{ .Title }}</h1>
21 | 		<div class="content">
22 | 			{{ .Content | replaceRE "(<h[1-6] id=\"([^\"]+)\".+)(</h[1-6]+>)" `${1}<a href="#${2}" class="anchor" aria-hidden="true"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3"></path><line x1="8" y1="12" x2="16" y2="12"></line></svg></a>${3}` | safeHTML }}
23 | 		</div>
24 | 		{{- if .Params.comments }}
25 | 		<div id="comments" class="thin">
26 | 			{{ partial "comments.html" . }}
27 | 		</div>
28 | 		{{- end }}
29 | 	</main>
30 | {{ end }}
31 | 
32 | {{ define "footer" }}
33 | {{ partialCached "footer.html" . }}
34 | {{ end }}
35 | 


--------------------------------------------------------------------------------
/themes/hermit/layouts/index.html:
--------------------------------------------------------------------------------
 1 | {{ define "head" }}
 2 | 	{{ if .Site.Params.bgImg -}}
 3 | 	<style>.bg-img {background-image: url('{{.Site.Params.bgImg}}');}</style>
 4 | 	{{- else if .Site.Params.images -}}
 5 | 		{{- range first 1 .Site.Params.images -}}
 6 | 		<style>.bg-img {background-image: url('{{. | absURL}}');}</style>
 7 | 		{{- end -}}
 8 | 	{{- end -}}
 9 | {{ end }}
10 | 
11 | {{ define "main" }}
12 | 	{{- if (or .Site.Params.images .Site.Params.bgImg) }}
13 | 	<div class="bg-img"></div>
14 | 	{{- end }}
15 | 	<div id="spotlight" class="animated fadeIn">
16 | 		<div id="home-center">
17 | 			<h1 id="home-title">{{ .Site.Title }}</h1>
18 | 			{{- with .Site.Params.homeSubtitle }}
19 | 			<p id="home-subtitle">{{.}}</p>
20 | 			{{- end }}
21 | 			{{- with .Site.Params.social }}
22 | 			<div id="home-social">
23 | 				{{ partialCached "social-icons.html" . }}
24 | 			</div>
25 | 			{{- end }}
26 | 			<nav id="home-nav" class="site-nav">
27 | 				{{- range .Site.Menus.main }}
28 | 				<a href="{{ .URL | absLangURL }}">{{ .Name }}</a>
29 | 				{{- end }}
30 | 			</nav>
31 | 		</div>
32 | 		<div id="home-footer">
33 | 			<p>
34 | 				&copy; {{ now.Format "2006" }} <a href="{{ .Site.BaseURL }}">{{ .Site.Author.name }}</a>{{ .Site.Params.footerCopyright | safeHTML }}
35 | 				{{- with (not (in (.Site.Language.Get "disableKinds") "RSS")) }} &#183; <a href="{{ "post/index.xml" | absURL }}" target="_blank" title="rss"><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="feather feather-rss"><path d="M4 11a9 9 0 0 1 9 9"></path><path d="M4 4a16 16 0 0 1 16 16"></path><circle cx="5" cy="19" r="1"></circle></svg></a>{{ end }}
36 | 			</p>
37 | 		</div>
38 | 	</div>
39 | {{ end }}
40 | 


--------------------------------------------------------------------------------
/themes/hermit/layouts/partials/analytics.html:
--------------------------------------------------------------------------------
1 | {{ template "_internal/google_analytics_async.html" . }}
2 | 


--------------------------------------------------------------------------------
/themes/hermit/layouts/partials/favicons.html:
--------------------------------------------------------------------------------
1 | 	<link rel="apple-touch-icon" sizes="180x180" href="{{"apple-touch-icon.png" | relURL}}">
2 | 	<link rel="icon" type="image/png" sizes="32x32" href="{{"favicon-32x32.png" | relURL}}">
3 | 	<link rel="icon" type="image/png" sizes="16x16" href="{{"favicon-16x16.png" | relURL}}">
4 | 	<link rel="manifest" href="{{"site.webmanifest" | relURL}}">
5 | 	<link rel="mask-icon" href="{{"safari-pinned-tab.svg" | relURL}}" color="{{.Site.Params.themeColor}}">
6 | 	<link rel="shortcut icon" href="{{"favicon.ico" | relURL}}">
7 | 


--------------------------------------------------------------------------------
/themes/hermit/layouts/partials/footer.html:
--------------------------------------------------------------------------------
1 | 	<footer id="site-footer" class="section-inner thin animated fadeIn faster">
2 | 		<p>&copy; {{ now.Format "2006" }} <a href="{{ .Site.BaseURL }}">{{ .Site.Author.name }}</a>{{ .Site.Params.footerCopyright | safeHTML }}</p>
3 | 		<p>
4 | 			Made with <a href="https://gohugo.io/" target="_blank" rel="noopener">Hugo</a> &#183; Theme <a href="https://github.com/Track3/hermit" target="_blank" rel="noopener">Hermit</a>
5 | 			{{- with (not (in (.Site.Language.Get "disableKinds") "RSS")) }} &#183; <a href="{{ "post/index.xml" | absURL }}" target="_blank" title="rss"><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="feather feather-rss"><path d="M4 11a9 9 0 0 1 9 9"></path><path d="M4 4a16 16 0 0 1 16 16"></path><circle cx="5" cy="19" r="1"></circle></svg></a>{{ end }}
6 | 		</p>
7 | 	</footer>
8 | 


--------------------------------------------------------------------------------
/themes/hermit/layouts/partials/header.html:
--------------------------------------------------------------------------------
 1 | 	<header id="site-header" class="animated slideInUp faster">
 2 | 		<div class="hdr-wrapper section-inner">
 3 | 			<div class="hdr-left">
 4 | 				<div class="site-branding">
 5 | 					<a href="{{.Site.BaseURL}}">{{ .Site.Title }}</a>
 6 | 				</div>
 7 | 				<nav class="site-nav hide-in-mobile">
 8 | 					{{- range .Site.Menus.main }}
 9 | 					<a href="{{ .URL | absLangURL}}">{{ .Name }}</a>
10 | 					{{- end }}
11 | 				</nav>
12 | 			</div>
13 | 			<div class="hdr-right hdr-icons">
14 | 				{{ if (or .Params.images .Params.featuredImg) -}}
15 | 				<button id="img-btn" class="hdr-btn" title="{{i18n "featuredImage"}}"><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="feather feather-image"><rect x="3" y="3" width="18" height="18" rx="2" ry="2"></rect><circle cx="8.5" cy="8.5" r="1.5"></circle><polyline points="21 15 16 10 5 21"></polyline></svg></button>
16 | 				{{- end }}
17 | 				{{- with .Params.toc -}}
18 | 				<button id="toc-btn" class="hdr-btn desktop-only-ib" title="{{i18n "tableOfContents"}}"><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="feather feather-list"><line x1="8" y1="6" x2="21" y2="6"></line><line x1="8" y1="12" x2="21" y2="12"></line><line x1="8" y1="18" x2="21" y2="18"></line><line x1="3" y1="6" x2="3" y2="6"></line><line x1="3" y1="12" x2="3" y2="12"></line><line x1="3" y1="18" x2="3" y2="18"></line></svg></button>
19 | 				{{- end }}
20 | 				{{- with .Site.Params.social -}}
21 | 				<span class="hdr-social hide-in-mobile">{{ partialCached "social-icons.html" . }}</span>
22 | 				{{- end -}}
23 | 				<button id="menu-btn" class="hdr-btn" title="{{i18n "menu"}}"><svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="feather feather-menu"><line x1="3" y1="12" x2="21" y2="12"></line><line x1="3" y1="6" x2="21" y2="6"></line><line x1="3" y1="18" x2="21" y2="18"></line></svg></button>
24 | 			</div>
25 | 		</div>
26 | 	</header>
27 | 	<div id="mobile-menu" class="animated fast">
28 | 		<ul>
29 | 			{{- range .Site.Menus.main }}
30 | 			<li><a href="{{ .URL | absLangURL }}">{{ .Name }}</a></li>
31 | 			{{- end }}
32 | 		</ul>
33 | 	</div>
34 | 


--------------------------------------------------------------------------------
/themes/hermit/layouts/partials/social-icons.html:
--------------------------------------------------------------------------------
1 | {{ range . -}}
2 | <a href="{{ .url }}" target="_blank" rel="noopener me" title="{{ .name | humanize }}">{{ partial "svg.html" . }}</a>
3 | {{- end -}}
4 | 


--------------------------------------------------------------------------------
/themes/hermit/layouts/partials/structured-data.html:
--------------------------------------------------------------------------------
1 | {{/* We use some Hugo built-in templates, you can find their source here: */}}
2 | {{/* https://github.com/gohugoio/hugo/tree/master/tpl/tplimpl/embedded/templates */}}
3 | 
4 | {{- template "_internal/schema.html" . }}
5 | {{- template "_internal/opengraph.html" . }}
6 | {{- template "_internal/twitter_cards.html" . }}
7 | 


--------------------------------------------------------------------------------
/themes/hermit/layouts/post/rss.xml:
--------------------------------------------------------------------------------
 1 | <rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
 2 | 	<channel>
 3 | 		<title>{{ if eq  .Title  .Site.Title }}{{ .Site.Title }}{{ else }}{{ with .Title }}{{.}} on {{ end }}{{ .Site.Title }}{{ end }}</title>
 4 | 		<link>{{ .Permalink }}</link>
 5 | 		<description>Recent content {{ if ne  .Title  .Site.Title }}{{ with .Title }}in {{.}} {{ end }}{{ end }}on {{ .Site.Title }}</description>
 6 | 		<generator>Hugo -- gohugo.io</generator>{{ with .Site.LanguageCode }}
 7 | 		<language>{{.}}</language>{{end}}{{ with .Site.Author.email }}
 8 | 		<managingEditor>{{.}}{{ with $.Site.Author.name }} ({{.}}){{end}}</managingEditor>{{end}}{{ with .Site.Author.email }}
 9 | 		<webMaster>{{.}}{{ with $.Site.Author.name }} ({{.}}){{end}}</webMaster>{{end}}{{ with .Site.Copyright }}
10 | 		<copyright>{{.}}</copyright>{{end}}{{ if not .Date.IsZero }}
11 | 		<lastBuildDate>{{ .Date.Format "Mon, 02 Jan 2006 15:04:05 -0700" | safeHTML }}</lastBuildDate>{{ end }}
12 | 		{{ with .OutputFormats.Get "RSS" -}}
13 | 			{{ printf "<atom:link href=%q rel=\"self\" type=%q />" .Permalink .MediaType | safeHTML }}
14 | 		{{ end -}}
15 | 		{{ range .Pages }}
16 | 		<item>
17 | 			<title>{{ .Title }}</title>
18 | 			<link>{{ .Permalink }}</link>
19 | 			<pubDate>{{ .Date.Format "Mon, 02 Jan 2006 15:04:05 -0700" | safeHTML }}</pubDate>
20 | 			{{ with .Site.Author.email }}<author>{{.}}{{ with $.Site.Author.name }} ({{.}}){{end}}</author>{{end}}
21 | 			<guid>{{ .Permalink }}</guid>
22 | 			<description>{{ .Summary | html }}</description>
23 | 			<content type="html">{{ printf `<![CDATA[%s]]>` .Content | safeHTML }}</content>
24 | 		</item>
25 | 		{{ end }}
26 | 	</channel>
27 | </rss>
28 | 


--------------------------------------------------------------------------------
/themes/hermit/layouts/posts/rss.xml:
--------------------------------------------------------------------------------
 1 | <rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
 2 | 	<channel>
 3 | 		<title>{{ if eq  .Title  .Site.Title }}{{ .Site.Title }}{{ else }}{{ with .Title }}{{.}} on {{ end }}{{ .Site.Title }}{{ end }}</title>
 4 | 		<link>{{ .Permalink }}</link>
 5 | 		<description>Recent content {{ if ne  .Title  .Site.Title }}{{ with .Title }}in {{.}} {{ end }}{{ end }}on {{ .Site.Title }}</description>
 6 | 		<generator>Hugo -- gohugo.io</generator>{{ with .Site.LanguageCode }}
 7 | 		<language>{{.}}</language>{{end}}{{ with .Site.Author.email }}
 8 | 		<managingEditor>{{.}}{{ with $.Site.Author.name }} ({{.}}){{end}}</managingEditor>{{end}}{{ with .Site.Author.email }}
 9 | 		<webMaster>{{.}}{{ with $.Site.Author.name }} ({{.}}){{end}}</webMaster>{{end}}{{ with .Site.Copyright }}
10 | 		<copyright>{{.}}</copyright>{{end}}{{ if not .Date.IsZero }}
11 | 		<lastBuildDate>{{ .Date.Format "Mon, 02 Jan 2006 15:04:05 -0700" | safeHTML }}</lastBuildDate>{{ end }}
12 | 		{{ with .OutputFormats.Get "RSS" -}}
13 | 			{{ printf "<atom:link href=%q rel=\"self\" type=%q />" .Permalink .MediaType | safeHTML }}
14 | 		{{ end -}}
15 | 		{{ range .Pages }}
16 | 		<item>
17 | 			<title>{{ .Title }}</title>
18 | 			<link>{{ .Permalink }}</link>
19 | 			<pubDate>{{ .Date.Format "Mon, 02 Jan 2006 15:04:05 -0700" | safeHTML }}</pubDate>
20 | 			{{ with .Site.Author.email }}<author>{{.}}{{ with $.Site.Author.name }} ({{.}}){{end}}</author>{{end}}
21 | 			<guid>{{ .Permalink }}</guid>
22 | 			<description>{{ .Summary | html }}</description>
23 | 			<content type="html">{{ printf `<![CDATA[%s]]>` .Content | safeHTML }}</content>
24 | 		</item>
25 | 		{{ end }}
26 | 	</channel>
27 | </rss>
28 | 


--------------------------------------------------------------------------------
/themes/hermit/resources/_gen/assets/js/js/main.js_d11fe7b62c27961c87ecd0f2490357b9.content:
--------------------------------------------------------------------------------
1 | const throttle=(callback,limit)=>{let timeoutHandler=null;return()=>{if(timeoutHandler==null){timeoutHandler=setTimeout(()=>{callback();timeoutHandler=null;},limit);}};};const listen=(ele,e,callback)=>{if(document.querySelector(ele)!==null){document.querySelector(ele).addEventListener(e,callback);}}
2 | let header=document.getElementById('site-header');let lastScrollPosition=window.pageYOffset;const autoHideHeader=()=>{let currentScrollPosition=window.pageYOffset;if(currentScrollPosition>lastScrollPosition){header.classList.remove('slideInUp');header.classList.add('slideOutDown');}else{header.classList.remove('slideOutDown');header.classList.add('slideInUp');}
3 | lastScrollPosition=currentScrollPosition;}
4 | let mobileMenuVisible=false;const toggleMobileMenu=()=>{let mobileMenu=document.getElementById('mobile-menu');if(mobileMenuVisible==false){mobileMenu.style.animationName='bounceInRight';mobileMenu.style.webkitAnimationName='bounceInRight';mobileMenu.style.display='block';mobileMenuVisible=true;}else{mobileMenu.style.animationName='bounceOutRight';mobileMenu.style.webkitAnimationName='bounceOutRight'
5 | mobileMenuVisible=false;}}
6 | const showImg=()=>{document.querySelector('.bg-img').classList.add('show-bg-img');}
7 | const hideImg=()=>{document.querySelector('.bg-img').classList.remove('show-bg-img');}
8 | const toggleToc=()=>{document.getElementById('toc').classList.toggle('show-toc');}
9 | if(header!==null){listen('#menu-btn',"click",toggleMobileMenu);listen('#toc-btn',"click",toggleToc);listen('#img-btn',"click",showImg);listen('.bg-img',"click",hideImg);document.querySelectorAll('.post-year').forEach((ele)=>{ele.addEventListener('click',()=>{window.location.hash='#'+ele.id;});});window.addEventListener('scroll',throttle(()=>{autoHideHeader();if(mobileMenuVisible==true){toggleMobileMenu();}},250));}


--------------------------------------------------------------------------------
/themes/hermit/resources/_gen/assets/js/js/main.js_d11fe7b62c27961c87ecd0f2490357b9.json:
--------------------------------------------------------------------------------
1 | {"Target":"js/main.min.784417f5847151f848c339cf0acb13a06cbb648b1483435a28ed4556c4ead69b.js","MediaType":"application/javascript","Data":{"Integrity":"sha256-eEQX9YRxUfhIwznPCssToGy7ZIsUg0NaKO1FVsTq1ps="}}


--------------------------------------------------------------------------------
/themes/hermit/resources/_gen/assets/scss/scss/style.scss_c16d144eee185fbddd582cd5e25a4fae.json:
--------------------------------------------------------------------------------
1 | {"Target":"css/style.min.31706917653d2b9e8410abd431f30ec4359a88a94fc87a63654779d87329edec.css","MediaType":"text/css","Data":{"Integrity":"sha256-MXBpF2U9K56EEKvUMfMOxDWaiKlPyHpjZUd52HMp7ew="}}


--------------------------------------------------------------------------------
/themes/hermit/static/android-chrome-192x192.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/eddycjy/blog/5d1b9c17c374d7c18b6cb6085beeb2e22c18ee24/themes/hermit/static/android-chrome-192x192.png


--------------------------------------------------------------------------------
/themes/hermit/static/android-chrome-384x384.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/eddycjy/blog/5d1b9c17c374d7c18b6cb6085beeb2e22c18ee24/themes/hermit/static/android-chrome-384x384.png


--------------------------------------------------------------------------------
/themes/hermit/static/apple-touch-icon.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/eddycjy/blog/5d1b9c17c374d7c18b6cb6085beeb2e22c18ee24/themes/hermit/static/apple-touch-icon.png


--------------------------------------------------------------------------------
/themes/hermit/static/browserconfig.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <browserconfig>
 3 |     <msapplication>
 4 |         <tile>
 5 |             <square150x150logo src="/mstile-150x150.png"/>
 6 |             <TileColor>#00aba9</TileColor>
 7 |         </tile>
 8 |     </msapplication>
 9 | </browserconfig>
10 | 


--------------------------------------------------------------------------------
/themes/hermit/static/favicon-16x16.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/eddycjy/blog/5d1b9c17c374d7c18b6cb6085beeb2e22c18ee24/themes/hermit/static/favicon-16x16.png


--------------------------------------------------------------------------------
/themes/hermit/static/favicon-32x32.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/eddycjy/blog/5d1b9c17c374d7c18b6cb6085beeb2e22c18ee24/themes/hermit/static/favicon-32x32.png


--------------------------------------------------------------------------------
/themes/hermit/static/favicon.ico:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/eddycjy/blog/5d1b9c17c374d7c18b6cb6085beeb2e22c18ee24/themes/hermit/static/favicon.ico


--------------------------------------------------------------------------------
/themes/hermit/static/mstile-150x150.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/eddycjy/blog/5d1b9c17c374d7c18b6cb6085beeb2e22c18ee24/themes/hermit/static/mstile-150x150.png


--------------------------------------------------------------------------------
/themes/hermit/static/safari-pinned-tab.svg:
--------------------------------------------------------------------------------
1 | <svg version="1" xmlns="http://www.w3.org/2000/svg" width="666.667" height="666.667" viewBox="0 0 500.000000 500.000000"><path d="M0 250v250h500V0H0v250zm203.2-55l-.5 43H297v-86h29.9l-.1 107.5V367H297V263h-94v104h-29V152h29.8l-.6 43z"/></svg>


--------------------------------------------------------------------------------
/themes/hermit/static/site.webmanifest:
--------------------------------------------------------------------------------
 1 | {
 2 |     "name": "",
 3 |     "short_name": "",
 4 |     "icons": [
 5 |         {
 6 |             "src": "/android-chrome-192x192.png",
 7 |             "sizes": "192x192",
 8 |             "type": "image/png"
 9 |         },
10 |         {
11 |             "src": "/android-chrome-384x384.png",
12 |             "sizes": "384x384",
13 |             "type": "image/png"
14 |         }
15 |     ],
16 |     "theme_color": "#ffffff",
17 |     "background_color": "#ffffff",
18 |     "display": "standalone"
19 | }
20 | 


--------------------------------------------------------------------------------
/themes/hermit/theme.toml:
--------------------------------------------------------------------------------
 1 | name = "Hermit"
 2 | license = "MIT"
 3 | licenselink = "https://github.com/Track3/hermit/blob/master/LICENSE"
 4 | description = "A minimal and fast hugo theme for bloggers."
 5 | homepage = "https://github.com/Track3/hermit"
 6 | tags = ["blog", "minimal", "dark", "responsive"]
 7 | features = [
 8 |   "single column",
 9 |   "featured image",
10 |   "social icons",
11 |   "google analytics",
12 |   "disqus"
13 | ]
14 | min_version = 0.43
15 | 
16 | [author]
17 |   name = "Track3"
18 |   homepage = "https://www.xxxlbox.com"
19 | 


--------------------------------------------------------------------------------