Software 2.0: From Rule‑Based Programming to Model‑Based Development

Software 2.0 is not a brand‑new concept but many are unfamiliar with it; it denotes a programming paradigm that relies on data rather than explicit logic, essentially swapping a set of rules for one or more neural networks to make decisions.

Software 2.0: From Rule‑Based Programming to Model‑Based Programming

In 2017, Andrej Karpathy, director of AI and autonomous‑driving vision at Tesla, introduced the term Software 2.0 in his blog, noting that vision, speech, machine translation, games, and even databases are shifting toward this approach, which offers fixed runtime, fixed memory usage, portability, ease of hardware hardening, and rapid response.

Today many fields rapidly upgrade by leveraging neural networks (NN), from financial risk control to ad recommendation, moving from rule‑based to model‑based solutions.

Google’s paper "The Case for Learned Index Structures" shows that even classic database indexing can be outperformed by NNs, because in complex systems human‑crafted rules struggle to find optimal solutions, whereas data‑driven NNs can use gradient descent to discover statistically optimal answers.

The real world is complex and often cannot be described by precise physical formulas; rule‑based implementations must approximate subjective human judgment, making precise matching difficult. For example, determining whether a car has crossed a line by rule requires many parameters, whereas a NN can be trained simply by labeling images.

In the Software 2.0 era, task descriptions become pure data while implementation is handled by underlying neural networks, enabling faster and more efficient software production.

When results are unsatisfactory, additional labeled data can be collected, allowing the NN to adjust quickly—something hard to achieve with static rules. For instance, removing lynxes from a cat‑classification task is trivial for a NN but cumbersome for rule‑based code.

What Should Developers Prepare for in the Software 2.0 Era?

Focus on Neural‑Network Training and Inference

Just as front‑end developers must understand browsers and databases, Software 2.0 developers need to become familiar with NN characteristics.

As NN code proliferates in repositories, new challenges arise, which the MegEngine team addresses through several initiatives:

Optimizing NN inference performance across platforms (MegEngine full‑platform inference optimization).

Rapidly describing NN‑based processing logic (MegFlow streaming framework).

Accelerating NN learning (MegStudio teaching platform).

Providing ready‑to‑use models (basecls model repository).

Adopt a Dataset‑Centric Development Model

Using the cat‑classification example, datasets play a crucial role in Software 2.0:

The data distribution of the dataset precisely represents product requirements .

The dataset also serves as QA test cases .

Instead of lengthy PRDs, a collection of data can define functional boundaries, and QA results become accuracy percentages rather than simple pass/fail flags.

Consequently, dataset collection, annotation, and management become prominent concerns, and traditional PM‑Dev‑QA roles may be challenged:

PMs focus on precision/recall trade‑offs.

Developers may act as data annotators.

QAs become developers of algorithm‑accuracy evaluation systems.

Image source: Wikipedia.

Embrace Probabilistic Results Instead of Absolute Certainty

NN outputs are confidence scores (e.g., 80% certainty a picture contains a cat), and performance metrics are expressed as percentages (e.g., 90% accuracy, 70% recall).

Because NN behavior can be opaque, users may feel uneasy trusting probabilistic decisions; however, statistical outputs are often superior to human or rule‑based judgments, and systems can be designed to handle low‑confidence cases, filter extreme outliers, and prevent error accumulation.

Trigger proactive actions on low confidence : a risk‑control system may request additional verification instead of outright rejecting.

Use common‑sense filters to discard extreme model errors : e.g., flagging implausible numbers of electric bikes in an elevator.

Prevent error amplification in iterative processes : introduce negative feedback to stop occasional wrong clustering decisions from compounding.

Will Rule‑Based Programming Disappear?

In several scenarios, rule‑based approaches remain preferable:

Clear physical laws : problems describable by simple physics are more efficiently solved with explicit formulas.

Strong interpretability requirements : fields like medicine demand explainable decisions.

Early‑stage systems or data‑scarce domains (model cold‑start): limited data makes rules a faster way to prototype.

Ultra‑low‑cost hardware : microcontrollers cost a few yuan, whereas NN accelerators are much pricier.

Future Trends of Software 2.0

Significant improvements in dataset storage and management : as datasets grow larger than code, new tools and services will emerge.

Lowering the barrier to algorithm production : reducing cost and expertise needed to create models will boost development efficiency.

Greater focus on social fairness : statistical models can inherit data bias; developers must balance datasets to avoid discrimination.

Online learning and continuous QA becoming the norm : models will continuously ingest fresh data, improving over time while posing new verification challenges.

Author: Xu Xinran, head of the MegEngine open‑source framework, dedicated to accelerating deep‑learning product deployment. Joined Megvii in 2015, previously responsible for large‑scale AI cluster management (Brain++) and a hundred‑billion‑scale feature retrieval system (Feature Store), building a suite of foundational infrastructure.

MegEngine Juejin account: MegEngine