🔗 Raymond Hettinger's professional experience at doing code review and architecture review

P vs. NP 👉 Pythonic vs. Non-Pythonic!

# How to make use of PEP 8

1. Golden rule of PEP-8: PEP-8 onto yourself. PEP 8 is style guide, not a law book.
2. Care about intelligibility, not simply visually better
3. Transforming (Java) API to pythonic ones

# Why not PEP 8

1. Code beautifully PEP 8 compliant but bad
2. Distraction from code quality
3. PEP 8-tify would wrap history in case of git blame

More details can be found in codes comments and talks.

# P vs. NP #1

It just works:

# XXX -- Top level review comments:
#
# * Nice exception recovery and logging.
#
# * Please cleanup code formatting.
#   This is a little rough on my eyes.
#
# * Should we use this as template for other
#   short network element scripts?
#
# -- Thanks.   The Boss :-)

import jnettool.tools.elements.NetworkElement, \
       jnettool.tools.Routing, \
       jnettool.tools.RouteInsector

ne=jnettool.tools.elements.NetworkElement( '171.0.2.45' )
try:
    routing_table=ne.getRoutingTable()  # fetch table

except jnettool.tools.elements.MissingVar:
  # Record table fault
  logging.exception( '''No routing table found''' )
  # Undo partial changes
  ne.cleanup( '''rollback''' )

else:
    num_routes=routing_table.getSize()   # determine table size
    for RToffset in range ( num_routes ):
           route=routing_table.getRouteByIndex( RToffset )
           name=route.getName()       # route name
           ipaddr=route.getIPAddr()          # ip address
           print "%15s -> %s"% (name,ipaddr) # format nicely
finally:
    ne.cleanup( '''commit''' ) # lockin changes
    ne.disconnect()

# P vs. NP #2

After automated tools for style checking:

import jnettool.tools.elements.NetworkElement
import jnettool.tools.Routing
import jnettool.tools.RouteInsector

ne = jnettool.tools.elements.NetworkElement('171.0.2.45')

try:
    routing_table = ne.getRoutingTable()
except jnettool.tools.elements.MissingVar:
    logging.exception('No routing table found')
    ne.cleanup('rollback')
else:
    num_routes = routing_table.getSize()
    for RToffset in range(num_routes):
        route = routing_table.getRouteByIndex(RToffset)
        name = route.getName()
        ipaddr = route.getIPAddr()
        print "%15s -> %s" % (name, ipaddr)
finally:
    ne.cleanup('commit')
    ne.disconnect()

# P vs. NP #3

A Pythonista, however, would write elegantly encapsulated template file:

from nettools import NetworkElement

with NetworkElement('171.0.2.45') as ne:
    for route in ne.routing_table:
        print "%15s -> %s" % (route.name, route.ipaddr)

# P vs. NP #4

And that's what's happening under the hood:

''' Pythonic means "coding beautifully in harmony with
    the language to get the maximum benefits from Python"
    Learn to recognize non-pythonic APIs and to recognize
    good code.  Don't get distracted by PEP 8.  Focus
    first an Pythonic versus NonPython (P vs NP).
    When needed, write an adapter class to convert from
    the former to the latter.
    * Avoid unnecessart packageing in favor of
      simpler imports
    * Create custom exceptions
    * Use properties instaed of getter methods
    * Create a context manager for recurring
      set-up and teardown logic
    * Use magic methods:
          __len__ instead of getSize()
          __getitem__ instead of getRouteByIndex()
          make the table iterable
    * Add good __repr__ for better dubuggability
'''

# Adapter ###########################################

import jnetool.tools.elements.NetworkElement
import jnetool.tools.Routing

class NetworkElementError(Exception):
    pass

class NetworkElement(object):

    def __init__(self, ipaddr):
        self.ipaddr = ipaddr
        self.oldne = jnetool.tools.elements.NetworkElement(ipaddr)

    @property
    def routing_table(self):
        try:
            return RoutingTable(self.oldne.getRoutingTable())
        except jnetool.tools.elements.MissingVar:
            raise NetworkElementError('No routing table found')

    def __enter__(self):
        return self

    def __exit__(self, exctype, excinst, exctb):
        if exctype == NetworkElementError:
            logging.exception('No routing table found')
            self.oldne.cleanup('rollback')
        else:
            self.oldne.cleanup('commit')
        self.oldne.disconnect()

    def __repr__(self):
        return '%s(%r)' % (self.__class__.__name__, self.ipaddr)


class RoutingTable(object):

    def __init__(self, oldrt):
        self.oldrt = oldrt

    def __len__(self):
        return self.oldrt.getSize()

    def __getitem__(self, index):
        if index >= len(self):
            raise IndexError
        return Route(self.oldrt.getRouteByIndex(index))


class Route(object):

    def __init__(self, old_route):
        self.old_route = old_route

    @property
    def name(self):
        return self.old_route.getName()

    @property
    def ipaddr(self):
        return self.old_route.getIPAddr()

# P vs. NP #misc1

You can barely read your own code like this:

ts('obama', 20, False, True)

p = (170, 0.1, 0.6)
if p[1] >= 0.5:
    print 'Whew, that is bright!'
if p[2] >= 0.5:
    print 'Wow, that is light'

def get_routes(*args):
    'Return a dictionary of real-time stock quotes'
    return {symbol: get_quote(symbol for symbol in args)}

for interface, status in interfaces:
    if status == 'up':
        print interface

# P vs. NP #misc2

…without realizing that you could have done so with “batteries included”:

twitter_search('obama', numtweets=20, retweets=False, unicode=True)

from collections import namedtuple

Color = namedtuple('Color', ['hue', 'saturation', 'luminiosity'])

p = Color(170, 0.1, 0.6)
if p.saturation >= 0.5:
    print 'Whew, that is bright!'
if p.luminiosity >= 0.5:
    print 'Wow, that is light'

def get_routes(*symbols):
    'Return a dictionary of real-time stock quotes'
    return {symbol: get_quote(symbol for symbol in symbols)}

for interface, status in interfaces:
    if status.lower() == 'up':
        print interface

# TL;DR

GRE 一战 V161 Q169 AW4.0，复习主要用：

核心：GRE Official Guidance
单词：用 Anki 准备 GRE
填空：麟渡兮填空
阅读：陈虎平_新 GRE 阅读理解 36 套
阅读：杨鹏_GRE & GMAT 阅读难句教程
写作：新 GRE 写作 5.5
模考：GRE 考满分
机经：考满分_机经
经验：千张_如何准备 GRE 考试？

# 考前

文中提到的书籍都已经整理好放在公共仓库了。最后看 GRE Diagnostic Service，填空部分两个 Section 各错一道。

我是 9月初的 GRE 考试，之前的备考经历有当年四月份的托福一次103分(R30 L29 S19 W25)。读过半本单词书 Word Power Made Easy，人称小白本，和人称韦氏小绿本的 Merriam-Webster’s Vocabulary Builder，与 Robin 大神大力推荐的 Verbal Advantage 号称江湖三大单词书。这三本书用我的偶像 @管鑫Sam 的话来讲是：

小绿：构建词汇思维、打造深层理解 Merriam-Webster Vocabulary Builder
小白：转化积极词汇、提升语用意识 Word Power Made Easy
第三推荐：Verbal Advantage
三本书都为外国专家所著，语言生动有趣，尤其是小绿，对于构建英语的词汇思维很要帮助。
三本都更类似内功心法，旨在提高内力、点拨运功法门。

我在寄托天下、一亩三分地这两个论坛上读了许多经验帖子，最合我心的是一位「语言学爱好者」的备考经验、对于各种材料的褒贬有拨云见雾之感。和其他备考经验上来就是五遍三十遍的轰炸思路完全不同。遂决定跟着作者的思路复习。

为了决定了备考过程完全电子化，也因为此错过了解析只有纸质版的阅读36套，主要使用了 Anki 背诵单词和 PDF Expert 读书做题，文章最后会介绍这部分经验。

@山羊月 谈到他对实体笔记的观点：

非常可怕的是，我们的信息整理和利用的意识还系统性的停留在对于「书本」和「笔记」实体的迷信阶段。这种实体诚然具有一定的优势，但却完全无法阻挡科技进步的脚步。

# 单词

全程使用：

• 《麟渡兮字彙》：GRE 词汇怎么考？怎么学？怎么查？
• GRE核心词汇考法精析（再要你命 3000）
• 新东方佛脚短语表（佛脚词汇表）

考前一周左右看：

• 《麟渡兮字彙》(同反近義)單字彙整（麟渡兮老师：GRE 填空题中的选项只有广义的同义、广义的反义，再也没有第三种了）

单词在 GRE 考试的备考过程中占了相当大的比例，单词背什么？ 第一轮看中文意思，读英文释义自行理解含义。为什么呢？因为单词很多义项其实是本义、比喻义、引申义之间的关系，在中文里一说你肯定也懂的那种，但是书中的释义很多时候并不能体现这种关系。看了某臣教育大当家琦老师的一节录屏课，老师给了一个单词变体表。词根是他是从三千个词中一个个找出来的，他的结论是统计学意义上有效的吗？奇技淫巧的「词根」脱离了场景全无意义。同近反义在上述都掌握情况下可以看一看，背诵请看整理词表，各类助记垃圾都不要看。

请记住，要想快速学习英语单词，一定要掌握词根。一个词根在现代英语中的衍生常有十数个单词原型，考虑词性变换，加上前后缀就更多，从词根出发，编织出是语义交织的网。

# 填空

填空部分推荐《麟渡兮填空》，「陈圣元后继有人，惊世之作，思维方式细分」，含 ETS 官方题目全部翻译。摘几段对我很有启发的观点：

背字彙與做題並進：
提早做題，熟練解題技巧，同時努力背單字。在查字典 (MW) 上要下苦工，把不 會的單字都查過並仔細弄懂 (包含英文解釋、例句)。

填空解題邏輯包含以下四個重點：
句型結構、正反意涵、關鍵字句、刪去法

就 ETS 出題法則歸納出以下三個解題實戰技巧
還原選項中的名詞、長選項的簡化、二三格選項刪去法（中性字通常不是答案）

像这样把单词读精的思路，对背了大量单词仍不得要领的我非常有启发。书中的解题思路和技巧更是点拨地透彻，希望大家都能读到这本书。

节选自 PPII 中的题目都加了删除线，因为担心影响考前模考估分，但是当例子讲解时看看也无妨。书中用到的「删去法 POE」 (Process of Elimination) 来自 《Princeton Review: Cracking the new GRE》 一书，可以补充略读一下介绍 POE 的部分。

Manhattan 我没有做。试了套 Very Hard 正确率比其他题目低 20%，有网友评论词汇太偏太怪，并且这个自己通过暗示诋毁其他教育机构的方式宣传自己，但也有人说题目的考核方式和内在逻辑是接近 ETS 的。我以为，了解考核逻辑莫过于官方给出的考试资料，我备考时间不多，最后 OG + Verbal + PPO 都没做完，匆匆看了两百道机经就上了考场，Verbal 还是推荐大家多看官方资料。

# 阅读

Verbal 30分钟的时间内，一般建议 10道填空题 10 分钟，10道阅读题20分钟。GRE 阅读同时也是研究生阶段阅读的关键，就是 OG 中所说的「主动阅读」。

《陈虎平 - 新 GRE 阅读理解 36 套》千张答主评价很高：「分层阅读与笔记法佶屈聱牙，但一旦掌握终身受益」。没有怎么准备阅读，靠管鑫Sam 的外刊精读笔记和平时阅读的功底做下来，考试时阅读错误也不少。读过一本《阅读题源》，将文章结构化的方法对内化、理解文章很有帮助。现在看来也是分层阅读结构法一书的延展。

《杨鹏 - GRE & GMAT 阅读难句教程》（杨鹏长难句）：把长难句聚集起来这种模式，可以帮助你读某一个句子，但是忽略了上下文的关系，而我们是靠句子逻辑和文章逻辑共同解题的。刚开始看时一直忍受着生理和心理上的不适。把这本书制作成了 Anki 单词卡。¹

《陈虎平 - 新 GRE 阅读逻辑 10 套》：「简单粗暴刷逻辑。我的建议是先做一套，正确率80%以上就不用继续做了，反之则请你刷完。」

此外，还看了《花儿 - GRE阅读39+3全攻略》二、三章的题型和解题方法，对阅读思路有一点帮助，切记不要想套入书中的四种模板，不了解文章结构是很难回答出考试的题目的。

# 模考 & 机经

模考用官方的 PPO 和 GRE 考满分网。

机经方面，我用的考满分填空1100题和阅读200题，只做了老师整理出的高频部分，中了多道原题。免费的机经质量居然能这么高，推荐不参加培训机构的大家考虑一下。

# 数学

Math Review 看看，单词和一些没接触过的概念要看看 。 「OG：看完 Math review 之后把习题做一遍，要是全对就可以不管数学了。」

# 写作

《新GRE写作5.5》介绍了写作的大致形势，对官方题库所有的 issue 和 argument 提纲给出了「正反合」、「正反散」的模版/思路。看官方范文和要求，自己总结模板。

在之前的英语辩论课上，整理了部分常见「逻辑谬误」，也一并发出。

考前两天，PPO (PPll) 第二套考试 156+170，按照网友分 享的 PP2 备考经验看来，预期 Verbal 分数在 160 分附近，心里有数，笃定。

# 软件经验

# PDF Expert

PDF Expert 是我常用的 pdf 阅读软件（结构化阅读的任务现在交给了 MarginNote），能够满足我的几个要求：流畅的标注、标注，检索目录和标注、分割视图同时打开文档和答案/解析，并且同步滚动和阅读。

# pdfdir

用来给 PDF 文件增加目录

# Anki

Anki ²是一款开源、跨平台、拓展性强的记忆卡软件。采用基于遗忘曲线的「间隔重复」（Spaced Repetition）算法组织卡片复习。国外视频网站上有大量网友分享他们使用 Anki 快速掌握各种知识/语言的经验。用过小卡片背单词的一定懂的一个概念「主动召回测试」，在翻到背面之前要求你主动思考、组织语言并表达。选择它准备 GRE 单词有如下考虑：

• 背诵单位精细化：仅仅是词而甚至某个义项，不是一个大 list 一起复习，你每次选择的答案和花费的时间都会被记录，并按此计算复习时间。
• 复习精细化：卡组按照独立的遗忘率复习，在恰好将忘未忘，记忆效率最大的时间点提醒你复习单词，不做无用功。同样也因为 “Use It or lose it”，督促自己主动学习。牌组有大量的复习参数可以调整。
• 筛选方便：考前一天，我使用 Anki 筛选出了未来几天会复习到的单词强化背诵。此外，我还收集到了 300 个词左右的，一本属于我自己的难词表。
• 沉浸阅读：配合 Anki 制卡插件，可以在阅读时一键查词，并将单词、正在阅读的句子和解释一并一键制卡。语境的力量无比强大。
• 「可以用一辈子的记忆学习工具」：截止今天，我一共在在使用 Anki 软件的 58 天里，花了 49 小时，平均每天 41.7 分钟；一共看了 67911 张卡片，平均每天 956.5 张（包括回顾）。「我们会在48小时内忘记约75%的学习内容」，我们在期末备考花费大量的时间和精力，得到的知识却又在更快的忘却了。对终身学习者而言，信息的长期记忆是持续学习的基石，记忆方法的价值常常被我们低估。如果你也有同样的疑惑，Anki 可能也适合你。

# RescueTime

记录在你的电脑和 Android 手机上使用各个软件，浏览各个网页的时间，并按各类应用计算出你的效率 Productivity。

# 附录

1. GRE 资料中还有我制作的「杨鹏_《新东方•GRE & GMAT阅读难句教程》」等 ANKI 文件，也可以在 Anki 共享牌组中搜索到。

2. Anki 是一款开源、跨平台、拓展性强的记忆卡软件，你可以在这里看到介绍：

• Anki 使用详解
• Anki 理解笔记

# Why would you need a domain email?

Surely there’re numerous out-of-the-box email service providers. Why would you want an email at your own domain? It is common for companies to have their unique email account, for branding and managing purposes. For people like you and me, domain email would help your personal branding, and more importantly the free to transfer between mail service providers. Domain email comes at zero price, yet paying tribute to the Open Web. I would use my shawnxli.com and me@shawnxli.com as an example throughout the passage.

# Why Yandex?

Yandex is a Russian Google counterpart. Yandex Connect’s email service meets all my expectations: stable, secure, fast, ad-free, domain email, import/export data, email alias, mass storage, calendar, synchronize, push, IMAP, two-step/ two-factor verification, Yubikey, email forward and filtering… even for advanced security features like SPF, DKIM, DMARC support are all there. Offered at $0 for the individual.

# 0. Prerequisite

• A domain (I bought my domain from Tencent Cloud at the price of ~$15 for three years, available to transfer after 60 days.)
• Patience to follow the instructions

# 1. Acting as the main Yandex Account

# 1.1. Sign-up the main Yandex Account

# 1.2. Add and verify your domain

First, add a DNS TXT record at your domain DNS service provider, delete when the domain is verified.

Then add an MX record at your domain DNS service provider

# 1.3. Create a user account

Taken my account for example:

Email: me@shawnxli.com Department: All employees Grant admin rights (Optional)

# 1.4. Set a catch-all address routing

This is meant to redirect all the emails sent to invalid email addresses on your domain.

# 2. Acting as the user Yandex account

# 2.1. Log-in the user account

• Enable IMAP and POP3 at: Mail → All settings → Email clients

• You may also:

  • Enable app passwords
  • Set up two-factor authentication

# 3. Set Gmail to send and receive email

• Gmail → Accounts and import → “Send mail as”

Mail server address: smtp.yandex.com
Connection security: SSL
Port: 465
Account: your-account@your-domain.com
Password: your-account-password or app-password

• Gmail → Accounts and import → “Import mail and contacts”

Mail server address: pop.yandex.com
Connection security: SSL
Port: 995
Account: your-account@your-domain.com
Password: your-account-password or app-password

Useful Resources

# 4. (Optional) Advanced Security/ Anti-Spamming Setting

• SPF (Not Recommended, Why?)
• DKIM, DMARC

# References

• https://6ki.org/archives/53

This article contains some code template that would elaborate you from the dull routine of adding process.env || at the beginning of each Node.js configuration file. Following the 12 Factor's config methodology, configs are stored in the environment variable, while also be able to read from files for default setting/ bootstrapping, etc.

# Motivation

The motivation of the project are from the ES6 tutorial and SmartVIS Back-End project that I've been doing. I'm excited by the idea of using the ES6's Proxy, Reflect and Symbol feature to introduce an automatic environmental variable loader, without hampering how the rest of code is retrieving configs from file.

// src/app.js
const config = require("../config");

# So… What it's like?

We want to keep it this way, and with 50 lines of code, the explicitly annoying process.env is now exempted from config implementation.

// FROM: config.js (or config/index.js)
module.exports = {
  env: {
    PORT: process.env.PORT || 3000
  },
  database: {
    HOST: process.env.DATABASE_HOST || "mysql",
    PORT: process.env.DATABASE_PORT || "3306",
    USER: process.env.DATABASE_USER || "example",
    PASSWORD: process.env.DATABASE_PASSWORD || "example",
    DATABASE: process.env.DATABASE_DATABASE || "example"
  }
};

// TO: config/default.js
module.exports = {
  env: {
    PORT: 3000
  },
  database: {
    HOST: "mysql",
    PORT: "3306",
    USER: "example",
    PASSWORD: "example",
    DATABASE: "example"
  }
};

# Intuition and Installation

But how can we possibly achieve this? The answer is the magical config/index.js that I'm going to introduce to you. The intuition is quite clear and straight forward: whenever a client try to get a certain config, we first search for process.env and otherwise return the default value (process.env.KEY || 'default_value'). An extra key is required for configs of process.env.SERVICE_FIELD in order to store the previously called service. ES6's Proxy, Reflect and Symbol feature are required as to intercept the getter. You may check for implementation for more detail.

To get the power of no-more-explict-process-env, just download the config/index.js and organized it like the templates, and enjoy!

# Show me the code

/* eslint-disable no-process-env */
"use strict";

const config = require("./default");

const KEY = Symbol();

function isObject(value) {
  return value && typeof value === "object" && value.constructor === Object;
}

function ProxyFactory(obj) {
  /**
   * Handler with getter to return env/value/Proxy<-object when inspecting configs
   *
   * @type {{get}}
   */
  const configHandler = {
    get: (target, key, receiver) => {
      // Concat to the matched name required for env
      // e.g. config.oss.sts.ROLE_ARN -> OSS_STS_ROLE_ARN
      const envName = [Reflect.get(target, KEY, receiver), key]
        .filter(Boolean)
        .map(_ => _.toString().toUpperCase())
        .join("_");
      // Return the environment variable if there is one
      const p = process.env[envName];
      if (p) {
        return p;
      }
      // Get original value/object
      const o = Reflect.get(target, key, receiver);
      // Return the value/undefined
      if (!isObject(o)) {
        return o;
      }
      // Return ProxyFactory(obj) with new object appended with a Symbol key to store envName
      return ProxyFactory(
        {
          ...o,
          [KEY]: envName
        },
        configHandler
      );
    }
  };
  return new Proxy(obj, configHandler);
}

/**
 * Loader for environmental variable configs named after <SERVICE_FIELD> if set else config
 *
 * @type {Proxy}
 */
module.exports = ProxyFactory(config);

👆 “MarginNote”, literally

# MarginNote - 在 iPad 上提升学习效率，它可能是最合适的 PDF 阅读器

• 如何使用 MarginNote
• MarginNote 提供的工具：批注（摘录）、大纲、思维导图、记忆卡
• MarginNote 工作流：书、笔记本、摘录
• PDF 结构化：[传统的] 书签、大纲、页码 🆚 [MarginNote] 摘录、大纲、思维导图、记忆卡（上下文）
• MarginNote 应用 - 复习考试：回忆模式
• 扩展接口：Anki（学习卡）、OmniOutliner（大纲）、MindManager & iThoughts（思维导图）、Evernote（导图、大纲、书）、MS Word（大纲）、DEVONthink（笔记）

@路灯等灯等灯：

除了用在课业学习上，marginnote对于我这种喜欢深入阅读，尤其是阅读论说类书籍的人来说，是神器一样的存在。

《如何阅读一本书》践行分析阅读和主题阅读的平台，比纸质书还更好。

阅读时打开侧边栏，随时对划线的重点句子的主旨进行提炼，并调整其在大纲中的层级与位置，这样就顺利的将一本书肢解，成为了直观的思维导图和大纲，并可以即刻跳转至该条笔记的出处，哪怕是来自不同的书。」

# MarginNote Pro 读书人的神器 - 知乎专栏

阅读笔记流程：

1. PDF Expert 标注，做大概的整理知识整理
2. SimpleMind 思维脑图，知识图文化，用逻辑思维再梳理一遍，找出自己的逻辑
3. OmniOutliner Pro 大纲，把知识结构化

MarginNote Pro：标注，大纲，思维导图。完整工作流

# MarginNote : 如此强大的笔记 App，每个人都该有 #iOS #Mac_AppSo

MarginNote Pro - 剪书, 批注, 重组, 快速的创建思维导图和记忆卡来复习 http://v.youku.com/v_show/id_XMTc2NzgxMTc4MA==.html

• 应用内搜索（in-depth search）
• 下载网页（download as epub）
• epub 页边笔记（KJV）

MarginNote 核心逻辑：

1. 标记、批注，都会被「剪藏」到一个笔记本，作为备用的笔记素材收集起来；
2. 这些笔记可以在页边、大纲列表、思维导图、学习卡集中不同的视图里自由切换；他们是联动的。

「这种将不同思维空间连接起来的能力可以促进学习中的创造力和记忆，是纸书或其他电子工具无法做到的。」

开发者 Sun Min 的使用思路：

我的工作流一般是就某一个主题建一个笔记本，然后把这个主题下最棒的资料 PDF 拖进来，然后陆续把看到的网页通过 MarginNote 的 EPUB 转存功能也拖进来。 在碎片的时间里把一片片摘录慢慢收集起来，然后有空再到思维导图和 Outline 里整理。最后用 Flashcards 回顾和记忆。 除此之外，Min 也推荐了知乎网友 @山羊月 的分享：用 pdf 版看完大部头专著是怎样一种体验？ 以及 Einswell 的分享：iPad 上有哪些实用得令人惊艳的 App？

MarginNote 为解决碎片知识重组的问题。就像洛克的索引系统一样，MarginNote 不仅能让读者快速地找要查询的笔记内容，还可以完成一个更高难度的任务，即促进读者思考与反思。AppSo 也认为，无论是深度学习还是多线程任务处理，人都可以凭借科技，到达新的高度。在混乱中建立新秩序，是我们必须学会的技能。

用 pdf 版看完大部头专著是怎样一种体验？_山羊月

我们的阅读体验并不是来自于 PDF，而是来自于阅读 PDF 的软件。一个好的阅读软件给人带来的阅读体验和阅读效率的提升是多么显著。

前期主要利用 Nvivo 来阅读 PDF，这个工具应该被很多人熟知，是做质性研究编码的一个主要软件。但是国外很多人用 Nvivo 来读 PDF，因为它具备很好的信息整理，归类，思维导图建立等功能，是做文献综述的大杀器。简而言之，你可以把不同 PDF 文件上的信息归为一个个节点，每一个节点代表一个知识元，以后你每一次需要用到这个知识元的时候，只需要打开它，你之前整理的所有相关论文里的信息全部都在里面，轻轻一点自动跳转到 PDF 的段落。你还可以导入语音，视频，截图，笔记等各类文件，同时用思维导图来整理这些知识元，构建二级甚至三级知识网络。

在论文阅读过程中建立思维导图整理逻辑联系的重要性

同时这个软件也有缺陷。Marginnote标注的PDF和笔记似乎没法被其他PDF软件读取。同时 Marginnote 的UI设计有些丑不说，很多界面和功能的引导做的不好，学习曲线比较高。当然，Nvivo可能更高。最后，Marginnote还存在很多 Bug，目前正在等待下一个大版本更新，后续功能会进一步加强。

最后，我个人的理解是：处在当今这么一个知识爆炸的时代，对于信息的整理，对于软件的学习，实际上是科研能力的一个重要组成部分。而我们中国学生对这种能力的训练和思考远远不如西方国家的学生。我们甚至都没有建立起利用软件进行高效的信息整理和利用的意识。非常可怕的是，我们的信息整理和利用的意识还系统性的停留在对于「书本」和「笔记」实体的迷信阶段。这种实体诚然具有一定的优势，但却完全无法阻挡科技进步的脚步。我们的意识如果不更新，我们终有一天会发现我们自己信息整理和利用的效率远远落后于其他国家的学生，而这种落后导致的后果，就是信息壁垒，就是科技壁垒，就是发展壁垒。

一个工具如果不好用就不会被广泛接受；它被广泛接受也并不代表它就对你好用。

# iPad 上有哪些实用得令人惊艳的 App？

• 详细介绍了 MarginNote 的使用操作

# MN&Anki天生CP，完美的学习闭环

• 介绍 MarginNote 和 Anki 的协作场景
• 分享 iPad Pro 的使用体验

# 忙碌时代的读书方法 - 汪丁丁的想法 - 知乎

忙碌时代的读书方法，今天我介绍晚近几个月我使用的一种新的阅读技术，我认为超过目前流传的那些。文献存多了，每一位学者都要建立自己的更好用的检索和阅读方法。我喜欢跨学科研究方法，围绕同一主题同时阅读许多文献。或许我尝试的几十种同类阅读软件里，这一款最佳。

我还没有挑战它的存书极限，应当不会太大，因为每次阅读任何一本书必须保存许多信息。

阅读时它自动保存的思维导图。使用笔记工具，每次需要标出重要段落，用矩形框出相关段落，可以跨页，可以无限延伸，这时，左栏就出现矩形之内的文字。我试过，输出笔记为PDF格式之后，可放大八倍，通常够用。这些矩形之间的关系，完全由你的思路决定。我习惯于将一本书的核心思路相互联结成一张图，然后就不再读这本书，只看图即可回忆书的细节。虽然文档很大，但日积月累，同一主题的不同文献阅读笔记，可合并为一本丁丁笔记，优势明显！

# 行为经济学心智地图 - 汪丁丁的想法 - 知乎