Writing enterprise software - A Rust experiment

Rust has more to bring to the table than performance and tight control over resources.
Luca Palmieri will walk us through the implementation of a Realworld backend service using Rust (Tide + Diesel), with a focus on the opportunities opened up by the Rust type system for domain modelling, API design and communicating intent when writing enterprise software.

www.lpalmieri.com/

Transcript

1. Writing Enterprise Software A Rust experiment Luca Palmieri @algo_luca / LukeMathWalker
2. What is Enterprise Software? @algo_luca lpalmieri.com
3. What is Enterprise Software? Enterprise software is the art and craft of formalising processes as code. @algo_luca lpalmieri.com
4. Corollary Enterprise software developers are bureaucrats, version 2.0 @algo_luca lpalmieri.com
5. What are the challenges? Understanding the underlying business domain. @algo_luca lpalmieri.com
6. What are the challenges? Processes change over time. @algo_luca lpalmieri.com
7. What are the challenges? Different expertises have to cooperate. @algo_luca lpalmieri.com
8. What are the challenges? People come and go. The code stays. In production. @algo_luca lpalmieri.com
9. What do we need? We’d like correct code which is expressive enough to model the domain and supple enough to support its evolution over time. (Yes, it should also be executable by a machine) @algo_luca lpalmieri.com
10. @algo_luca lpalmieri.com
11. Why Rust? • Powerful type-system • Great modularity (traits) • Vibrant community • Solid tooling … • Great performance @algo_luca lpalmieri.com
12. Are you sure? Rust is great, but… <Risk> @algo_luca lpalmieri.com
13. De-risking: a “toy” project! @algo_luca lpalmieri.com “The mother of all demo apps”
14. De-risking: a “toy” project! @algo_luca lpalmieri.com ...and many more
15. De-risking: a “toy” project! @algo_luca lpalmieri.com https://demo.realworld.io
16. Realworld-tide @algo_luca lpalmieri.com
17. The architecture @algo_luca lpalmieri.com Db Domain Web Repository Commands Postgres SQL REST API Uses Tide Uses Diesel depends on depends on The application
18. Domain The persistence layer @algo_luca lpalmieri.com Db Repository Postgres SQL Uses Diesel Web Commands REST API Uses Tide depends on depends on
19. Persistence-layer | The ORM @algo_luca lpalmieri.com https://diesel.rs
20. ORM/Diesel | SQL-first migrations @algo_luca lpalmieri.com CREATE TABLE articles ( title VARCHAR(255) NOT NULL, slug VARCHAR(255) PRIMARY KEY, description VARCHAR(1024) NOT NULL, body TEXT NOT NULL, tag_list TEXT[] NOT NULL, user_id UUID NOT NULL, created_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP, updated_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP, FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE ); SELECT diesel_manage_updated_at('articles');
21. ORM/Diesel | Compile-time checks @algo_luca lpalmieri.com table! { articles (slug) { title :> Varchar, slug :> Varchar, description :> Varchar, body :> Text, tag_list :> Array<Text>, user_id :> Uuid, created_at :> Timestamptz, updated_at :> Timestamptz, } }
22. ORM/Diesel | Query builder @algo_luca lpalmieri.com pub fn update(repo: &Repo, user_id: Uuid, details: UpdateUser) :> Result<User, Error> { use crate::schema::users::dsl::*; diesel::update(users.find(user_id)) .set(&details) .get_result(&repo.conn()) }
23. ORM/Diesel | Compilation time @algo_luca lpalmieri.com cargo +nightly build -Z timings
24. Persistence-layer | Inversion of control @algo_luca lpalmieri.com Repository trait, defined in the domain layer. pub trait Repository { fn find_articles(&self, query: ArticleQuery) :> Result<Vec<Article>, DatabaseError>; fn feed(&self, user: &User, query: FeedQuery) :> Result<Vec<ArticleView>, DatabaseError>; fn delete_article(&self, article: &Article) :> Result<(), DatabaseError>; ::. }
25. The domain layer @algo_luca lpalmieri.com Db Domain Web Repository Commands Postgres SQL REST API Uses Tide Uses Diesel depends on depends on
26. We can leverage the type system to represent the constraints of our domain, making incorrect state difficult or impossible to represent. Designing with types (F# for fun and profit) Domain Modeling Made Functional (Scott Wlaschin) Parse, don’t validate (Alexis King) Domain-layer | Type-driven development @algo_luca lpalmieri.com
27. Domain-layer | Control over mutability @algo_luca lpalmieri.com :[derive(Clone, Debug, PartialEq)] pub struct ArticleContent { pub title: String, pub description: String, pub body: String, pub tag_list: Vec<String>, } impl ArticleContent { ::/ Convert a title into a url-safe slug pub fn slug(&self) :> String { self.title .to_ascii_lowercase() .split_ascii_whitespace() .join("-") } }
28. Domain-layer | Semantic usage of ownership @algo_luca lpalmieri.com :[derive(Clone, Debug, PartialEq)] pub struct Password(String); impl Password { ::/ Given a clear-text password, it returns a `Password` instance ::/ containing the password's hash. ::/ The clear text password is consumed. pub fn from_clear_text(clear_text_password: String) :> Result<Password, PasswordError> { let hash = bcrypt::hash(clear_text_password, 4)?; Ok(Password(hash)) } }
29. Domain-layer | Meaningful signatures @algo_luca lpalmieri.com fn publish_article( &self, draft: ArticleContent, author: &User, ) :> Result<Article, PublishArticleError>;
30. Domain-layer | Error as values @algo_luca lpalmieri.com :[derive(thiserror::Error, Debug)] pub enum PublishArticleError { :[error("There is no author with user id {author_id:?}.")] AuthorNotFound { author_id: Uuid, :[source] source: GetUserError, }, :[error("There is already an article using {slug:?} as slug. Change title!")] DuplicatedSlug { slug: String, :[source] source: DatabaseError, }, :[error("Something went wrong.")] DatabaseError(:[from] DatabaseError), }
31. The API layer @algo_luca lpalmieri.com Db Domain Web Repository Commands Postgres SQL REST API Uses Tide Uses Diesel depends on depends on
32. API-layer | De/Serialization @algo_luca lpalmieri.com :[derive(Serialize, Deserialize, Clone, Debug)] :[serde(rename_all = "camelCase")] pub struct Comment { pub id: u64, pub created_at: DateTime<Utc>, pub updated_at: DateTime<Utc>, pub body: String, pub author: Author, } impl From<domain::Comment> for Comment { fn from(c: domain::Comment) :> Self { Self { id: c.id, body: c.body, created_at: c.created_at, updated_at: c.updated_at, author: c.author.into(), } } }
33. API-layer | State management @algo_luca lpalmieri.com ::/ The shared state of our application. ::/ It's generic with respect to the actual implementation of the repository: ::/ this enables swapping different implementations, both for production usage ::/ or ease of testing (mocks and stubs). pub struct Context<R: 'static + Repository + Sync + Send> { pub repository: R, }
34. API-layer | State management @algo_luca lpalmieri.com pub async fn tags<R: ::.>(cx: Request<Context<R:>) :> Result<Response, ErrorResponse> { let repository = &cx.state().repository; ::. } pub fn get_app<R: Repository + Send + Sync>(repository: R) :> Server<Context<R:> { let context = Context { repository }; let mut app = Server::with_state(context); app = add_middleware(app); app = add_routes(app); app }
35. API-layer | Routing @algo_luca lpalmieri.com api.at("/api/user") .get(|req| async move { result_to_response(crate::users::get_current_user(req).await) }) .put(|req| async move { result_to_response(crate::users::update_user(req).await) });
36. API-layer | Black-box testing @algo_luca lpalmieri.com pub type TestServer = TestBackend<Service<Context<Repository::>; pub struct TestApp { pub server: TestServer, pub repository: Repository, } impl TestApp { pub fn new() :> Self { let app = get_app(get_repo()); let server = make_server(app.into_http_service()).unwrap(); Self { server, repository: get_repo(), } } }
37. API-layer | Black-box testing @algo_luca lpalmieri.com pub async fn get_current_user(&mut self, token: &String) :> Result<UserResponse, Response> { let auth_header = format!("token: {}", token); let response = self .server .simulate( http::Request::get("/api/user") .header("Authorization", auth_header) .body(http_service::Body::empty()) .unwrap(), ) .unwrap(); response_json_if_success(response).await }
38. Wrapping up @algo_luca lpalmieri.com
39. Ask me anything! Luca Palmieri @algo_luca / LukeMathWalker
40. Designing with types (F# for fun and profit) Domain Modeling Made Functional (Scott Wlaschin) Parse, don’t validate (Alexis King) Ferris’ doodles (Esther Arzola) References @algo_luca lpalmieri.com