Rust is a unique programming language that blends imperative and functional concepts to make low-level systems safer. However, compared to other modern languages, designing APIs in Rust requires a fundamentally different mindset -- for example, designing without classes or inheritance. In this talk, I will live-code the design of a simple Rust API. Through the evolution of the API, I will demonstrate how Rust’s type system (especially traits) can be used to design interfaces that cleanly compose with existing code, and that help API clients catch mistakes at compile-time.

Will Crichton
Stanford University
@wcrichton

Will Crichton is a 6th year CS Ph.D. student at Stanford University advised by Profs. Pat Hanrahan and Maneesh Agrawala. His research is about applying cognitive psychology and programming language theory to understand programmers and to design better programming tools.

Recorded at Strange Loop 2021
thestrangeloop.com

As Rust is a young language containing many innovative features, questions about how to structure Rust libraries and API's are common. Heavy use of metaprogramming and trait constraints can make libraries hard to understand and use, but also bring great power to reason about programs at compile-time. How do you design a library that exploits the power of Rust without making new users say 'This is way too complicated to bother with'? We will discuss these issues using an existing Rust crate as a case study in both designing an API and how it is influenced by the API decisions of the crates it uses as dependencies.

---

Simon is a recovering geologist who has always been interested in programming and a general language nerd, and now works as a software engineering consultant. He started using Rust seriously shortly after the 1.0 release and is interested in using it in video games, operating systems and distributed network infrastructure.

In this video, we’ll give an overhaul to newsapi in terms of the public API and remove a few rough edges and also integrate an async fetch method. This is in continuation of exploratory style videos that am making on Rust. Future videos will dive deeper into language features.

Previous video in the series: youtube.com/watch?v=LHPV3z9OSic

(Repository link)

Checkout tag `ep06` for changes so far: github.com/creativcoder/clinews/releases/tag/ep06

Timecodes:
0:00 - Prologue
0:50 - Overview
2:48 - A top level NewsAPI struct
5:27 - Builder pattern for methods
5:59 - A helper prepare_url method

9:00 - Implementing the ToString trait
9:28 - Match in Rust
10:48 - Add fetch method and pass API_KEY as authorization header
12:20 - Using #[from] for terse error type mapping
13:08 - Defining an error mapper
14:58 - Trying out the new API
17:13 - Implementing getters for Article aka encapsulation
18:11 - It works!!
18:27 - Adding fetch_async method

20:36 - Putting fetch_async behind feature flags
21:34 - Trying out fetch_async using tokio
24:07 - Outro

Target audience: Programmers who are new to Rust and want a bird’s eye overview of the development experience in Rust.

A few resources:

url: docs.rs/url/2.2.2/url/
reqwest: github.com/seanmonstar/reqwest

builder pattern: doc.rust-lang.org/1.0.0/style/ownership/builders.html
authorization header: developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Authorization

Tokio: tokio.rs/
async-std: async.rs/
smol: github.com/smol-rs/smol
thiserror: docs.rs/thiserror/1.0.29/thiserror/

This series is aimed at programmers who already have some experience with at
least one imperative language such as Python or C/C++, but who are new to Rust.

What is Rust and why should you invest time in learning it?

Rust is the most loved programming language according to the Stack Overflow survey for 6th year in a row (2016-2021).
Read more in the following blog:
stackoverflow.blog/2020/06/05/why-the-developers-who-use-rust-love-it-so-much/

Thanks for watching!

This channel is dedicated in helping people become better at programming.

Social Platforms:
🐤 Twitter: twitter.com/creativcoder
📒 GitHub: github.com/creativcoder
📗 Polywork: polywork.com/creativcoder
🕸️ Blog: creativcoder.dev

Free and open source software that I use:
🌐 Firefox: mozilla.org/en-US/exp/
📽️ Open Broadcaster Software: obsproject.com
🎬 Kdenlive: kdenlive.org
🎨 GIMP: gimp.org/
🔊 Audacity: audacityteam.org/
🖌️ MyPaint: mypaint.org/

Your support is very much appreciated.

Have a great day!

Evolving API design in Rust
Rust Vs. Haskell: Which Language is Best for API Design?
☞ morioh.com/p/f40873a1cf47

Why you should move from Node.js to Rust in 2019
☞ morioh.com/p/79aaf93ed93a

The Rust Programming Language
☞ learnstartup.net/p/cCYORs_kj

An introduction to Web Development with Rust for Node.js Developers
☞ morioh.com/p/81bce2efcb4f

Rust for IOT
☞ morioh.com/p/82c997985e81

7 reasons why you should learn Rust programming language in 2019
☞ morioh.com/p/96fe5f027715

The Rust developers should Know top 8 Rust IDE & text Editors
☞ morioh.com/p/2070bc0d12b2

As Rust is a young language containing many innovative features, questions about how to structure Rust libraries and API's are common. Heavy use of metaprogramming and trait constraints can make libraries hard to understand and use, but also bring great power to reason about programs at compile-time. How do you design a library that exploits the power of Rust without making new users say 'This is way too complicated to bother with'? We will discuss these issues using an existing Rust crate as a case study in both designing an API and how it is influenced by the API decisions of the crates it uses as dependencies.

#Rust #API #Morioh

Originally published at youtube.com/watch?v=Xt1JOVeQ5hw
------------------------------------------------------------------------------------
Social Network for Developers: bit.ly/2M1cxD2
Developer's Store: bit.ly/2L27JNR
Learn Startup: bit.ly/2UDotMN
Learn to code: bit.ly/2pN2aXx
Fanpage: bit.ly/2LyM4fJ
Twitter: bit.ly/2J7vCS0

Check out Bastian Gruber's book 📖 Rust Web Development | mng.bz/KBKK ​ 📖 To save 40% off this book ⭐ DISCOUNT CODE: watchgruber40 ⭐ Learn web development with Rust! In this video, Bastian shows how to choose a runtime and a web framework, create your first REST endpoint, enable logging, and create a multi-platform binary for production deployment.

📚📚📚
Rust Web Development | mng.bz/KBKK
To save 40% off this book use discount code: watchgruber40
📚📚📚

About the book:
In Rust Web Development, you’ll learn to build server-side web applications using the Rust language and its key libraries. If you know the basics of Rust, you’ll quickly pick up some pro tips for setting up your projects and organizing your code. This book gets you hands-on fast, with numerous small and large examples. You’ll get up to speed with how Rust streamlines backend development, implements authentication flows, and even makes it easier for your APIs to interact. As you go, you’ll build a complete Q&A web service and iterate on your code chapter-by-chapter, just like a real development project.

About the author:
Bastian Gruber is a Solutions Architect at Twilio Inc. He was part of the official Rust Async Working group, and founded the Rust and Tell Berlin MeetUp group. He has worked for one of the world’s largest Digital Currency exchanges, using Rust on its core backend. He has over twelve years of experience as a writer, and blogs regularly on Rust for LogRocket, his own blog, and other magazines and news outlets.

****
INTERESTED IN THE STOCK MARKET?
I developed a profitable trading model that generates high probability BUY & SELL signals on S&P500. To learn about it, visit yuriymatso.com/sp500-model/

An overview of one of the fastest web frameworks available today - Actix Web. To get a feel for the developer experience it provides, we walk through building a task management REST service.

00:00 Overview
00:53 Project Creation / Directory Structure
01:38 Cargo.toml
02:40 Main.rs Iteration 1
05:36 API Module Iteration 1
06:45 Responders
07:30 Extractors
09:52 Integrating with DynamoDB
11:23 Injecting DDB Client Into Handler Functions
14:07 Model Module
17:32 API Module Iteration 2
18:41 Error Handling
21:34 API Module Iteration 2 Cont.
29:36 Main.rs Iteration 2
30:00 Testing
31:11 Conclusion & Review

Stuff I use to make these videos - I absolutely love all of these products. Using these links is an easy way and free way to support the channel, thank you so much if you do so!!!

Camera: Canon EOS R5 amzn.to/3CCrxzl
Monitor: Dell U4914DW 49in amzn.to/3MJV1jx
Lens: Sigma 24mm f/1.4 DG HSM Art for Canon EF amzn.to/3hZ10mz
SSD for Video Editing: VectoTech Rapid 8TB amzn.to/3hXz9TM
Microphone: Rode NT1-A amzn.to/3vWM4gL
Microphone Interface: Focusrite Clarett+ 2Pre amzn.to/3J5dy7S
Tripod: JOBY GorillaPod 5K amzn.to/3JaPxMA
Keyboard: Redragon Mechanical Gaming Keyboard amzn.to/3I1A7ZD
Mouse: Razer DeathAdder amzn.to/3J9fYCf
Computer: 2021 Macbook Pro amzn.to/3J7FXtW

Caffeine: High Brew Cold Brew Coffee amzn.to/3hXyx0q
More Caffeine: Monster Energy Juice, Pipeline Punch amzn.to/3Czmfox

The full code for this project can be found here: github.com/Me163/youtube/tree/main/ActixWebTaskService

Source code from video available at github.com/iferc/basic-rocket-web-server

This video is the first part of a Rust API project. In this video, we build our Database with Diesel.

Source Code: github.com/tensor-programming/rust_api_part_1

Production-ready APIs in Rust. Learn how to create microservice-based architecture using Rust.
The Rust developers should Know top 8 Rust IDE & text Editors
☞ morioh.com/p/2070bc0d12b2
Rust vs C++ | Which is Better and Why?
☞ morioh.com/p/b9fd052843b5
Programming in Rust: the good, the bad, the ugly
☞ morioh.com/p/29454cbeb326

00:00:00 Start
00:01:28 Intro
00:02:14 Agenda
00:03:25 About Erich
00:04:36 Books for learning
00:06:01 About Bippit
00:07:26 Technical goals
00:10:36 Building the platform
00:13:59 Web framework
00:16:29 Database layer
00:20:11 Network calls
00:27:26 HTTPS client and async/await
00:32:05 What makes Rust special?
00:34:21 Takeaways
00:42:45 What's next?
00:44:58 Q&A
00:45:17 Q: What are you looking for in hires?
00:46:51 Q: When do you see a Rails-like solution on Rust?

#Rust #Programming #Developer

PUBLICATION PERMISSIONS:
Original video was published with the Creative Commons Attribution license (reuse allowed).
Link: youtube.com/watch?v=_L41ze88pls
------------------------------------------------------------------------------------
Social Network for Developers: bit.ly/2R1Lw31
Developer's Store: bit.ly/2L27JNR
Fanpage: bit.ly/2LyM4fJ
Twitter: bit.ly/2J7vCS0

Today we are discussing what kind of programs you can build using Rust!

📝 Get notified when the Rust Cheatsheet comes out: letsgetrusty.com/cheatsheet

Small introductory video for the Komodo-Rust-API that we build as a senior design project (Spring2020) at University of Texas at Arlington.

The Rust Komodo API is here to supply Rust developers with the opportunity to create applications that use the Komodo Blockchain without having to understand the inner workings of the blockchain itself. With our built-in methods and configuration file, any developer will be able to call the functions they need using the natural input style of Rust and the API will convert it into a usable input of Komodo and return the output to the developer. Using a simple web application, we are able to show the basic functionality of the API in a currency trading app. Without having to know how Komodo’s blockchain takes input when accessing the wallet, we can see our balance, send money, and request money from another user within our chain.

GitHub for Komod-Rust-API: github.com/sudipghale/Komodo-RPC-API-Rust
GitHub for Kpay app: github.com/sudipghale/Komodo-Web-APP

@teams:
Sudip Ghale,
Scott Gouldsbrough
Kenny Huynh
Ashish Mainali

Many Thanks to our:
Sponser : Dr Sajib Datta
Mentors: Vaibhab Murkute, Chris
Giffy, Aditya Rajguru

In this video I use the Rust Reqwest crate to fetch some data from a REST API!

We also pull environment variables from a .env file using the dotenv crate and deserialize our response using the serde crate

Crates Used:
reqwest: github.com/seanmonstar/reqwest
dotenv: npmjs.com/package/dotenv
serde: github.com/serde-rs/serde

VSCode Theme (GrayJack): marketplace.visualstudio.com/items?itemName=GrayJack.monokai-grayjack

today I go over how to build an HTTP server in Rust with Rocket.rs! Rocket.rs is a simple server framework similar to Python's Flask or Ruby's Sinatra. It was built by a dude named Sergio Benitez.

-- Music --
Joakim Karud - Clouds
Loxbeats - Skydive

-- Social Media --
Twitter: twitter.com/alugocp/
Instagram: instagram.com/alugocp1/
Reddit: reddit.com/user/alugocp
GitHub: github.com/alugocp/

Web APIs with Rust Rocket
Is Rust only relevant for systems programming? Do you need platforms like Go or Node.js to build great web APIs? Rainer has been building cloud-based distributed systems for many years and for this Rust Linz meetup he looked into the Rocket framework. He will give a short introduction and compare it to frameworks he knows from other programming languages.

About Rainer Stropek ( twitter.com/rstropek)
Rainer Stropek is co-founder and CEO of the company software architects and has been serving this role since 2008. At software architects, Rainer and his team are developing the award-winning SaaS time tracking solution “time cockpit”. Previously, Rainer founded and led two IT consulting firms that worked in the area of developing software solutions based on the Microsoft technology stack.

Rust Linz at rust-linz.at
Twitter: twitter.com/rustlinz
Speak at Rust Linz: sessionize.com/rust-linz

Rust for Web Development - A full introduction to Warp by example, a filter based Web Framework.

GitHub Source: github.com/jeremychone-channel/rust-warp-intro

00:00 - Intro
00:27 - Setup
00:59 - Hello World Filter
02:10 - VS Code Rest Client
03:52 - HI Api (first path)
07:55 - Static File Serving
11:33 - Rest API - Todo List
14:02 - Async Closure
15:26 - Async Filter Function
16:04 - JSON Result
17:34 - Todo Get API
20:43 - Todo Create API (Body Parsing)
23:16 - Custom Filter (Request Authentication)
27:45 - Request/Filter Exception Handling
29:01 - Extract Request Data (e.g., User Context)
32:31 - Global Resource Injection
35:30 - Don't forget

In this video, we'll explore async/await in Rust using the tokio library, and create a minimalistic event dispatching API.

---
Links:

Incident Github: github.com/mbolt35/incident
tokio: tokio.rs/

---
Chapters:

0:00 Intro
0:44 Trying Something New
0:02:33 Creating GitHub Repo
0:04:50 Cargo Init
0:07:07 Tokio Test Bootstrap
0:10:09 Basic Events API Design
0:15:40 Implementation
0:38:10 Writing the Test
0:47:34 Multithreaded Tokio Test
0:50:34 API Improvement
0:54:26 Update Test
0:59:55 Test Success
1:00:40 Possible Improvements and Farewell

The ultimate Rust lang tutorial. Follow along as we go through the Rust lang book chapter by chapter.

📝 Get notified when the Rust Cheatsheet comes out: letsgetrusty.com/cheatsheet

The Rust book: doc.rust-lang.org/stable/book/​​

Chapters:
0:00​ Intro
0:27 Object-Oriented Design Pattern
3:00 Defining Post
5:15 Storing Text
6:18 Content Method
6:59 Requesting a Review
10:27 Adding the Approve Method
14:48 Trade-offs of the State Pattern
15:48 Encoding States and Behavior as Types
19:39 Outro

#letsgetrusty​​ #rust​lang​ #tutorial

Today we will be discussing how to parse JSON in Rust using serde and reqwest!

📝Get your FREE Rust cheat sheet :
letsgetrusty.com/cheatsheet

code: github.com/letsgetrusty/json_parsing_example

Rust Programming Web Development Tutorial for building a simple Web Application, the Todo App (TodoMVC) from scratch with Database (PostgreSQL) and Native Web Components.

- Part 1 (this one) (database / model access) - youtu.be/VIig9IcQ-w8
- Part 2 (web / warp filters) - youtu.be/plKzUo8F6Mg

GitHub Source - github.com/jeremychone-channel/rust-todomvc

00:00 - Dev Setup
02:55 - Database creation and db_init()
19:45 - CRUD todo list
28:32 - CRUD todo create
35:25 - With SQL Builder (sqlb)
41:21 - First security infrastructure
45:09 - Finishing CRUD (get, update, delete)

#Rust #WebDevelopment #sqlx #postgresql #WebComponents #TodoMVC