├── 27f30b093b7237104dd9b098e70758e.jpg
├── LICENSE
├── README.md
├── on-the-criteria-to-be-used-in-decomposing-systems-into-modules
    ├── README.md
    └── figure1.drawio.svg
└── 今日阅读.md


/27f30b093b7237104dd9b098e70758e.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/LeoYuan/awesome-lowcode/760d4d86143d5014468e41ac2fdc4aaf2852835e/27f30b093b7237104dd9b098e70758e.jpg


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
  1 | Creative Commons Legal Code
  2 | 
  3 | CC0 1.0 Universal
  4 | 
  5 |     CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE
  6 |     LEGAL SERVICES. DISTRIBUTION OF THIS DOCUMENT DOES NOT CREATE AN
  7 |     ATTORNEY-CLIENT RELATIONSHIP. CREATIVE COMMONS PROVIDES THIS
  8 |     INFORMATION ON AN "AS-IS" BASIS. CREATIVE COMMONS MAKES NO WARRANTIES
  9 |     REGARDING THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS
 10 |     PROVIDED HEREUNDER, AND DISCLAIMS LIABILITY FOR DAMAGES RESULTING FROM
 11 |     THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS PROVIDED
 12 |     HEREUNDER.
 13 | 
 14 | Statement of Purpose
 15 | 
 16 | The laws of most jurisdictions throughout the world automatically confer
 17 | exclusive Copyright and Related Rights (defined below) upon the creator
 18 | and subsequent owner(s) (each and all, an "owner") of an original work of
 19 | authorship and/or a database (each, a "Work").
 20 | 
 21 | Certain owners wish to permanently relinquish those rights to a Work for
 22 | the purpose of contributing to a commons of creative, cultural and
 23 | scientific works ("Commons") that the public can reliably and without fear
 24 | of later claims of infringement build upon, modify, incorporate in other
 25 | works, reuse and redistribute as freely as possible in any form whatsoever
 26 | and for any purposes, including without limitation commercial purposes.
 27 | These owners may contribute to the Commons to promote the ideal of a free
 28 | culture and the further production of creative, cultural and scientific
 29 | works, or to gain reputation or greater distribution for their Work in
 30 | part through the use and efforts of others.
 31 | 
 32 | For these and/or other purposes and motivations, and without any
 33 | expectation of additional consideration or compensation, the person
 34 | associating CC0 with a Work (the "Affirmer"), to the extent that he or she
 35 | is an owner of Copyright and Related Rights in the Work, voluntarily
 36 | elects to apply CC0 to the Work and publicly distribute the Work under its
 37 | terms, with knowledge of his or her Copyright and Related Rights in the
 38 | Work and the meaning and intended legal effect of CC0 on those rights.
 39 | 
 40 | 1. Copyright and Related Rights. A Work made available under CC0 may be
 41 | protected by copyright and related or neighboring rights ("Copyright and
 42 | Related Rights"). Copyright and Related Rights include, but are not
 43 | limited to, the following:
 44 | 
 45 |   i. the right to reproduce, adapt, distribute, perform, display,
 46 |      communicate, and translate a Work;
 47 |  ii. moral rights retained by the original author(s) and/or performer(s);
 48 | iii. publicity and privacy rights pertaining to a person's image or
 49 |      likeness depicted in a Work;
 50 |  iv. rights protecting against unfair competition in regards to a Work,
 51 |      subject to the limitations in paragraph 4(a), below;
 52 |   v. rights protecting the extraction, dissemination, use and reuse of data
 53 |      in a Work;
 54 |  vi. database rights (such as those arising under Directive 96/9/EC of the
 55 |      European Parliament and of the Council of 11 March 1996 on the legal
 56 |      protection of databases, and under any national implementation
 57 |      thereof, including any amended or successor version of such
 58 |      directive); and
 59 | vii. other similar, equivalent or corresponding rights throughout the
 60 |      world based on applicable law or treaty, and any national
 61 |      implementations thereof.
 62 | 
 63 | 2. Waiver. To the greatest extent permitted by, but not in contravention
 64 | of, applicable law, Affirmer hereby overtly, fully, permanently,
 65 | irrevocably and unconditionally waives, abandons, and surrenders all of
 66 | Affirmer's Copyright and Related Rights and associated claims and causes
 67 | of action, whether now known or unknown (including existing as well as
 68 | future claims and causes of action), in the Work (i) in all territories
 69 | worldwide, (ii) for the maximum duration provided by applicable law or
 70 | treaty (including future time extensions), (iii) in any current or future
 71 | medium and for any number of copies, and (iv) for any purpose whatsoever,
 72 | including without limitation commercial, advertising or promotional
 73 | purposes (the "Waiver"). Affirmer makes the Waiver for the benefit of each
 74 | member of the public at large and to the detriment of Affirmer's heirs and
 75 | successors, fully intending that such Waiver shall not be subject to
 76 | revocation, rescission, cancellation, termination, or any other legal or
 77 | equitable action to disrupt the quiet enjoyment of the Work by the public
 78 | as contemplated by Affirmer's express Statement of Purpose.
 79 | 
 80 | 3. Public License Fallback. Should any part of the Waiver for any reason
 81 | be judged legally invalid or ineffective under applicable law, then the
 82 | Waiver shall be preserved to the maximum extent permitted taking into
 83 | account Affirmer's express Statement of Purpose. In addition, to the
 84 | extent the Waiver is so judged Affirmer hereby grants to each affected
 85 | person a royalty-free, non transferable, non sublicensable, non exclusive,
 86 | irrevocable and unconditional license to exercise Affirmer's Copyright and
 87 | Related Rights in the Work (i) in all territories worldwide, (ii) for the
 88 | maximum duration provided by applicable law or treaty (including future
 89 | time extensions), (iii) in any current or future medium and for any number
 90 | of copies, and (iv) for any purpose whatsoever, including without
 91 | limitation commercial, advertising or promotional purposes (the
 92 | "License"). The License shall be deemed effective as of the date CC0 was
 93 | applied by Affirmer to the Work. Should any part of the License for any
 94 | reason be judged legally invalid or ineffective under applicable law, such
 95 | partial invalidity or ineffectiveness shall not invalidate the remainder
 96 | of the License, and in such case Affirmer hereby affirms that he or she
 97 | will not (i) exercise any of his or her remaining Copyright and Related
 98 | Rights in the Work or (ii) assert any associated claims and causes of
 99 | action with respect to the Work, in either case contrary to Affirmer's
100 | express Statement of Purpose.
101 | 
102 | 4. Limitations and Disclaimers.
103 | 
104 |  a. No trademark or patent rights held by Affirmer are waived, abandoned,
105 |     surrendered, licensed or otherwise affected by this document.
106 |  b. Affirmer offers the Work as-is and makes no representations or
107 |     warranties of any kind concerning the Work, express, implied,
108 |     statutory or otherwise, including without limitation warranties of
109 |     title, merchantability, fitness for a particular purpose, non
110 |     infringement, or the absence of latent or other defects, accuracy, or
111 |     the present or absence of errors, whether or not discoverable, all to
112 |     the greatest extent permissible under applicable law.
113 |  c. Affirmer disclaims responsibility for clearing rights of other persons
114 |     that may apply to the Work or any use thereof, including without
115 |     limitation any person's Copyright and Related Rights in the Work.
116 |     Further, Affirmer disclaims responsibility for obtaining any necessary
117 |     consents, permissions or other rights required for any use of the
118 |     Work.
119 |  d. Affirmer understands and acknowledges that Creative Commons is not a
120 |     party to this document and has no duty or obligation with respect to
121 |     this CC0 or use of the Work.
122 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # 国内低代码平台
  2 | 
  3 | ## 全栈平台
  4 | 
  5 | * 阿里-云凤蝶
  6 |   * [蚂蚁杨周璇：我做前端这十多年来的感悟](https://mp.weixin.qq.com/s/GiFpswpm_N_5MlnBywRTgw)
  7 |   * [云凤蝶可视化搭建的推导与实现](https://zhuanlan.zhihu.com/p/101665976)
  8 |   * [云凤蝶中台研发提效实践](https://zhuanlan.zhihu.com/p/78425921)
  9 |   * [中台建站的智能化探索](https://zhuanlan.zhihu.com/p/54422324)
 10 |   * [云凤蝶如何打造媲美 sketch 的自由画布](https://zhuanlan.zhihu.com/p/92469406)
 11 |   * [云凤蝶自由画布之道：分层模型](https://zhuanlan.zhihu.com/p/97768853)
 12 | * 阿里-金蝉
 13 |   * [长夜未央——企业级研发提效的下一阶段](https://zhuanlan.zhihu.com/p/66474056)
 14 |   * [十倍效能提升——Web 基础研发体系的建立](https://zhuanlan.zhihu.com/p/34790596)
 15 |   * [前端服务化——页面搭建工具的死与生](https://www.cnblogs.com/sskyy/p/6496287.html)
 16 | * [阿里-宜搭](https://www.aliwork.com/)
 17 |   * https://github.com/alibaba/lowcode-engine 
 18 | * 阿里-天马
 19 |   * [如何设计阿里经济体都在用的搭建服务—天马](https://zhuanlan.zhihu.com/p/137470317)
 20 | * 腾讯-积木
 21 |   * [积木系统v2@江源.pptx](https://vdisk.weibo.com/s/cSKQveSBDMPco)
 22 |   * [积木系统，将运营系统做到极致](https://cloud.tencent.com/developer/article/1055079)
 23 | * 腾讯-lowcode
 24 |   * [腾讯云开发低码平台](https://console.cloud.tencent.com/lowcode)
 25 | * 葡萄城-活字格
 26 |   * [活字格企业级低代码开发平台](https://www.grapecity.com.cn/solutions/huozige)
 27 |   * [活字格产品经理胡耀：看活字格低代码平台是如何诞生的](https://www.soft6.com/news/2021/08/24/377493.html)
 28 |   * [驳“低代码开发取代程序员”论 为什么专业开发者也需要低代码？](https://segmentfault.com/a/1190000040842990)
 29 | * [无远开发平台](https://wuyuan.io/)
 30 |   * [案例](https://wuyuan.io/case)
 31 |   * [为什么专业开发者都选择无远](https://zhuanlan.zhihu.com/p/382493959)
 32 | * [奥哲](https://www.authine.com/)
 33 |   * [氚云](https://h3yun.com/index.php?g=Chuanyun&m=Index&a=index)
 34 | * [ivx](https://www.ivx.cn/index)
 35 |   * [关于iVX平台实现的总体技术栈【低代码/无代码、可视化开发语言】](https://blog.csdn.net/troymeng/article/details/110384703)
 36 |   * [iVX是怎么开发出来的？0代码开发的理论基础是什么？】](https://bbs.ivx.cn/1535) 
 37 |   * [iVX和其他低代码的开发平台区别究竟在哪里](https://bbs.ivx.cn/mobile/2746)
 38 |   * [ih5](https://www.ih5.cn/)
 39 | * [闪电数据管理](http://www.gitmen.com/lightning)
 40 |   * [闪电数据管理 —— 无代码数据管理(开发)系统](https://zhuanlan.zhihu.com/p/162964986)
 41 |   * [lightning —— 基于Django的无代码Admin及低代码开发框架](https://github.com/git-men/lightning)
 42 | * [巴克云](https://www.buckycloud.com/)
 43 | * [数式科技](https://shushi.pro/technology)
 44 | * [明道云](https://www.mingdao.com/) 支持公共云和私有部署，私有部署在Github可获得[免费社区版下载](https://github.com/mingdaocom/private-deployment)
 45 | * [轻流](https://qingflow.com/)
 46 | * [速融云](https://www.surongyun.cn/)
 47 | * [简道云](https://www.jiandaoyun.com/)
 48 | * [启业云](https://www.qycloud.com.cn/)
 49 | * [双链DaaS](https://github.com/doublechaintech/daas-start-kit)
 50 |   * [直接通过Github Actions体验](https://github.com/doublechaintech/daas-with-github-actions)
 51 |   * [大型系统构建案例-1.5K Stars](https://github.com/doublechaintech/scm-biz-suite)
 52 |   * [包含实时预效果的KSML操练场-开发中](http://kg2x.doublechaintech.com/view/playground)
 53 | * [炎黄盈动](https://www.actionsoft.com.cn/)
 54 | * [广州天翎myApps](http://www.teemlink.com/)
 55 | * [起步科技](http://www.wex5.com/)
 56 | * [金蝶云-苍穹](http://www.kingdee.com/products/cosmic)
 57 | * [普元](http://primeton.com/products/ep/overview.php)
 58 | * OpsMind
 59 |   * [OpsMind 前端低代码开发平台--MPlatform](https://mp.weixin.qq.com/s/gTVUii6ekVZNoX-6k5UCcg)
 60 | * [xdeer](https://www.xdeer.cn/)
 61 | * [湘北智造](https://www.xjrsoft.com/)
 62 | * [表单大师](https://www.jsform.com/)
 63 | * [Zion/载航](https://functorz.com/)
 64 | * [Appsmith](https://www.appsmith.com/)（[Github](https://github.com/appsmithorg/appsmith)）
 65 | * [白码](https://www.bnocode.com/product.html)
 66 | * [捷码](https://gemcoder.com/)
 67 |   * 支持业务系统/管理系统、可视化大屏、3D园区低码快速开发
 68 |   * 支持离线部署
 69 | * [明源云-天际开放平台](https://open.mingyuanyun.com)
 70 |   * [移动平台](https://open.mingyuanyun.com/product/mobile)
 71 |   * [建模平台](https://open.mingyuanyun.com/product/model)
 72 | * [织信低代码平台](https://www.informat.cn/)
 73 |   * [平台简介](https://www.informat.cn/promotion)
 74 |   * [生产领域实践案例&君乐宝](https://www.informat.cn/case/jlb)
 75 |   * [织信Informat携手低码星球探讨「企业数字化转型之路」](https://www.informat.cn/detail/248)
 76 |   * [如何通过织信Informat快速搭建流程审批系统？](https://www.informat.cn/detail/228)
 77 |   * [5K字深度讲解：如何用织信Informat搭建OA和进销存？](https://zhuanlan.zhihu.com/p/393588263)
 78 | * [crudapi-增删改查接口平台](https://crudapi.cn)
 79 |   * [无需编程，通过配置零代码生成crud增删改查RESTful API和UI](https://help.crudapi.cn/helloworld.html)
 80 |   * [前端（开源）](https://github.com/crudapi/crudapi-admin-web)：Vue + Quasar实现Web管理UI，可任意修改
 81 |   * [后端（个人版免费）](https://github.com/crudapi/crudapi-example)：Java + MySql实现Service，支持二次开发和私有部署
 82 |   * [demo演示](https://demo.crudapi.cn/crudapi/)
 83 | * [Gadmin企业级低代码开发平台](https://www.gadmin8.com/)
 84 |   * [平台简介](https://www.gadmin8.com/index/about.html)
 85 |   * [平台演示](https://demo.gadmin8.com/)
 86 | * [象传智慧](https://www.iqka.com/docs/?engine)
 87 |   * [Yao](https://yaoapps.com/)
 88 |   
 89 | ## 页面搭建
 90 | 
 91 | 仅包含前端部分的 low code 平台
 92 | 
 93 | * [MAKA](http://maka.im/)
 94 | * [易企秀](https://store.eqxiu.com/)
 95 | * [上线了](https://www.sxl.cn/)
 96 | * [兔展](https://www.rabbitpre.com/)
 97 | * [稿定设计](https://m.gaoding.com/)
 98 | * [壹伴](https://yiban.io/)
 99 | * [创客贴](https://www.chuangkit.com/)
100 | * [点石](https://www.h5ds.com/)
101 | * 京东-通天塔
102 |   * [京东商城活动页面构建系统——通天塔](https://blog.csdn.net/zl1zl2zl3/article/details/84661421)
103 | * [阿里-imgcook](https://imgcook.taobao.org/)
104 | * 转转-魔方
105 |   * [持续迭代的电商可视化运营页面生成系统](https://www.cnblogs.com/zhuanzhuanfe/p/10500786.html)
106 | * 人人贷-活动运营平台
107 |   * [活动运营自动化平台实践](https://zhuanlan.zhihu.com/p/68108055)
108 | * 美团-乐高
109 |   * [美团外卖前端可视化界面组装平台 —— 乐高](https://zhuanlan.zhihu.com/p/27288444)
110 | * [百度-h5](https://h5.bce.baidu.com/)
111 |   * [前端即服务-通向零成本开发之路](https://os.alipayobjects.com/rmsportal/sJqXvOtwePsVWGNIwlas.pdf)
112 | * 政采云-鲁班
113 |   * [前端工程实践之可视化搭建系统（一）](https://juejin.im/post/5d8774bff265da03ae78b2a1)  
114 | * 携程-民宿CMS
115 |   * [活动专题系统搭建过程中我的一些思考](https://www.dazhuanlan.com/2019/10/07/5d9a698bdde35/)
116 | * 携程-乐高
117 |   * [干货 | 已配置4000+页面，携程前端组件化探索之“乐高”运营系统](https://mp.weixin.qq.com/s/WDCkXEBa0bA-h_8L6cBcJw)
118 | * 知乎-Versatile Editor
119 |   * [「可视化搭建系统」——从设计到架构，探索前端领域技术和业务价值](https://zhuanlan.zhihu.com/p/164558106)
120 | * [阿里-bi designer](https://github.com/dt-fe/weekly/blob/v2/164.%E7%B2%BE%E8%AF%BB%E3%80%8A%E6%95%B0%E6%8D%AE%E6%90%AD%E5%BB%BA%E5%BC%95%E6%93%8E%20bi-designer%20API-%E8%AE%BE%E8%AE%A1%E5%99%A8%E3%80%8B.md)
121 | * [360 - 即视](https://arena.360.cn/)
122 | * http://h5.dooring.cn/
123 | * https://quarkly.io/  No-code / Low-code platform for creating websites and web apps.
124 | * [乐搭云](https://ledayun.com.cn/)
125 |   
126 | ## 店铺装修
127 | 
128 | 非独立页面，依附于业务系统存在的页面搭建
129 | 
130 | * [shopify](https://apps.shopify.com/browse/store-design-page-builders)
131 | * 有赞-微页面
132 | * 淘宝店铺装修
133 |   
134 | ## ![Open Source Love svg3](https://badges.frapsoft.com/os/v3/open-source.svg?v=103)
135 | 
136 | * [阿里-飞冰](https://ice.work/)
137 | * [阿里-formilyjs](https://formilyjs.org/)
138 |   * [MegaLayout - 下一代Formily表单布局解决方案](https://zhuanlan.zhihu.com/p/133906363)
139 |   * https://github.com/alibaba/designable
140 | * [阿里-gaea-editor](https://github.com/ascoders/gaea-editor)
141 |   * [可视化在线编辑器架构设计](https://www.jianshu.com/p/840e0b0b2c6a)
142 | * [阿里-sula](https://github.com/umijs/sula)
143 | * https://github.com/alibaba/lowcode-engine
144 | * [blockVisualEditor](https://github.com/sww1230/blockVisualEditor)
145 | * [pager](https://github.com/laispace/pager)
146 | * [运满满-码良](https://github.com/ymm-tech/gods-pen)
147 |   * [如何设计高扩展的在线网页制作平台](https://juejin.im/post/5bd83daee51d4524b50d23b5)
148 | * [X-Page-Editor](https://github.com/OXOYO/X-Page-Editor-Vue)
149 | * [Vue-Layout](https://github.com/jaweii/Vue-Layout)
150 | * [antd-visual-editor](https://github.com/xinyu198736/antd-visual-editor)
151 | * [pipeline-editor](https://github.com/page-pipepline/pipeline-editor)
152 |   * [【第1524期】页面可视化搭建工具技术要点](https://mp.weixin.qq.com/s/90JJAFhGokKmicOQZxdAGg)
153 | * [panel-magic](https://ricbet.github.io/panel-magic/)
154 |   * [基于 Angular 的小程序可视化编辑器 Panel-Magic 的实现解析](https://zhuanlan.zhihu.com/p/101677992)
155 | * [百度外卖-blocks](https://github.com/Eyot424/blocks)
156 |   * [百度外卖如何做到前端开发配置化](https://juejin.im/post/59536bad6fb9a06ba024d96d)
157 | * [Esview ](https://github.com/furioussoul/esview)
158 | * [gen](https://github.com/genany/gen)
159 | * [bee gen pro](https://gocn.vip/topics/10724)
160 | * [百度-amis](https://github.com/baidu/amis)
161 |   * [Ovine](https://github.com/CareyToboo/ovine)：基于 amis 补全了路由、权限相关的组件
162 |   * [爱速搭](https://suda.baidu.com/)
163 | * [唯品会-ams](https://github.com/vipshop/ams)
164 | * [vue-admin](https://github.com/jiangshanmeta/vue-admin)
165 | * [鲁班 H5](https://github.com/ly525/luban-h5)
166 | * [华炎魔方](https://github.com/steedos/steedos-platform/)
167 |   * [低代码 DevOps 平台协议](https://low-code-protocol.com/docs/overview) 
168 | * [h5-factory](https://github.com/yangyuji/h5-factory)
169 |   * [一个简单易用的电商活动页面生成系统](https://juejin.im/post/5cf328706fb9a07f042030f0)
170 | * [vision](https://github.com/tuoxiansp/vision)
171 | * [brick-design](https://github.com/brick-design/react-visual-editor)
172 | * [随心秀](https://github.com/lzuntalented/lz-h5-edit)
173 | * [yh5](https://github.com/qq15725/yh5)
174 | * [rxeditor](https://github.com/rxwater/rxeditor)
175 | * [activity-YD](https://github.com/vkcyan/activity-YD)
176 | * [layoutit](https://github.com/justjavac/layoutit)
177 | * [Ramiko](https://github.com/fantasticit/ramiko)
178 |   * [使用 React 构建页面可视化搭建工具](https://www.v2ex.com/t/685143)
179 | * [jeecg-boot](https://github.com/zhangdaiscott/jeecg-boot)
180 | * [sparrow-js](https://github.com/sparrow-js/sparrow)
181 |   * [实时输出前端代码，折腾大半年的开源项目 sparrow-js](https://www.v2ex.com/t/718505)
182 | * [Tefact](https://github.com/staringos/tefact): Tefact 轻量级无代码/低代码，H5、表单编辑器
183 | * [星搭](https://staringos.com): 星搭无代码平台，快速构建中后台、小程序
184 | * [好未来晓黑板go-zero微服务框架](https://github.com/tal-tech/go-zero): 你不需要懂微服务，懂业务就行
185 | * [cube](https://github.com/fantasticit/cube)：快速搭建中后台页面
186 | * [react-visual-design](https://github.com/react-visual-design/react-visual-design): 基于react的h5组件搭建
187 | * [Web Designer](https://github.com/xiaoai7904/web_designer)
188 | * [h5maker](https://github.com/zhengguorong/h5maker)
189 | * [pl-drag-template](https://github.com/livelyPeng/pl-drag-template)
190 | * [form-generator](https://github.com/JakHuang/form-generator)：Element UI表单设计及代码生成器
191 | * [form-render](https://github.com/alibaba/form-render)：通过 JSON Schema 生成标准 Form，基于React
192 | * [Vue Json Design](https://github.com/fyl080801/vjdesign)
193 | * [rebuild](https://gitee.com/getrebuild/rebuild)
194 | * [W5 SOAR](https://github.com/w5teams/w5)
195 | * [Moria - Lowcode development platform](https://github.com/MudOnTire/moria)
196 | * [nocobase](https://github.com/nocobase/nocobase)
197 | 
198 | ---
199 | 
200 | * https://github.com/blocks/blocks
201 | * https://github.com/frappe/frappe
202 | * https://github.com/ipselon/structor
203 | * https://github.com/vigetlabs/colonel-kurtz
204 | * https://github.com/BuilderIO/builder
205 | * https://github.com/vuegg/vuegg
206 | * https://webcodesk.com/
207 | * https://github.com/odoo/odoo
208 | * https://github.com/imgcook/imove
209 | 
210 | ## 办公/管理系统 a.k.a no-code
211 | 
212 | * [黑帕云](https://hipacloud.com/)
213 | * [维格表](https://vika.cn/)
214 | * [阿里云-Teambition](https://www.teambition.com/tour)
215 | * [阿里云-RPA](https://cn.aliyun.com/product/codestore)
216 | * [SeaTable](https://seatable.cn/)
217 | * [蒲公英-Tracup](https://www.tracup.com/)
218 | * [蒲公英-Seed](https://seed.pgyer.com/)
219 | * [伙伴云](https://www.huoban.com/)
220 | * [monday.com](https://monday.com/)
221 | * [Airtable](https://airtable.com/)
222 | * [Notion](https://www.notion.so/)
223 | * https://welovenocode.com/nocodelist
224 | 
225 | ## 声明式编程
226 | 
227 | * ["Probabilistic scripts for automating common-sense tasks" by Alexander Lew](https://www.youtube.com/watch?v=MiiWzJE0fEA)
228 | 
229 | ## 行业综述
230 | 
231 | * [Forrester《The State Of Low-Code Platforms In China》（中国低代码平台发展报告）](https://zhuanlan.zhihu.com/p/436106248)
232 | * [精读《对低代码搭建的理解》](https://zhuanlan.zhihu.com/p/161783546)
233 | * [页面可视化搭建工具前生今世](https://zhuanlan.zhihu.com/p/37171897)
234 | * [React.js 可视化编辑工具](https://juejin.im/post/5d7ae944f265da03c5033e38)
235 | * [对低代码、零代码产品的一些看法](https://zhuanlan.zhihu.com/p/156887528)
236 | * [对 aPaaS 的产品认知](https://zhuanlan.zhihu.com/p/149801853)
237 | * [无代码编程](https://zhuanlan.zhihu.com/p/61288928)
238 | * [万物代码化：从低代码、云开发到云研发的思考](https://zhuanlan.zhihu.com/p/141742525)
239 | * [《早早聊搞搭建》搞过搭建的我收获了什么？](https://juejin.im/post/6844904106767695880) 
240 | * [工程化之低代码体系](https://juejin.cn/post/6913698066935578631)
241 | * [LowCode平台前端实战之京东投放素材中心](https://zhuanlan.zhihu.com/p/386761240) 
242 | 
243 | ## 技术点
244 | 
245 | * 可逆计算
246 |   * [可逆计算：下一代软件构造理论](https://zhuanlan.zhihu.com/p/64004026)
247 |   * [从可逆计算看声明式编程](https://zhuanlan.zhihu.com/p/85492497)
248 | * [161.精读《可视化搭建思考 - 富文本搭建》](https://github.com/dt-fe/weekly/issues/262)
249 | * [面向 Model 编程的前端架构设计](https://zhuanlan.zhihu.com/p/144157268)
250 | * [流动的数据——使用 RxJS 构造复杂单页应用的数据逻辑](https://github.com/xufei/blog/issues/38)
251 | * [使用 React 写个简单的活动页面运营系统 - 设计篇](https://segmentfault.com/a/1190000004540256)
252 | * [【电商】用可视化编辑，解构看起来非常炫酷的专题页面](https://www.jianshu.com/p/c4359a7338d3)
253 | * [如何搭建一个功能复杂的前端配置化框架(一)](https://www.cnblogs.com/wukong-holmes/p/9287763.html)
254 | * [可视化拖拽组件库一些技术要点原理分析](https://juejin.cn/post/6908502083075325959)
255 | * [可视化拖拽组件库一些技术要点原理分析（二）](https://juejin.cn/post/6918881497264947207)
256 | * [可视化拖拽组件库一些技术要点原理分析（三）](https://juejin.cn/post/6929302655118344200)
257 | * [揭秘活字格最受程序员喜爱的三大功能背后的设计思路](https://www.grapecity.com.cn/blogs/huozige-the-three-most-popular-features-for-programmers)
258 | 
259 | ## 国外
260 | 
261 | * https://www.honeycode.aws/
262 | * https://developers.google.com/appmaker
263 | * https://powerapps.microsoft.com/zh-cn/
264 | * https://www.zoho.com/creator/
265 | * https://www.salesforce.com/
266 | * https://www.appian.com/
267 | * https://bubble.io/
268 | * https://www.adalo.com/
269 | * https://thunkable.com/
270 | * http://www.vvveb.com/vvvebjs/editor.html
271 | * https://www.forestadmin.com/
272 | * https://mobirise.com/
273 | * https://paperbits.io/
274 | * https://builderx.io/
275 | * https://grapesjs.com/
276 | * https://reactstudio.com/
277 | * https://www.wix.com/
278 | * https://university.webflow.com/
279 | * https://www.squarespace.com/
280 | * https://www.framer.com/
281 | * https://www.figma.com/
282 | * https://www.mendix.com/zh/
283 | * https://www.outsystems.com/
284 | * https://retool.com/
285 | * https://www.quickbase.com/
286 | * https://layoutit.com/
287 | * https://www.claris.com/zh/filemaker/
288 | * FoC 聊天记录：https://marianoguerra.github.io/future-of-coding-weekly/history/?fromDate=2017-06-13&toDate=2017-06-14&channel=general&filter=
289 | * https://www.joget.com/
290 | * https://help.appsheet.com/en/
291 | 
292 | # 一切改进都是源自于人类的缺陷
293 | 
294 | ## How we think
295 | 
296 | * 人脑是串行的，无法有效并行思考多条线索
297 |   * 人脑不适合思考并行执行的多线程
298 |     * 【单线程】把共享变量的编程模式改成事务整体提交的模式
299 |   * 人脑不适合思考同时呈现在屏幕上的多个独立的业务流程
300 |     * 代码是按发生时间组织的，在一起的代码未必是逻辑上有关联的业务流程
301 |       * 【按业务切分文件】阅读者应该可以按照自己的任务目标来跟踪索引，而不是默认一个按钮点击引起的处理逻辑都一定要写在一个大文件里
302 |       * 【按变更频率切分文件】业务变更是阅读的首要原因，代码应该按照业务变更的频率来组织。会同时变更的代码应该放在一起
303 |   * ![#f03c15](https://via.placeholder.com/15/f03c15/000000?text=+)人脑很难管理多份独立可变的状态，本质上每个独立变化的状态就是一个独立的线程
304 |     * 驱动状态数量熵增的三大因素：
305 |       * 因为交互体验的要求，从后端到富客户端到3d动画，状态被复制多份，越来越靠近展示层
306 |       * 因为硬件物理的约束，内存从CPU统一寻址，到异构计算，CUDA，每个硬件核都有一层自己的内存
307 |       * 因为数据量的增长，从统一的OLAP从库，到Data Lake，Data Mart，数据被复制成越来越多份，流水线越来越长
308 |     * 对抗状态数量熵增的手段：
309 |       * 【声明式数据联动】减少独立变化的状态，用表达式来表达 derived state
310 |       * 【全局虚拟数据层】借鉴Unix的统一文件抽象，引入一层统一的虚拟数据层。尽可能把状态转化成 cache
311 |   * 人脑很难理解新增对原有行为的剧烈变化，更习惯逐层稳定叠加。也就是人更希望“控制变量”
312 |     * css 最大的难度在于不正交，新增一条对规则会引起意想不到的效果
313 |       * 【局部化布局】swiftui 的 HStack/VStack/ZStack 布局规则数量少，每条规则作用都是局部的稳定的叠加
314 |     * 性能优化往往需要破坏局部性，因为局部的自治容易引起重复劳动
315 |       * 【局部化IO】系统自动实现 I/O 的批量等可以自动化做的全局优化
316 |       * 【局部化IO】业务写成自治的，但是可以附加额外的手工全局调优。而不是强制要求把业务逻辑从局部抽出去
317 |       
318 | ## How we perceive 
319 | 
320 | * 人眼只能在狭窄的感受野里获得信息
321 |   * 人对时间的感知是来自于对空间的感知
322 |   * 人希望在一个屏幕内从上往下的获取时间顺序上从早到晚的信息
323 |     * callback 的编程方式破坏了屏幕上的顺序和时间顺序的直接映射关系
324 |       * 【协程式IO】用协程取代 callback，把屏幕上的代码撸直
325 |     * ![#f03c15](https://via.placeholder.com/15/f03c15/000000?text=+)通过 status 字段驱动的业务状态机破坏了屏幕上的顺序和时间顺序的直接映射关系
326 |       * 【协程式业务流程】用协程取代 status 状态机，把屏幕上的代码撸直
327 |   * 因为感受野的限制，源代码没有空间展示所有的细节
328 |     * 类型定义，内存分配等“细节”占用了大量的视觉区域
329 |       * 【IDE细节隐藏】在文本上省略掉细节，由 IDE 进行补全，当鼠标移动上去的时候才展示出来
330 |     * 人最习惯的空间整理方式仍然是层状的文件夹
331 |       * 所有的“架构”设计，最终都是对文件夹和文件的设计。但是一个维度的静态索引（文件夹嵌套）无法满足所有可能的检索需求
332 |         * 【IDE按需索引】由 IDE 来补全文件夹分类不能满足的索引需求，针对阅读者的任务来设计IDE索引
333 |   * 视杆细胞容易忽略形状和顺序的差异，但是对颜色更敏感
334 |     * 语法高亮占用了宝贵的资源，但是并没有考虑阅读者的诉求
335 |       * 【IDE按需高亮】对于不同的任务，阅读者希望找到的重点是不同的，语法高亮应该结合任务来做 
336 |       
337 | ## How we collaborate
338 | 
339 | * 人与人之间最高效的沟通的方式是面对面的交互式声波震动
340 |   * 人类低下的沟通带宽根本上限制了一个团队的规模
341 |     * 上线速度要求越快越好，但是加人带来的边际效益递减
342 |       * 减少开会拉齐，团队应该尽可能地自治，而不是什么都要靠 feature team 横向拉通
343 |         * ![#f03c15](https://via.placeholder.com/15/f03c15/000000?text=+)高内聚，低耦合
344 |           * 【静态链接包】编程工具应该提供更多的组合可能，而不是所有的组合都要在运行时用面向对象的多态来实现
345 |           * 【按变更频率切分包】分工应该按照变更频率来确定，分工应该是明确的
346 |   * 尽可能由最终用户，或者靠近最终用户的团队来解决问题，而不是长距离传递需求
347 |     * 最终用户编程：直接让需求提出者自己来实现需求
348 |       * 把“学习”内置到工具里，需要内置一个教学工具
349 |         * 最终用户的编程工具开发难度高，成本高，投入超过了单个软件的回报
350 |           * ![#f03c15](https://via.placeholder.com/15/f03c15/000000?text=+)【编辑器预制】把“公式编辑”，“店铺装修”等常见共性需求提前预制
351 |       * 教学工具的目标是教学，而不是把自己标杆为更先进的生产力
352 |         * 【教学内置】提供教学模式和生产力模式的无缝切换
353 |     * 低代码编程：通过提前预制，把工作量前置，减少应用开发者的规模，从而可以在组织架构上把开发者内置到用户组织内部。与此相对应的是文档驱动的外包式开发。
354 |       * “预制”来自于对共性需求的提前预判
355 |         * 【非功能性需求云化】非功能性需求的实现，都是运行在相似的机器上
356 |           * 操作系统
357 |           * k8s
358 |           * RPC 框架
359 |         * 开发者都是人类
360 |           * 编程工具
361 |           * 沟通工具
362 |         * 用户都是人类
363 |           * 【SaaS组件】IM / 电话 / 短信
364 |           * 【Ui组件】字处理器 / 表格
365 |           * 【CRUD生成】惯用的展现和交互
366 |             * 列表详情
367 |             * 树状层级
368 |             * 表格结构
369 |             * 可拖拽白板
370 |         * 【SaaS组件】相对稳定的业务流程
371 |           * 登录注册
372 |           * 支付
373 |         * 行业内相对稳定的业务共性流程
374 |           * 电商
375 |           * HR / 招聘
376 |           * 销售管理 / CRM
377 |           
378 | ## How we learn
379 | 
380 | * 人的“归纳/理解/学习”能力高度依赖于可视化交互式地操纵与反馈
381 |   * 帮助应该放在任务执行的地方，与其说“可视化”，不如说是“可发现”
382 |     * 【填空题变选择题】单独的语法手册是不好使的，必须提供界面上的按钮，把填空题变成选择题，这样才能启发学习
383 |       * GUI 设计器 / 店铺装修
384 |       * 公式编辑器
385 |       * 审批 / 工作流设计器
386 |       * trigger 流程设计器
387 |   * 人习惯于用手触碰一下对象，然后观测其反馈，从而归纳学习
388 |     * 不可观测的行为无法学习
389 |       * 生产环境的bug无法本地复现，我怎么找规律？
390 |         * ![#f03c15](https://via.placeholder.com/15/f03c15/000000?text=+)【TestInProduction】tracing，大量的 tracing，流量回放
391 |       * lowcode 平台的bug没有任何线索，除了找平台开发者，我能怎么办？
392 |         * 不能要求用户了解所有的内部细节，“平台”要做到可依赖
393 |         * 业务逻辑问题的定位和生产环境的bug定位一样，靠 tracing
394 |     * 反馈太慢的行为给人的负面感受是指数增加的
395 |       * 本地机器太慢了跑不起来，需要上公司的沙盒环境来复现问题
396 |         * ![#f03c15](https://via.placeholder.com/15/f03c15/000000?text=+)【云IDE】
397 |       * 改完了代码需要重新编译重新加载
398 |         * 【LanguageServer】交互式开发的时候跳过不必要的编译
399 |         * ![#f03c15](https://via.placeholder.com/15/f03c15/000000?text=+)【所见即所得】所见即所得的 GUI 开发，本质上就是用解释器执行，换取编译时间的缩减
400 |         * 【HMR】重加载的时候保持页面状态
401 |         
402 | # no code / low code / pro code
403 | 
404 | 一切的改进都是源自于人类的缺陷
405 | 
406 | * no code：自己编程给自己用，给用户的感觉是一个更强大的办公/实用软件。主要的手段是用图形化操作等方式降低学习曲线。no code 一定要面向非常固定的领域才能做到好用。
407 | * low code：编程给其他人用，为此创造了一个 citizen developer 的概念。主要的手段是平台预制好常见的需求，减少需要从头写的代码。low code 也要面向指定的领域才能让平台提前预测需求，但相比 no code 可以不把使用场景限定得那么死。
408 | * pro code：low code 的平台自己不会选择 low code 来创建这个平台本身，因为 low code 并没有降低从头构建一个系统的成本。但是 pro code 的平台自己会选择 pro code 来创建这个平台本身，比如 react 开发者会选择用 react 来创建自己的开发工具，因为 pro code 的工具和平台都是以从根本上降低从头构建一个系统的复杂度为目标的。
409 | 


--------------------------------------------------------------------------------
/on-the-criteria-to-be-used-in-decomposing-systems-into-modules/README.md:
--------------------------------------------------------------------------------
  1 | # On the criteria to be used in decomposing systems into modules
  2 | 
  3 | D. L. Parnas
  4 | 
  5 | Department of Computer Science Carnegie-Mellon University
  6 | 
  7 | Pittsburgh, Pa.
  8 | 
  9 | August, 1971
 10 | 
 11 | This works as supported by the Advanced Research Projects Agency of the Office of the Secretary of Defense (F44620-70-C-0107) and is monitored by the Air Force Office of Scientific Research. This document has been approved for public release and sale; its distribution is unlimited.
 12 | 
 13 | # Abstract 
 14 | 
 15 | This paper discusses modularization as a mechanism for improving the flexibility and comprehensibility of a system while allowing the shortening of its development time. The effectiveness of a "modularization" is dependent upon the criteria used in dividing the system into modules. Two system design problems are presented, and for each, both conventional and unconventional decomposition are described. It is shown that the unconventional decompositions have distinct advantages for the goals outlined. The criteria used in arriving at the decompositions are discussed. The unconventional decomposition, if implemented with the conventional assumption that a module consists of one or more subroutines, will be less efficient in most cases. An alternative approach to implementation which does not have this effect is sketched.
 16 | 
 17 | # Introduction
 18 | 
 19 | If programmers sang hymns, some of the most popular would be hymns in praise of modular programming. A lucid statement of this philosophy is to be found in a new textbook on the design of system programs which we quote below:
 20 | 
 21 | > "A well-defined segmentation of the project effort ensures system modularity. Each task forms a separate, distinct program module. At implementation time each module and its inputs and outputs are well-defined, there is no confusion in the intended interface with other system modules. At checkout time the integrity of the module is tested independently; there are few scheduling problems in synchronizing the completion of several tasks before checkout can begin. Finally, the system is maintained in modular fashion; system errors and deficiencies can be traced to specific system modules, thus limiting the scope of detailed error searching."[1, paragraph 10.23]*
 22 | 
 23 | I must begin by saying that I am in complete agreement with this statement though I might not agree with some possible interpretations. Note, however, that nothing is said about the criteria to use in dividing the system into modules. Because the decision to divide a system into n modules of a given size does not determine the decomposition, this paper will discuss that issue and, by means of examples, suggest the type of criteria that should be used in decomposing the system into modules.
 24 | 
 25 | # A brief status report
 26 | 
 27 | The major progress in the area of modular programming has been the development of coding techniques and assemblers which (1) allow one module to be written with little knowledge of the **code** used in another module and, (2) allow modules to be reassembled and replaced without reassembly of the whole system. This facility is extremely valuable for the production of large pieces of code, but its use has not resulted in the expected benefits. In fact, the system most often used as examples of the problems involved in producing large systems are themselves highly modularized programs which make use of the sophisticated coding and assembly techniques mentioned above.
 28 | 
 29 | # Expected benefits of modular programming
 30 | 
 31 | The expected benefits of modular programming fall into three classes: (1) managerial -- development time could be shortened because separate groups would work on each module with little need for communication (and little regret afterward that eree had not been more communication); (2) product flexiibility -- it was hoped that it would be possible to make quite drastic changes or improvements in one module without changing others; (3) comprehensibility -- it was hoped that the system could be studied a module at a time with the result that the whole system could be better designed because it was better understood.
 32 | 
 33 | # What is a "modularization"?
 34 | 
 35 | In the sequel I give several partial system descriptions called "modularizations". In this contexst "module" is best considered to be a work assignment unit rather than a subprogram. The modularizations are intended to describe the deisgn decisions which must be made **before** the work on independent modules can begin. Although quite different decisions are made in each alternative, in all cases the intention is to describe all "system level" decisions (i.e., decisions which affect more than one module).
 36 | 
 37 | # Example system 1: a KWIC index production system
 38 | 
 39 | For those who may not know what a KWIC index is the following description will suffice for this paper. The KWIC index system accepts an ordered set of lines, each line is an ordered set of characters. Any line may be "circularly shifted" by repeatedly removing the first word and adding it to the end of the line. The KWIC index system outputs a listing of all circular shifts of all lines in alphabetical order. This is a samll sytem. Except under extreme circumstances (huge database, no supporting software), such a system could be produced by a good programmer within a week or two. Consequently it is a poor example in the none of the reasons motivating modular programming are important for this sytem. Because it is impractical to treat a large system thoroughly, we shall go through the eexercise of treating this problem as if it were a large project. We give two modularizations. One, we fell, typifies current projects; the other has been used successfully in an undergraduate class project.
 40 | 
 41 | ## Modularization 1
 42 | 
 43 | We see the following modules:
 44 | 
 45 | **Module 1**: **Input**: This module contains a single main program which reads the data lines from the input medium and stores them in core for processing by the remaining modules. In core the characters are packed four to a word, and an otherwise unused character is used to indicate end of a word. An index is kept to show the starting address of each line.
 46 | 
 47 | **Module 2**: **Circular Shift**: This module is called after the input module as completed its work. Rather than store all of the circulaar shifts in core, it prepares an index which gives the address of the first character of each circular shift, and the original index of the line in the array made up by module 1. It leaves its output in core with words in pairs (original line number, starting address).
 48 | 
 49 | **Module 3**: **Alphabetizing**: This module takes as input the arrays produced by modules 1 and 2. It produces an array in the same format as that produced by module 2. In this case, however, the circular shifts are listed in another order (alphabetically).
 50 | 
 51 | **Module 4**: **Output**: Using the arrays produced by module 3 and module 1, this module produces a nicely formatted output listing all of the circular shifts. In a sophisticated system, the actual start of each line will be marked, pointers to further information may be inserted, the start of the circular shift may actually not be the first word in the line, etc., etc.
 52 | 
 53 | **Module 5**: **Master Control**: This module does little more than control t he sequencing among the other four modules. It may also handle error messages, space allocation, etc.
 54 | 
 55 | It should be clear that the above does not constitute a definitive document. Much more information would have to be supplied before work could start. The defining documents would include a number of pictures showing core formats, pointer conventions, calling conventions, etc., etc. Only when all of the interfaces between the four modules had been specified could work really begin.
 56 | 
 57 | This is a modularization in the sense menat by all proponents of modular programming. The system is divided into a number of relatively independent modules with well defined interfaces; each one is small enought and simple enough to be thoroughly understood and well programmed. Experiments on a small scale indicate that this is approximately the decomposition which would be proposed by most programmers for the task specified. Figure 1 gives a picture of the structure of the system.
 58 | 
 59 | Figure 1
 60 | 
 61 | Structure of KWIC index decomposition 1
 62 | 
 63 | ![figure1](./figure1.drawio.svg)
 64 | 
 65 | ## Modularization 2
 66 | 
 67 | We see the following modules:
 68 | 
 69 | **Module 1**: **Line Storage**: This module consists of a number of functions each one of which is given a precise specification in Figure 2. By calling these functions one may add a character to the end of the last word in the last line, start a new word, or start a new line. One may call other functions to find  the kth character of the kth word in the jth line. Other routines in this module may be called to reveal the number of lines, the number of words in a line, or the number of characters in any word. A precise definition of this module is  given in Figure 2. The method of specification haas been explained in [3].
 70 | 
 71 | **Module 2**: **Input**: This module reads the original lines from the input media **and calls the Line Storage module to have them stored internally**.
 72 | 
 73 | **Module 3**: **Circular Shifter**: This module contains a number of functions. CSSTUP cause the others to have defined values. The others are intended to be analogue of  the information giving functions in module 1. Using them one may refer to the kth character of jth word of  the ith circular shift, as well as getting the lengths of lines and words, etc. This is shown in Figure 3.
 74 | 
 75 | **Module 4**: **Alphabetizer**: This module consists principally of two functions. One, ALPH, must be called before the others will have a defined value. The second, ITH, will serve as an index. ITH(i) will give the index of the circular shift which comes ith in the alphabetical ordering. Formal definitions of these functions are given in Figure 4.
 76 | 
 77 | **Module 5**: **Output**: This module will give the desired printing of any circular shift. It calls upon Circular Shift functions.
 78 | 
 79 | **Module 6**: **Master Control**: Similar in function to the modularization above.
 80 | 
 81 | Figure 2
 82 | 
 83 | Definition of a "Line Storage" Module
 84 | 
 85 | **Introduction**: This definition specifies a mechanism which may be used to hold up to p1 line, each line consisting of up to p2 words, and each word may be up to p3 characters.
 86 | 
 87 | ```
 88 | Function WORD
 89 |   Possible values: integers
 90 |   initial values: undefined
 91 |   parameters: l,w,c all integer
 92 |   effect:
 93 |     call ERLWEL* if 1 < 1 or 1 > p1
 94 |     call ERLWNL if 1 > LINES
 95 |     call ERLWEW if w < 1 or w > p2
 96 |     call ERLWNW if w > WORDS(1)
 97 |     call ERLWEC if c < 1 or c > p3
 98 |     call ERLWNC if c > CHARS(1, w)
 99 |     
100 | ---
101 | * The routine named are to be written by the user of the module. The call
102 | informs the user that he has violated a restriction on the module; the sub-
103 | routine should contain his recovery instructions [3].
104 | ```
105 | 
106 | ```
107 | Function SETWRD
108 |   possible values: none
109 |   initial values: not applicable
110 |   parameters: l,w,c,d all integers
111 |   effect:
112 |     call ERLSLE if l < 1 or l > p1
113 |     call ERLSBL if l > 'LINES' + 1
114 |     call ERLSBL if 1 < 'LINES'
115 |     call ERLSWE if w < 1 or w > p2
116 |     call ERLSBW if w > 'WORDS'(1) + 1
117 |     call ERLSBW if w < 'WORDS'(1)
118 |     call ERLSCE if c < 1 or c > p3
119 |     if l = 'LINES' + 1 then LINES = 'LINES' + 1
120 |     if w = 'WORD'(1) + 1 then WORDS(1) = w
121 |     CHARS(1,w) = c
122 |     WORD(1,w,c) = d
123 | ```
124 | 
125 | # Comparison of the Two Modularizations 
126 | 
127 | Both schemes will work. The first is quite conventional; the second has been used successfully in a class project [7]. Both will reduce the programming to the relatively independent programming of a number of small, manageable, programs. We must, however, look more deeply in order to investigate the progress we have made towards the stated goals. 
128 | 
129 | I must emphasize the fact that in the two decompositions I **may not** have changed any representations or methods. It is my intention to talk about two different ways of cutting up what **may** be the same object. A system built according to decomposition 1 could conceivably be identical after assembly to one built according to decomposition 2. The differences between the two systems are in the way that they are divided into modules, the definitions of those modules, the work assignments, the interfaces, etc. The algorithms used in both cases **might** be identical. I claim that the systems are substantially different even if identical in the runnable representation. This is possible becuase the runnable representation is used only for running; other representations are used for changing, documenting, understanding, etc. In those other representations the two systems will not be identical. 
130 | 
131 | ## (1) Changeability. 
132 | 
133 | There are a number of design decisions which are questionable and likely to change under many circumstances. A partial list: 
134 | 
135 | 1. Input format. 
136 | 1. The decision to have all lines stored in core. For large indices it may prove inconvenient or impractical to keep all of the lines in core at any one time. 
137 | 1. The decision to pack the characters four to a word. In cases where we are working with small indices it may prove undesirable to pack the characters, time will be saved by a
138 | character per word layout. In other cases, we may pack, but in different formats. 
139 | 1. The decision to make an index for the circular shifts rather than actually store them as such. Again, for a small index or a large core^writing them out may be the preferable
140 | approach. 
141 | 1. The decision to alphabetize the list once, rather than search for each item when needed, or partially alphabetize as is done in Hoare's FIND [2]. In a number of circumstances it would be advantageous to distribute the computation involved in alphabetization over the time required to produce the index. 
142 | 
143 | It is by looking at changes such as these that we can see the differences between the two modularizations. The first change is, in both decompositions, confined to one module, but the second change would result in changes in every module for the first decomposition. The same is true of the third change. In the first decomposition the format of
144 | the line storage in core must be used by all of the programs. In the second decomposition the story is entirely different. Knowledge of the exact way that the lines are stored is entirely hidden from all but module 1. Any change in the manner of storage can be confined to that module! 
145 | 
146 | In fact, in some of the versions of this system there was an additional module in the decomposition. A symbol table module as described in [3] was used within the line storage module. This fact, where true, was completely invisible to the rest of the system. 
147 | 
148 | The fourth change is confined to the circular shift module in the second decomposition but in the first decomposition, the alphabetizer, and the output routines will also know of the change. 
149 | 
150 | The fifth change will also prove difficult in the first decomposition. The output module will expect the index to have been completed before it began. The alphabetizer module in the second decomposition was designed so that a user could not detect when the alphabetization was actually done. No other module need be changed. 
151 | 
152 | ## (2) Independent development. 
153 | 
154 | In the first modularization the interfaces between the modules are the fairly complex formats and table organizations described above. These represent design decisions which
155 | cannot be taken lightly. The table structure and organisation are essential to the efficiency of the various modules and must be designed carefully. The development of those formats will be a major part of the module development and that part must be a joint effort among the several development groups. In the second modularization the interfaces
156 | are more abstract, they consist primarily in the function names and the numbers and types of the parameters. These are relatively simple decisions and the independent development of modules should begin much earlier. 
157 | 
158 | ## (3) Comprehensibility. 
159 | 
160 | To understand the output module in the first modularization, it will be necessary to understand something of the alphabetizer, the circular shifter and the input module. There will be aspects of the tables used by output which will only make sense because of the way that the other modules work. There will be constraints on the structure of the tables due to the algorithms used in the other modules. The system will only be comprehensible as a whole. It is my subjective judgment that this is not true in the second modularization
161 | 
162 | # The Criteria 
163 | 
164 | Many readers will now see what criteria were used in each decomposition. In the first decomposition the criterion used was make each 'major step' in the processing a module. One might say that to get the first decomposition one makes a flowchart. Figure 1 is a flowchart. This is the most common approach to decomposition or modularization. It is an outgrowth of all programmer training which teaches us that we should begin with a rough flowchart and move from there to a detailed implementation. The flowchart was a useful abstraction for systems with on the order of 5,000-10,000 instructions, but as we move beyond that it does not appear to be sufficient; something additional is needed. 
165 | 
166 | The second decomposition was made using "information hiding" [4] as a criteria. The modules no longer correspond to steps in the processing. The line storage module, for example, is used in almost every action by the system. Alphabetization may or may not correspond to a phase in the processing according to the method used. Similarly, circular shift might, in some circumstances, not make any table at all but calculate each character as demanded. Every module in the second decomposition is characterized by its knowledge of a design decision which it hides from all others. Its interface or definition was chosen to reveal as little as possible about its inner workings. 
167 | 
168 | # Improvement in Circular Shift Module 
169 | 
170 | To illustrate the impact of such a criterion let us take a closer look at the definition of the circular shifter module from the second decomposition. Hindsight now suggests that this definition reveals more information than necessary. While we have carefully hidden the method of storing or calculating the list of circular shifts, we have indicated an order to that list. Programs could be effectively written if we specified only (1) that the 'lines1 indicated in circular shift's definition will all exist in the "table", (2) that no one of them would be included twice and (3) that a function existed which would allow us to identify the original line given the "shift". By prescribing the order for the shifts we have given more information than necessary and so unnecessarily restricted the class of systems that we can build without changing the definitions. For example, we have not allowed for a system in which the circular shifts were "produced" in alphabetical order, alph is empty, and ITH simply returns its argument as a value. Our failure to do this in constructing the systems with the second decomposition must clearly be classified as a design error. 
171 | 
172 | # Efficiency and Implementation 
173 | 
174 | If we are not careful the second decomposition will prove to be much less efficient. If each of the "functions" is actually implemented as a procedure with an elaborate calling sequence there will be a great deal of such calling due to the repeated switching between modules. The first decomposition will not suffer from this problem because there is relatively infrequent transfer of control between modules. 
175 | 
176 | To save the procedure call overhead yet gain the advantages that we have seen above we must implement these modules in an unusual way. In many cases the routines will be best inserted into the code by an assembler; in other cases, highly specialized and efficient transfers would be inserted. To successfully and efficiently make use of the second type of decomposition will require a tool by means of which programs may be written as if the functions were subroutines but assembled by whatever implementation is appropriate. If such a technique is used, the separation between modules may not be clear in the final code. For that reason additional, program modification, features would also be useful. In other words, the other representations of the program (which were mentioned earlier) must be maintained in the machine together with a machine supported mapping between them.
177 | 
178 | # A SECOND EXAMPLE: A MARKOV ALGORITHM TRANSLATOR 
179 | 
180 | Although the first example makes most of the points of this paper it will be useful to look briefly at a somewhat different example. This one is a translator intended to execute Markov Algorithms. Markov Algorithms have been described in numerous places; the description of them as a programming language is best found in Galler and Perils [6]. For those who are not familiar with them, Markov Algorithms might be described as a poor man's SNOBOL. The only memory in the machine is a character string (always expandable if needed). The algorithm is described by a set of rules. Each rule consists of a pattern to be matched and a substitution part specifying a string to be used to replace the matched wtring. The sequencing rule is that the first rule which can be applied (its pattern matches) is applied at the leftmost part of the register where it will match. When the substitution is complete, the first applicable rule again applies (i.e., there is no memory of the last rule to be applied or the last change made). 
181 | 
182 | # Conventional Modularizations 
183 | 
184 | There are two conventional modularizations of this type of translator, They are: 
185 | 
186 | ## 1. Interpretor 
187 | 
188 | **Input module**: Reads the input, parsing it into rules and storing a direct representation of the rule in core. 
189 | 
190 | **Interpretor**: Attempts to apply each rule to the register. It accesses the data structure storing the rules, uses the pattern to look for a match, and if a match is found, then uses the substitution to change the register. 
191 | 
192 | There may also be an output module doing appropriate printing. 
193 | 
194 | ## 2. Compiler: 
195 | 
196 | **Input module**: Reads the input, parses it, and passes a representation of each syntactic unit as a parameter to the next module, encoder. 
197 | 
198 | **Encoder**: This consists of routines which are passed a rule or part of a rule and produce machine code which would enact it, e.g., they produce a machine code program for each pattern which searches for the occurrence of that pattern. This is known as the compiled code. 
199 | 
200 | **Run Time Routines**: Consist of a standard set of machine code routines used in every algorithm. The compiled routines link to these routines for such functions as output, etc. 
201 | 
202 | # An Alternative Approach 
203 | 
204 | We have used successfully the following modularization: 
205 | 
206 | **Rule Storage**: Stores a representation of the rules in core. This module is in many ways analagous to the Line Storage Module. 
207 | 
208 | **Rule Interpretation**: Knows the meaning of a rule, e.g., knows how to examine the stored rule and apply any given rule. 
209 | 
210 | **Register Manipulation**: Consists of a set of routines which make all manipulations on the register. 
211 | 
212 | **Sequencing**: Chooses the next rule to be applied.
213 | 
214 | **Input**: Reads the input and calls rule storage and register manipulation modules for the purpose of internal storage. 
215 | 
216 | **Output**: Does necessary printing of register, last rule to apply, etc. 
217 | 
218 | # Discussion of Second Example
219 | 
220 | Many of the arguments from the first example could be repeated here. For example, the separation of register manipulation from the other modules allows easier changing of the register representation. The separation of rule sequencing from rule interpretation allows one to experiment easily with some of the other forms of Markov Algorithms described in [6]. 
221 | 
222 | We have chosen this example to make another point, however. This modularization has not made a decision between interpretor and compiler. We can switch between an interpretive translator and a compiler relatively easily and we can also choose many points on a spectrum between the two. Register manipulation, sequencing, input and output will remain (or may remain) with little changes. The major change is in the rule interpretation module, which in the compiler stores a machine code program once, but in the interpretor applies the rule when called to interpret. There can be a great deal of code in common between the two systems. For example, the register manipulation code is used in both versions. In the computer it is part of the run time routines; in the interpretor it is called by the rule interpretation module. 
223 | 
224 | # HIERARCHICAL STRUCTURE 
225 | 
226 | We can find a program hierarchy in the sense illustrated by Dijkstra [5] in the system defined according to decomposition 2. If a symbol table exists, it functions without any of the other modules, hence it is on level 1. Line storage is on level 1 if no symbol table is used or on level 2 otherwise. Input and Circular Shifter require line storage for their functioning. Output and Alphabetizer will require Circular Shifter, but since circular shifter and line holder are in some sense compatible it would be easy to build a parameterized version of those routines which could be used to alphabetize or print out either the original lines or the circular shifts. In the first usage they would not require circular shifter; in the second they would. In other words, our design has allowed us to have a single representation for programs which may run at either of two levels in the hierarchy. 
227 | 
228 | In discussions of system structure it is easy to confuse the benefits of a good decomposition with the benefits of a hierarchical structure. We have a hierarchical structure if a certain relation may be defined between the modules or programs and that relation is a partial ordering. The relation we are concerned with is "uses11 or "depends upon".  It is better to have a relation between programs since in many cases one module depends upon only part of another module (e.g.,  Circular Shifter depends only on the output parts of the line holder and not on the correct working of SETWORD). It is conceivable that we could obtain the benefits that we have been discussing without such a partial ordering, e.g., if all the modules were on the same level. The partial ordering gives us two additional benefits. First, parts of the system are benefited by (simplified) because they use the services of lower levels. Second, we are able to cut off the upper levels and still have a usable and useful product. For example, the symbol table can be used in other applications, the line holder could be the basis of a question answering system. The existence of the hierarchical structure assures us that we can "prune" off the upper levels of the tree and start a new tree on the old trunk. If we had designed a system in which the "low level" modules made some use of the "high level" modules we would not have the hierarchy, we would infd it much harder to remove portions of the system,and "level" would not have much meaning in the system. 
229 | 
230 | Since it is conceivable that we could have a system with the type of decomposition described shown in version 1 (important design decisions in the interfaces) but retain a hierarchical structure, we must conclude that hierarchical structure and "clean" decomposition are two desirable but independent properties of a system structure. 
231 | 
232 | # CONCLUSION
233 | 
234 | We have tried to demonstrate by these examples that it is almost always incorrect to begin the decomposition of a system into modules on the basis of a flowchart. We propose instead that one begins with a list of difficult design decisions or design decisions which are likely to change. Each module is then designed to hide such a decision from the others. Since, in most cases, design decisions transcend time of execution, modules will not correspond to steps in the processing. To achieve an efficient implementation we must abandon the assumption that a module is one or more subroutines, and instead allow subroutines and programs to be assembled collections of code from various modules. 
235 | 
236 | # References
237 | 
238 | 1. Gauthier, Richard and Stephen Ponto, Designing Systems Programs, (C) 1970, Prentice-Hall, Inc.
239 | 2. Hoare, C. A. R., "Proof of a Program, FIND,11 Comm. ACM. January 1971.
240 | 3. Parnas, D. L., A Paradigm for Software Module Specification with Examples, Technical Report, Department of Computer Science, Carnegie Mellon University, Pittsburgh, Pa., 1971.
241 | 4. Parnas, D. L., Information Distribution Aspects of Design Methodology, Technical Report, Department of Computer Science, Carnegie-Mellon University, Pittsburgh, Pa., 1971. Also to be presented at the IFIP Congress 1971, Ljubeljana, Yugoslavia.
242 | 5. Dijkstra, E. W., "The T.H.E. Multiprogramming System," CACM, May 1967.
243 | 6. Galler, B. and A. J. Perils, A View of Programming Languages, Addison Wesley, 1970.
244 | 7. Parnas, D. L., A Course on Software Engineering, in preparation. 
245 | 
246 | 
247 | 
248 | 
249 | 


--------------------------------------------------------------------------------
/on-the-criteria-to-be-used-in-decomposing-systems-into-modules/figure1.drawio.svg:
--------------------------------------------------------------------------------
  1 | <svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" version="1.1" width="203px" height="519px" viewBox="-0.5 -0.5 203 519" content="&lt;mxfile host=&quot;2ba402da-b815-4a6f-9014-d97ba9f3960a&quot; modified=&quot;2020-08-03T06:48:19.209Z&quot; agent=&quot;5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Code-Insiders/1.48.0-insider Chrome/83.0.4103.122 Electron/9.1.0 Safari/537.36&quot; etag=&quot;IIHzSllt-CbMB4q7pdeT&quot; version=&quot;13.1.3&quot;&gt;&lt;diagram id=&quot;6hGFLwfOUW9BJ-s0fimq&quot; name=&quot;Page-1&quot;&gt;7Vdbb5swFP41vE4BQrI8rmm2Vdq0SnnY+ujgE/DkcJBjGuiv3zE2t5BGVaOlq7SXhPPZx5jvwsULl7vyi2J5+h05SC+Y8NILb70gWPgR/RqgssB8PrFAogS3kN8Ba/EEDmymFYLDfjBRI0ot8iEYY5ZBrAcYUwoPw2lblMOz5iyBEbCOmRyjPwXXqUU/BvMO/woiSZsz+7OFHdmxZrK7kn3KOB56ULjywqVC1PZoVy5BGu4aXmzf52dG240pyPRLGma24ZHJwl3bXVYTp4D+FOQK9rQU0wINjlvTm+WFdtvXVcMJcKLIlah0iglmTK469EZhkXEwJ55Q1c35hpgT6BP4G7SunN6s0EhQqnfSjUIp9C/T/iFy1UNv5LZ0K9dF5Qq7T7O5Zxly0B4LFbtZgTMVUwm4WWGrDrkacAdaVTVFksh5HK7OnL+Sdl4nAR04FU4rEpxQpOZ7QjEqiMhj4jtaDROHVGhY56y+kgOlb0ihWxyUhvI8IeNLdQ0zZ12X3cbJhy4IfoOlvRA0bZdwMz/rVi4UhR3rvXLYikxkiTlhvUQsVFxIpurMia3ee8FM0tZuNgTNEnPUN/dEiozuMKau7xkbQV4wC6PioN6L+UlRVfWaTPnQH+va6uqy0ITj0EyvFJpwZIxlq/exzGsjf22NfytIfnTFJC1ek6QTGbL5GJPMZJ6yDWhBD83/qTmXmuk4NdGVUjMdmeBTI9vTCbne+kGzuGI+mjfNHjf3yjiNsDtioXwvZn6dKS91oGu9R5HpTtBWLadoFB4pZUPguo7EarfxIv2ikXw/Cn3qtfWNTT31/56pqew+JCyH3ddYuPoD&lt;/diagram&gt;&lt;/mxfile&gt;">
  2 |     <defs/>
  3 |     <g>
  4 |         <path d="M 101 60 L 101 123.63" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="stroke"/>
  5 |         <path d="M 101 128.88 L 97.5 121.88 L 101 123.63 L 104.5 121.88 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="all"/>
  6 |         <g transform="translate(-0.5 -0.5)">
  7 |             <switch>
  8 |                 <foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility">
  9 |                     <div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 1px; height: 1px; padding-top: 95px; margin-left: 101px;">
 10 |                         <div style="box-sizing: border-box; font-size: 0; text-align: center; ">
 11 |                             <div style="display: inline-block; font-size: 11px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; background-color: #ffffff; white-space: nowrap; ">
 12 |                                 In core representation of input
 13 |                             </div>
 14 |                         </div>
 15 |                     </div>
 16 |                 </foreignObject>
 17 |                 <text x="101" y="98" fill="#000000" font-family="Helvetica" font-size="11px" text-anchor="middle">
 18 |                     In core representation of input
 19 |                 </text>
 20 |             </switch>
 21 |         </g>
 22 |         <rect x="41" y="0" width="120" height="60" rx="9" ry="9" fill="#ffffff" stroke="#000000" pointer-events="all"/>
 23 |         <g transform="translate(-0.5 -0.5)">
 24 |             <switch>
 25 |                 <foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility">
 26 |                     <div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 118px; height: 1px; padding-top: 30px; margin-left: 42px;">
 27 |                         <div style="box-sizing: border-box; font-size: 0; text-align: center; ">
 28 |                             <div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">
 29 |                                 Input Module
 30 |                             </div>
 31 |                         </div>
 32 |                     </div>
 33 |                 </foreignObject>
 34 |                 <text x="101" y="34" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">
 35 |                     Input Module
 36 |                 </text>
 37 |             </switch>
 38 |         </g>
 39 |         <path d="M 101 190 L 101 263.63" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="stroke"/>
 40 |         <path d="M 101 268.88 L 97.5 261.88 L 101 263.63 L 104.5 261.88 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="all"/>
 41 |         <g transform="translate(-0.5 -0.5)">
 42 |             <switch>
 43 |                 <foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility">
 44 |                     <div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 1px; height: 1px; padding-top: 230px; margin-left: 101px;">
 45 |                         <div style="box-sizing: border-box; font-size: 0; text-align: center; ">
 46 |                             <div style="display: inline-block; font-size: 11px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; background-color: #ffffff; white-space: nowrap; ">
 47 |                                 In core directory defining all circular shifts
 48 |                                 <br/>
 49 |                                 of input lines in arbitary order
 50 |                             </div>
 51 |                         </div>
 52 |                     </div>
 53 |                 </foreignObject>
 54 |                 <text x="101" y="233" fill="#000000" font-family="Helvetica" font-size="11px" text-anchor="middle">
 55 |                     In core directory defining all circular shifts...
 56 |                 </text>
 57 |             </switch>
 58 |         </g>
 59 |         <rect x="41" y="130" width="120" height="60" rx="9" ry="9" fill="#ffffff" stroke="#000000" pointer-events="all"/>
 60 |         <g transform="translate(-0.5 -0.5)">
 61 |             <switch>
 62 |                 <foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility">
 63 |                     <div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 118px; height: 1px; padding-top: 160px; margin-left: 42px;">
 64 |                         <div style="box-sizing: border-box; font-size: 0; text-align: center; ">
 65 |                             <div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">
 66 |                                 Circular
 67 |                                 <br/>
 68 |                                 Shifting
 69 |                             </div>
 70 |                         </div>
 71 |                     </div>
 72 |                 </foreignObject>
 73 |                 <text x="101" y="164" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">
 74 |                     Circular...
 75 |                 </text>
 76 |             </switch>
 77 |         </g>
 78 |         <path d="M 101 330 L 101 383.63" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="stroke"/>
 79 |         <path d="M 101 388.88 L 97.5 381.88 L 101 383.63 L 104.5 381.88 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="all"/>
 80 |         <g transform="translate(-0.5 -0.5)">
 81 |             <switch>
 82 |                 <foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility">
 83 |                     <div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 1px; height: 1px; padding-top: 360px; margin-left: 101px;">
 84 |                         <div style="box-sizing: border-box; font-size: 0; text-align: center; ">
 85 |                             <div style="display: inline-block; font-size: 11px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; background-color: #ffffff; white-space: nowrap; ">
 86 |                                 In core directory defining circular shifts in 
 87 |                                 <br/>
 88 |                                 alphabetical order
 89 |                             </div>
 90 |                         </div>
 91 |                     </div>
 92 |                 </foreignObject>
 93 |                 <text x="101" y="363" fill="#000000" font-family="Helvetica" font-size="11px" text-anchor="middle">
 94 |                     In core directory defining circular shifts in...
 95 |                 </text>
 96 |             </switch>
 97 |         </g>
 98 |         <rect x="41" y="270" width="120" height="60" rx="9" ry="9" fill="#ffffff" stroke="#000000" pointer-events="all"/>
 99 |         <g transform="translate(-0.5 -0.5)">
100 |             <switch>
101 |                 <foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility">
102 |                     <div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 118px; height: 1px; padding-top: 300px; margin-left: 42px;">
103 |                         <div style="box-sizing: border-box; font-size: 0; text-align: center; ">
104 |                             <div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">
105 |                                 Alphabetizer
106 |                             </div>
107 |                         </div>
108 |                     </div>
109 |                 </foreignObject>
110 |                 <text x="101" y="304" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">
111 |                     Alphabetizer
112 |                 </text>
113 |             </switch>
114 |         </g>
115 |         <path d="M 101 450 L 101 503.63" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="stroke"/>
116 |         <path d="M 101 508.88 L 97.5 501.88 L 101 503.63 L 104.5 501.88 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="all"/>
117 |         <g transform="translate(-0.5 -0.5)">
118 |             <switch>
119 |                 <foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility">
120 |                     <div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 1px; height: 1px; padding-top: 480px; margin-left: 101px;">
121 |                         <div style="box-sizing: border-box; font-size: 0; text-align: center; ">
122 |                             <div style="display: inline-block; font-size: 11px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; background-color: #ffffff; white-space: nowrap; ">
123 |                                 Pretty Index
124 |                             </div>
125 |                         </div>
126 |                     </div>
127 |                 </foreignObject>
128 |                 <text x="101" y="483" fill="#000000" font-family="Helvetica" font-size="11px" text-anchor="middle">
129 |                     Pretty Index
130 |                 </text>
131 |             </switch>
132 |         </g>
133 |         <rect x="41" y="390" width="120" height="60" rx="9" ry="9" fill="#ffffff" stroke="#000000" pointer-events="all"/>
134 |         <g transform="translate(-0.5 -0.5)">
135 |             <switch>
136 |                 <foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility">
137 |                     <div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 118px; height: 1px; padding-top: 420px; margin-left: 42px;">
138 |                         <div style="box-sizing: border-box; font-size: 0; text-align: center; ">
139 |                             <div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">
140 |                                 Output
141 |                             </div>
142 |                         </div>
143 |                     </div>
144 |                 </foreignObject>
145 |                 <text x="101" y="424" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">
146 |                     Output
147 |                 </text>
148 |             </switch>
149 |         </g>
150 |     </g>
151 |     <switch>
152 |         <g requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"/>
153 |         <a transform="translate(0,-5)" xlink:href="https://desk.draw.io/support/solutions/articles/16000042487" target="_blank">
154 |             <text text-anchor="middle" font-size="10px" x="50%" y="100%">
155 |                 Viewer does not support full SVG 1.1
156 |             </text>
157 |         </a>
158 |     </switch>
159 | </svg>


--------------------------------------------------------------------------------
/今日阅读.md:
--------------------------------------------------------------------------------
   1 | 3.11 【今日阅读】https://www.adama-platform.com/ A single file will define an infinite space of documents where each document is like a tiny computer with storage, networking, and compute. 
   2 | 
   3 | 3.10 【今日阅读】https://yaoapps.com/blog 在知乎上，我注意到“低代码”相关话题的回答，80%的回答趋于负面，60%的回答是一种高高在上的心态在谈论着一件似乎与自己毫不相关的事情，而 20%的正面或者中性回答也大都在宣传自己的平台有多好。“低代码”已被污名化。
   4 | 
   5 | 3.9 【今日阅读】https://github.com/taowen/define-function 用 WebAssembly 执行 quick.js 实现的 eval 沙盒
   6 | 
   7 | 3.8 【今日阅读】https://instadeq.com/blog/categories/history/ No-code History
   8 | 
   9 | 3.7 【今日阅读】https://syndicate-lang.org/ The Syndicated Actor model is a new model of concurrency, closely related to the actor, tuplespace, and publish/subscribe models.
  10 | 
  11 | 3.6 【今日阅读】https://docs.relational.ai/rkgms/intro/why-rkgms In the RGKMS, all information, such as a product’s color or an employee-employer relationship, is expressed by a relation. This approach lets the RGKMS support the flexibility and extensibility required for modern knowledge graph applications: because relations are fully-normalized, your database grows organically, eliminating the need to create new schemas or move data for new business problems.
  12 | 
  13 | 3.5 【今日阅读】https://ourmachinery.com/ Unlike any other engine, The Machinery supports real-time collaborative game editing. Multiple people can work together in the same game project and see each other’s changes instantly, just like in a Google Doc.
  14 | 
  15 | 3.4 【今日阅读】https://mp.weixin.qq.com/s/qgUk2cyQwgEH_tmfGo18oQ OpenSumi是一款面向垂直领域，低门槛、高性能、高定制性的双端（Web 及 Electron）IDE研发的框架。
  16 | 
  17 | 3.3 【今日阅读】https://www.convex.dev/ Convex understands the execution of these functions and automatically handles caching, data distribution and invalidation while providing powerful features like subscriptions to changes in the output of functions.
  18 | 
  19 | 3.2 【今日阅读】https://www.youtube.com/watch?v=Q7yHokTFvrY Why is the software industry now willing and excited to buy developer tools instead of building them internally? In this episode, Kelly Norton, principal software engineer at Mailchimp and creator of open-source code search engine Hound, joins Beyang Liu, co-founder and CTO of Sourcegraph, to talk about his work on the controversial project that would become Google Web Toolkit, share his experience trying to build an ecosystem of tooling, which resulted in Google Dart, and explain how the company he founded, FullStory, pioneered user testing. Along the way, Kelly describes how and why he developed Hound at Etsy and shares his thoughts on the developer tools market.
  20 | 
  21 | 3.1 【今日阅读】https://jasonmorrissc.github.io/post/2022-02-24_no-code/ if people are choosing to do something one way, and not the “better” way, the problem is never with the people, the problem is with the “better” way. People will do what costs the least, but the costs are measured in stress, ambiguity, effort, and human experience.
  22 | 
  23 | 2.28 【今日阅读】https://mp.weixin.qq.com/s/i0fFtRF00tfeZcP6V8Hzlg 上 micro-frontend？大可不必。如果只是为了强制代码的模块化，完全不需要上 micro-frontend 这样的重型运行时方案，typescript+vite 在代码构建阶段就能把这个事给办了。
  24 | 
  25 | 2.27 【今日阅读】https://veykril.github.io/posts/ide-proc-macros/ rust-analyzer enabled #[attribute] expansion by default on Sep 27, 2021, and since then we've seen several issues pop up about user experience degrading when it comes to completions inside of attributed items. This is a pretty big issue for most users, especially those who write async or webserver code, as attributes are prominently used there.
  26 | 
  27 | 2.26 【今日阅读】https://docs.atomicdata.dev/atomic-data-overview.html Atomic Data is a modular specification for sharing, modifying and modeling graph data. It combines the ease of use of JSON, the connectivity of RDF (linked data) and the reliability of type-safety.
  28 | 
  29 | 2.25 【今日阅读】https://git.live/ those uncommited changes in your vscode, is the key of future social coding
  30 | 
  31 | 2.24 【今日阅读】https://alpha.trycarbide.com/ Comments live in a Rich Text sidebar #LiterateProgramming; Carbide shows results in-between the lines of your code— letting you see data in context; The result of any expression can be logged, visualized, and directly manipulated with powerful (and shiny) widgets; Carbide doesn't distinguish between input and output, using generalized machine learning techniques to run programs backwards
  32 | 
  33 | 2.23 【今日阅读】https://vercel.com/live Code in the browser. With your team. Instantly share, chat, draw, and edit from anywhere in the world. Next.js Live enables real-time collaboration for your entire team.
  34 | 
  35 | 2.22 【今日阅读】https://neilmadden.blog/2022/02/19/is-datalog-a-good-language-for-authorization/ Datalog is a logic programming language, based on Prolog, which is seeing something of a resurgence in interest in recent years. In particular, several recent approaches to authorization (working out who can do what) have used Datalog as the logical basis for access control decisions. 
  36 | 
  37 | 2.21 【今日阅读】https://zhuanlan.zhihu.com/p/470015215 低代码/无代码十日谈(一)——趋势背后的逻辑
  38 | 
  39 | 2.20 【今日阅读】https://briandfoy.github.io/ide-driven-development/ IDE handles the complexity, and that’s how things get so complex
  40 | 
  41 | 2.19 【今日阅读】https://www.youtube.com/watch?v=KvMnpVMp0jk Programming by Demonstration (PBD)  https://zhuanlan.zhihu.com/p/468984524
  42 | 
  43 | 2.18 【今日阅读】https://jaked.org/blog/2021-09-07-Reconstructing-TypeScript-part-0 This approach—check an expression against a type when we know what type to expect, synthesize a type from an expression when we don't—is called bidirectional type checking, so named because type information flows in two directions in the abstract syntax tree: from leaves to root when synthesizing, from root to leaves when checking.
  44 | 
  45 | 2.17 【今日阅读】https://cmpct.info/~calvin/Drafts/Relational%20query%20language%20ideas.html one of the biggest causes of NoSQL is that while SQL is a powerful language because of the ideas behind it, it's often implemented in clumsy and archaic ways. A language that learns from SQL could make relational data better to manipulate for programmers.
  46 | 
  47 | 2.16 【今日阅读】https://alain.xyz/blog/a-review-of-shader-languages A review of the state of the art in real time graphics shading languages and compilers in both graphics and compute. What are some of the differences between HLSL, GLSL, MSL, and WGSL? What are some ways to transpile shaders?
  48 | 
  49 | 2.15 【今日阅读】https://mp.weixin.qq.com/s/8r2rfKY_ZNYVpsB-bjtoAA 应用程序灵活组合，是个存在了40年的伪命题
  50 | 
  51 | 2.14 【今日阅读】https://www.infoq.com/presentations/moldable-development/ Tudor Girba discusses Moldable Development, a way of programming through which we construct custom tools for every development problem.
  52 | 
  53 | 2.13 【今日阅读】https://typesupply.github.io/ezui/overview.html Ezui is designed to easily and/or automatically make interfaces follow the design recommendations in the macOS Human Interface Guidelines. 
  54 | 
  55 | 2.12 【今日阅读】https://www.producthunt.com/posts/clay-8 Create spreadsheets that fill themselves, without code
  56 | 
  57 | 2.11 【今日阅读】https://mapsmap.org/ Imagine writing down 99 problems for your domain. Alongside a million other people! Now make it easy to gather the problems into maps. It’s a network of problems!
  58 | 
  59 | 2.10 【今日阅读】https://www.zhihu.com/question/514763047/answer/2339539512 从低代码引擎到搭建平台化建设
  60 | 
  61 | 2.9 【今日阅读】https://www.noodl.net/ Noodl lets you build powerful web-apps without code or limitations.
  62 | 
  63 | 2.8 【今日阅读】https://hub.tines.com/lessons/send-to-story-action 在拖拽的界面里结合了代码补全的编辑器
  64 | 
  65 | 2.7 【今日阅读】https://www.microsoft.com/en-us/research/publication/mergebert-program-merge-conflict-resolution-via-neural-transformers/ 使用模型代替规则提高代码冲突合并的成功率
  66 | 
  67 | 1.30 【今日阅读】https://observablehq.com/@tomlarkworthy/ui-development trying to figure out the best way to build UIs in a scalable way on the ObservableHQ platform.
  68 | 
  69 | 1.29 【今日阅读】https://www.joelonsoftware.com/2022/01/27/making-the-web-better-with-blocks/ joel propose https://blockprotocol.org/ to easily pass data between applications because the data within each block is structured
  70 | 
  71 | 1.28 【今日阅读】https://www.cs.utexas.edu/~swarat/pubs/PGL-049-Plain.pdf survey of program synthesis algorithems: symbolic search, gradient-based search, learning to synthesize, distillation, neural relaxations
  72 | 
  73 | 1.27 【今日阅读】https://www.youtube.com/watch?v=HadE8YnCIRw programming as synthetic dataset pre-training, Self-supervised Occlusion-aware Line Description and Detection
  74 | 
  75 | 1.26 【今日阅读】https://getsturdy.com/features/instant-integration Builds and tests your code as you type it
  76 | 
  77 | 1.25 【今日阅读】https://github.com/max-sixty/prql Even this simple query demonstrates some of the problems with SQL's lack of abstractions: Unnecessary repetition, Functions have multiple operators, Operators have multiple functions, Awkward syntax
  78 | 
  79 | 1.24 【今日阅读】https://github.com/maximecb/noisecraft NoiseCraft is an open source, visual programming language and platform for sound synthesis and music making, with the goal of creating a community for the open exchange of musical ideas.
  80 | 
  81 | 1.23 【今日阅读】https://engineering.contentsquare.com/2021/click-and-swap-alternative-to-drag-and-drop/ The drag and drop system was making it hard for customers to place a widget at a very specific position or to relocate a widget. This happens especially with a large number of widgets: the layout often breaks with some unexpected behavior and widgets a user did not intend to move can be moved accidentally.
  82 | 
  83 | 1.22 【今日阅读】https://sourceacademy.org/sicpjs/index Structure and Interpretation of Computer Programs — JavaScript Edition
  84 | 
  85 | 1.21 【今日阅读】https://www.youtube.com/watch?v=6wZmYMWKLkY making spreadsheets/tables act more like SQL databases (but no sql required), presented by https://en.wikipedia.org/wiki/Dabble_DB founded at 2006, follow up https://www.quora.com/Why-did-Dabble-DB-never-get-any-traction
  86 | 
  87 | 1.20 【今日阅读】https://kelp.app/ Kelp is a low-code visual development platform for building interactive data-driven applications. No traditional coding required.
  88 | 
  89 | 1.19 【今日阅读】https://interrupt.memfault.com/blog/trice Embedded engineers need something as easy to use as printf, usable within interrupts, small enough for today’s MCU’s, and have minimal performance impact when running. The Trice technique tries to fill this gap. It is the result of a long-year dissatisfaction and several attempts to find a loophole to make embedded programming more fun and effective.
  90 | 
  91 | 1.18 【今日阅读】https://jasonmorrissc.github.io/post/prolala/ Programming Languages and the Law (ProLaLa 2022)
  92 | 
  93 | 1.17 【今日阅读】https://news.ycombinator.com/item?id=29860951 Literate programming: Knuth is doing it wrong (2014)
  94 | 
  95 | 1.16 【今日阅读】https://lobste.rs/s/01gogy/teaching_how_code_is_broken Teaching how to code should be about problem-solving and effectively using the tools of a programming language to solve it. Say for example modeling a card game. Even better if the example is a continuous improvement starting from the very basics, hard coding stuff, and then increasing the scope
  96 | 
  97 | 1.15 【今日阅读】https://news.ycombinator.com/item?id=29933858 The market is actually pretty small for super focussed with PaaS with a specialized business model. Trust me, been there, done that. You have to not only communicate why your PaaS is better than others out there in the market but Also de-mystify why they should adopt your pricing model too.
  98 | 
  99 | 1.14 【今日阅读】https://userinterfaces.aalto.fi/c-rwd/ an existing web design is automatically retargeted to a fully responsive web page personalized for the user and device.
 100 | 
 101 | 1.13 【今日阅读】http://blog.pnkfx.org/blog/2022/01/10/why-i-use-a-debugger/ There are four main features that a debugger gives me that are not always fulfilled by adding log statements: object code inspection,
 102 | raw control-flow, memory exploration, and hardware watchpoints.
 103 | 
 104 | 1.12 【今日阅读】http://liveprog.org/ The Seventh Workshop on Live Programming (LIVE 2021) took place online and in Chicago on October 19 in conjunction with SPLASH 2021. Presentation recordings are linked below.
 105 | 
 106 | 1.11 【今日阅读】https://news.ycombinator.com/item?id=29590681 Ask HN: How would a programming language look if designed by non-programmer 
 107 | 
 108 | 1.10 【今日阅读】https://2021.splashcon.org/details/live-2021-papers/9/Modifiable-Software-Systems-Smalltalk-and-HyperCard When software doesn’t fully meet the needs of its user, what are the user’s options? For commercial software, the user can lobby the manufacturer for the feature they need—but the manufacturer may not respond. For open-source software, the user can fork the repo and add the feature themselves—but this requires becoming a developer on the platform the app is written in.
 109 | 
 110 | 1.9 【今日阅读】https://blog.xfbs.net/posts/tracing-linux-macos Being able to easily trace syscalls or library calls can be super handy when debugging. The strace, dtruss and ltrace utilities are definitely a must-have in a programmer’s toolbelt, even if many things can also be done in a debugger. DTrace however is a totally different beast.
 111 | 
 112 | 1.8 【今日阅读】https://github.com/maxwellito/minimator/ Minimator is a minimalist graphical editor.
 113 | 
 114 | 1.7 【今日阅读】https://zverok.substack.com/p/what-you-can-learn-by-merely-writing I provided code examples for most of the features, not only the most trivial usage. Sometimes, I felt it needs realistic examples of how it could be useful, thus complementing the “Reason”; other times, non-obvious behaviors needed to be demonstrated.
 115 | 
 116 | 1.6 【今日阅读】https://dubroy.com/blog/three-ways-of-handling-user-input/ It’s 2022 and things are pretty much the same: the dominant way of handling user input is still based on events and — in some form or another — callbacks. They come in slightly different forms (addEventListener, responder objects, etc.) but the core idea is the same.
 117 | 
 118 | 1.5 【今日阅读】https://web.eecs.utk.edu/~azh/blog/featurestheywanted.html The goal was to create an automated code reviewer that provides program analysis feedback in code reviews. That way the entire team can see the feedback, instead of only the author of the code changes, and they can spend their time on design discussions, instead of superficial nitpicking.
 119 | 
 120 | 1.4 【今日阅读】https://web.engr.oregonstate.edu/~sarmaa/wp-content/uploads/2020/08/icse20-chattopadhyay.pdf we investigated both how often cognitive biases occur in the workplace, and how these biases impact development. Our results indicate that cognitive biases frequently disrupt development, and compromise developers’ problem solving abilities like exploration, sense-making and contextual awareness
 121 | 
 122 | 1.3 【今日阅读】https://www.youtube.com/watch?v=P0EyyutOjDs Procure to Invoice Demo using Warpdrive
 123 | 
 124 | 1.2 【今日阅读】https://kinopio.club/ 比脑图功能更丰富的脑图，其作者分享了他是如何决定对新功能的选择的 http://pketh.org/how-i-build.html
 125 | 
 126 | 1.1 【今日阅读】https://mp.weixin.qq.com/s/Y2A7-Ui2nzUgodkEbgR6lQ 回顾一下Hashicorp过去10年的发展史。这或许不是一本完美的教科书，一开始几年融资也不顺利，中间也走过弯路，也曾经在市场上被撞得鼻青脸肿。但是，在云计算这个时代大背景下，有这么特别的几位创业者，抱着对产品的坚持，集合了全世界几万人的力量，绝对足以在未来IT的发展史中，留下一道值得铭记的痕迹。
 127 | 
 128 | 12.31 【今日阅读】https://zhuanlan.zhihu.com/p/451340998 从2015 开始研发低代码前端渲染（amis），从 2018 年开研发后端低代码数据模型，发布了爱速搭低代码平台，这些年调研过了几乎所有市面上的相关技术和产品，发现虽然每家产品细节都不太一样，但在底层技术上却只有少数几种方案
 129 | 
 130 | 12.30 【今日阅读】https://mp.weixin.qq.com/s/_FMwvY42RUzEsOwN2M90Kg 搜索中台为业务提供两种接入方式，一种是使用者以配置化的形式进行定制，之后使用提供的API接口访问中台的能力，另一种是允许使用者以代码开发、部署服务的形式在中台内部系统中进行定制，实现高度灵活的产品逻辑。
 131 | 
 132 | 12.29 【今日阅读】https://giansegato.com/essays/what-future-ides/ I want to believe that we can (and should) delocalize development to remote servers, while investing R&D into making our local machines better clients to interact with instead of faster machines to run code on.
 133 | 
 134 | 12.28 【今日阅读】https://web.stanford.edu/class/cs208e/reader/CS54N-CS208E-Reader.pdf To avoid overwhelming beginners with the intricacies inherent in those languages, computer science courses often introduce programming in the context of a simplified environment called a microworld. By design, microworlds are easy to learn and enable students to start programming right away. In the process, those students become familiar with the fundamental concepts of programming without having to master a lot of extraneous details.
 135 | 
 136 | 12.22 【今日阅读】https://news.ycombinator.com/item?id=29625625 Ask HN: What's the next big thing in computing / programming? 
 137 | 
 138 | 12.21 【今日阅读】https://www.youtube.com/watch?v=QQhVQ1UG6aM Alan Kay demonstrates a GRaIL (GRaphical Input Language) system from about 1968. From "Doing With Images Makes Symbols: Communicating With Computers"
 139 | 
 140 | 12.20 【今日阅读】https://github.com/samuelmtimbo/unit  units are Multi Input Multi Output (MIMO) Finite State Machines (FSE). A program in unit is represented as a Graph.
 141 | 
 142 | 12.19 【今日阅读】https://utcc.utoronto.ca/~cks/space/blog/programming/Go18GenericsSpecialized The news of the time interval is that Go 1.18 Beta 1 is available, with generics. Barring something terrible being discovered about either the design or the current implementation of Go generics, this means that they will be part of Go 1.18 when it's released in a few months.
 143 | 
 144 | 12.18 【今日阅读】https://github.blog/2021-12-15-a-brief-history-of-code-search-at-github/ We set out to provide an experience that could become an integral part of every developer’s workflow. This has imposed hard constraints on the features, performance, and scalability of the system we’re building.
 145 | 
 146 | 12.17 【今日阅读】https://www.germanvelasco.com/blog/lateral-joins-instead-of-window-functions If only Postgres had a for_each function… 
 147 | 
 148 | 12.16 【今日阅读】https://earthly.dev/blog/printf-debugging/ Printf Debugging and Srinivasa Ramanujan
 149 | 
 150 | 12.15 【今日阅读】https://github.blog/2021-12-09-introducing-stack-graphs/ Today, we announced the general availability of precise code navigation for all public and private Python repositories on GitHub.com. Precise code navigation is powered by stack graphs, a new open source framework we’ve created that lets you define the name binding rules for a programming language using a declarative, domain-specific language (DSL).
 151 | 
 152 | 12.14 【今日阅读】https://www.codeproject.com/Articles/9815/Visual-Leak-Detector-Enhanced-Memory-Leak-Detectio Step 1: Registering the Allocation Hook Step 2: Walking the Stack Step 3: Generating a Better Memory Leak Report
 153 | 
 154 | 12.13 【今日阅读】https://www.pcworld.com/article/559001/the-future-of-esports-is-microsoft-excel-and-its-on-espn.html Top Excel experts will battle it out in an esports-like competition this weekend
 155 | 
 156 | 12.12 【今日阅读】https://www.youtube.com/watch?v=5U6MkU5fLJw What if, instead of thinking of computing as technology for greater efficiency and convenience, we thought of it as a medium approaching that of conventional literacy? What might the environments be like, whom would they serve, and what can we imagine to be the artifacts of that interaction?
 157 | 
 158 | 12.11 【今日阅读】https://denigma.app/ Denigma explains code in understandable english.
 159 | 
 160 | 12.10 【今日阅读】https://www.youtube.com/watch?v=Qytg0Ibet2E Automerge: a new foundation for collaboration software
 161 | 
 162 | 12.9 【今日阅读】https://www.reddit.com/r/programming/comments/rbvpmy/bank_python_the_strange_world_of_python_as_used/ Bank Python: The strange world of Python, as used by big investment banks. AMA.
 163 | 
 164 | 12.8 【今日阅读】https://hondrytravis.com/x-spreadsheet-doc/ 基于 JavaScript 快速构建 Web Excel
 165 | 
 166 | 12.7 【今日阅读】https://breadboard.redefine.software/ 使用 DSL 表达界面原型和页面流，源码位于 https://github.com/redefinesoftware/breadboarder
 167 | 
 168 | 12.6 【今日阅读】https://github.com/json-iterator/tinygo/blob/main/gen/main.go go generate is underrated，GOFILE GOLINE精确提供metadata，解析ast又方便又快，同一个目录下生成多个文件自动拼接
 169 | 
 170 | 12.5 【今日阅读】https://queue.acm.org/detail.cfm?id=3487024 Developer tools can do more to facilitate programmer behavior by making tacit knowledge more explicit. One must ask: What are best practices of good software engineering, and how can such behavioral outcomes be designed into the tooling? Usability heuristics are one approach to bridging this gap.
 171 | 
 172 | 12.4 【今日阅读】https://fauna.com/ Fauna is a flexible, developer-friendly, transactional database delivered as a secure and scalable cloud API with native GraphQL. Never again worry about database provisioning, scaling, sharding, replication, or correctness.
 173 | 
 174 | 12.3 【今日阅读】https://emacsconf.org/2021/talks/structural/ tree-edit seeks to provides a structural editing plugin supporting conceivably any language with a tree-sitter parser.
 175 | 
 176 | 12.2 【今日阅读】https://uizard.io/design-assistant/ Design doesn't have to be hard! Uizard's AI design assistant is here to help you bring your ideas to life easily and make them look professional and beautiful in minutes.
 177 | 
 178 | 12.1 【今日阅读】https://github.com/taowen/wasm3.js/blob/main/demo/demo.js compile wasm3 using emscripten
 179 | 
 180 | 11.30 【今日阅读】https://www.jetbrains.com/zh-cn/fleet/ JetBrains 出品下一代 IDE，使用原生 AOT 技术 https://github.com/JetBrains/skiko 实现，但是不开源
 181 | 
 182 | 11.29 【今日阅读】https://queue.acm.org/detail.cfm?id=3487026 That study found that time constraints are the main influence on how developers interact with static-analysis tools and therefore also influence the strategies they use to optimize their work. For example, to save time, 44 percent of the participants mark warnings as false positives based on the type of issue without investigating the warning further. Similarly, some participants ignore or suppress a warning if they do not understand its description. In both cases, a different UI might help developers make better decisions (e.g., by providing examples of similar warnings that were already resolved).
 183 | 
 184 | 11.28 【今日阅读】https://pratikmistry.medium.com/customization-in-saas-all-you-need-to-know-about-customizing-software-as-a-service-e1685146af72 Instead of owners and managers spending hours every day working around shortcomings in standardized systems and consumers attempting to place orders using clunky user interfaces — why not build a customized software app for your unique business needs and priorities?
 185 | 
 186 | 11.27 【今日阅读】https://www.youtube.com/watch?v=860d8usGC0o Have Single-Page Apps Ruined the Web? https://github.com/builderio/qwik fine-grained lazy-loading to achieve low time to interactive score
 187 | 
 188 | 11.26 【今日阅读】https://vimeo.com/640304817/13aaa16679 Way to gather all kinds of diverse types of media (tweet is a medium) on a visual canvas which is also an information system
 189 | -- with each gesture of the UI evolving the system and being remembered.
 190 | 
 191 | 11.25 【今日阅读】https://zhuanlan.zhihu.com/p/417269967 在前面的七篇文章中，我从概论开始，论述了简单WebGPU渲染引擎的实现，并实现了一个支持BVH加速结构和BRDF光照模型的实时路径追踪渲染器。但由于WebGPU的API的实验性，目前相关标准仍然可能不断变更，而由于配套于WebGPU的调试工具还不存在，所以在不重编Chromium的情况下只能想一些朴素的方法来调试，这里就记录了一些调试心得。
 192 | 
 193 | 11.24 【今日阅读】https://www.tiltfive.com/ Next-Level Gaming With Tabletop Holograms
 194 | 
 195 | 11.23 【今日阅读】https://github.com/withfig/autocomplete Fig uses the Accessibility API on Mac to position the window, insert text on your behalf, and read what you've typed in your terminal.
 196 | 
 197 | 11.22 【今日阅读】https://blog.cloudflare.com/webassembly-on-cloudflare-workers/ We're excited by the possibilities that WebAssembly opens up. Perhaps, by integrating with Cloudflare Spectrum, we could allow existing C/C++ server code to handle arbitrary TCP and UDP protocols on the edge, like a sort of massively-distributed inetd.
 198 | 
 199 | 11.21 【今日阅读】https://primitive.io/ At Primitive, we believe that collaboration and immersive visualization are the future of software development. The Primitive Immersive Development Environment is taking advantage of everything that collaboration in VR can offer while applying new tools for visually analyzing software in 3D.
 200 | 
 201 | 11.20 【今日阅读】https://christine.website/blog/xeact-0.0.69-2021-11-18 Xeact 0.0.69: A Revolutionary Femtoframework For High Efficiency JavaScript Development
 202 | 
 203 | 11.19 【今日阅读】https://powerapps.microsoft.com/en-us/blog/power-fx-open-source-now-available/ 微软的 power fx 开源了
 204 | 
 205 | 11.18 【今日阅读】https://rosieos.com/ If you've ever spent 15 minutes crawling StackOverflow to figure out some specific CLI command, then Rosie is for you. Just type in plain english what you'd like to do, and Rosie will give you the CLI command.
 206 | 
 207 | 11.17 【今日阅读】https://nickarner.com/notes/a-personal-history-of-visual-programming-enviornments-november-13-2021/ A Personal History of Visual Programming Environments
 208 | 
 209 | 11.16 【今日阅读】https://webflow.com/interactions-animations Webflow's interactions and animations tools bring all the power of CSS and JavaScript into a completely visual tool, empowering designers to build complex, rich animations without even thinking about code.
 210 | 
 211 | 11.15 【今日阅读】https://ourmachinery.com/post/the-story-behind-the-truth-designing-a-data-model/ What is a data model and why should you have one?
 212 | 
 213 | 11.14 【今日阅读】https://www.youtube.com/watch?v=icHLoxOFerk Two developers author a set of encryption functions in VR using only voice commands. The davinci-codex API from OpenAI provides the method body code.
 214 | 
 215 | 11.13 【今日阅读】https://developer.chrome.com/docs/devtools/recorder/ chrome 开发者工具新增界面的录制和回放，以及度量该录像过程的性能指标
 216 | 
 217 | 11.12 【今日阅读】https://astro.build/blog/introducing-astro/ Build your site using React, Svelte, Vue, Preact, web components, or just plain ol’ HTML + JavaScript.
 218 | 
 219 | 11.11 【今日阅读】https://www.bilibili.com/video/BV1vQ4y127gF Apollo Dreamview集中了车辆驾驶信息的可视化，包括车道、车辆位置、地图等信息，视频将通过示例演示和具体操作来和大家分享Apollo Dreamview 的学习笔记
 220 | 
 221 | 11.10 【今日阅读】https://developer.nvidia.com/drive/drive-sim NVIDIA DRIVE Sim is an end-to-end simulation platform, architected from the ground up to run large-scale, physically accurate multi-sensor simulation. It's open, scalable, modular and supports AV development and validation from concept to deployment, improving developer productivity and accelerating time to market.
 222 | 
 223 | 11.9 【今日阅读】https://www.quora.com/Does-Alan-Kay-see-any-new-ideas-in-computing Does Alan Kay see any new ideas in computing?
 224 | 
 225 | 11.8 【今日阅读】https://developer.mozilla.org/en-US/docs/Web/Web_Components/Using_templates_and_slots 浏览器原生支持使用 slot 分离 template 的动态数据部分
 226 | 
 227 | 11.7 【今日阅读】https://lime-porcupine-b86.notion.site/Intro-to-Sutro-for-engineers-raising-the-level-of-abstraction-for-programming-by-multiple-orders-of-06f2566973714b3298d8f3cf0ad29c66 Sutro is a new platform for full-stack multi-platform software development where "the product definition *is* the implementation"
 228 | 
 229 | 11.6 【今日阅读】https://www.codesee.io/ Quickly identify cross-code dependencies and navigate between files and folders. With insights to improve your understanding of the codebase and guide onboarding, planning, and reviews.
 230 | 
 231 | 11.5 【今日阅读】https://github.com/microsoft/TypeScript/issues/46452 The ecosystem is CONFUSING here. Here's a taste of what we've found 每一个包，每一个工具都参与了生态的塑造。esm 糟糕的现状，各位都有责任
 232 | 
 233 | 11.4 【今日阅读】https://luau-lang.org/ Around 2006, Roblox started using Lua 5.1 as a scripting language for games. Over the years we ended up substantially evolving the implementation and the language; to support growing sophistication of games on the Roblox platform, growing team sizes and large internal teams writing a lot of code for application/editor (1+MLOC as of 2020), we had to invest in performance, ease of use and language tooling, and introduce a gradual type system to the language.
 234 | 
 235 | 11.3 【今日阅读】https://www.researchgate.net/publication/35247353_A_Programming_System_for_Children_that_is_Designed_for_Usability Throughout the design and refinement of this system, I will apply prior results from empirical studies of programmers and the psychology of programming, my own empirical studies about the ways that nonprogrammers naturally express solutions to programming tasks, and usability testing.
 236 | 
 237 | 11.2 【今日阅读】https://extension.dev/ Customize the browser to fit how you and your team work. Build internal tools and sidebars on top of websites. Automate away manual tasks that waste time. 缺少对二次开发的开放性是很大的一个问题，在一次开发者之间的协作都是问题的现在，二次开发的体验就更糟糕了。
 238 | 
 239 | 11.1 【今日阅读】https://mp.weixin.qq.com/s/lBbyxAN0geNC9lWNGB0jXQ PLG（Product-Led Growth）中文翻译过来叫产品驱动增长，随着采用PLG策略的SaaS公司市值/估值屡创新高，也终于看到他的热度从国外飘到了国内
 240 | 
 241 | 10.31 【今日阅读】https://mp.weixin.qq.com/s/xwps2hzTM5oiq_7QN71q8Q 了解一下 SAP 长什么样子
 242 | 
 243 | 10.30 【今日阅读】https://github.com/terminusdb/terminusdb/blob/dev/docs/whitepaper/terminusdb.pdf TerminusDB is an open source, model driven, revision controlled RDF graph database for distributed collaboration designed for the web-age. TerminusDB allows you to push, pull, time-travel and merge graphs, much in the way that is possible in git.
 244 | 
 245 | 10.29 【今日阅读】https://modernjs.dev/docs/guides/features/server-side/web/routes 是什么原因阻碍了从[前后端分离]到[前后端一体化]？是文件和目录没有放一起么？把文件和目录放一起就能达到前后端一体化了么？
 246 | 
 247 | 10.28 【今日阅读】https://blog.yiningkarlli.com/2021/10/takua-on-m1-max.html M1 Max’s unified memory architecture opens up a wide variety of interesting optimizations that are otherwise difficult to do when managing separate pools of CPU and GPU memory. 软件的编程模型很大程度上也是受到底层硬件平台的左右
 248 | 
 249 | 10.27 【今日阅读】https://www.dspace.com/zh/zho/home/learning-center/recordings/video_icb_simphera.cfm SIMPHERA is a software solution for simulating and validating applications for autonomous driving. The software brings them to life at an early stage, and helps you analyze them and handle their complexity. How? By giving you easy access to powerful functions for simulating the vehicle dynamics, traffic, and more. So you can trial new algorithms, such as for vehicle control, in the virtual world: simpliCity.
 250 | 
 251 | 10.26 【今日阅读】https://docs.google.com/document/d/e/2PACX-1vSt2VB1zQAJ6JDMaIA9PlmEgBxz2K5Tx6w2JqJNeYCy0gU4aoubdTxlENSKNSrQ2TXqPWcuwtXe6PlO/pub We attempted to represent ownership and borrowing through the C++ type system, however the language does not lend itself to this. Thus memory safety in C++ would need to be achieved through runtime checks.
 252 | 
 253 | 10.25 【今日阅读】http://apm.bplaced.net/w/index.php?title=Annotated_lambda_diagram_mockups Annotated lambda diagrams (ALDs) are a proposed interactive programming interface.
 254 | This page presents some mockups about what functionalities could be implemented and how they could be used.
 255 | 
 256 | 10.24 【今日阅读】https://vimeo.com/631461226  If we are to liberate programming from text we need to make structure editing work, including version control. After all, there will be limited benefit from structure editing if collaboration forces us to return to text editing. 
 257 | 
 258 | 10.23 【今日阅读】https://matduggan.com/why-we-need-better/ Coding for non-programmers: Why we need better GUI automation tools
 259 | 
 260 | 10.22 【今日阅读】http://spindynamics.org/wiki/index.php?title=Simple_liquid_state_NMR_simulations a simple example that is both sufficiently easy to get you started and sufficiently difficult to require Spinach, consider the simulation of a magnitude-mode COSY45 spectrum of rotenone -- a system with 22 spins and an irregular coupling pattern
 261 | 
 262 | 10.21 【今日阅读】https://utopia.app/p/36ae27be-public-beaches/ 之前分享过 utopia。不仅提供了在线 vscode + 可视化 UI，还有源代码 https://github.com/concrete-utopia/utopia
 263 | 
 264 | 10.20 【今日阅读】https://zhuanlan.zhihu.com/p/422705566 最好的可观测性是能够指导用户：“我接下来该做什么？”。帮用户多想一步，告诉用户半步，让用户自己走半步
 265 | 
 266 | 10.19 【今日阅读】https://lobste.rs/s/lbero9/what_we_can_learn_from_why_long_lost_open when you don’t create things, you become defined by your tastes rather than ability. your tastes only narrow & exclude people. so create.
 267 | 
 268 | 10.18 【今日阅读】https://www.geoffreylitt.com/2021/03/05/bring-your-own-client.html Bring Your Own Client 听起来和 Headless xxx 差不多
 269 | 
 270 | 10.17 【今日阅读】https://www.youtube.com/watch?v=ZarqJBzJkmA 在一份已有代码上升级，远比如何从无到有更难。Programming Support for Evolving Database Applications
 271 | 
 272 | 10.16 【今日阅读】https://github.com/ivanreese/visual-programming-codex/blob/main/impressions/app-store-illustration.md node-wire programming 的可能性
 273 | 
 274 | 10.15 【今日阅读】https://mp.weixin.qq.com/s/y04rhHFFVe-oBSf-bMYjeQ 软件 2.0 时代的程序分析
 275 | 
 276 | 10.14 【今日阅读】https://render.com/docs 看完感觉就是，不怕麻烦地做好服务业。不一定要有技术含量，更重要的是服务心态和质量
 277 | 
 278 | 10.13 【今日阅读】http://tomasp.net/commodore64/ It is easy to start programming. It is easy to learn. There is just one kind of interaction. You get a simple yet flexible workspace. Hacker access to extra features. 
 279 | 
 280 | 10.12 【今日阅读】https://handtracking.io/ 基于 web 摄像头的手势实时识别
 281 | 
 282 | 10.11 【今日阅读】https://www.youtube.com/watch?v=OQQgezM6avw Idyll Studio: A Structured Editor for Authoring Interactive & Data-Driven Articles
 283 | 
 284 | 10.10 【今日阅读】https://www.youtube.com/watch?v=wgY64Eic2dg Modern OS kernels like Linux are based on traditional MMUs and have no clear abstractions to represent this complexity, mostly leaving IOMMU configuration to device drivers. This has led to a recent spate of serious bugs, and increasing concern over “cross-SoC” attacks on memory security. To address this, we propose a new kernel primitive, mmapx
 285 | 
 286 | 10.9 【今日阅读】https://www.youtube.com/watch?v=36myc8wQhLo we generally program for hardware systems that no longer actually exist. That point was an important part of this talk 何为操作系统？操作系统解决了什么问题？
 287 | 
 288 | 9.30 【今日阅读】https://trekhleb.dev/blog/2021/self-parking-car-evolution/ 用动画来直观的 debug
 289 | 
 290 | 9.29 【今日阅读】https://www.gitpod.io/blog/openvscode-server-launch VS Code in the browser for everyone
 291 | 
 292 | 9.28 【今日阅读】https://tjhunter.github.io/dds_py/ 一完整的可运行系统不仅仅是 git 中的代码，还包括一堆相关的数据。如何同源管理 data+code 的版本分支成为了一个问题。
 293 | 
 294 | 9.27 【今日阅读】http://lambda-the-ultimate.org/node/4655 2012年的人们是怎么预测2020年的开发体验的
 295 | 
 296 | 9.26 【今日阅读】https://future.a16z.com/the-case-for-developer-experience/ Here’s how the Software Heterogeneity Problem came to pose one of the biggest challenges to good developer experience today: Even the simplest web app has a front end, an application layer, and a database. As the needs of a system evolve, along with the tools available, tech stacks inevitably become messy collages of tools, full of their own languages, technologies, workflows.
 297 | 
 298 | 9.25 【今日阅读】https://hyperfiddle.notion.site/Reactive-Clojure-You-don-t-need-a-web-framework-you-need-a-web-language-44b5bfa526be4af282863f34fa1cfffc Reactive Clojure: You don't need a web framework, you need a web language
 299 | 
 300 | 9.24 【今日阅读】https://threadreaderapp.com/thread/1238539198203822081.html This is about engaging almost everybody in the process of building real-world applications. It develops the rationale for, and will end with, a product concept.
 301 | 
 302 | 9.23 【今日阅读】https://mp.weixin.qq.com/s/jqaxmsNJK2-BOKiOI10hDw 挑战之一，就是频繁切换应用的诉求。随着客户使用黑帕云管理的业务越来越多，黑帕云表现得越来越像一个操作系统。我们保持黑帕云在浏览器打开，上一个应用在看销售进展，下一个跳到了市场关键数据跟踪。在不同的应用之间切换，就像在MacOS/Windows切换任务一样。目前，大多数客户只能返回到应用列表，费劲的找到新的应用，再次打开。 评论：所以 UX 是无法妥协的东西，https://zhuanlan.zhihu.com/p/412034775
 303 | 
 304 | 9.22 【今日阅读】https://docs.looker.com/data-modeling/learning-lookml/what-is-lookml For data analysts, LookML fosters DRY style (“don’t repeat yourself”), meaning you write SQL expressions once, in one place, and Looker uses the code repeatedly to generate ad hoc SQL queries. For business users, the end result is the ability to build complex queries in Looker, focusing only on the content they need, not the complexities of SQL structure.
 305 | 
 306 | 9.21 【今日阅读】https://blog.airplane.dev/i-started-a-saas-company-in-2013-and-2021-heres-how-its-changed/ I started SaaS companies in 2013 and 2021. Here's how things have changed
 307 | 
 308 | 9.20 【今日阅读】https://futureofcoding.org/catalog/parabola.html It enables businesses to perform ETL-type operations to and from their SaaS apps (Salesforce, Clearbit, Stripe, MailChimp, etc). It allows for joining across SaaS data sources and then re-exporting back to those apps.
 309 | 
 310 | 9.19 【今日阅读】https://www.bilibili.com/video/BV1Eq4y1K7ju?from=search&seid=8502214852557702222&spm_id_from=333.337.0.0 hololens 的新 AR 交互界面
 311 | 
 312 | 9.18 【今日阅读】https://github.dev/github/dev github codespaces 在线 IDE
 313 | 
 314 | 9.17 【今日阅读】https://blog.bitsrc.io/introduction-to-aleph-the-react-framework-in-deno-322ec26d0fa9 使用 deno 和 esm.sh 来干掉 node_modules
 315 | 
 316 | 9.16 【今日阅读】https://www.osohq.com/post/why-authorization-is-hard Enforcing authorization is hard because it needs to happen in so many places.  Decision architecture is hard because you want to separate authorization from the application. Modeling authorization is hard too.
 317 | 
 318 | 9.15 【今日阅读】https://en.wikipedia.org/wiki/End-user_development 提供 End-user development 一个很大的问题是搞这些各种编辑器的成本太高了。如果能标准化弄几种 EUD 的能力，为啥不试试呢，反正又不会投入很大。
 319 | 
 320 | 9.14 【今日阅读】https://sdg.csail.mit.edu/projects/espalier Espalier (formerly Object Spreadsheets) is a new computational paradigm that combines the usability advantages of spreadsheets with SQL-like expressive power, providing a way to build a wide class of interactive applications more easily than with existing tools.
 321 | 
 322 | 9.13 【今日阅读】https://lobste.rs/s/pkmzlu/fsharp_designer_on_downsides_type_level This happens all the time once extensive type-level programming facilities are available in a language - they immediately, routinely get mis-applied in ways that makes code harder to understand, excludes beginners and fails to convince those from the outside.
 323 | 
 324 | 9.12 【今日阅读】https://elliot.website/editor/ Polytope doesn't draw a distinction between text-based code editors and domain-specific editors, they are all just editors. That means that with Polytope you can embed any editor in any editor (that allows for embedding), and you can embed editors in editors in editors... and so on.
 325 | 
 326 | 9.11 【今日阅读】https://bytebase.com/blog/database-version-control-state-based-vs-migration-based In Infrastructure as Code (IaC) space,  state-based approach has become the de-facto standard. By contrast, in Database as Code (DaC) space, team still prefer migration-based approach to manage their database schemas. Below we give an overview of these 2 approaches, dive the rationale behind the industry divergence. In the end, we show how Bytebase can help to get the best of both worlds.
 327 | 
 328 | 9.10 【今日阅读】https://vision.plato.io/ It’s the age of low-code, it’s the age of creativity, it’s the epoch of internal tools, it’s the epoch of user-facing products, it’s the season for general purpose apps, it’s the season of the vertical, it’s the spring of small business, it’s the summer of the enterprise, we’re all going to IPO, we’re all going directly the other way.
 329 | 
 330 | 9.9 【今日阅读】https://mp.weixin.qq.com/s/55LNXtxf1PjgT5s1KygMYQ 10款2021年国外顶尖的lowcode开发平台
 331 | 
 332 | 9.8 【今日阅读】https://mp.weixin.qq.com/s/zO8htVJoDz19O9Ngb8YA0g 我们可以用五个层面去评价和优化一款SaaS产品的用户体验，包括: 1）战略层2）资源层3）能力层4）场景层 5）感受层
 333 | 
 334 | 9.7 【今日阅读】https://mp.weixin.qq.com/s/AdZjOMWny4Cc70PtusfiVw 1. 互联网产品底层逻辑改变，设计成为产品的灵魂。2. 工作模式改变，从孤军奋战到团队配合。3. 网红经济发展，人人皆可成为内容创作者，亟需能降低门槛的创作工具。那下一个十年呢？生产力工具的未来是怎样的？
 335 | 
 336 | 9.6 【今日阅读】https://blog.mozilla.org/nnethercote/2020/09/08/how-to-speed-up-the-rust-compiler-one-last-time/ It’s rare that a single micro-optimization is a big deal, but dozens and dozens of them are. Persistence is key.
 337 | 
 338 | 9.5 【今日阅读】https://kissflow.com/low-code/no-code/no-code-overview/ No-code frameworks are software design systems that allow even non-technical people to execute software without composing a line of code. These tools usually have a user-friendly interface and drag-and-drop capabilities, allowing you to envision the implementation process and describe the overall business logic with ease.
 339 | 
 340 | 9.4 【今日阅读】http://zimulala.github.io/2016/02/02/schema-change-implement/ TiDB 的异步 schema 变更实现
 341 | 
 342 | 9.3 【今日阅读】https://www.workato.com/solutions/hr https://www.workato.com/solutions/finance workato 这种列举各种使用场景的介绍方式不错
 343 | 
 344 | 9.2 【今日阅读】https://thenewstack.io/mary-thengvall-on-measuring-the-value-of-developer-relations/ Awareness: making sure people know about the product. Enablement: anything that makes sure the developer is successful in getting started and using the product. Community: engaging over forums, Slack channels, Meetups, and events, introducing different aspects of the community to each other.
 345 | 
 346 | 9.1 【今日阅读】https://www.youtube.com/watch?v=9MqVfzxAp6A Making Progress — Alan Kay
 347 | 
 348 | 8.31 【今日阅读】https://mp.weixin.qq.com/s/BjdsLxxM_tefeJt8FeP-JQ 如果我们认同“玩耍“所蕴含的自主探索和创新是一种值得长期追求的学习状态，那么就要创造出能够支持这样学习发生的环境，它可以是新的界面、新的工具或新的语言。
 349 | 
 350 | 8.30 【今日阅读】https://www.growkudos.com/publications/10.1145%25252F3446871.3469759/reader Challenges students face when learning to work with relational databases and SQL
 351 | 
 352 | 8.29 【今日阅读】https://mp.weixin.qq.com/s/hOdqMpsS2RoOBTMvoGHK2Q 宜家如何利用低代码平台提升员工效率，提高数据价值
 353 | 
 354 | 8.28 【今日阅读】https://www.ansys.com/blog/digitally-developing-ar-hud When engineers incorporate augmented reality (AR) into head-up displays (HUDs) roads will become safer.
 355 | 
 356 | 8.27 【今日阅读】https://getsturdy.com/features/live When a directory on your computer is connected to Sturdy, it gains real-time superpowers. As you code in this directory, the changes that you make are instantly shared to Sturdy and made available for your team to comment and give feedback on. 大家终于意识到了阻碍云端开发的最大难点就是一个本地开发目录的代码实时同步问题
 357 | 
 358 | 8.26 【今日阅读】https://www.evidence.dev/ SQL + Markdown → Beautiful Reports。 Evidence enables analysts to build a trusted, version-controlled reporting system by writing SQL and a superset of markdown.
 359 | 
 360 | 8.25 【今日阅读】http://loyc.net/ We believe that programming languages should interoperate with each other on a high level and share as much technology and terminology as possible. Poor interoperability is a serious problem today, and we want to fix that.
 361 | 
 362 | 8.24  【今日阅读】https://mp.weixin.qq.com/s/TXyfTnVCQbKUXJC7qxtC8g SaaS这个模式啊，对乙方厂商的好处很多，但对甲方企业客户嘛...
 363 | 
 364 | 8.22 【今日阅读】https://museapp.com/podcast/37-visual-programming/ Creating software is typically done in text-based environments—but would programming be more accessible with graphical programming tools? Maggie joins Mark and Adam to talk about the relative success of Scratch, Shortcuts, and Zapier; how to make the abstract visible; embodied metaphors; and the false duality of artistic versus logical thinkers.
 365 | 
 366 | 8.21 【今日阅读】https://u-tor.com/topic/automated-penetration-testing 依赖后端程序员正确检查了  api 调用的权限是非常脆弱的。要打破“工具有多通用，人就要多智能”的瓶颈，就是要降低对开发者职业素养的依赖。而自动化安全渗透测试是一个非常有潜力的方向
 367 | 
 368 | 8.20 【今日阅读】https://zhuanlan.zhihu.com/p/26692371 为什么SQL不适合？ 我们再念一遍SQL的全称：structured query language，structured * 3。
 369 | 
 370 | 8.19 【今日阅读】https://www.causal.app/ Spreadsheets are used for 2 things: Number-crunching — modelling, forecasting, calculations, data visualisation. Everything else — business processes, project management, lightweight database, CRM. No-code tools like Airtable and Notion are taking over the 'everything else'. Causal is taking over number-crunching.
 371 | 
 372 | 8.18 【今日阅读】https://imba.io/ 全栈的 web 编程语言，comes with a built-in bundler based on the blazing fast esbuild
 373 | 
 374 | 8.17 【今日阅读】https://shopify.dev/themes/tools/online-editor 原来的 shopify theme 只有源代码，现在增加了可视化编辑器模式。那 theme 还能随意写吗？第三方 theme 开发者如何和官方的可视化编辑器配合呢？
 375 | 
 376 | 8.16 【今日阅读】https://www.36kr.com/p/1347322127117697 冷轧厂在简道云上主要搭建了两大类系统：事务性系统和业务性系统。其中，前者是包含疫情防控、费用报销、用印审批、请假OA等核心业务之外的行政类应用；后者是包含设备巡检、物资管理、缺陷管理、有害气体监测等的核心业务应用
 377 | 
 378 | 8.15 【今日阅读】https://blog.bracha.org/exemplarDemo/exemplar2021.html?snapshot=BankAccountExemplarDemo.vfuel# A live program is dynamic; it changes over time; it is animated. A program is alive when it's running. When you work on a program in a text editor, it is dead.
 379 | 
 380 | 8.14 【今日阅读】https://www.judo.app/ Judo is meant to integrate into your existing iOS and Android app. It's not an "app builder" platform. Instead, Judo facilitates server-driven UI for parts of your app where it makes sense. Typically areas that are displaying lots of data driven content and/or benefit from rapid iteration. It's also a great fit for ephemeral marketing content that doesn't make sense to be built by hand and go through a full release cycle.
 381 | 
 382 | 8.13 【今日阅读】http://www.woshipm.com/it/5011462.html 一文看懂低代码的现状、打法、机会和挑战
 383 | 
 384 | 8.12 【今日阅读】https://www.zhihu.com/question/28772815/answer/1907971744 嵌入式 DSL 的三种实现，第一种是运算符重载，第二种是基于宏，基于宏的eDSL由于工作在语法树上，缺乏类型信息，所以设计者往往会通过增加新的关键字来获取相关的信息，于是这一类eDSL的好坏往往非常取决于设计者的编程水平和品味，第三种是基于生成函数和抽象解释器（abstract interpreter）框架，也就是编译器插件 https://juliacompilerplugins.github.io/
 385 | 
 386 | 8.11 【今日阅读】https://openai.com/blog/openai-codex/ 有6个视频，分别是 Creating a Space Game with OpenAI Codex，“Hello World” with OpenAI Codex，Data Science with OpenAI Codex，Talking to Your Computer with OpenAI Codex，Converting Python to Ruby with OpenAI Codex，Giving OpenAI Codex a First Grade Math Test
 387 | 
 388 | 8.10【今日阅读】http://www.woshipm.com/pd/4933081.html  低代码产品的“逆熵”小败局。传统企业舍弃Sass，投向“逆熵”能不能行得通？作者从六个方面进行了分析，我们一起来看下吧。
 389 | 
 390 | 8.9 【今日阅读】https://css-tricks.com/css-animations-vs-web-animations-api/ 对比 css animation 和 waapi，对于 DSL 如何赋能是否有所启发？即便如此 https://drafts.csswg.org/web-animations-2/#group-effect 和 https://drafts.csswg.org/web-animations-2/#sequence-effects 这些新写法仍然在往里面加，以及制作弹簧动效所需要的自定义 easing 仍然处于提案状态 https://github.com/jakearchibald/easing-worklet 从这些例子又可以学到什么？
 391 | 
 392 | 8.8 【今日阅读】之前 vscode 单元测试扩展是由一个 https://github.com/hbenl/vscode-test-explorer 的插件，提供给其他插件 api。这种一个插件给其他插件提供平台 api 的做法，最终还是被官方亲自下场给终结了 https://code.visualstudio.com/api/extension-guides/testing 这是一个很经典的管理扩展性案例
 393 | 
 394 | 8.7 【今日阅读】https://en.wikipedia.org/wiki/List_of_software_bugs 从历史上这些著名的 bug，看软件对社会的影响
 395 | 
 396 | 8.6 【今日阅读】https://octo.github.com/projects/repo-visualization How can we “fingerprint” a codebase to see its structure at a glance? Let’s explore ways to automatically visualize a GitHub repo, and how that could be useful.
 397 | 
 398 | 8.5 【今日阅读】https://www.zhihu.com/question/382742683/answer/1108096279 哪些具体的场景需要使用 rpa 技术
 399 | 
 400 | 8.4 【今日阅读】https://instadeq.com/blog/posts/japans-fifth-generation-computer-systems-success-or-failure/ 日本第五代计算机系统的故事。用并行式的 prolog 对巨大的知识库编程。a high level requirements specification is sufficient for automatic processing, so that program verification is possible
 401 | 
 402 | 8.3 【今日阅读】https://zhuanlan.zhihu.com/p/395554473 理想的分工应该如下，即UI完成设计逻辑与页面样式（通过设计软件），软件根据规范生成前端可用的静态页面代码，前端基于生成的代码编写功能逻辑
 403 | 
 404 | 8.2 【今日阅读】https://yip.pe/analog.html anything relevant to paper computing, diy punchards machines, graph-paper coding, vedic mathematics, mechanical programming 好多有意思的玩意
 405 | 
 406 | 8.1 【今日阅读】https://github.com/prathyvsh/models-of-interaction Models of Interaction is a catalogue of the different ways of interacting with computers and their underlying models.
 407 | 
 408 | 7.31 【今日阅读】https://maggieappleton.com/drawinginvisibles1 How to Draw Invisible Programming Concepts 共有四篇
 409 | 
 410 | 7.30 【今日阅读】https://news.ycombinator.com/item?id=27985594 把 python 编译到 GPU 上执行，性能达到 cuBLAS 手工优化后的 CUDA C++ 水平
 411 | 
 412 | 7.29 【今日阅读】https://news.ycombinator.com/item?id=27979399 No-code startup Bubble raises $100M  看评论，很欢乐
 413 | 
 414 | 7.28 【今日阅读】https://mp.weixin.qq.com/s/ly02eHuednBqdPyDCdzlew 钉钉们热捧的低代码，正成为工业数字化的核心
 415 | 
 416 | 7.27 【今日阅读】https://github.com/cuba-guides/cuba-petclinic-online-demo/blob/master/modules/front/src/app/pet/PetclinicPetEditor.tsx CUBA platform 的示例代码。用 Java 注解定义模型 https://github.com/cuba-guides/cuba-petclinic-online-demo/blob/master/modules/global/src/com/haulmont/sample/petclinic/entity/pet/Pet.java 代码生成到 React 前端代码，然后提供 React 表单组件做双向绑定。
 417 | 
 418 | 7.26 【今日阅读】https://mp.weixin.qq.com/s/RHFBU9-HOYLN0TvcDznLrg 每家公司招聘需求产生和确认的机制各不相同，有的需要审批、有的不需要；有的有严格的管控，有的比较灵活、松散；有的希望在OA或其他系统中审批通过后，自动导入ATS，在ATS创建职位。录用审批，每家客户也不尽相同，有的需要在线上审批，有的不需要；有的需要在ATS内，有的需要在OA、或eHR、或BPM系统。
 419 | 
 420 | 7.25 【今日阅读】https://www.dialogic.nl/wp-content/uploads/2018/02/demo1.gif 可视化 blockly 编程的动画演示。表达数据流的组合关系，比表达命令流程传达的信息量更大
 421 | 
 422 | 7.24 【今日阅读】https://www.come-future.com/pc-solution-intelligent-detail.html?type=business 原阿里副总裁玄难去搞了家公司做医院信息化的中台
 423 | 
 424 | 7.23 【今日阅读】https://www.tuya.com/cn/product/product-development/mcu-low-code-development 使用即插即用的云模组, 在 MCU 内编写少量代码即可完成产品智能化
 425 | 
 426 | 7.22 【今日阅读】https://news.ycombinator.com/item?id=27906787 We are a team of engineering and design leaders from SpaceX, Google, Northrop Grumman, and Stanford. I spent 11 years at SpaceX and 5 years at Northrop working on spacecraft operations. I’ve taken part in over 100 launches and was the lead trainer for astronauts who went to the space station and back last year. I’ve seen what works and what doesn’t when it comes to software tools and managing operations.
 427 | 
 428 | 7.21 【今日阅读】https://news.ycombinator.com/item?id=27892226 以及 https://flowforge.com/blog/first-deploy/ we do have the Projects feature that brings version control (backed by git) into the editor. And when you view a diff of a flow, as we know what it is, we present a structured visual diff of the flow contents, rather than the raw JSON diff. working on long-standing features such as the Test framework and Flow Debugger.
 429 | 
 430 | 7.20 【今日阅读】https://medium.com/airbnb-engineering/a-deep-dive-into-airbnbs-server-driven-ui-system-842244c5f5 In a traditional world, data is driven by the backend and the UI is driven by each client (web, iOS, and Android). What if clients didn’t need to know they were even displaying a listing? What if we could pass the UI directly to the client and skip the idea of listing data entirely? That’s essentially what SDUI does — we pass both the UI and the data together, and the client displays it agnostic of the data it contains.
 431 | 
 432 | 7.19 【今日阅读】https://arxiv.org/abs/2101.06305 The Role of Working Memory in Program Tracing
 433 | 
 434 | 7.18 【今日阅读】https://krit.com/blog/five-examples-of-no-code-prototypes 5 个使用 nocode 构建 prototype 原型的例子。我觉得独立的 lo-fi prototype 用来快速迭代还是有其价值，hi-fi prototype 确实应该往融合的方向发展
 435 | 
 436 | 7.17 【今日阅读】https://google.github.io/mediapipe/ 提供了大量开箱即用的 photoshop 滤镜一样的机器学习解决方案，作用于实时流媒体上。提供预制件，降低开发成本。
 437 | 
 438 | 7.16 【今日阅读】https://mp.weixin.qq.com/s/O6Sf7-M6-T2LzPFtvYPmTw UI 设计稿智能生成源代码 https://code.fun/
 439 | 
 440 | 7.15 【今日阅读】https://zhuanlan.zhihu.com/p/387854652 现今的设计系统世界晴空万里，唯独有两朵乌云，分别是“设计与开发之间的鸿沟”与“大颗粒度组件的复杂性”
 441 | 
 442 | 7.14 【今日阅读】https://mp.weixin.qq.com/s/aRG789st1OQAYPe2K44FYA 我们阿里巴巴有 18000 个低代码程序员，就我们一家公司，自己员工自己开发的，各种各样的，我还点开看过几个，我已经看不懂了，因为太专业了。那些业务系统一般程序员去理解，光理解业务需求可能就要好几天。
 443 | 
 444 | 7.13 【今日阅读】https://zhuanlan.zhihu.com/p/387971740 《游戏制作工具漫谈》系列文章旨在借助调研游戏制作工具这一方式，为正在低代码领域奋战的诸位开发及产品们提供一条不一样的设计思路。第一节，深度介绍任天堂《Game Builder Garage》，特别是其依靠极具趣味性的导航课堂解决设计器上手门槛很高的问题。
 445 | 
 446 | 7.12 【今日阅读】https://www.youtube.com/watch?v=n8YvL_YvXRA 一步步讲解基于 figma 实现的 lowcode 是如何使用的
 447 | 
 448 | 7.11 【今日阅读】https://www.zhihu.com/question/363707822 低代码开发可以解决哪些问题？
 449 | 
 450 | 7.10 【今日阅读】https://www.forbes.com/sites/forbestechcouncil/2019/10/16/developer-tools-quietly-become-a-growth-story/?sh=7f4f15bd6dea&utm_source=pocket_mylist As a market sector and an investment opportunity, developer tools had long been technology’s underachiever. While demand for software products boomed, companies making developer tools failed to attract any significant investment.
 451 | 
 452 | 7.9 【今日阅读】https://zhuanlan.zhihu.com/p/384274011 写引擎的时候也没发现需要元编程，客户端渲染管线写完就写完了，至多要写好几条管线让人选择，不需要“变化”，不需要元编程。但在写编辑器的时候，我发现支持元编程很重要，有很多编辑器需求依赖元编程。
 453 | 
 454 | 7.8 【今日阅读】https://mp.weixin.qq.com/s/OXCBORheAx99o3fS-ZfUdg 低代码不是一个想吸引业务用户的用语，业务人员见了“代码”两个字就吓跑了，再低也没用，如果业务人员写不了100行代码的话，那10行也一样写不了。低代码平台主要面向专业开发，这点已经是头部分析机构的共识
 455 | 
 456 | 7.7 【今日阅读】https://drossbucket.com/2021/06/30/hacker-news-folk-wisdom-on-visual-programming/ 可视化编程的常见实现，常见的反对声音，以及什么样的问题领域适合可视化编程
 457 | 
 458 | 7.6 【今日阅读】https://jakob.engbloms.se/archives/3051 Personally, I am rather skeptical as to the ecosystem relevance of the “make programming easy enough for anyone” tools. I do not doubt that they can make throwing some bits of code together easier, but is that really something that is useful in a real-world setting?
 459 | 
 460 | 7.5 【今日阅读】https://trailhead.salesforce.com/en/content/learn/projects/convert-lightning-web-components-open-source-to-salesforce/retrieve-data-using-apex Salesforce 的所谓“低代码”开发模式下的前后端一体式开发是怎样的体验？
 461 | 
 462 | 7.4 【今日阅读】https://research.protocol.ai/blog/2021/designing-a-dataflow-editor-with-typescript-and-react/ 讲解可拖拽的框线编辑器如何实现。成品演示 https://joelgustafson.com/react-dataflow-editor/demo/editable.html
 463 | 
 464 | 7.3 【今日阅读】https://mp.weixin.qq.com/s/KiWiaLyaBd79MrgCRwAjxw Low code 或 no code 平台是抽象泄漏的典型。部分 Low code 建站平台的一个重要目标是赋能产品运营或非技术人员，但 low code 平台在设计时往往无法完全屏蔽技术
 465 | 
 466 | 7.2 【今日阅读】4 款 python 的 tracing 工具（所谓时间旅行debugger）https://kolo.app/ http://pythontutor.com/ https://pytrace.com/ https://viztracer.readthedocs.io/en/latest/
 467 | 
 468 | 7.1 【今日阅读】https://www.animaapp.com/ Design & development, united at last. Go from high fidelity prototypes to developer friendly code that engineers can build upon quickly.
 469 | 
 470 | 6.30 【今日阅读】https://copilot.github.com/ 由 AI 来和你结对编程
 471 | 
 472 | 6.29 【今日阅读】https://www.163.com/dy/article/G814O15O0516BJGJ.html 泽森自研的可视化编程框架已经到了一个比较完善的版本， 我们可以开始用这个代码框架将我们所有的基础解算算法重新实现为可以被可视化运用的“节点”， 并成功的用这些“节点”实现了一个复杂的流体仿真算法
 473 | 
 474 | 6.28 【今日阅读】https://utopia.app/ 有点类似 https://developer.apple.com/xcode/swiftui/ 的编辑器设计，代码视图和可视化视图双向实时同步
 475 | 
 476 | 6.27 【今日阅读】https://mp.weixin.qq.com/s/zzBWOfxdIPmT5hybpYLwnA 阿朱讲成功的 SaaS 公司，系列文章 5 篇
 477 | 
 478 | 6.26 【今日阅读】https://zhuanlan.zhihu.com/p/146655911 围绕实际业务出现的高频场景（列表、详情、图表和表单，主要体现在组件上），进行组件抽象和功能开发
 479 | 
 480 | 6.25 【今日阅读】https://futureofcoding.org/episodes/042 The world’s been divided into people who can make software, and the people who use software all day, and basically we think that that paradigm is not a good one. It feels kind of broken
 481 | 
 482 | 6.24 【今日阅读】https://www.nocode.tech/lessons/how-to-build-an-airbnb-clone-without-code How to build an AirBnB clone without code
 483 | 
 484 | 6.23 【今日阅读】https://mp.weixin.qq.com/s/LusLcvhxd404Cp_9SI2Wvg “香山”开源高性能RISC-V处理器利用 chisel 领域专用语言设计，相比直接编写底层 verilog 语言，提高了cpu设计者的设计效率。其核心的特性是基于“生成器” 的复用，提供了 FIFO queue 和 arbiters  这样的预制件来提升芯片搭建速度 https://www.chisel-lang.org/
 485 | 
 486 | 6.22 【今日阅读】https://m.qctt.cn/news/1011669 对于主机厂来说，传统汽车的功能组件（由独立ECU控制）或者单一功能解决方案（譬如自动驾驶），都是“黑盒子”，其核心技术由Tier1把控。主机厂沦为写任务书的角色，还被Diss参数提得不专业。对于Tier2来说，Tier1是择而噬之的怪兽，多数情况下，必须小心翼翼保供，还要对后者实行单向技术透明。
 487 | 
 488 | 6.21 【今日阅读】https://www.sainstore.com.cn/about-shopify-flow/ Shopify Flow的一些经典工作案例
 489 | 
 490 | 6.20 【今日阅读】https://www.codementor.io/howitworks/mentorship 找个 mentor 在线协作编程
 491 | 
 492 | 6.19 【今日阅读】https://www.cnblogs.com/cubacn/p/cubacustomizable.html 如何开发高度可定制的系统
 493 | 
 494 | 6.18 【今日阅读】https://mp.weixin.qq.com/s/UoRAHnSNtVpLta0E-XBT_w 找到像财和税这样有共性的业务才是关键。共性是无法强行抽象出来的，没有就是没有。
 495 | 
 496 | 6.17 【今日阅读】https://support.apple.com/zh-cn/guide/shortcuts/apdf22b0444c/4.0/ios/14.0 苹果 ios shortcuts app
 497 | 
 498 | 6.16 【今日阅读】https://pythonhunter.org/episodes/taowen-vol1 我第一次参与录制podcast，和大家聊聊软件开发的一些问题
 499 | 
 500 | 6.15 【今日阅读】https://blog.jse.li/posts/software/ Where Did Software Go Wrong?
 501 | 
 502 | 6.14 【今日阅读】https://datablocks.pro/ a node-based editor for exploring, analyzing and transforming data without code
 503 | 
 504 | 6.13 【今日阅读】https://mp.weixin.qq.com/s/DYYELKMGNuG56EREyLn37g 145 个有趣的无代码/低代码创业公司
 505 | 
 506 | 6.12 【今日阅读】http://canonical.org/~kragen/memory-models/ 不同编程范式背后的不同“内存模型”
 507 | 
 508 | 6.11 【今日阅读】https://www.bilibili.com/video/BV1564y1S7es 低代码开发平台落地实战
 509 | 
 510 | 6.10 【今日阅读】https://jvns.ca/blog/2021/06/08/reasons-why-bugs-might-feel-impossible/ Reasons why bugs might feel "impossible"
 511 | 
 512 | 6.9 【今日阅读】https://www.douglasdong.com/blog/%E6%88%91%E6%98%AF%E6%80%8E%E4%B9%88%E8%B8%8F%E4%B8%8A%20Lowcode%20%E8%BF%99%E6%9D%A1%E4%B8%8D%E5%BD%92%E8%B7%AF%E7%9A%84/ 参与低代码建设的理由会有很多，有的人可能是希望提供一套上手门槛足够低的工具，让更多的人能够享受到编写代码的乐趣（Workflow），也有些人是听到了市场上经常出现的「只差一个程序员」的声音，希望为这些有梦想的人提供一套快速实现梦想的工具，更有些人是因为工作调动、入职被分配去做低代码方向之类的。而我比较特殊，确切的来说，我是被坑过去的。。。
 513 | 
 514 | 6.8 【今日阅读】https://www.youtube.com/watch?v=gkjbWKp4VgM https://www.manning.com/books/the-programmers-brain 程序员的大脑
 515 | 
 516 | 6.7 【今日阅读】https://zhuanlan.zhihu.com/p/84029931 “守强”的风格类似：一个人要出去办事，神机妙算的军师给他三个锦囊，告诉他：遇到困难的时候打开，按着做就能逢凶化吉。换成守弱的写法，退到可靠的依赖上：我直接告诉你我提供了什么，我怎么考虑我的东西可以被运行到你的系统上的，我让你创建一个用户，是为了什么。我给你做一张SD卡，我的这个卡的要求是什么，用户遇到问题了，就能自己解决，也就是能够帮你，这种情况下，你不怎么牛，但这解决问题。这就是守弱。
 517 | 
 518 | 6.6 【今日阅读】https://news.ycombinator.com/item?id=27385208 One of the coolest parts of our codebase is the new general purpose language at its foundation. Though the semantics of the language are substantially different than Clojure, it’s defined entirely within Clojure using macros to express the differing behavior. It compiles directly to bytecode using the ASM library. The rest of our system is built using both this language and vanilla Clojure, interoperating seamlessly.
 519 | 
 520 | 6.5 【今日阅读】https://futureofcoding.org/episodes/050.html That if you are looking for features to design into your futuristic programming environment, there’s a great big menu of choices you can choose from for interactions or for behaviours or for dynamic relationships between things, that we can see, and we’ve proven are very easy to teach intuitively, or that there exists a way to do a really good job of teaching it intuitively and through play rather than didactically where you have to explain it with a pop-up or a manual or something like that.
 521 | 
 522 | 6.4 【今日阅读】4年前我写了篇文章《噢，你的代码像一坨翔。然后呢？》https://zhuanlan.zhihu.com/p/25336551 ，列举了我尝试过的各种药方。4年后，我也开了个药方《如何不 Review 每一行代码，同时保持代码不被写乱？》https://mp.weixin.qq.com/s/UtBkJYpQHIvRQ_AQnzxxMw
 523 | 
 524 | 6.3 【今日阅读】https://zhuanlan.zhihu.com/p/377234404 程序员为什么不喜欢低代码，关于这个话题大家觉得文章中还有什么遗漏了的地方
 525 | 
 526 | 6.2 【今日阅读】https://mp.weixin.qq.com/s/Fj553uRkdom_6NTl7z7RxQ 之所以存在叫好不叫座的SaaS产品，还是因为这些产品不是企业的核心系统，替换成本极低。而且该SaaS所处的行业已经陷入同质化竞争，协作文档明显就是这种情况。
 527 | 
 528 | 6.1 【今日阅读】http://www.creativante.com.br/download/boehm2006.pdf George Santayana's statement, "Those who cannot remember the past are condemned
 529 | to repeat it," is only half true.
 530 | 
 531 | 5.31 【今日阅读】https://blogs.microsoft.com/ai/from-conversation-to-code-microsoft-introduces-its-first-product-features-powered-by-gpt-3/ With the new GPT-3-powered features, a person can get the same result by typing plainspoken language like: “Show 10 orders that have stroller in the product name and sort by purchase date with newest on the top.”
 532 | 
 533 | 5.30 【今日阅读】https://mp.weixin.qq.com/s/RZugXR3PRtU_xoGbtx4_yQ 如何构建一个完整的To B应用开发平台
 534 | 
 535 | 5.29 【今日阅读】https://nusi-webback.terminus.io/docs/overview 将常见模式（单模型 CRUD 的 Form 、Table ，关联模型 CRUD 的 Form 等）产出为标准，并借由平台沉淀成强约束的功能，避免交互上的细微差异。后端 API 和逻辑仍然可保持分散独立，但提供统一平台，统一接入用户、组织架构和权限，并接入所有后端 API ；前端交互部分全都有平台实现并展示。这种方式下，企业的遗留系统也可以接入进来。抽象业务间衔接的标准，由平台统一提供能力和接入机制，例如：审批流、通知/待办、检索、Share
 536 | 
 537 | 5.28 【今日阅读】https://beadslang.org/the-beads-project 有个哥们发明了一门新语言 Declarative languages, which have almost no bugs, and offer a 10:1 reduction in total lifecycle cost 然后在 hackernews 上收获大量评论 https://news.ycombinator.com/item?id=27287989 恰好我前两天也写了两篇相关的文章 https://zhuanlan.zhihu.com/p/373001720 减少样板代码为啥不受欢迎 https://zhuanlan.zhihu.com/p/375062873 如果一个好主意50年了还没有落地，那它也不是那么好的主意 
 538 | 
 539 | 5.27 【今日阅读】https://www.sciencedirect.com/science/article/pii/S0167642304000978 以自动化出警为领域例子，解释如何用 frame 技术实现基于 frame 的组装
 540 | 
 541 | 5.26 【今日阅读】https://www.bilibili.com/video/BV1hK4y1R7xD/ 业务逻辑拆分模式的探索
 542 | 
 543 | 5.25 【今日阅读】https://www.youtube.com/watch?v=woMybx3gRIs 用 DSL 表达保险和再保险的合同条款
 544 | 
 545 | 5.24 【今日阅读】https://turtlespaces.org/2021/05/21/past-and-future-turtles-the-evolution-of-the-logo-programming-language-part-1/ However, if the child is able to actively explore these concepts in an environment that has some measure of feedback, the likelihood of their gaining understanding improves. 
 546 | 
 547 | 5.23 【今日阅读】https://cpojer.net/posts/principles-of-devx Developer Experience or _“DevX”_ is the experience developers have when building, maintaining, testing, deploying, and analyzing software. Think about the tooling you use: Some of them are probably hard to use, slow, and there aren’t any plans to improve them.
 548 | 
 549 | 5.22 【今日阅读】https://www.v2ex.com/t/778356#r_10545506 尤雨溪谈低代码无代码
 550 | 
 551 | 5.21 【今日阅读】http://foamdev.com/ You write very high-level, declarative models, and FOAM builds many features from them: default views, storage, serialization, Java and Swift classes, and much more.
 552 | 
 553 | 5.20 【今日阅读】https://www.adalo.com/posts/spotto-the-first-adalo-app-to-get-acquired Adalo 拿了融资，用 Adalo 写的 https://www.spotto.work/ 被收购了，看看这个 nocode 工具有啥过人之处
 554 | 
 555 | 5.19 【今日阅读】https://mp.weixin.qq.com/s/4cF9CdM3uBKrd3XfywI3Dg 从no-code到low-code：企业级hpaPaaS的未来
 556 | 
 557 | 5.18 【今日阅读】https://blog.robenkleene.com/2021/05/16/codespaces/ Codespaces: GitHub's Play for a Remote Development Future
 558 | 
 559 | 5.17 【今日阅读】https://lobste.rs/s/nlcstu/modern_compiler_for_french_tax_code 法国税法的 DSL
 560 | 
 561 | 5.16 【今日阅读】https://playb.it/ A DOM-like data structure for building collaborative software that works just as well while connected to the Internet as when running offline locally. This software can run natively as a Go or C library or in a web browser or JavaScript environment like NodeJS. It features zero-cost snapshots, a DOM-like API, subgraphs, aliases and permissions. It is a form of CRDT.
 562 | 
 563 | 5.15 【今日阅读】https://juejin.cn/post/6961966535472578590 现在在搜索引擎上搜“低代码”这样的关键词，你会看到很多夸张的标题。甚至我还在福报长的抖音账号中，看到了程序员下午坐在外面喝咖啡，说有了低代码，现在大把时间休息的短视频。。。
 564 | 
 565 | 5.14 【今日阅读】https://simons.berkeley.edu/talks/dreamcoder 之前已经有很多让计算机根据例子反推代码的努力了，比如 Excel 里的 Flash Fill。DreamCoder 是这些努力中最近的进展，它不仅仅可以根据函数凑出程序，还能自己重构出子函数来。嗯，也就是发明 DSL。
 566 | 
 567 | 5.13 【今日阅读】https://payment.feishu.cn/docs/doccnPtNn2kJXmyqkKLHmGtbRfb# 解码无代码/低代码创业圈子及其玩家
 568 | 
 569 | 5.12 【今日阅读】https://zhuanlan.zhihu.com/p/371061803 一是根植应用场景的现实派。二是打造独立平台的未来派。现阶段的低代码平台只是程序员手中的工具，选择使用什么样的工具，权利仍然在数量庞大的程序员手中。在越来越多程序员面临35岁焦虑，并且行业鄙视链越来越严酷的局面下，一味高喊“消灭程序员”的口号，绝非是最佳的营销方式。
 570 | 
 571 | 5.11 【今日阅读】https://mp.weixin.qq.com/s/V8l7S7A-kRF_WDb7tlJJ0Q 在提赋能之前，先想想这5个问题
 572 | 
 573 | 5.10 【今日阅读】https://zhuanlan.zhihu.com/p/370980863 元数据驱动，表单 schema 与类型系统
 574 | 
 575 | 5.9 【今日阅读】https://mp.weixin.qq.com/s/gvCQqNFaGSWCJv9XHMl94A lowcode/nocode 的问题和 https://xargin.com/the-death-of-middleground/ 中台的问题一样
 576 | 
 577 | 5.8 【今日阅读】https://mp.weixin.qq.com/s/Qx08FDyNxHOi7hI1bvnrzg 软件开发提效哪有那么容易，都是坑啊~
 578 | 
 579 | 5.7 【今日阅读】https://zhuanlan.zhihu.com/p/370230771 云研发 IDE Uncode：演示版发布
 580 | 
 581 | 5.6 【今日阅读】https://youtu.be/aHXY3_xCGOE 在运行时进行所见即所得的界面编辑
 582 | 
 583 | 4.30 【今日阅读】https://web.eecs.utk.edu/~azh/blog/informationforaging.html?utm_source=pocket-app&utm_medium=share A theory of how developers seek information
 584 | 
 585 | 4.29 【今日阅读】https://juejin.cn/post/6955775203771154446 对于盒马而言，立志于将盒马前端团队从资源型支持，转到服务型前端团队，需要让资深前端开发人员专注在复杂场景的 ProCode 开发上，然后通过 LowCode/NoCode 让外包、后端、非技术人员来完成应用交付。我们希望一个应用，能按 NoCode -> LowCode -> ProCode 的方式支持，一种模式无法满足就降级下一种模式，我们称之为渐进式研发模式。
 586 | 
 587 | 4.28 【今日阅读】https://pernos.co/ 的作者说 Print Debugging Should Go Away https://news.ycombinator.com/item?id=26955344 评论区 https://lobste.rs/s/zimwzw/print_debugging_should_go_away https://news.ycombinator.com/item?id=26955344
 588 | 
 589 | 4.27 【今日阅读】https://zhuanlan.zhihu.com/p/367729180 一个由最新版的ZENO系统“拉”出来的场景计算过程， 它是一个冰系的法杖， 掌握着“宇宙”的能力， 我想象中这个法杖的头部有一颗珠子， 其中是一个瓶中世界， 里面运行着互相绕转的星宿， 并应该还有一些水一样质感的效果。
 590 | 
 591 | 4.26 【今日阅读】https://emilwallner.medium.com/how-you-can-train-an-ai-to-convert-your-design-mockups-into-html-and-css-cc7afd82fed4 How you can train an AI to convert your design mockups into HTML and CSS
 592 | 
 593 | 4.25 【今日阅读】https://www.youtube.com/watch?v=H7BiZBOYCIs 使用拖拽工具编写温度单位转换器
 594 | 
 595 | 4.24 【今日阅读】https://replay.io/ Replay is a browser that lets you record your website, discuss with your team, and debug your application with next-gen devtools.
 596 | 
 597 | 4.23 【今日阅读】https://www.geoffreylitt.com/margin-notes/ Margin Notes automatically generates code documentation by recording example data from function calls as a program executes and displaying those examples in an interactive UI next to the code. 
 598 | 
 599 | 4.22 【今日阅读】https://mp.weixin.qq.com/s/SIyIcn2V2yMB5ykACPQBfw 这四个才是真正的低代码平台
 600 | 
 601 | 4.21 【今日阅读】https://www.36kr.com/p/1161716584777097 技术门槛低，换句话说是“没有技术壁垒”，更容易出现同质化竞争。还是以无代码工具为例，可以看出目前市面上的维格表、treelab、黑帕云的使用页面和功能没有太大的差异。一位tob投资人明确告诉36氪，无代码、低代码等没有技术门槛的工具，没有投资价值。
 602 | 
 603 | 4.20 【今日阅读】https://news.ycombinator.com/item?id=26855037 You've discovered what many other people have: The cloud is the new time-share mainframe.
 604 | 
 605 | 4.19 【今日阅读】https://pernos.co/about/overview/ Many developers spend a lot of time debugging, using traditional debuggers or no tools at all. Pernosco is a much better debugger that can reduce this debugging time dramatically and make it more fun.
 606 | 
 607 | 4.18 【今日阅读】https://www.graphile.org/postgraphile/ Instantly spin-up a GraphQL API server by pointing PostGraphile at your existing PostgreSQL database
 608 | 
 609 | 4.17 【今日阅读】https://arxiv.org/abs/2103.00352 The widespread adoption of Free/Libre and Open Source Software (FLOSS) means that the ongoing maintenance of many widely used software components relies on the collaborative effort of volunteers who set their own priorities and choose their own tasks. We argue that this has created a new form of risk that we call 'underproduction' which occurs when the supply of software engineering labor becomes out of alignment with the demand of people who rely on the software produced. 
 610 | 
 611 | 4.16 【今日阅读】https://docs.dapr.io/concepts/overview/ 昨天我们看到了 encore 这样的搞法被人骂得很惨。当业务代码无法被侵入的时候，人们就在 sidecar 上死命了加东西
 612 | 
 613 | 4.15 【今日阅读】https://encore.dev/ Most low-code and no-code tools promise the world, but get abandoned when your application grows. Not so with Encore. Encore offers a real programming environment with the full power and flexibility that comes with it.
 614 | 
 615 | 4.14 【今日阅读】https://www.infoworld.com/article/3611369/how-to-build-an-internal-developer-platform-from-those-who-have-done-it.html How to build an internal developer platform, from those who have done it
 616 | 
 617 | 4.13 【今日阅读】https://blog.tailwindcss.com/building-react-and-vue-support-for-tailwind-ui headless 这，headless 那，终于到了 headless ui
 618 | 
 619 | 4.12 【今日阅读】https://greaterdanorequalto.com/evaluating-modest-saas-business-ideas/ Evaluating Modest SaaS Business Ideas
 620 | 
 621 | 4.11 【今日阅读】https://www.infoq.cn/article/b9RlsXuwT9jtZSUJcfUl 低代码开发平台混战：如何区分“李逵”和“李鬼”？
 622 | 
 623 | 4.10 【今日阅读】https://www.youtube.com/watch?v=bX-k0pXNT0c JetBrains Connect, Ep. 5 – "DSLs: Bringing the Experts into Development"
 624 | 
 625 | 4.9 【今日阅读】https://mp.weixin.qq.com/s/e1MPCPAglLOmOGZQ22wVDg 代码是如何变烂的，toB代码又是如何更烂的
 626 | 
 627 | 4.8 【今日阅读】https://news.ycombinator.com/item?id=26725370 The Dynamicland researchers are not developing a product. The computers that the researchers build are models: not for distribution, but for studying and evaluating. The goal of the research is not to provide hardware or software to users, but to discover a new set of ideas which will enable all people to create computational environments for themselves, with no dependence on Dynamicland or anyone else, and to understand how these ideas can be taught and learned. The end result of the research is fundamentally intended to be a form of education, empowering communities to be self-sufficient and teach these ideas to each other.
 628 | 
 629 | 4.7 【今日阅读】https://adriancitu.com/tag/the-common-reuse-principle/ 把自己定位为开发者工具的 lowcode 都应该了解一下开发者对于自己工具的传统认识，归结为这张图 https://adriancitu.files.wordpress.com/2017/11/componetcohesion.jpg
 630 | 
 631 | 4.6 【今日阅读】https://medium.com/pito-s-blog/why-improv-didnt-succeed-3e06a43acf73 But when spreadsheets get complicated they get messy and error-prone and this is what Improv set out to address.In the end it didn’t go anywhere, probably because in setting out to improve on spreadsheets, Improv lost the essence of a spreadsheet and in doing so lost the market.
 632 | 
 633 | 4.5 【今日阅读】https://penpot.app/ Penpot is the first Open Source design and prototyping platform meant for cross-domain teams.
 634 | 
 635 | 4.4 【今日阅读】https://www.gamesindustry.biz/articles/2020-07-21-adopt-me-interview 让小孩子创造自己的游戏，和让最终用户定制自己的应用。我觉得这两者之间有很大的重叠。可以看看 Roblox  的成功故事
 636 | 
 637 | 4.3 【今日阅读】https://iggyfernandez.wordpress.com/2014/01/06/the-twelve-days-of-nosql-day-twelve-concluding-remarks/ The final innovation of the NoSQL camp is “schemaless design.” In database management systems of the NoSQL kind, data is stored in “blobs” and documents the database management system does not police their structure. 
 638 | 
 639 | 4.2 【今日阅读】https://www.brcommunity.com/articles.php?id=b227 The idea of having 'end-users' -- people with no background in software testing or development -- directly manipulate software that is critical for a company frightens many software professionals. Some contend that end-user programming is a threat for mission-critical systems from the perspective of both correctness and security.
 640 | 
 641 | 4.1 【今日阅读】https://github.com/airbytehq/airbyte 是一个开源项目，同时也是一个创业公司 https://airbyte.io/articles/our-story/startups-avoid-being-vitamins-at-all-costs/ 他们得到的经验教训是 you should never settle for a vitamin in B2B，要成为 painkiller
 642 | 
 643 | 3.31 【今日阅读】https://www.infoworld.com/article/3438819/why-developers-hate-low-code.html Why developers hate low-code
 644 | 
 645 | 3.30 【今日阅读】https://mitpress.mit.edu/books/small-matter-programming A Small Matter of Programming asks why it has been so difficult for end users to command programming power and explores the problems of end user-driven application development that must be solved to afford end users greater computational power. 
 646 | 
 647 | 3.29 【今日阅读】http://www.pathsensitive.com/2021/03/developer-tools-can-be-magic-instead.html Developer tools can be magic. Instead, they collect dust. In spite of this, tools research is still light-years ahead of what’s being deployed. It is not unusual at all to read a 20 year-old paper with a tool empirically shown to make programmers 4x faster at a task, and for the underlying idea to still be locked in academia.
 648 | 
 649 | 3.28 【今日阅读】https://blueprintsfromhell.tumblr.com/ ue游戏引擎内置了 blueprint 图形化编程方式，据说是给策划用的。这里收集了一些非常极端的 blueprint 样例
 650 | 
 651 | 3.27 【今日阅读】https://en.wikipedia.org/wiki/Visual_programming_language 可视化编程语言大全
 652 | 
 653 | 3.26 【今日阅读】https://zhuanlan.zhihu.com/p/359122473 Notion 编辑器原理分析
 654 | 
 655 | 3.25 【今日阅读】https://qmacro.org/2009/04/21/tarpipecom-programming-20/ http://blog.davemo.com/posts/2009-04-06-yahoo-pipes-at-vendasta.html 两篇来自12年前的文章，对比一下，看看12年之后有没有什么进步
 656 | 
 657 | 3.24 【今日阅读】https://airtable.com/shr8PyyMH5TiYX3c1/tblG2pFx5WJUHJyIc 各种创作工具的截图
 658 | 
 659 | 3.23 【今日阅读】https://www.jolie-lang.org/ 配合 https://wasp-lang.dev/ 服用
 660 | 
 661 | 3.22 【今日阅读】https://www.youtube.com/watch?v=mU1aPvvQbqk Whoa, pictures! A visual history of visual programming languages! by Emily Nakashima
 662 | 
 663 | 3.21 【今日阅读】http://lighttable.com/2014/03/27/toward-a-better-programming/ So if it's not just the feedback loop, what is it then? What's wrong with programming? 视频版 https://www.infoq.com/presentations/reimagining-software/
 664 | 
 665 | 3.20 【今日阅读】https://www.apollographql.com/docs/react/performance/optimistic-ui/ 乐观的UI，这词也不知道是谁发明的。meteor 当年也只是称之为 latency compensation
 666 | 
 667 | 3.19 【今日阅读】https://www.2ndquadrant.com/en/blog/postgresql-anti-patterns-unnecessary-jsonhstore-dynamic-columns/ json is the new EAV – a great tool when you need it, but not something you should use as a first choice.
 668 | 
 669 | 3.18 【今日阅读】https://medium.com/@dabit3/tackling-user-authorization-in-graphql-with-aws-appsync-7886aef60b4a 当 AWS 希望你在它的平台上写代码了之后，这就是你的开发体验。如果你抱怨这东西太复杂了，它就会再给你一份代码生成器 https://github.com/aws-amplify/amplify-cli/blob/master/packages/graphql-relational-schema-transformer/src/RelationalDBResolverGenerator.ts 这就是 AppSync 和 Amplify 的故事
 670 | 
 671 | 3.17 【今日阅读】https://paulhammant.com/2021/02/16/buildless-sfc-vuejs-applications/ 用浏览器直接 import .vue 文件
 672 | 
 673 | 3.16 【今日阅读】https://dzone.com/articles/evil-annotations An Annotation is evil, if it represents some additional functionality or constraint that alters runtime behavior of code. This is bad, because it hides aspects of a class or method and therefore makes the Code harder to understand, reuse, debug, refactor and to test. 评论区还有 152 条评论
 674 | 
 675 | 3.15 【今日阅读】https://www.researchgate.net/publication/226455669_Future_Perspectives_in_End-User_Development Future Perspectives in End-User Development 写于 January 2006
 676 | 
 677 | 3.14 【今日阅读】https://futureofcoding.org/episodes/049.html He’s famous for leading the Sketch-n-Sketch project, an output-directed, bidirectional programming tool that lets you seamlessly jump back and forth between coding and directly manipulating your program’s output. 
 678 | 
 679 | 3.13 【今日阅读】https://medium.com/grid-spreadsheets-run-the-world/spreadsheets-as-a-ui-pattern-leveraging-knowledge-workers-existing-skills-f376b08781a8 Spreadsheets as a UI pattern — leveraging knowledge workers’ existing skills
 680 | 
 681 | 3.12 【今日阅读】https://www.notboring.co/p/excel-never-dies If you want to see the future of B2B software, look at what Excel users are hacking together in spreadsheets today. 评论区 https://news.ycombinator.com/item?id=26386419
 682 | 
 683 | 3.11 【今日阅读】https://mcluck.tech/blog/abusing-proxies-for-dsls/ statement is optional, expression is all you need
 684 | 
 685 | 3.10 【今日阅读】https://www.silvestar.codes/articles/you-want-a-single-enabling-selector-not-the-one-that-disables-the-rule-of-the-previous-one/ 相信很多人不知道 css 可以用 li + li 来表达 selector 吧。当一门编程语言的需要背诵的基础“语法块”太多了，就变成了一个“咒语系统”。
 686 | 
 687 | 3.9 【今日阅读】https://mp.weixin.qq.com/s/dBHgw-mUwSaCALivnOatVA 颠覆SaaS（2.0版本）
 688 | 
 689 | 3.8 【今日阅读】https://nodes.io/story/#background 他们调研了市面上已有的可视化编程工具 https://nodes.io/assets/visual-tools-landscape.pdf 然后自己做了一个
 690 | 
 691 | 3.7 【今日阅读】https://medium.com/@012parth/daptin-walk-through-oauth2-google-drive-subsites-and-grapejs-a6de27d9658a 使用 google drive 当数据库用，基于 GrapesJS  实现可视化界面设计
 692 | 
 693 | 3.6 【今日阅读】https://web.eecs.utk.edu/~azh/blog/coderibbon.html After conducting a lab study with professional engineers8, we came up with a set of design principles that can be applied to virtually any code editor
 694 | 
 695 | 3.5 【今日阅读】https://media.handmade-seattle.com/whitebox-systems/ time travel debugging 的 demo
 696 | 
 697 | 3.4 【今日阅读】https://devblogs.microsoft.com/visualstudio/repeated-edits-intellicode-suggestions-completion-list/ 微软基于 PROgram Synthesis by Example 的黑科技改进了IDE代码提示。生成全套代码未必是唯一选择，辅助人工写代码也是可以的。
 698 | 
 699 | 3.3 【今日阅读】https://www.microsoft.com/en-us/research/publication/tweakit-supporting-end-user-programmers-who-transmogrify-code/ End-user programmers opportunistically copy-and-paste code snippets from colleagues or the web to accomplish their tasks. Unfortunately, these snippets often don’t work verbatim, so these people — who are non-specialists in the programming language — make guesses and tweak the code to understand and apply it successfully.
 700 | 
 701 | 3.2 【今日阅读】http://www.invisiblerevolution.net/engelbart/full_62_paper_augm_hum_int.html By "augmenting human intellect" we mean increasing the capability of a man to approach a complex problem situation, to gain comprehension to suit his particular needs, and to derive solutions to problems.
 702 | 
 703 | 3.1 【今日阅读】https://github.com/GiggleLiu/NiLang.jl 常规的冯诺依曼编程是不可微分的，逆lang提出了一种可逆的 DSL 来使得代码可微分
 704 | 
 705 | 2.28 【今日阅读】https://martin.kleppmann.com/2021/01/13/decentralised-content-moderation.html 如果把存储去中心化，那内容审查应该怎么做呢？
 706 | 
 707 | 2.27 【今日阅读】https://mp.weixin.qq.com/s/suRIYWo84TORN3lMx4QLwA 编程就是压缩
 708 | 
 709 | 2.26 【今日阅读】https://www.infoq.com/presentations/facebook-ppl/ 让专家表达核心的领域知识，计算机去补充剩下的部分
 710 | 
 711 | 2.25 【今日阅读】https://www.youtube.com/watch?v=NWkicrRTupo 深度学习得到的模型是咋工作的？Interpretability: of what, for whom, why, and how?
 712 | 
 713 | 2.24 【今日阅读】https://mp.weixin.qq.com/s/85yWLNQmq99SbBopwNd2MQ 代码如何防腐呢？不靠 Code Review 又靠什么呢？
 714 | 
 715 | 2.23 【今日阅读】https://www.youtube.com/watch?v=8hVuOmgcd04 As a programmer with 20 years of professional experience, I've always wished for better tools which would let us perform our craft more smoothly and efficiently. By tools I mean things like text editors, compilers, integrated development environments, version control systems, build systems, and so on. This video series will present some ideas.
 716 | 
 717 | 2.22 【今日阅读】https://www.36kr.com/p/1106571585965316 数字化转型浪潮下，中国低/无代码市场发展现状分析
 718 | 
 719 | 2.6 【今日阅读】2/6 ~ 2/21 休刊，祝大家节日快乐。
 720 | 
 721 | 2.5 【今日阅读】https://www.youtube.com/watch?v=xTzFJIknh7E 通过无监督学习实现 java/c++/python 的任意两两互译。注意噢，这不再是有多少人工就有多少智能了，这是不依赖人工标注靠机器无监督学习实现的。
 722 | 
 723 | 2.4 【今日阅读】https://mp.weixin.qq.com/s/94ijfap3OQT22QeuwhMPvw 人类的视觉恰恰相反：通过长时间的观察学习，只需很少的监督样本就可以快速达到多个领域的专家水平。要给这种长期的，无监督的学习定义一个清晰的目标函数或目标任务，却是一项非常具有挑战的课题，也是计算机视觉一直在探索的问题。
 724 | 
 725 | 2.3 【今日阅读】https://www.36kr.com/p/1059663090897031 简道云联合创始人单兰杰：低代码开发会像Office一样普及
 726 | 
 727 | 2.2 【今日阅读】https://dl.acm.org/doi/abs/10.1145/1082983.1083241 End user development  essentially out-sources development effort to the end user. Hence one element of the cost is the additional design time expended. Another cost is learning. This is a critical cost in EUD because end users are busy people for whom programming is not their primary task.
 728 | 
 729 | 2.1 【今日阅读】https://tcher.tech/publications/PPIG2018_WhatLiesInThePathOfTheRevolution.pdf We argue that a form of “digital serfdom” has rapidly grown up around us, where various important classes of artefacts, increasingly essential for everyday life, including participation in political and economic life, cannot be effectively owned by ordinary individuals. The power to own these artefacts is increasingly reserved only to corporations
 730 | 
 731 | 1.31 【今日阅读】https://lobste.rs/s/huv7m6/ikea_effect So how do we stop investing more and more into what we have already worked on, rather than striving for better or more efficient alternatives?
 732 | 
 733 | 1.30 【今日阅读】https://www.figma.com/blog/how-we-built-the-figma-plugin-system/ How to build a plugin system on the web and also sleep well at night
 734 | 
 735 | 1.29 【今日阅读】https://www.cs.kent.ac.uk/people/staff/srk21/research/papers/kell20convivial.pdf Consider how many web applications contain their own embedded ‘rich text’ editing widget. If linking were truly at the heart of the web’s design, a user (not just a developer) could supply their own preferred editor easily, but such a feat is almost always impossible. A convivial system should not contain multitudes; it should permit linking to them.
 736 | 
 737 | 1.28 【今日阅读】https://doriantaylor.com/softwares-ailing-mythology storyboards and concept art as progress, so too can the executive with the precursor materials generated through the process of software development. 不一定是产出最终产物才有价值，中间的 prototype 一样是有价值的。软件开发可以从电影行业学习到什么？
 738 | 
 739 | 1.27 【今日阅读】https://mp.weixin.qq.com/s/QtVkcbTrjf1MyQq9aEQpxw 近几年又是独立的科技公司，又是低代码开发平台的，好像又回光返照了。这背后的逻辑是什么？
 740 | 
 741 | 1.26 【今日阅读】http://mitliagkas.github.io/ift6085/student_slides/IFT6085_Presentation_IB.pdf 先把书读厚，然后把书读薄
 742 | 
 743 | 1.25 【今日阅读】https://mintdata.com/docs/learn/core-mechanics/craft-the-user-experience/display-based-on-spreadsheet/ 把 webflow 和 excel 加到一起会发生什么化学反应呢？今天来了解一款用 excel 写逻辑，然后绑定到 UI 的 lowcode 工具吧
 744 | 
 745 | 1.24 【今日阅读】https://news.ycombinator.com/item?id=22857551 I think it's a pipe dream. Non-experts making changes to a system an expert wrote will yield either: 1) very few little changes, such as changing the color of an item, etc. Or 2) disasters where it's better to throw away the changes and start over doing it "the right way".
 746 | 
 747 | 1.23 【今日阅读】https://jpaulm.github.io/fbp/index.html 可视化框线编程范式 Flow-based Programming 发明于上世纪 60 年代
 748 | 
 749 | 1.22 【今日阅读】https://www.youtube.com/watch?v=421gU482xFE most influential test-of-time paper award for his POPL 2011 paper (which describes the technology behind the popular Flash Fill feature in Excel)
 750 | 
 751 | 1.21 【今日阅读】https://www.inkandswitch.com/end-user-programming.html What if we, and all computer users, could reach in and modify our favorite apps? Or even create new apps on the fly according to our needs in the moment?
 752 | 
 753 | 1.20 【今日阅读】https://www.cs.kent.ac.uk/people/staff/srk21/research/papers/kell09mythical.pdf Conventional tools yield expensive and inflexible software. … I propose that a solution must radically separate the concern of integration in software: firstly by using novel tools specialised towards integration (the “integration domain”), and secondly by prohibiting use of preexisting interfaces (“interface hiding”) outside that domain.
 754 | 
 755 | 1.19 【今日阅读】https://gtoolkit.com/ Glamorous Toolkit is the moldable development environment. It is a live notebook. It is a flexible search interface. It is a fancy code editor. It is a software analysis platform. It is a data visualization engine. All in one. And it is free and open-source under an MIT license.
 756 | 
 757 | 1.18 【今日阅读】https://mp.weixin.qq.com/s/Mer860LciQSTKG0PzFVxmQ 为什么特斯拉要自研ERP
 758 | 
 759 | 1.17 【今日阅读】https://www.geoffreylitt.com/wildcard/salon2020/ Wildcard: Spreadsheet-Driven Customization of Web Applications 
 760 | 
 761 | 1.16 【今日阅读】https://daniel.haxx.se/blog/2021/01/15/food-on-the-table-while-giving-away-code/ curl 的作者写了篇开源如何收费的文章，Food on the table, while giving away code
 762 | 
 763 | 1.15 【今日阅读】https://tcher.tech/publications/PhilipTchernavskij_PhDThesis.pdf The figure illustrates how entanglers can help shift the distribution of work between programmers and end users. As I mentioned in the introduction to chapter 4, a key goal of the vision is that software reusability should be a property of the user experience, rather than just the developer experience.
 764 | 
 765 | 1.14 【今日阅读】https://www.researchgate.net/publication/221515740_User-tailorable_systems_Pressing_the_issues_with_buttons It is impossible to design systems which are appropriate for all users and ail situations. We believe that a useful technique is to have end users tailor their systems to match their personal work practices. 
 766 | 
 767 | 1.13 【今日阅读】https://www.netlify.com/products/forms/ 搭建了一个静态网站，又想要动态收集用户提交的信息怎么办? netlify 的 forms 帮你托管服务端的事情，和 zapier 集成更能把表单和上千个服务联通。这种看起来简单的工作，虽然你觉得 low，但也许可能就是普通用户所需要的 low。
 768 | 
 769 | 1.12 【今日阅读】https://zhuanlan.zhihu.com/p/93536872 这是一个氛围分外热烈的中年男性社群，从全国各地赶到杭州，完全不是为了找客户，而是为了解开心中的困惑。为什么这个明明优越的产品和商业模式，在中国市场的发展速度迟缓。无论是创业者，还是投资人，明显都对自己不够满意。是产品能力不够强吗？还是中国的客户吝啬？
 770 | 
 771 | 1.11 【今日阅读】https://36kr.com/p/973639336079623 爆火的低代码，到底是真需求还是伪风口？
 772 | 
 773 | 1.10 【今日阅读】http://www.continuousdelivery20.com/blog/maximizing-developer-effectiveness/ 问题的一个主要原因是：工程组织忽视了一点，即：为开发人员提供一个有效的工作环境。在变革期间，组织引入了许多新流程、新工具和新技术，这导致在开发人员的日常任务中，增加了一定量的复杂性和摩擦力。
 774 | 
 775 | 1.9 【今日阅读】http://gotocon.com/dl/goto-amsterdam-2015/slides/MaryShaw_KEYNOTEProgressTowardAnEngineeringDisciplineOfSoftware.pdf 视频 https://www.youtube.com/watch?v=lLnsi522LS8 软件工程可以向桥梁工程学习经验。桥梁工程的根本问题是要解决 Composition of forces 和 Bending。那么软件工程呢?
 776 | 
 777 | 1.8 【今日阅读】https://www.heavybit.com/library/podcasts/developer-love/ The podcast for people who build developer communities.
 778 | 
 779 | 1.7 【今日阅读】https://zhuanlan.zhihu.com/p/342402682 打着低代码旗号的商业化开发工具有前途吗? 本文脱胎于群里前几天的讨论，我总结了一下我发表过的观点，整理成了更像体系的东西。欢迎其他同学发文反驳。
 780 | 
 781 | 1.6 【今日阅读】https://alarmingdevelopment.org/?p=1475 Software is eating the world. But progress in software technology itself largely stalled around 1996.  https://alarmingdevelopment.org/?p=1489 We could blame technology lock-in effects (the QWERTY syndrome). We could also blame civilization-wide decadence: the Great Stagnation that was alluded to. But a big part of the blame is something completely unique to software: the open source movement.
 782 | 
 783 | 1.5 【今日阅读】https://anvil.works/ Full stack web apps with nothing but Python.
 784 | 
 785 | 1.4 【今日阅读】http://nealford.com/memeagora/2013/01/22/why_everyone_eventually_hates_maven.html Every Access project will eventually fail because, while 80% of what the user wants is fast and easy to create, and the next 10% is possible with difficulty, ultimately the last 10% is impossible because you can’t get far enough underneath the built-in abstractions, and users always want 100% of what they want.
 786 | 
 787 | 1.3 【今日阅读】https://mp.weixin.qq.com/s/9IGeRx8vDWs0S3jZv7OuKw 基于 KAITIAN 的前端工程研发模式变革
 788 | 
 789 | 1.2 【今日阅读】https://apenwarr.ca/log/20201227 The defining characteristic of a chicken-egg technology or product is that it's not useful to you unless other people use it. Since adopting new technology isn't free (in dollars, or time, or both), people aren't likely to adopt it unless they can see some value, but until they do, the value isn't there, so they don't. A conundrum.
 790 | 
 791 | 1.1 【今日阅读】https://beyang.org/time-to-build-dev-tools.html 来吧，2021，开发工具写起来～
 792 | 
 793 | 12.31 【今日阅读】https://threader.app/thread/1343969802080030720 google 前员工反思 google的云服务为什么没有干过 aws
 794 | 
 795 | 12.30 【今日阅读】https://danluu.com/essential-complexity/ 老人家总是会对下一代说，孩子们，可以做的事情他们都尝试过了，你们也不会有什么新的发现哒。Fred Brooks 1986 年的 No Silver Bullet 其实也差不多是这个意思。The main thing these claims demonstrate are a lack of imagination.
 796 | 
 797 | 12.29 【今日阅读】https://www.budibase.com/blog/github-stars/ 6个让 github 项目获得更多星星的方法
 798 | 
 799 | 12.28 【今日阅读】https://jessitron.com/2017/06/24/the-most-productive-circumstances-for/ 为什么有一些开发者，在某些场合，看起来比其他人高效 10x 倍?
 800 | 
 801 | 12.27 【今日阅读】https://www.deconstructconf.com/2019/dan-abramov-the-wet-codebase Dan Abramov 的演讲，The Wet Codebase
 802 | 
 803 | 12.26 【今日阅读】https://www.youtube.com/watch?v=001SxQCEuv8 Code runs the world. And when our code goes wrong, the solution is almost always… more code. In this talk, Dylan Beattie will take a fresh look at the cost of the code we're shipping every day. What's the real cost of code — to our organisations, to our society, to our environment? How can we help our teams and users understand that cost? And what can we do to reduce it?
 804 | 
 805 | 12.25 【今日阅读】https://parentheticallyspeaking.org/articles/pedagogic-ide/ 以教学为目的集成开发环境，还缺什么?
 806 | 
 807 | 12.24 【今日阅读】利用服务端渲染来部分刷新页面接连出了两个新技术，分别是 Ruby on Rails 团队的 https://hotwire.dev/ 和 React 团队的 https://reactjs.org/blog/2020/12/21/data-fetching-with-react-server-components.html，表面上看似乎 SSR / Blazor 之类的也是类似的技术，帮你捋一下发展脉络 https://www.zhihu.com/question/435921124/answer/1642258665
 808 | 
 809 | 12.23 【今日阅读】https://juejin.cn/post/6908502083075325959 可视化拖拽组件库一些技术要点原理分析
 810 | 
 811 | 12.22 【今日阅读】http://evrl.com/devops/cloud/2020/12/18/serverless.html 最近的热词是 Serverless，让我很大程度上觉得这不就是又回到了 1970 么?
 812 | 
 813 | 12.21 【今日阅读】http://pages.cs.wisc.edu/~remzi/Naur.pdf 图灵奖得主 Peter Naur 写于 1985 年 《Programming as theory building》。我昨天读完了，写了点读后感 https://zhuanlan.zhihu.com/p/338273150
 814 | 
 815 | 12.20 【今日阅读】https://zhuanlan.zhihu.com/p/338091580 应该怎样debug，难道就是到处加 console.log 吗?
 816 | 
 817 | 12.19 【今日阅读】https://twitter.com/theflowingsky/status/1332020417410834433 对sketch的一些抱怨，以及有哪些替代品可以选择
 818 | 
 819 | 12.18 【今日阅读】https://zhuanlan.zhihu.com/p/337537055 有没有什么办法不去指望有一个万能的“独裁者”去天天盯着架构不被腐化，而是让架构朝着正确的方向自然而然的生长出来呢? 或者至少让这个“独裁者”能够不那么痛苦。
 820 | 
 821 | 12.17 【今日阅读】https://www.youtube.com/watch?v=id1WShzzMCQ https://www.youtube.com/watch?v=1e8VZlPBx_0 Alan Kay 在斯坦福大学的演讲 - 《How to Invent the Future》
 822 | 
 823 | 12.16 【今日阅读】https://zhuanlan.zhihu.com/p/337185052 开个通用的 HTTP 接口，让前端写 SQL 咋样?
 824 | 
 825 | 12.15 【今日阅读】https://book.douban.com/subject/6526454/ 《梦断代码》作者把Chandler的开发历程，软件开发的历史，和软件开发的基础概念精巧地编织起来，只为探索一个问题：为什么软件开发那么困难？
 826 | 
 827 | 12.14 【今日阅读】https://www.cs.cornell.edu/courses/cs6120/2020fa/self-guided/ 高级编译器构造课程，包含静态分析，内存管理，运行时编译等话题
 828 | 
 829 | 12.13 【今日阅读】https://stackoverflow.blog/2020/12/07/measuring-developer-productivity/ 开发者的生产效率可以被度量吗？
 830 | 
 831 | 12.12 【今日阅读】https://github.blog/2020-11-20-nbdev-a-literate-programming-environment-that-democratizes-software-engineering-best-practices/
 832 | 
 833 | 12.11 【今日阅读】http://archive.computerhistory.org/resources/text/Knuth_Don_X4100/PDF_index/k-9-pdf/k-9-u2769-1-Baker-What-Programmer-Does.pdf
 834 | 
 835 | 12.10 【今日阅读】https://zhuanlan.zhihu.com/p/335309652 如何让前端程序员没有后端也能完成项目? 在 GraphQL 和 BFF 之外的第三种解法，Backend as a "Database"
 836 | 
 837 | 12.9 【今日阅读】https://www.youtube.com/watch?v=m4AikuoWNFw 1940年代的时候，人们的编程与调试的方式是怎样的? 从70年的发展历程，我们能学到什么?
 838 | 
 839 | 12.8 【今日阅读】https://zhuanlan.zhihu.com/p/333331281 我在 vue 语法上精简而来的页面模板语法。如果你想要给 GUI Designer 搞一种 JSON 持久化格式，不妨参考一下。
 840 | 
 841 | 12.7 【今日阅读】https://developer.aliyun.com/article/778172 相比 OLTP 业务，OLAP 业务的开发工具更容易被搬到线上，业务可视化带来的协同收益也更明显
 842 | 
 843 | 12.6 【今日阅读】https://www.infoq.com/articles/book-review-rise-software-recipes/  The industry as a whole has spent over thirty years looking for the philosopher’s stone, a way of organizing the development process, a methodology, a formal subdivision in tasks that would allow us to produce adequate results reliably and deterministically, in short, a software recipe.
 844 | It has failed, over and over again.
 845 | 
 846 | 12.5 【今日阅读】https://www.youtube.com/watch?v=Ml6Dp3F4Inc 看见程序的执行过程。console.log 是不够的，我们需要 http://jsdares.com/ 这样的东西。low code 平台搞可视化不仅仅是拖拽组件，也可以朝降低 debug 难度的方向努力。
 847 | 
 848 | 12.4 【今日阅读】https://serverless-stack.com/#table-of-contents 如何使用 serverless 开发全栈应用，所谓“云函数”开发并不是一个函数一个函数的部署 https://serverless-stack.com/chapters/organizing-serverless-projects.html
 849 | 
 850 | 12.3 【今日阅读】https://sites.tufts.edu/devtech/files/2019/11/The-Language-of-Programming-A-Cognitive-Perspective.pdf the hypothesis that programming draws on some of the same resources as natural language processing, in addition to the traditional proposal whereby programming shares computations with mathematics, logic, and problem solving.
 851 | 
 852 | 12.2 【今日阅读】https://github.com/dbohdan/classless-css 搜集了大量 classless 风格的 css 框架，适合于快速用最简单的 HTML 元素布局出一个原型
 853 | 
 854 | 12.1 【今日阅读】https://tally.so/videos/demo/form-builder.mp4 交互界面像一个文本编辑器的 Form Builder，还有点特色
 855 | 
 856 | 11.30 【今日阅读】https://www.infoq.com/articles/events-workflow-automation/ Do events decrease coupling? Does centralised control need to be avoided? Are workflow engines painful?
 857 | 
 858 | 11.29 【今日阅读】https://zhuanlan.zhihu.com/p/35303567 Visual Studio Code有哪些工程方面的亮点
 859 | 
 860 | 11.28 【今日阅读】https://mp.weixin.qq.com/s/athylh1iV1K6G2KFMQHAtg 八个维度对低代码能力度量模型的思考
 861 | 
 862 | 11.27 【今日阅读】https://www.youtube.com/watch?v=TkPy7aLTtAw Borrowing from Thomas Kuhn, Robert Floyd introduced the notion of a programming paradigm. Today, paradigms are constantly debated. What might Kuhn tell us about this sad state of affairs? What can Programming learn from Philosophy? 
 863 | 
 864 | 11.26 【今日阅读】https://www.youtube.com/watch?v=y3Y2HNUCT1c SPLASH2020 会议录像，SPLASH is the ACM SIGPLAN conference on Systems, Programming, Languages, and Applications: Software for Humanity
 865 | 
 866 | 11.25 【今日阅读】https://procomponents.ant.design/components/ 从 Ant Design Pro 看常见中后台预制件有哪些，参数又有哪些。为什么这些预制件很难用?
 867 | 
 868 | 11.24 【今日阅读】https://web.eecs.utk.edu/~azh/blog/guidehciseresearch.html 软件工程中有关人的因素。对比一下学界的研究成果，和你日常的开发体验，就知道空间真是巨大。
 869 | 
 870 | 11.23 【今日阅读】https://lobste.rs/s/z96jmk/experimental_o_1_garbage_collector 让 GC 时间降到 O(1)，代价是把工作转移到 dereference 句柄的时候。用句柄，Fat Pointer等机制代替裸指针的做法越来越多了。https://floooh.github.io/2018/06/17/handles-vs-pointers.html
 871 | 
 872 | 11.22 【今日阅读】https://mp.weixin.qq.com/s/csTnnZ0V2JGG_3XTyvCElQ DevOps不是请客吃饭，改进就一定会动到别人的山头，开发想要的改进和运维想要的改进根本就不是一个改进，所以我们才会看到今天这么一个缝合怪。
 873 | 
 874 | 11.21 【今日阅读】https://www.youtube.com/playlist?list=PLkTCpJUe8hMwLV4miGQbqiqpAYXy4XfN- LIVE Programming 2020 大会的视频上线了，提高反馈速度，增强互动性，有很多创新的空间
 875 | 
 876 | 11.20 【今日阅读】https://wagtaillabs.com/2020/11/17/introducing-grant-pt-1/ 一种可解释 AI 的算法，如何让解释不过分简化，从而偏离模型实际做的计算行为。
 877 | 
 878 | 11.19 【今日阅读】https://invisibleup.com//articles/33/ 还记得当年大明湖畔的 Frontpage 吗?
 879 | 
 880 | 11.18 【今日阅读】https://tratt.net/laurie/blog/entries/automatic_syntax_error_recovery.html since every programmer relies upon parsing, the better a job we can do of helping them fix errors quickly, the better we make their lives
 881 | 
 882 | 11.17 【今日阅读】https://ivanish.ca/hest-time-travel/ 玩过弹珠台的朋友应该会觉得这种可视化编程方式很有意思
 883 | 
 884 | 11.16 【今日阅读】https://www.youtube.com/watch?v=TcrmLfQx_to 看30年前的电视节目是如何吹捧面向对象编程语言的
 885 | 
 886 | 11.15 【今日阅读】https://www.youtube.com/watch?v=8htgAxJuK5c 代码何必是纯文本的
 887 | 
 888 | 11.14 【今日阅读】https://courses.cs.washington.edu/courses/cse503/08wi/parnas-1979.pdf 这是一篇1979年的论文，因为年代久远甚至连依赖管理的概念都还没有统一术语，用的是 Use Structure 这样的说法。最大的亮点是把需求定义，尤其是 Identifiying Minimal Subset 做为改进的前提条件。现浇出来的软件总是走向 Feature Bloat 的终局，其宿命来自于需求总是膨胀。产品经理只会告诉你要加什么东西，从来不去管已经有了什么东西还需要保持。“装配式建筑”的愿景，其最大难点就在于如何管理需求上。
 889 | 
 890 | 11.13 【今日阅读】https://www.yuque.com/docs/share/44a8d6c7-3fb4-42ad-bbb7-1326f1406028 关于研发基建的问题分解
 891 | 
 892 | 11.12 【今日阅读】https://mp.weixin.qq.com/s/pev-OHk9DvdO3OxM4cJMZg 大众化编程，YES。降低人力需求搞外包，胡扯。
 893 | 
 894 | 11.11 【今日阅读】@侯振宇 的大作 https://www.yuque.com/rainer_h/cgrh7x/kn5p27 描述了他心目中的研发基建
 895 | 
 896 | 11.10 【今日阅读】https://ingbrief.wordpress.com/2014/04/06/19961008-christopher-alexander-patterns-in-architecture-oopsla-96/ Christopher Alexander 1996 年的 OOPSLA 演讲录像
 897 | 
 898 | 11.9 【今日阅读】https://stefan-lesser.com/2020/10/27/how-to-adopt-christopher-alexanders-ideas-in-the-software-industry/ 设计模式号称是从 Christopher Alexander 的理论借鉴而来的，但是人家本来的意思是设计模式是给 end-user 用来改造自己的 living environment 的，也就是说“给用户赋能”
 899 | 
 900 | 11.8 【今日阅读】https://medium.com/dev-genius/software-engineering-great-quotes-3af63cea6782 读一些不明觉厉的名人名言
 901 | 
 902 | 11.7 【今日阅读】https://zhuanlan.zhihu.com/p/273350851 用 AirTable 打造自己专属的个人数据库
 903 | 
 904 | 11.6 【今日阅读】https://zhuanlan.zhihu.com/p/183691258 low-code 与 20 年前的 Dreamweaver 有什么区别？
 905 | 
 906 | 11.5 【今日阅读】https://roadmap.darklang.com/goals-of-dark-v2 darklang 以挑战现状的姿态问世，迅速地向现实低头。
 907 | 
 908 | 11.4 【今日阅读】https://xie.infoq.cn/article/b55d24c2456cba95b656093d0 小蝴蝶胜在定制性比较好上手简单但性能上不能支持1w以上的节点，G6渲染引擎是Canvas性能是比较优秀但是定制性有所欠缺入门门槛也会相对高一点
 909 | 
 910 | 11.3 【今日阅读】https://eugenkiss.github.io/7guis/tasks GUI开发框架这么多，如何从 notation 的角度来评价开发者的体验? 评测的任务应该是什么，而评价的标准又应该怎么设定?
 911 | 
 912 | 11.2 【今日阅读】https://johnstarich.medium.com/how-to-compile-code-in-the-browser-with-webassembly-b59ffd452c2b 通过 WebAssembly 在浏览器里编译 Go 代码，直达 demo https://go-wasm.johnstarich.com/
 913 | 
 914 | 11.1 【今日阅读】https://deepnote.com/ 实时协作版的 "jupyter notebook"
 915 | 
 916 | 10.31 【今日阅读】https://www.youtube.com/watch?v=WgzdFoXLX9c Object-Oriented Drawing 对拖拽可视化编辑的界面提出了一些新的创意。作者还有很多其他的作品 https://haijunxia.ucsd.edu/ 
 917 | 
 918 | 10.30 【今日阅读】https://stackoverflow.com/questions/59686151/what-is-gpu-driven-rendering GPU 正在逐步蚕食 CPU 的工作负荷。也许将来可以把一个完整的应用完全跑在 GPU 上，从 GPU 去 drive 整个算法流程。
 919 | 
 920 | 10.29 【今日阅读】https://awslabs.github.io/diagram-maker/usage/architecture.html aws 开源了一个 diagram-maker，学习一下 react + 拖拽的实现方案。
 921 | 
 922 | 10.28 【今日阅读】https://www.dendron.so/notes/4bb85c39-d8ac-48ad-a765-3f2a071f7bc9.html 把 vscode 改造成结构化的笔记本，看起来还行
 923 | 
 924 | 10.27 【今日阅读】https://wiki.c2.com/?DatabaseNotMoreGlobalThanClasses Class interfaces are essentially as global as any database entity through a database interface (such as SQL).
 925 | 
 926 | 10.26 【今日阅读】https://www.metaranx.com/post/metaranx-2-is-launching-no-code-artificial-intelligence 手里拿着 nocode 和 ai 两个锤子，到哪里去找钉子呢?
 927 | 
 928 | 10.25 【今日阅读】http://www.cs.cmu.edu/~418/schedule.html Parallel Computer Architecture and Programming, Fall 2020: Schedule
 929 | 
 930 | 10.24 【今日阅读】https://mp.weixin.qq.com/s/Z9yT_hySsH_dr9olu23yDw 中国SaaS平台的三种商业模式
 931 | 
 932 | 10.23 【今日阅读】https://boxbase.org/entries/2019/oct/4/flaws-in-structured-programming/ 结构化编程范式优点，也是它的缺点：single entry/ single exit
 933 | 
 934 | 10.22 【今日阅读】https://modeling-languages.com/low-code-vs-model-driven/ 所谓 low-code 和 model-driven 是不是一回事? 
 935 | 
 936 | 10.21 【今日阅读】https://zhuanlan.zhihu.com/p/37562698 https://zhuanlan.zhihu.com/p/37563837 从协程到状态机--regenerator源码解析
 937 | 
 938 | 10.20 【今日阅读】https://www.gamasutra.com/blogs/NathanCheever/20180618/320112/A_Prefab_Primer.php 游戏引擎中的 prefab 是干什么的，是不是就是 UI 组件呢?
 939 | 
 940 | 10.19 【今日阅读】https://zhuanlan.zhihu.com/p/49434688 SaaS早已不是当年喊出口就能带来优越感和安全感的词儿了，现在的企业级服务从业者们显然不应当将企业的命运寄托在这种结构性缺陷明显的商业模式身上。SaaS已死。去找下一个出路吧。
 941 | 
 942 | 10.18 【今日阅读】https://zhuanlan.zhihu.com/p/33446652 进入九十年代后，由于（部分）装配式建筑自身有许多问题，主要可用“热、裂、漏“来概括，和现浇结构相比，这些问题更显突出。于是现浇结构几乎全部替代了装配式结构。现阶段装配式技术相比之前取得了明显的进步，主要体现在以下几个方面。
 943 | 
 944 | 10.17 【今日阅读】https://www.buildbox.com/tutorials-buildbox2/ buildbox 号称零代码开发手机游戏，录制了很多 youtube 的教学视频。只要有人愿意用，就是有价值的产品。
 945 | 
 946 | 10.16 【今日阅读】https://www.youtube.com/watch?v=TT0r6-B5YHA How learners develop mental models of the programming model/language
 947 | 
 948 | 10.15 【今日阅读】https://github.com/apple/swift/blob/main/docs/ErrorHandlingRationale.rst 对市面上各种错误处理方式的一个全面总结。无论语法怎么包装，到头来就是个语法糖。错误处理的运行时实现方式就只有三种。
 949 | 
 950 | 10.14 【今日阅读】https://sketch2react.gitbook.io/sketch2react-io/ Sketch2React is a tool and framework that lets you build React & HTML powered prototypes (and simple websites) directly from inside Sketch
 951 | 
 952 | 10.13 【今日阅读】https://www.toutiao.com/i6882586732936561156/ 虽然都是CRUD，主要还是要看提供了啥业务价值。一家化纤工厂的数字化转型之路
 953 | 
 954 | 10.12 【今日阅读】 https://zhuanlan.zhihu.com/p/197291361 基于React+Koa实现一个h5页面可视化编辑器－Dooring
 955 | 
 956 | 10.11 【今日阅读】https://github.com/KlausSchaefers/figma-low-code 把 UI 设计工具 figma 改造成 lowcode 平台
 957 | 
 958 | 10.10 【今日阅读】 https://www.polygon.com/tv/2020/2/20/21146152/the-mandalorian-making-of-video-unreal-engine-projection-screen 如何使用 Unreal 游戏引擎拍摄《曼达洛人》，真 AR
 959 | 
 960 | 10.9 【今日阅读】https://mp.weixin.qq.com/s/Kd1Kt6Uf8586Cc6rD-Kbzg 双端一体，业务逻辑上云，云端一体：目前已经落地了下单页面，由原有的前后端3人开发变为1人开发，研发效率有效提升
 961 | 
 962 | 10.8 【今日阅读】https://hedy-beta.herokuapp.com/ The overarching goal of Hedy is to successively add syntactic complexity to a Python-like language, until novices have mastered Python itself.
 963 | 
 964 | 10.7 【今日阅读】https://www.youtube.com/watch?v=agMxgYE4mf4 从机器模型了解人类认知的固执与偏见
 965 | 
 966 | 10.6 【今日阅读】https://www.alexhudson.com/2020/01/13/the-no-code-delusion/ No Code 的妄想，评论区更精彩 https://news.ycombinator.com/item?id=22033827
 967 | 
 968 | 10.5 【今日阅读】https://mp.weixin.qq.com/s/ITlwudzmspG1iGg9axhLEA 谁该承担中国SaaS贫瘠生态的一点责任
 969 | 
 970 | 10.4 【今日阅读】https://faculty.washington.edu/ajko/books/cooperative-software-development/#/comprehension 专家和初学者阅读代码的行为方式有什么区别? 专家阅读代码是冲着理解代码之间的依赖去的。
 971 | 
 972 | 10.3 【今日阅读】https://www.glideapps.com/learn-to-glide 这个和 airtable 还不太一样，你给它一个 google 表格，然后拿这个做为基础去开发 app
 973 | 
 974 | 10.2 【今日阅读】https://zhuanlan.zhihu.com/p/225987562 低代码，要怎么低？和低代码有关的 10 个问题
 975 | 
 976 | 10.1 【今日阅读】https://arxiv.org/pdf/1911.10691.pdf LSC targets creation of models and systems directly from requirement specifications, and Statecharts is used mainly for specifying final component behavior.
 977 | 
 978 | 9.30 【今日阅读】https://ourai.ws/posts/the-features-of-frontend-ui-components/ 本文从前端 UI 组件的构成、分类及组件间的继承关系等角度出发，通过分析组件的特征来探讨建立一个组件体系所需要关注的一些点。其中，UI 组件各构成元素的易变性是最应该被关注的，它会对组件体系的可复用性、可扩展性等产生很大影响。
 979 | 
 980 | 9.29 【今日阅读】https://openlowcode.com/the-art-of-tailoring/ 一家法国的 lowcode 产品谈他们如何支撑定制化需求
 981 | 
 982 | 9.28 【今日阅读】https://youtu.be/ya1xDCCMh7g?t=5068 uncle bob 把编程语言过去70年的发展浓缩成了三行：discipline imposed upon direct transfer of control, discipline imposed upon indirect transfer of control, discipline imposed upon assignment
 983 | 
 984 | 9.27 【今日阅读】https://www.willusher.io/graphics/2019/11/20/the-sbt-three-ways code 最终还是要操作宿主设备的，当 RTX 显卡越来越普及的时候，我们除了要面临 new object 的时候要指定 placement，写 if/else 要考虑 warp，甚至光线追踪的硬件指令还需要你提供回调函数。在这样的情况下，如何实现跨端，如何在 CPU 上实现和 RTX 一样的编程模型? 这个探索的过程所揭露的编程的本质，值得思考 
 985 | 
 986 | 9.26 【今日阅读】除了纯文本形式，以及拖拽连框的形式，单步的可视化交互式编程介于两种形式的中间。写代码就像在用 debugger 那样，也是挺有趣的，在数据科学领域比较流行 https://bamboolib.8080labs.com/ 以及 https://exploratory.io/
 987 | 
 988 | 9.25 【今日阅读】Google 新推出了自己的 nocode 平台（https://news.ycombinator.com/item?id=24554592），而因为没有多少人用，明年1月份 lowcode 平台 Google App Maker 将下线（https://gsuiteupdates.googleblog.com/2020/01/app-maker-update.html）
 989 | 
 990 | 9.24 【今日阅读】https://9to5google.com/2020/06/30/google-sheets-smart-fill/ Google Sheets 新增了学习你给的几个例子，然后自动填充剩余数据的 Smart Fill 功能。这类的功能被称为 PBD（Programming by Demonstration）http://acypher.com/wwid/WWIDToC.html
 991 | 
 992 | 9.23 【今日阅读】https://baymard.com/blog/accordion-and-tab-design CRUD 生成的界面经常被人诟病的一点是交互非常机械，例如 master/detail 无法在同一个屏幕内编辑，而需要频繁跳页来实现。而 Accordion 和 Tab 则是在移动设备上实现内联编辑避免跳页的常见 UI 模式，这里面有哪些坑呢?
 993 | 
 994 | 9.22 【今日阅读】https://amasad.me/disintegrated 当你在阅读这篇文章的时候，可能是为了打发 webpack 重编译的时间。我们是为啥会走到这般田地的呢?
 995 | 
 996 | 9.21 【今日阅读】https://code.visualstudio.com/api/extension-guides/notebook vscode 即将添加类似 jupyter notebook 的编辑器。vscode 越来越像是在制定开发工具的 UI 标准。
 997 | 
 998 | 9.20 【今日阅读】https://subformapp.com/articles/dynamic-layout/ 如果不使用绝对定位，是否还能设计一个出有 Direct Manipulation 感觉的 Gui Designer?
 999 | 
1000 | 9.19 【今日阅读】https://pchiusano.github.io/2013-05-22/future-of-software.html The future of software, the end of apps, and why UX designers should care about type theory
1001 | 
1002 | 9.18 【今日阅读】https://jishuin.proginn.com/p/763bfbd2b4b9 基于日志记录的屏幕音画同步录制，效果还是很不错的，有黑科技的感觉 https://timecat.xxxxoo.com/
1003 | 
1004 | 9.17 【今日阅读】https://www.dropbox.com/s/ve6m3ngp5rmgu74/interface-design-patterns-checklist-2020.pdf?dl=0 2020年版用户界面设计模式速查手册
1005 | 
1006 | 9.16 【今日阅读】https://zhuanlan.zhihu.com/p/245027602 简单的单表 CRUD 生成谁都会做。但是复杂一点的就感觉不是那么好弄。但啥叫复杂的呢?又说不上来。然后扔下来一句，CRUD 生成是行不通的，代码还得手撸。
1007 | 
1008 | 9.15 【今日阅读】https://zhuanlan.zhihu.com/p/103385322
1009 | 但凡是个写过点代码的人，都认为应用可以用可复用的积木组合而成。这个愿景已经有几十年了，最新的名字叫 Low Code 开发。这个难度在于三方面：
1010 | 1. 切分出模块是容易的，但是怎么保证我可以只去阅读每个模块的行为，就能够理解整个系统的行为呢? 也就是达到降低阅读理解难度的目的。
1011 | 2. 怎么保证今天给这个项目切分出来的“积木”，在明天另外一个项目上还有复用价值。或者复用之后看起来，写起来不会那么难受。
1012 | 3. 如何降低分解模块以及拼装模块的门槛。也就是通过拖拉拽等方式代替“code”来实现平滑的学习曲线。
1013 | 今天我们来聚焦这三个问题中的第一个问题，也就是可组合性问题。
1014 | 
1015 | 9.14 【今日阅读】https://www.nocodejournal.com/ 专门有人整了个nocode的期刊
1016 | 
1017 | 9.13 【今日阅读】https://github.com/hediet/vscode-debug-visualizer/blob/master/extension/README.md 在用 vscode 调试的时候，用可视化的方式把内存中的数据结构呈现出来。
1018 | 
1019 | 9.12 【今日阅读】http://www.woshipm.com/pd/1303432.html 要实现lowcode的目的，很大程度上要对常见需求进行预制。而审批流和工单分派是最常见的共性需求，这都来自于人的操作习惯和人群管理上的共性。
1020 | 
1021 | 9.11 【今日阅读】https://cadenceworkflow.io/docs/concepts/workflows/#overview 工作流引擎是烂大街的东西，但是 cadence 的独特之处在于它没有直接对 status 这样的状态进行持久化。它不用通过反射之类的方式去读取状态，从而和特定编程语言进行绑定，可以支持 go / java 等多种编程语言。
1022 | 
1023 | 9.10 【今日阅读】https://journeyapps.com/engineering-blog/no-code-vs-pro-code-a-new-hope/ 一家lowcode公司开始做procode的web ide了，听听他们是怎么说的
1024 | 
1025 | 9.9 【今日阅读】https://www.zhihu.com/zvideo/1285224204020310016?utm_source=wechat_session&utm_medium=social&utm_oi=27985918820352 通过录制函数执行，可视化定位bug。作者还很有创意地搞了个视频demo
1026 | 
1027 | 9.8 【今日阅读】https://lobste.rs/s/1sscvn/infrastructure_as_pseudocode 声明式编程听起来很美好。但是用的时候总是会有人抱怨。让人不禁思考，声明式编程到底是解决什么问题来着?
1028 | 
1029 | 9.7 【今日阅读】http://northstar.mit.edu/ 数据可视化的 no code 解决方案，看起来和 tableau 完全不同，在交互方面创新十足。
1030 | 
1031 | 9.6 【今日阅读】https://thesephist.com/posts/programming-environment/ 开发工具比编程语言更重要
1032 | 
1033 | 9.5 【今日阅读】https://sdk.dfinity.org/docs/videos-tutorials.html WASM 时代的计算，以及编程语言。基于互联网计算机的特性，我们得以重新思考软件的搭建、部署和使用方式，进而对复杂度做出 优化：
1034 | 
1035 | -代码即服务，服务不再运行在定制的操作系统上，降低开发复杂度和成本；
1036 | -不用考虑数据的安全性与存储问题，无需数据库等组件，简化了编程，缩短了开发周期；-多个服务能像运行一台计算机中那样做到相互通信，且不需要获取网络拓扑或端口信息；
1037 | -软件可以“自洽运行”，就像一个开源项目一样，任何人都能自发地进行创新、贡献和改进。
1038 | 
1039 | 9.4 【今日阅读】https://mp.weixin.qq.com/s/dpQTP3p2YIrcJ0QpvOT4sQ 快速构建内部工具 Retool
1040 | 
1041 | 9.3 【今日阅读】https://godotengine.org/article/godot-editor-running-web-browser 在浏览器里用 WebAssembly 开发的游戏编辑器
1042 | 
1043 | 9.2 【今日阅读】https://news.ycombinator.com/item?id=24332418 Giving developers more control over their interfaces allows them to shape their requests to exactly what’s needed, instead of sending superfluous data—or not sending enough.
1044 | 
1045 | 9.1 【今日阅读】https://juejin.im/post/6844904106767695880 https://juejin.im/post/6844904110731296775 《早早聊搞搭建》搞过搭建的我收获了什么？
1046 | 
1047 | 8.31 【今日阅读】https://ryosuzuki.org/realitysketch/ 用户界面叫 UI，那基于 AR 的界面叫什么呢? augmented reality interface。AR 不仅仅是单向的提供信息，也可以是一个交互式的输入媒介
1048 | 
1049 | 8.30 【今日阅读】https://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.1072.3218&rep=rep1&type=pdf 从“Social Complexity”看软件的敏捷性。
1050 | 
1051 | 8.29 【今日阅读】https://www.youtube.com/watch?v=dZv-vRrnHDA Getting Started in Automated Game Design。Automated game design, or AGD, is an artificial intelligence research area all about building AI that can design games. I made this tutorial to help introduce people to the area.
1052 | 
1053 | 8.28 【今日阅读】https://juejin.im/post/6858893199902638088 本文将给大家分享关于《如何设计实现中后台搭建 PaaS 平台》这个话题，主要围绕阿里淘系技术部飞冰系列产品中的中后台搭建产品 iceluna 来进行展开。
1054 | 
1055 | 8.27 【今日阅读】https://www.wired.com/story/databases-coding-real-programming-myth/ ‘Real’ Programming Is an Elitist Myth
1056 | 
1057 | 8.26 【今日阅读】https://www.youtube.com/watch?v=IdhnP00Y1Ks julia 社区把 vscode 魔改得不像 vscode 了
1058 | 
1059 | 8.25 【今日阅读】https://juejin.im/post/6844903974244630535 React无门槛实现拖拽布局、表单设计器
1060 | 
1061 | 8.24 【今日阅读】https://existentialtype.wordpress.com/2013/07/18/what-if-anything-is-a-declarative-language/ 啥算是“声明式编程”?
1062 | 
1063 | 8.23 【今日阅读】https://blog.acolyer.org/2020/01/27/reverb-speculative-debugging/ 响应式的 javascript 应用如何调试? 数据流不清晰，行为不可预测?
1064 | 
1065 | 8.22 【今日阅读】https://observablehq.com/@observablehq/observable-for-jupyter-users 搞机器学习的同学都很熟悉 jupyter 了，observable 号称自己比 jupyter 更像 excel，能够实现数据改变了，自动重算公式。这样的编程界面会好用吗?
1066 | 
1067 | 8.21 【今日阅读】https://zhuanlan.zhihu.com/p/188437243 GPT-3 袭来，前端又要失业？谈谈如何实现智能切图
1068 | 
1069 | 8.20 【今日阅读】https://hilton.org.uk/presentations/beautiful-code 从字体的角度来谈代码的可读性
1070 | 
1071 | 8.19 【今日阅读】http://docs.wex5.com/ Justep 是一家非常老牌的公司。当年还叫思维加速的时候就已经圈内闻名了。如今有了一个新品牌 http://www.wex5.com/newdaodev/ 牛刀云，支持手机、平板、PC、智能硬件各种设备的应用开发，全栈开发，跨端发布，包括app开发、html开发、html5 app开发、微信小程序开发、Web应用开发、企业应用开发等
1072 | 
1073 | 8.18 【今日阅读】https://polaris.shopify.com/experiences/layout 页面生成的前提是页面规范。shopify 有一个偏商务的 polaris 规范值得我们借鉴
1074 | 
1075 | 8.17 【今日阅读】http://worrydream.com/MagicInk/ 不同类型的软件对于如何呈现是不一样的，不是所有的系统都是CRUD。本文把软件分成了：信息软件，操控软件，沟通软件三类。信息软件是占大头的。作者认为“交互”太多了，用户用起来太麻烦了。我们应该更多的把软件设计成“报纸”那样，而不是提供一堆下拉框。
1076 | 
1077 | 8.16 【今日阅读】https://arxiv.org/ftp/arxiv/papers/19
1078 | 7ab9-bc81-4607-b963-99ecb4954bfa 走进一个独特的3D环境，用代码与有趣的角色互动。您将学习编码逻辑和基础知识，同时使用只有虚拟现实才能提供的所有有趣体验。探索编码概念，如循环、条件、变量、数组和函数，同时沉浸在虚拟3D环境中，用3D代码块进行编码。你会以程序员想象不到的方式接触代码！
1079 | 
1080 | 8.14 【今日阅读】https://www.inkandswitch.com/local-first.html 用过 google doc 的同学都遇到过网络连接失败的错误提示。编辑器类的应用还是把数据放在本地体验更好。本文提出了“local-first software”的概念，以 CRDT 做为互联互通的核心技术。在 HackerNews 上也有很多轮有意思的讨论（https://news.ycombinator.com/item?id=21581444，https://news.ycombinator.com/item?id=19804478，https://news.ycombinator.com/item?id=24027663）
1081 | 
1082 | 8.13 【今日阅读】https://zhuanlan.zhihu.com/p/182211043 浅谈低代码平台涉及的一些技术选型
1083 | 
1084 | 8.12 【今日阅读】https://flume.dev/ 提供了一个 react 实现的拖拽编辑 node 的编辑器 https://youtu.be/00BrWZnbnLQ 可以学习一下对应的前端技术
1085 | 
1086 | 8.11 【今日阅读】https://github.com/dt-fe/weekly/issues/262 精读《可视化搭建思考 - 富文本搭建》 
1087 | 
1088 | 8.10 【今日阅读】http://witheve.com/ 这是又一个“model driven”的尝试。群里有不少 model first 信仰的同学，必须看看。其自带了一个 Inspector https://youtu.be/JJk9PTzz_8M，示范了下一代调试器应该是长成什么样子的。
1089 | 
1090 | 8.9 【今日阅读】The Psychology of Computer Programming https://www.amazon.com/Psychology-Computer-Programming-Silver-Anniversary/dp/0932633420 这是一本1971年的书。太阳底下，没有新雪。
1091 | 
1092 | 8.8 【今日阅读】https://mp.weixin.qq.com/s/GiFpswpm_N_5MlnBywRTgw 我们首先定下来的原则就是，我们要像做 PPT 一样去做应用。什么叫像做 PPT 一样去做应用呢？大家可以看一下左边这个小图，这个是市面上常见的一些同类产品的拖拽方式，这个拖拽方式是基于 Flex 布局的技术，所以当你拖出来一个东西到画布里面去的时候，通常只能上下位添加或者左右位添加。当你想要对这里面的东西做一些排版的时候，实际上是要经过一系列非常复杂的操作，才能够把它摆到想要的位置，这是现有的一些产品。那么在云凤蝶上怎么做这件事呢？大家看一下，这个真的是像做 PPT 一样做应用，就是想摆哪就摆哪，没有什么布局的概念。
1093 | 
1094 | 8.7 【今日阅读】https://www.youtube.com/watch?v=MiiWzJE0fEA 深度学习就像是机器来写代码，效果好与不好，人类都很难参与。就像是 nocode。有没有一种lowcode的方式呢，让人类可以贡献一点专家经验，同时仍然主要由机器来写代码? 概率编程语言就是这么一个类型。
1095 | 
1096 | 8.6 【今日阅读】http://www.cs.cmu.edu/~NatProg/papers/MyersICPC2013NatProg.pdf 推荐语：@欲三更 问过这个问题，如何提升基于低代码平台开发的项目的可调式/可维护性？
1097 | （https://www.zhihu.com/question/404837079）这个演讲虽然不直接回答这个问题，但是至少会非常有启发性。
1098 | 
1099 | 8.5 【今日阅读】https://cycling74.com/products/max 这款产品的独特之处在于它不是表单，也不是excel，也不是文档，而是一款音乐创作工具，并且已经存在了20多年了。音乐的可视化搭建会是怎样的产品形态呢?
1100 | 
1101 | 8.4 【今日阅读】https://docs.google.com/presentation/d/1MD-CgzODFWzdpnYXr8bEgysfDmb8PDV6iCAjH5JIvaI/preview?slide=id.g1da0625f1b_0_92 历史上各种语言的编辑器的截图，在 HN 上的讨论（https://news.ycombinator.com/item?id=16624724）（https://news.ycombinator.com/item?id=14290909）
1102 | 
1103 | 8.3 【今日阅读】https://blog.acolyer.org/2016/09/05/on-the-criteria-to-be-used-in-decomposing-systems-into-modules/ lowcode 方案给不同客户的差异化实施问题，最终仍然是要在经典的软件工程原则中去寻找答案。太阳底下，没有新雪。
1104 | 
1105 | 8.2 【今日阅读】https://zhuanlan.zhihu.com/p/58777072：Mel Conway 发明了协程，1967提出了康威定律。后来又转行去做了多年的教育工作。对于如何写代码和如何传授技能都有足够的经验。这个演讲讨论的不仅仅是一种新的、更好的构建软件方式。这个项目要比这个目标更野心勃勃。“我能否为计算机软件找到一个更简单的理论模型，从让更多人可以操控它？”
1106 | 
1107 | 8.1 【今日阅读】可视化的报表搭建demo（https://www.youtube.com/watch?v=CquSbOFFCpQ）它提供了一个可编程集成开发环境(IDE)，结合了交互式的可视化设计、拖拽式的可视编程和代码编写，能够有效的平衡编程和设计能力。 http://vlambda.com/wz_wD99yjtAGH.html
1108 | 
1109 | 7.31 【今日阅读】面向大众的可编程文书（https://www.notion.so/Dango-b46c07f3dc224f968c768885abe70e70）推荐语：notion 很火，airtable 也很火，notion + airtable 会是怎样的呢？下一代的 no code 平台可能都会长成这个样子
1110 | 
1111 | 7.30 【今日阅读】pattern是对常见问题的归纳。知道有哪些问题，比知道有哪些答案更重要。UI 可能是所有业务代码里共性最大的部分，积木复用的理想似乎仅仅在UI这个层面达成了。今天推荐 SAP 的 Fiori Design Guidelines（https://experience.sap.com/fiori-design-web/action-placement/）以及 UI-Patterns（https://ui-patterns.com/patterns/pull-to-refresh）。这两个资料库都非常详尽，可以从这里找到提取可复用组件的灵感。
1112 | 
1113 | 7.29【今日阅读】Out of the Tar Pit（https://github.com/papers-we-love/papers-we-love/blob/master/design/out-of-the-tar-pit.pdf）推荐语：昨天飞叔给大家分享了模型驱动框架中立的视图技术。此模型驱动和MDA的模型驱动完全不同。在本文中，作者提出了一个简称来指代这种技术，叫FRP（Functional Relational Programming）。FRP从老板的眼里看来是没有用的技术，因为逻辑是不灭的，FRP不过是让程序员把一段代码分成两部分来写，并没有消除什么工作量，反而会因为新技术引入管理风险。而MDA对于老板来说是银弹一般的存在，我只要招聘会写JSON的员工，就能快速生成各种页面了。而我们都知道，这不过是欲速则不达的另一个例子罢了，MDA实质是依赖管理，是复用一个黑箱的code generator。而 FRP 则被很多职业程序不约而同地一再重新发明出来，至少本群里就又4套实现了。那 FRP 到底是何方神圣呢？和 React/Vue 有什么不同？快来读读吧
1114 | 
1115 | 7.28 【今日阅读】变化驱动：正交设计（https://www.jianshu.com/p/d127b8afc8cb）推荐语：当你第一次定义好一个model，然后CRUD页面都生成出来的时候，你会以为你找到了银弹了。lowcode的一个很大的流派仍然是以 model 定义为中心的 MDA 思路。今天推荐这篇文章是因为我认为 MDA 实质上是引入了一个对 code generator 的包依赖来简化使用这个包的用户代码，静态还是动态 codegen 仅仅是一个依赖之间的实现细节，我们还是得从依赖管理这个全局问题入手。很少有文章讲“依赖管理的目的”这个话题，“什么样的依赖管理是好的”？如果你对这个问题感兴趣，那么你应该逐字逐句地读一下这篇文章。
1116 | 
1117 | 7.27 【今日阅读】bret victor 的经典之作 learnable programming（http://worrydream.com/LearnableProgramming/），中文译本 http://pythonic.zoomquiet.top/data/20150419235328/index.html 。推荐语：可视化设计流程图在《没有银弹》成文的1986年代已经是被吊起来打的批判对象了，“现代的”low code 平台还在拿可视化设计流程图来做为卖点不能不说是可悲的。bret victor 的这篇经典文章用大量的例子可视化的说明了啥叫真正的可视化。
1118 | 
1119 | 7.26 【今日阅读】云凤蝶如何打造媲美 sketch 的自由画布（https://zhuanlan.zhihu.com/p/92469406）云凤蝶自由画布之道：分层模型（https://zhuanlan.zhihu.com/p/97768853）对于在做可视化搭建的同学会有一些启发意义
1120 | 
1121 | 7.25【今日阅读】https://zhuanlan.zhihu.com/p/163565656 low-code / no-code 傻傻分不清楚？今天我就给一个非常清晰可操作的定义
1122 | 
1123 | 7.24【今日阅读】https://futureofcoding.org/catalog/ 推荐语：FutureOfCoding 是国外的一个探讨未来编程应该是什么样形态的社区，这篇文章研究了24种与此相关的语言和平台。我认为 no code / low code 不过是 alternative code，就是用 alternative 的技术去实现在不一样的约束条件下的编程体验。no code 就是用户编程给自己用，low code 就是citizen developer编程给其他人用。所以 FutureOfCoding 的 slack 社区（https://futureofcoding.org/community）是国内每一个做 no code / low code 的从业人员都应该去学习学习的地方。
1124 | 
1125 | 7.23【今日阅读】面向 Model 编程的前端架构设计 https://zhuanlan.zhihu.com/p/144157268
1126 | 


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