ObjectSense：一门千行内核、把可靠性写进骨子里的面向对象脚本语言

当大多数语言都在比拼"谁的功能更多、谁的运行时更重"时，ObjectSense 选择了一条相反的路：用不超过千行的精炼内核，把 Vim 语言（VimL）重新封装成一门真正的面向对象脚本语言，让"写出可靠且高效的软件"这件事变得更轻、更稳、更可控。

回到一个朴素的问题：我们真的需要那么多重型语言与庞大的依赖树，才能写完一个几百行的小工具吗？

答案常常是"不必"。语言生态的膨胀，让"启动一个项目"的仪式感越来越重——装运行时、拉依赖、配构建、学框架，真正写业务之前，一半精力已经耗在环境上。ObjectSense 想做的，正是把这部分成本还给你。

一、它从何而来：站在 VimL 肩膀上的 OOP

很多开发者对 Vim 的脚本语言并不陌生——它内嵌在几乎每一台 Unix 类机器里，启动快、可移植、无需额外运行时环境。但 VimL 的过程式写法，面对今天大规模、多人协作的工程场景时，显得力不从心：没有类、没有继承、没有封装，状态散落各处，复用与维护都困难。

ObjectSense（简称 OSE）做的事，不是另起炉灶造一门新语言，而是在 VimL 之上做了完整的面向对象封装。它在保留 VimL 轻量与可移植优势的同时，补齐了类（Class）、对象（Object）、继承（Inherits）、多态、封装（Encapsulation）与抽象（Abstraction）这些经典面向对象能力，并通过包（Package）、模块（Module）、注解、微语言（Micro）等机制，把一门"编辑器脚本语言"升格为一门可用于真实工程的语言。

选择基于 VimL 而非从头设计一门语言，本身也是一种务实。VimL 经过数十年打磨，内嵌于 Vim 生态，语法与运行时都极度成熟；OSE 站在它的肩膀上，等于免费继承了这份稳定性与可移植性，而只需把精力集中在"如何让它面向对象化、工程化"这一件事上。这种"不重复造轮子，只做最关键的封装"的思路，正是千行内核得以成立的前提。

更关键的是，它的核心实现代码控制在千行之内。这不是营销话术，而是一种刻意的设计克制：更少的代码意味着更少的隐藏分支、更低的认知负担，以及——对于使用者而言——更可预测、更可靠的行为。在软件工程里，复杂度往往是 Bug 的温床；把内核压薄，本身就是一种对可靠性的投资。对团队而言，这一点尤为重要：新人上手一门语言的成本，往往与它的"语法表面积"成正比——关键字、语法糖、隐式规则越多，踩坑概率越高。OSE 刻意收束语法集合，意味着团队可以把规范、评审、培训的成本压到更低，把注意力放回业务本身。

二、为什么"千行内核"是一种竞争力

我们习惯了"功能越多越好"的叙事。但在工程实践中，可靠性往往与系统复杂度成反比。当一门语言的核心只有千行，你能大致理解它的全部行为边界；当一个问题出现，你不必翻遍几十万行的运行时去定位根因。

ObjectSense 的克制具体体现在这些设计取舍上：

• 不支持函数重载（overload）：避免"同名不同参"带来的歧义与隐式行为，让方法签名始终清晰、可预测。

• 明确的对象生命周期：不传参调用 CreateInstance 时自动创建单例；需要具体实例时通过 #{} 字典或 Construct 构造函数显式构造。

• 注解驱动的可访问性：@accessible、@static、@hook 让接口边界与生命周期一目了然。

• 预编译 + JIT 加持的微语言：在保持脚本灵活性的同时，性能不输编译型语言。

换句话说，它把"简单"当作一种工程特性来交付：让构造可靠且高效的软件，变得更容易。这恰恰是很多重型语言在演进中逐渐丢失的东西。

三、五分钟上手：从 Hello World 开始

ObjectSense 对环境的要求相当朴素：一台 Linux、macOS，或装有前两者虚拟机的 Windows 设备，并具备基础的终端操作能力即可。在工程结构上，源码统一放在 src 目录下，源文件以 .ose（ObjectSense Extension）为后缀；Sense.ose 则承担项目配置的职责。

下面

" Hello.ose
Package demo

Class Hello

" @accessible
function! s:Main()
    echo "Hello Object Sense!"

是最简单的 Hello World：

把它放在 ose-sample-hello/src/demo/Hello.ose，然后在终端执行：

rose ~/ose-sample-hello/src/demo/Hello.ose

rose 是 ObjectSense 的包管理器与运行入口。只要输入 rose 能校验出环境就绪，就说明你已经站在了 OSE 的起跑线上。整个过程不需要冗长的脚手架——一个 .ose 文件、一行命令，工程就能跑起来。这种"零仪式感"的启动体验，在动辄需要配置文件、依赖清单、构建脚本的现代语言里，显得格外清爽。

四、面向对象：类、继承与多态

OSE 的面向对象能力是"经典且够用"的。它支持类、对象/实例、继承、多态、封装与抽象。下面用一组"车"的例子，说明继承与多态如何自然落地：

```ose
" Car.ose —— 基类
Package transport

Class Car

" @accessible
function! s:Run() dict
    echo "Car is running with " . self.refuel()
endfun

" @accessible
function! s:refuel() dict
    return "Unknown Energy"
endfun

" GasolineCar.ose —— 燃油车
Package transport

Class GasolineCar Inherits Car

" @accessible
function! s:refuel() dict
    return "gasoline"
endfun

" ElectricCar.ose —— 电动车
Package transport

Class ElectricCar Inherits Car

" @accessible
function! s:refuel() dict
    return "electric"
endfun
```

在 Playground 中构造对象并运行：

Package transport

Class Playground

" @accessible
function! s:Main()
    " 不传参时自动创建单例
    let s:leaderCar = CreateInstance('GasolineCar')
    " 用 #{} 快速构造带初始属性的实例
    let s:myCar = CreateInstance("ElectricCar",#{name:"Ose's car",size:6,color:'orange'})

    call s:leaderCar.Run()
    call s:myCar.Run()
endfun

执行后，GasolineCar 与 ElectricCar 各自返回不同的燃料类型——这正是多态的价值：父类定义行为骨架，子类只需替换差异化的实现细节。注意 OSE 明确不支持重载，这让方法的调用语义始终明确、没有意外。从 self 引用当前对象、到 super 在子类中回溯父类（可递归使用），再到 UseSuper 在静态成员函数中引用父类静态成员，OSE 把面向对象最核心的几种关系都讲清楚了，且没有引入晦涩的元编程黑魔法。

五、工程化：包与模块

当项目规模变大，命名冲突与依赖管理就成了绕不开的问题。ObjectSense 用包（Package）组织代码，用模块（Module）做发布与隔离。

包的声明要和目录结构对应，通过 Package 定义、Import 引用跨包类型。而 Sense.ose 作为模块描述文件，用 require / export 精确控制对外暴露的粒度——可以精确到某个包、某个类，甚至某个具体函数，从而在语言层面提升安全性和可维护性：

" Sense.ose
Module yourcompany-demo
{
    description  example                  " 描述
    version      1.0.0                    " 三段式版本号

    require      other-libA               " 依赖库
    require      other-libB

    export       mylib.system             " 导出给其他模块使用的包/类
    export       mylib.network.Http.Post  " 可精确到具体方法

    main         mylib.exec.Main          " 入口文件
}

模块默认在用户目录 ~/.vim/sense 下查找，也可以通过 ROSE_REPO 环境变量扩展搜索路径（多个目录用 : 分隔）。这种"按需加载 + 导出白名单"的设计，天然契合大型项目的协作与安全诉求：别人只能访问你明确导出的内容，攻击面与耦合度都被锁在了最小范围。

六、微语言：在通用语言里长出"无限语言"

如果说面向对象让 OSE 站稳了工程化的脚跟，那么微语言（Micro）就是它最具想象力的一块拼图。它类似 Lisp 宏的机制，允许你声明并使用自己的"语言片段"，并逐步支持自定义语言能力；在预编译与 JIT 的加持下，性能不输编译型语言。

下面的例子定义了一个 Insert 微语言，让你可以写出 Insert (ooo, ooo) Into Person 这样接近自然语义的语句：

 Insert.ose
Class Insert

function! s:Preload()
    Micro Insert s:RunInsert
    Insert (ooo, ooo) Into Person
    let object = CreateInstance("ApplyInsert")
endfun

function! s:RunInsert(code, notUsed)
    echo a:code
    return ""
endfun"

借助 Import! 引入宏、用 Insert! 定义宏体，开发者能把那些重复、啰嗦的样板代码，抽象成领域专属的"小语言"。这意味着你不再被单一语法束缚——在 ObjectSense 里，语言本身是可以被你扩展的。

预编译与 JIT 的加入，让微语言不至于沦为"语法糖表演"。宏在编译期展开、热点路径在运行期被即时编译优化，使得这类高度抽象的代码在性能上仍能贴近手写实现。换言之，你既享受了表达力的自由，又不必为抽象付出明显的运行时代价。配合 rose 命令体系中"向 rose 注册自定义命令"的能力，从写代码到扩展工具链，路径被压得很短。

七、让"可靠且高效"成为默认

除了以上核心能力，OSE 还提供了大量面向工程可靠性的细节，让"写出好软件"不再依赖个人自律：

• 对象成员动态增加：创建对象时可随时注入属性，灵活又不失结构；

• 注解体系：@accessible、@static、@hook 让接口与生命周期清晰可读；

• 内联变量与静态常量：Let >> / Let << 实现内联变量，Let! 定义不可变的静态常量，兼顾性能与约束；

• Switch 分支：为 VimL 补足了更易读的多分支语法，优化分支代码可读性；

• 单元测试：UnitTest 关键字之后的代码在正式运行时会自动剔除，工程化测试零侵入；

• 特权模块：g:PRIVILEGED_MODULES 按需动态加载，避免一次性加载所有模块造成内存浪费，提升启动速度；

• 工具链：rose 命令覆盖了安装、运行、测试、提交、扫描自定义命令等完整链路。例如 rose test 能直接跑单元测试并输出通过率与行/函数覆盖率，rose scan 可发现你注册的自定义命令，从本地验证到发布分发一气呵成。

这些特性单独看都不惊人，但组合在一起，构成了一套"默认偏向可靠"的开发体验。

八、典型场景：它适合解决什么问题

理解了能力，自然要问：它到底适合用在哪？结合 OSE 的设计取向，以下几类场景尤其契合：

• 轻量级工具与内部脚本：很多团队都有大量"几十到几百行"的小工具——构建辅助、数据搬运、环境巡检。用重型语言写显得笨重，用纯 Shell 又难以维护。OSE 的零脚手架启动 + 面向对象组织，正好补上这个空档。

• 嵌入式与受限环境：由于内核极小、复用 VimL 的运行时，OSE 能在资源受限或不宜引入额外运行时的环境中落地，启动快、依赖少。

• 需要领域专用语法的项目：借助微语言，你可以把业务里的固定句式抽象成可读的"小语言"，让领域专家也能看懂甚至参与维护代码。

• 多人协作的中型工程：包 + 模块的导出白名单、注解驱动的接口边界、内置单元测试，让协作时的耦合与误用更可控。

当然，它也不是银弹。如果你需要海量第三方库生态、或追求某门特定语言的极致性能，OSE 未必是首选。它的定位很清晰：在"够用、可靠、轻"这个象限里，把体验做到位。

九、写在最后：轻，是一种力量

ObjectSense 不追求成为"下一个大而全的语言"。它选择把内核压到千行之内，把面向对象、工程化与微语言能力扎实地缝进 VimL 的肌理里，让"构造可靠且高效的软件"这件事回归简单。

如果你也厌倦了为一点小工具引入一整套重型运行时，不妨从 rose 命令和一个 Hello.ose 开始，亲手感受这门"轻，但认真"的语言。