程序员鄙视链：搞AI的就比搞CRUD的高级？聊聊我的看法
程序员鄙视链确实存在，但我觉得没必要。技术没有高低之分，只有适合不适合。解决问题：能用技术解决实际问题持续学习：保持学习，跟上技术发展深入理解：不仅要会用，还要理解原理业务结合：技术和业务结合，创造价值好了，今天就聊到这里。这只是我个人的看法，不一定对。如果你有不同的观点，欢迎在评论区讨论。最后说一句，技术只是工具，人才是根本。不管做什么技术，保持学习，保持谦逊，才是最重要的。程序员鄙视链确实存在
·
程序员鄙视链：搞AI的就比搞CRUD的高级？聊聊我的看法
最近在技术群里看到有人讨论程序员鄙视链，说搞AI的瞧不上搞CRUD的，搞算法的瞧不上搞业务的。这个话题挺有意思的，作为一个两边都接触过的程序员，今天就来聊聊我的看法。
鄙视链确实存在，但没必要
说实话，程序员鄙视链确实存在，而且由来已久。从语言鄙视链（写C++的瞧不上Java，写Java的瞧不上PHP），到领域鄙视链（做算法的瞧不上做业务的，做AI的瞧不上做CRUD的）。
但我觉得这个鄙视链挺没意思的。每个领域都有自己的价值，没必要互相瞧不起。
CRUD真的low吗？
很多人觉得CRUD就是简单的增删改查，没什么技术含量。但实际情况呢？
CRUD的难点：
-
复杂的业务逻辑：看起来简单的增删改查，背后可能是复杂的业务流程。比如订单系统，看起来就是创建订单、更新状态，但实际要考虑库存、支付、物流、退款等等，逻辑复杂得很。
-
性能优化：高并发的CRUD系统，要考虑缓存、分库分表、读写分离、分布式事务，这些都不简单。
-
系统设计：如何设计一个可扩展、可维护的系统架构，这不是简单的事。
-
业务理解：要理解业务，把业务需求转化成技术方案，这需要很强的沟通能力和业务理解能力。
我见过很多做CRUD的同事，技术能力很强，业务理解也很深，解决的都是实际问题。这哪里low了？
AI开发真的高大上吗？
AI确实很火，但AI开发也不是什么高不可攀的东西。
AI开发的实际情况：
-
大部分是调API：很多AI应用其实就是调用API，封装一下，加个前端，并没有多复杂。
-
数据质量是关键：模型再牛逼，数据不好，效果也不行。数据清洗、标注这些工作，其实很枯燥，也需要很强的业务理解。
-
工程化挑战：把模型部署上线，处理并发、监控、调试，这些都是工程问题，和传统开发没什么区别。
-
效果不稳定：模型效果不稳定，需要不断调参、优化，这个过程其实很折磨人。
我见过很多做AI的同事，每天也是写代码、调试、解决问题，和做CRUD的程序员没什么本质区别。
技术没有高低，只有适合不适合
我觉得技术本身没有高低之分，只有适合不适合。
CRUD适合的场景：
- 业务系统开发
- 企业内部系统
- 电商、金融等传统行业
AI适合的场景：
- 智能化应用
- 数据分析
- 内容生成
两者解决的是不同的问题，不能简单比较。
实际项目中的思考
我在实际项目中，两种都做过，有些感触：
做CRUD项目时：
- 重点在业务理解和系统设计
- 要考虑可维护性、可扩展性
- 要处理各种边界情况
- 要保证系统稳定运行
做AI项目时：
- 重点在数据质量和模型效果
- 要考虑成本控制
- 要处理模型不稳定的问题
- 要把AI能力和业务结合
两者都需要很强的技术能力，只是侧重点不同。
鄙视链的危害
鄙视链最大的危害是：
-
限制学习：觉得自己做的技术low，不愿意深入学习，结果技术一直停留在表面。
-
阻碍合作：互相瞧不起，不愿意合作，结果项目做不好。
-
心态问题：老是想着转行做"高级"的技术，结果本职工作做不好。
-
行业偏见：让新人觉得某些领域不值得做，影响行业发展。
我的建议
-
专注解决问题：技术是工具，关键是解决问题。不管是CRUD还是AI，能解决问题就是好技术。
-
保持学习：技术更新很快，要保持学习。做CRUD的可以学学AI，做AI的也可以学学业务系统开发。
-
尊重他人：每个领域都有高手，都有值得学习的地方。不要因为技术栈不同就瞧不起别人。
-
找到平衡：技术深度和广度要平衡。既要有专精的领域，也要了解其他领域。
聊聊职业发展
很多人觉得做CRUD没前途，想转AI。我觉得这个想法有问题。
CRUD的职业路径：
- 业务专家：深入理解某个行业的业务
- 架构师：设计大型分布式系统
- 技术管理：带领团队做项目
AI的职业路径：
- AI算法专家：深入研究模型和算法
- AI应用专家：把AI应用到实际业务
- AI平台开发：开发AI平台和工具
两条路径都有发展空间，关键是看自己适合什么。
实际案例
我认识几个同事：
同事A： 做CRUD出身，后来做了架构师，现在负责公司核心业务系统的架构设计，技术能力很强，业务理解也很深。
同事B： 做AI出身，后来转做业务系统，发现业务系统也有很多值得学习的地方，现在做技术管理，做得很好。
同事C： 一直做CRUD，但技术很深入，对业务理解也很到位，现在是业务专家，在公司很受重视。
他们都在自己的领域做得很好，没有谁比谁高级。
总结
程序员鄙视链确实存在，但我觉得没必要。技术没有高低之分，只有适合不适合。不管是做CRUD还是做AI，关键是：
- 解决问题：能用技术解决实际问题
- 持续学习：保持学习，跟上技术发展
- 深入理解：不仅要会用，还要理解原理
- 业务结合：技术和业务结合，创造价值
好了，今天就聊到这里。这只是我个人的看法，不一定对。如果你有不同的观点，欢迎在评论区讨论。
最后说一句，技术只是工具，人才是根本。不管做什么技术，保持学习，保持谦逊，才是最重要的。
深度剖析：CRUD的技术深度
很多人觉得CRUD就是简单的增删改查，这其实是最大的误解。让我用实际的代码来说明CRUD到底有多复杂。
一个"简单"的订单创建功能
看起来简单的创建订单，实际代码有多复杂：
@Service
@Transactional
public class OrderService {
@Autowired
private OrderRepository orderRepository;
@Autowired
private InventoryService inventoryService;
@Autowired
private PaymentService paymentService;
@Autowired
private MessageQueue messageQueue;
@Autowired
private DistributedLock distributedLock;
public Order createOrder(CreateOrderRequest request) {
// 1. 参数验证
validateRequest(request);
// 2. 防重复提交（分布式锁）
String lockKey = "order:create:" + request.getUserId() + ":" + request.getProductId();
try (DistributedLock lock = distributedLock.acquire(lockKey, 30, TimeUnit.SECONDS)) {
if (lock == null) {
throw new BusinessException("请求过于频繁，请稍后重试");
}
// 3. 库存检查（分布式锁）
Inventory inventory = inventoryService.checkAndLock(
request.getProductId(),
request.getQuantity()
);
// 4. 价格计算（考虑优惠券、会员折扣、促销活动）
OrderPrice price = calculatePrice(request, inventory);
// 5. 创建订单（数据库事务）
Order order = new Order();
order.setUserId(request.getUserId());
order.setProductId(request.getProductId());
order.setQuantity(request.getQuantity());
order.setPrice(price);
order.setStatus(OrderStatus.PENDING);
order = orderRepository.save(order);
// 6. 创建订单明细
List<OrderItem> items = createOrderItems(order, request);
orderItemRepository.saveAll(items);
// 7. 扣减库存（异步处理，避免阻塞）
inventoryService.decreaseStockAsync(inventory.getId(), request.getQuantity());
// 8. 发送消息队列（解耦）
messageQueue.sendOrderCreatedEvent(new OrderCreatedEvent(order));
// 9. 记录操作日志
logService.logOrderCreated(order, request);
return order;
} catch (Exception e) {
// 10. 异常处理和回滚
handleCreateOrderException(request, e);
throw e;
}
}
private OrderPrice calculatePrice(CreateOrderRequest request, Inventory inventory) {
// 基础价格
BigDecimal basePrice = inventory.getPrice().multiply(
BigDecimal.valueOf(request.getQuantity())
);
// 会员折扣
BigDecimal memberDiscount = memberService.calculateDiscount(
request.getUserId(),
basePrice
);
// 优惠券
BigDecimal couponDiscount = couponService.calculateDiscount(
request.getCouponId(),
basePrice.subtract(memberDiscount)
);
// 促销活动
BigDecimal promotionDiscount = promotionService.calculateDiscount(
request.getProductId(),
request.getQuantity(),
basePrice.subtract(memberDiscount).subtract(couponDiscount)
);
BigDecimal finalPrice = basePrice
.subtract(memberDiscount)
.subtract(couponDiscount)
.subtract(promotionDiscount);
return new OrderPrice(basePrice, memberDiscount, couponDiscount,
promotionDiscount, finalPrice);
}
}
这还只是创建订单，还没算上：
- 订单状态流转的状态机
- 分布式事务处理
- 最终一致性保证
- 幂等性处理
- 性能优化（缓存、分库分表）
- 监控和告警
这还叫"简单"吗？
高并发场景下的CRUD挑战
场景：秒杀系统
@Service
public class SeckillService {
// 分布式锁
@Autowired
private RedisDistributedLock distributedLock;
// 缓存
@Autowired
private RedisTemplate<String, Object> redisTemplate;
// 数据库
@Autowired
private ProductRepository productRepository;
// 消息队列
@Autowired
private RabbitTemplate rabbitTemplate;
public SeckillResult seckill(Long productId, Long userId) {
String lockKey = "seckill:lock:" + productId;
// 1. 获取分布式锁
try (DistributedLock lock = distributedLock.acquire(lockKey, 5, TimeUnit.SECONDS)) {
if (lock == null) {
return SeckillResult.fail("活动太火爆，请稍后重试");
}
// 2. 检查库存（Redis）
String stockKey = "seckill:stock:" + productId;
Long stock = redisTemplate.opsForValue().decrement(stockKey);
if (stock == null || stock < 0) {
// 库存回滚
redisTemplate.opsForValue().increment(stockKey);
return SeckillResult.fail("商品已售罄");
}
// 3. 防重复购买（Redis Set）
String userKey = "seckill:users:" + productId;
Boolean isNewUser = redisTemplate.opsForSet().add(userKey, userId.toString());
if (!isNewUser) {
// 库存回滚
redisTemplate.opsForValue().increment(stockKey);
return SeckillResult.fail("您已经参与过本次活动");
}
// 4. 异步处理订单（消息队列）
SeckillOrder order = new SeckillOrder();
order.setProductId(productId);
order.setUserId(userId);
order.setCreateTime(new Date());
rabbitTemplate.convertAndSend("seckill.exchange", "seckill.order", order);
// 5. 返回结果
return SeckillResult.success(order);
} catch (Exception e) {
log.error("秒杀失败", e);
return SeckillResult.fail("系统繁忙，请稍后重试");
}
}
}
这里涉及的技术：
- 分布式锁（Redis/Zookeeper）
- 缓存一致性
- 消息队列
- 限流和降级
- 数据库优化（读写分离、分库分表）
这些都是CRUD系统必须掌握的技术，一点都不简单。
CRUD系统的架构复杂度
一个中等规模的CRUD系统架构：
┌─────────────┐
│ CDN/负载均衡 │
└──────┬──────┘
│
┌──────▼──────┐
│ API Gateway │
└──────┬──────┘
│
┌───┴───┐
│ │
┌──▼──┐ ┌─▼──┐
│服务1│ │服务2│ (微服务)
└──┬──┘ └─┬──┘
│ │
┌──▼──┐ ┌─▼──┐
│ Redis│ │MQ │ (中间件)
└──┬──┘ └─┬──┘
│ │
┌──▼──────▼──┐
│ 数据库集群 │ (主从、分库分表)
└─────────────┘
这样的系统，需要掌握：
- 微服务架构
- 服务治理（注册发现、配置中心、链路追踪）
- 分布式事务
- 缓存策略
- 消息队列
- 数据库优化
- 监控和运维
深度剖析：AI开发的技术深度
很多人觉得AI开发就是调API，这也是误解。让我展示AI开发到底需要什么。
一个"简单"的AI应用需要什么
@Service
public class IntelligentOrderService {
// 1. 模型调用
@Autowired
private ChatClient chatClient;
// 2. 向量数据库
@Autowired
private VectorStore vectorStore;
// 3. Embedding模型
@Autowired
private EmbeddingClient embeddingClient;
// 4. 文档处理
@Autowired
private DocumentProcessor documentProcessor;
// 5. Prompt工程
@Autowired
private PromptEngineer promptEngineer;
// 6. 重排序模型
@Autowired
private RerankModel rerankModel;
public String intelligentOrderQuery(String question, Long userId) {
try {
// 1. 用户意图识别
String intent = recognizeIntent(question);
// 2. 根据意图选择策略
switch (intent) {
case "查询订单":
return queryOrderWithRAG(question, userId);
case "创建订单":
return createOrderWithAI(question, userId);
case "投诉建议":
return handleComplaintWithAI(question, userId);
default:
return handleGeneralQuery(question);
}
} catch (Exception e) {
log.error("智能查询失败", e);
return "抱歉，我现在无法处理您的请求，请稍后再试";
}
}
private String queryOrderWithRAG(String question, Long userId) {
// 1. 问题向量化
List<Double> questionEmbedding = embeddingClient.embed(question);
// 2. 检索相关文档（向量检索 + 关键词检索）
List<Document> vectorResults = vectorStore.similaritySearch(
SearchRequest.builder()
.withQuery(questionEmbedding)
.withTopK(10)
.build()
);
List<Document> keywordResults = keywordSearch(question);
// 3. 合并和去重
List<Document> combinedResults = mergeResults(vectorResults, keywordResults);
// 4. 重排序
List<Document> rerankedResults = rerankModel.rerank(question, combinedResults);
// 5. 选择Top K
List<Document> topDocs = rerankedResults.stream()
.limit(5)
.collect(Collectors.toList());
// 6. 构建Prompt
String context = buildContext(topDocs);
String prompt = promptEngineer.buildRAGPrompt(context, question);
// 7. 调用大模型
String response = chatClient.call(prompt);
// 8. 后处理（提取结构化信息）
return postProcessResponse(response);
}
private String recognizeIntent(String question) {
// 使用分类模型识别用户意图
String prompt = "判断以下问题的意图：\n问题：" + question +
"\n意图类别：查询订单、创建订单、投诉建议、其他";
String result = chatClient.call(prompt);
return extractIntent(result);
}
private List<Document> keywordSearch(String question) {
// Elasticsearch关键词检索
// ...
}
private String buildContext(List<Document> docs) {
return docs.stream()
.map(Document::getContent)
.collect(Collectors.joining("\n\n"));
}
private String postProcessResponse(String response) {
// 提取JSON、验证格式、安全检查等
// ...
}
}
这涉及的技术：
- 自然语言处理
- 向量数据库和检索
- Embedding模型
- Prompt工程
- 重排序模型
- 多模型协同
- 模型性能优化
AI开发的技术栈
一个完整的AI应用需要的技术栈：
模型层面：
- 大语言模型（GPT、Claude等）
- Embedding模型
- 重排序模型
- 分类模型
工程层面：
- 向量数据库（Milvus、Pinecone等）
- 文档处理（PDF、Word解析）
- 缓存策略（Token缓存、结果缓存）
- 流式处理
- 异步调用
优化层面：
- Prompt优化
- 模型微调
- 成本控制
- 性能优化
运维层面：
- 模型部署
- 监控告警
- A/B测试
- 版本管理
客观对比：技术难度分析
CRUD系统的技术难点
1. 并发控制
- 分布式锁
- 乐观锁/悲观锁
- CAS操作
- 事务隔离级别
2. 数据一致性
- ACID事务
- 分布式事务（2PC、TCC、Saga）
- 最终一致性
- 补偿机制
3. 性能优化
- 数据库优化（索引、SQL优化）
- 缓存策略（多级缓存、缓存穿透、缓存击穿、缓存雪崩）
- 分库分表
- 读写分离
- CDN加速
4. 系统设计
- 架构设计（微服务、DDD）
- 领域建模
- 接口设计
- 数据模型设计
AI开发的技术难点
1. 模型选择
- 模型评估
- 成本分析
- 性能对比
- 适用场景
2. Prompt工程
- Prompt设计
- Few-shot学习
- Chain of Thought
- 模板优化
3. RAG系统
- 文档分块策略
- 向量检索优化
- 重排序
- 混合检索
4. 工程化
- 模型部署
- 流式处理
- 错误处理
- 监控告警
5. 成本控制
- Token计算
- 缓存策略
- 模型选择
- 请求优化
真实项目案例对比
案例1：电商系统（CRUD）
项目规模：
- 用户量：1000万+
- 日订单量：50万+
- 峰值QPS：10万+
技术挑战：
- 高并发：秒杀活动，瞬时QPS达到20万+
- 数据一致性：订单、库存、支付的一致性保证
- 性能优化：数据库查询优化，缓存策略
- 系统稳定性：99.99%可用性要求
技术方案：
// 核心代码示例
@Service
public class SeckillOptimizedService {
// 使用Lua脚本保证原子性
private static final String SECKILL_SCRIPT =
"local stock = redis.call('get', KEYS[1]) " +
"if stock and tonumber(stock) > 0 then " +
" redis.call('decr', KEYS[1]) " +
" redis.call('sadd', KEYS[2], ARGV[1]) " +
" return 1 " +
"else " +
" return 0 " +
"end";
public SeckillResult seckill(Long productId, Long userId) {
// Redis Lua脚本保证原子性
Long result = redisTemplate.execute(
new DefaultRedisScript<>(SECKILL_SCRIPT, Long.class),
Arrays.asList("stock:" + productId, "users:" + productId),
userId.toString()
);
if (result == 1) {
// 异步创建订单
asyncCreateOrder(productId, userId);
return SeckillResult.success();
} else {
return SeckillResult.fail("商品已售罄");
}
}
}
项目成果：
- 秒杀成功率：99.5%+
- 系统可用性：99.99%
- 响应时间：平均50ms
案例2：智能客服系统（AI）
项目规模：
- 日均咨询量：10万+
- 支持的意图：50+
- 准确率要求：85%+
技术挑战：
- 意图识别准确率：需要达到90%+
- 上下文理解：多轮对话的上下文管理
- 知识库构建：10万+文档的向量化
- 响应速度：要求<2秒
技术方案：
@Service
public class IntelligentCustomerService {
// 多模型协同
@Autowired
private IntentClassifier intentClassifier; // 意图分类
@Autowired
private ChatClient chatClient; // 对话模型
@Autowired
private VectorStore vectorStore; // 知识库
@Autowired
private ConversationManager conversationManager; // 对话管理
public ChatResponse chat(String question, String sessionId) {
// 1. 加载对话历史
List<Message> history = conversationManager.getHistory(sessionId);
// 2. 意图识别
Intent intent = intentClassifier.classify(question, history);
// 3. 根据意图选择策略
String response;
switch (intent.getType()) {
case KNOWLEDGE_QUERY:
// 知识库检索 + RAG
response = queryKnowledgeBase(question, intent);
break;
case ORDER_QUERY:
// 订单查询 + 结构化输出
response = queryOrder(question, intent, sessionId);
break;
case COMPLAINT:
// 投诉处理 + 情感分析
response = handleComplaint(question, intent, sessionId);
break;
default:
// 通用对话
response = generalChat(question, history);
}
// 4. 保存对话历史
conversationManager.addMessage(sessionId, question, response);
return new ChatResponse(response, intent);
}
private String queryKnowledgeBase(String question, Intent intent) {
// RAG检索
List<Document> docs = vectorStore.similaritySearch(question, 5);
String context = buildContext(docs);
// 构建Prompt
String prompt = String.format(
"基于以下知识库内容回答问题：\n\n%s\n\n问题：%s\n\n回答：",
context, question
);
return chatClient.call(prompt);
}
}
项目成果：
- 意图识别准确率：92%
- 问题解决率：85%+
- 平均响应时间：1.5秒
- 用户满意度：4.5/5
薪资和职业发展对比
CRUD开发者的职业路径
初级（1-3年）：
- 薪资范围：10-20K
- 技能要求：Spring、MyBatis、MySQL、Redis
- 工作内容：功能开发、Bug修复
中级（3-5年）：
- 薪资范围：20-35K
- 技能要求：微服务、分布式、高并发、性能优化
- 工作内容：模块设计、技术选型、问题排查
高级（5-8年）：
- 薪资范围：35-60K
- 技能要求：架构设计、技术规划、团队管理
- 工作内容：架构设计、技术攻关、团队培养
专家/架构师（8年+）：
- 薪资范围：60K+
- 技能要求：领域专家、技术深度和广度
- 工作内容：技术战略、架构演进、技术研究
AI开发者的职业路径
初级（1-2年）：
- 薪资范围：15-25K
- 技能要求：Python、机器学习基础、API调用
- 工作内容：模型调用、数据处理、简单应用
中级（2-4年）：
- 薪资范围：25-45K
- 技能要求：深度学习、NLP、模型优化、工程化
- 工作内容：模型训练、系统设计、性能优化
高级（4-6年）：
- 薪资范围：45-80K
- 技能要求：算法研究、系统架构、团队管理
- 工作内容：算法研究、架构设计、技术规划
专家/研究员（6年+）：
- 薪资范围：80K+
- 技能要求：学术研究、算法创新、领域专家
- 工作内容：算法研究、技术突破、论文发表
市场趋势分析
CRUD开发者：
- 市场需求：稳定，但竞争激烈
- 发展空间：从业务开发到架构师，路径清晰
- 技术更新：相对稳定，主要是框架升级
AI开发者：
- 市场需求：快速增长，但波动较大
- 发展空间：从应用开发到算法研究，路径多样
- 技术更新：快速迭代，需要持续学习
如何选择适合自己的方向？
评估维度
1. 兴趣和天赋
- 喜欢解决业务问题 → CRUD
- 喜欢算法和模型 → AI
2. 学习能力
- 喜欢深入钻研 → AI（需要持续学习）
- 喜欢稳定发展 → CRUD
3. 职业规划
- 想做架构师 → CRUD路径更清晰
- 想做算法专家 → AI路径更适合
4. 市场情况
- 追求稳定 → CRUD
- 追求高薪和挑战 → AI
我的建议
如果你刚入行：
- 先做CRUD，打好基础（数据结构、算法、系统设计）
- 再考虑是否转AI
如果你有经验：
- 可以两个方向都了解
- 根据项目需求选择
- 不要局限在一个方向
如果你已经确定方向：
- 深入学习，成为专家
- 同时了解其他方向，拓宽视野
破除鄙视链：共同成长
技术是相通的
不管是CRUD还是AI，都需要：
- 扎实的编程基础
- 良好的系统设计能力
- 问题分析和解决能力
- 持续学习的能力
互相学习
CRUD开发者可以向AI开发者学习：
- 算法思维
- 数据处理能力
- 模型思维
AI开发者可以向CRUD开发者学习：
- 工程化能力
- 系统设计能力
- 业务理解能力
未来趋势：融合
未来的开发，可能是：
- CRUD + AI：智能化业务系统
- AI + 工程化：可落地的AI应用
两者融合是大趋势，没必要分那么清楚。
总结
程序员鄙视链确实存在，但其实没必要。不管是CRUD还是AI：
- 都有技术深度：都需要很强的技术能力
- 都有发展空间：都有清晰的职业路径
- 都在创造价值：都在解决实际问题
- 都需要持续学习：技术更新都很快
关键是：
- 找到适合自己的方向
- 深入学习，成为专家
- 保持开放，互相学习
- 关注价值，而非标签
好了，今天就聊到这里。这只是我个人的看法，不一定对。如果你有不同的观点，欢迎在评论区讨论。技术只是工具，人才是根本。不管做什么技术，保持学习，保持谦逊，才是最重要的。
有“AI”的1024 = 2048，欢迎大家加入2048 AI社区
更多推荐
13
0- 0
已为社区贡献30条内容
所有评论(0)