Just as I was planning to continue reading a book on formal verification here comes a meetup about it. And as you might have guessed (if you are familiar with the field of formal verification) they will be doing this in Coq - verifying a subset of Rust programs.

https://twitter.com/RustLondon_/status/1403334223394639872?s=20

Recently was going through OCaml references. Found out that monadic operations were just* introduced in 2018, this late in the language! This was a huge surprise for me. I mean the language designers have to be really devoted to introduce such big changes this late in the language.

* People could write a monad in OCaml before, but there was no explicit support for this pattern from the language side.

Rust 1.53.0 is out!

Nested or patterns, Unicode identifiers, IntoIterator for arrays and some other minor changes https://blog.rust-lang.org/2021/06/17/Rust-1.53.0.html

I should probably write my own WASM runtime one day :)

The WebAssembly runtime Wasmer 2.0 is released: up to +50% faster runtime speed, up to 70% faster hot startups, reference types, SIMD and more!

https://wasmer.io/posts/wasmer-2.0

The joke about Unicode support. The thing is it will print 14, but it also will give you a ton of warnings.

https://twitter.com/tomaka17/status/1405546676790587392?s=19

From hacker news comments:

If the computer solves problems and we know what it's doing, that's software engineering If the computer solves problems and we don't know what it's doing, that's AI If the computer doesn't solve problems and we don't know what it's doing, that's Friday afternoon

Another quote from The Manager's Path book that I wanted to share:

There are some projects, usually described by words like infrastructure, platform, or system, that require architecture or significant advanced planning. When faced with this kind of project, which includes many unknowns and relatively hard deadlines, you will find it doesn’t fit so well into the standard agile process.

I really do think that Agile fans are sometimes just a bit too eager to see it everywhere.

In my years at Google and AWS, we had outages and failures, but very very few of them were due to anything as simple as a software bug. Botched deployments, throttling misconfigurations, cert problems (OMG cert problems), DNS hiccups, an intern doing a load test with a Python noscript, malfunctioning canaries, there are lots of branches in that trail of tears. But usually not just a bug. I can’t remember when precisely I became infected, but I can testify: Once you are, you’re never going to be comfortable in the presence of untested code.

https://www.tbray.org/ongoing/When/202x/2021/05/15/Testing-in-2021

Origin: https://twitter.com/jschauma/status/1409608031508303875?s=19

Here is my Monday pick of a programming language😁: Flix

- Developed in Aarhus University
- Syntax similar to Scala
- Functional First
- Design inspired by Haskell, Rust, Scala
- Has Higher Kinded Types
- Checks purity and impurity at type level
- Has a special contract (constraint) language

Actually at the first glance I would say I like it a lot. I really think that Haskell over-engineered with their IO monad, and Scala has no built-in purity checks. So here we go. Might actually give it a try.

Microsoft seems quite serious about their love for Linux lately. Recently they released a first version of their own Linux Distribution https://github.com/microsoft/CBL-Mariner

Just found this podcast from Jane Street (the famous finance company that uses OCaml). They talk about a variety of topics from OS to UI to compilers.

Mainly they discuss how their teams work on these topics. Seems like a hell of an insight into FP at scale.

Finally brought up again a personal blog website after fiddling with CSS for a couple of days😅.

So here you go - a blog post on absence of lifetimes in our daily Rust code https://www.ivkov.tech/absence-of-lifetimes/

SQLX is planning to drop async-std runtime support and only use tokio.

And it is very indicative of the state of async runtimes in Rust. A lot of people on Reddit are saying that tokio won.

I think this is quite sad. Rust async working group should have standardized interfaces for runtimes long ago. Then there would be no split in the ecosystem and consequently less popular projects dying out.

As if the async working group heard me - they have just published a vision for async in Rust for the coming years!😁

They mainly discuss:
1. Support for async fns in traits
2. Common interface for runtimes
3. Easier syntax for async iterators

https://blog.rust-lang.org/inside-rust/2022/02/03/async-in-2022.html

React like cross platform UI framework in Rust - https://dioxuslabs.com/

It's finally happening 😁. Rust is getting better for UI construction!

Amazon recently posted about their contribution to Rust and there they mentioned that Rust was started as a research project in Mozilla in 2010.

And that was a huge historical inaccuracy there!

But hopefully soon it was corrected by Graydon Hoare (the actual creator of Rust) himself:

A minor nit: Rust didn't start "as a research project at Mozilla in 2010".

It started as a personal project (on my own laptop, on my own time) in 2006.

It was a small but real 17kloc native compiler for linux, mac and windows by the time Mozilla began sponsoring it in 2009-10.

https://twitter.com/graydon_pub/status/1492634815748739077?t=pWPVYsyF5QKlhN6LyzFFNw&s=19

Original: https://twitter.com/e_salvaggio/status/1494322969127964679?t=foIKToFvHKhvyNAqInMQEw&s=19