Concept‑Driven Software Design: From Daniel Jackson’s “Concept” to Business‑Service‑Driven Development with AI Assistance

The author reviews Daniel Jackson’s talk at the 2024 Global Software R&D Conference, where Jackson proposes a “concept”‑based software design that treats software features as distinct concepts such as meeting links or video channels, illustrated with Zoom, Calendly and iPod examples.

These concepts are compared to domain‑driven design (DDD) elements: domain concepts (e.g., meeting link, video channel) and domain behaviors (e.g., user authentication), with innovative concepts mapped to core sub‑domains and generic concepts to shared sub‑domains.

By interpreting Jackson’s “concept” as a business service, the author aligns it with DDD terminology, defining a business service as an API‑exposed operation that encapsulates a complete interaction between a participant and a target system.

Using an AI prompt, the article extracts domain concepts from a sample “submit order” requirement and generates Java domain‑layer code, including classes Buyer , Product , OrderItem , Order , Cart , and OrderService that implement the core workflow.

// Buyer (买家)
public class Buyer {
    private String id;
    private String name;
    private String contactInfo;
    private String deliveryAddress;
    // getters and setters
}

// Product (商品)
public class Product {
    private String id;
    private String name;
    private int stockQuantity;
    public boolean isAvailable(int quantity) {
        return stockQuantity >= quantity;
    }
    // getters and setters
}

// OrderItem (订单项)
public class OrderItem {
    private Product product;
    private int quantity;
    public OrderItem(Product product, int quantity) {
        if (!product.isAvailable(quantity)) {
            throw new IllegalArgumentException("商品库存不足");
        }
        this.product = product;
        this.quantity = quantity;
    }
    // getters and setters
}

// Order (订单)
public class Order {
    private String id;
    private Buyer buyer;
    private List<OrderItem> items;
    private String status;
    public Order(Buyer buyer, List<OrderItem> items) {
        this.buyer = buyer;
        this.items = items;
        this.status = "已提交";
    }
    // getters and setters
}

// Cart (购物车)
public class Cart {
    private List<OrderItem> items = new ArrayList<>();
    public void addItem(OrderItem item) { items.add(item); }
    public void removeItem(OrderItem item) { items.remove(item); }
    public List<OrderItem> getItems() { return items; }
}

// OrderService (业务服务)
public class OrderService {
    public Order submitOrder(Buyer buyer, Cart cart) {
        if (cart.getItems().isEmpty()) {
            throw new IllegalArgumentException("购物车为空，无法提交订单");
        }
        List<OrderItem> orderItems = new ArrayList<>();
        for (OrderItem item : cart.getItems()) {
            if (!item.getProduct().isAvailable(item.getQuantity())) {
                throw new IllegalArgumentException("商品 " + item.getProduct().getName() + " 缺货");
            }
            orderItems.add(item);
        }
        Order order = new Order(buyer, orderItems);
        // persist order, remove items from cart, lock inventory, notify buyer
        return order;
    }
}

A second AI prompt asks for a RESTful backend implementation; the response provides a Spring‑Boot controller that receives an OrderRequest , constructs the domain objects, invokes OrderService.submitOrder , and returns appropriate HTTP status codes.

@RestController
@RequestMapping("/api/orders")
public class OrderController {
    private final OrderService orderService;
    @Autowired
    public OrderController(OrderService orderService) { this.orderService = orderService; }

    @PostMapping("/submit")
    public ResponseEntity<Order> submitOrder(@RequestBody OrderRequest orderRequest) {
        try {
            Buyer buyer = new Buyer();
            buyer.setId(orderRequest.getBuyerId());
            buyer.setContactInfo(orderRequest.getContactInfo());
            buyer.setDeliveryAddress(orderRequest.getDeliveryAddress());
            Cart cart = new Cart();
            for (OrderItemRequest itemReq : orderRequest.getItems()) {
                Product product = new Product();
                product.setId(itemReq.getProductId());
                product.setStockQuantity(itemReq.getQuantity()); // placeholder
                OrderItem orderItem = new OrderItem(product, itemReq.getQuantity());
                cart.addItem(orderItem);
            }
            Order order = orderService.submitOrder(buyer, cart);
            return new ResponseEntity<>(order, HttpStatus.CREATED);
        } catch (IllegalArgumentException e) {
            return new ResponseEntity<>(null, HttpStatus.BAD_REQUEST);
        }
    }
}

class OrderRequest { /* fields, getters, setters */ }
class OrderItemRequest { /* fields, getters, setters */ }

The article then expands the discussion to an AI‑driven “service storm” process with twelve steps, introduces a DDD‑Agent concept, and outlines the roles of domain experts, AI agents, and development teams in iteratively refining models and generating code.

Finally, it reflects on the feasibility of training large language models with DDD knowledge and improving interaction capabilities to automate much of the software development workflow.