Finish drafting blog post

Author: soareschen

content/blog/2025-05-08-v0.4.0-release.md

@@ -516,4 +516,57 @@ The preset inheritance works very similarly to how inheritance is typically unde
 
 First of all, presets only work as type-level lookup tables, with no ability to directly implement "methods" on the preset itself. Hence, it works more like protoypal inheritance in languages such as JavaScript. Furthermore, the lookup table only exists at the type level, meaning that it does not exist at runtime, and thus does not introduce any runtime overhead.
 
-More importantly, CGP and Rust do not support the notion of subtyping. This means that two contexts that "inherit" from the same preset are treated as completely distinct types, and there is no mechanism to "upcast" the values to a common preset "parent type", which does not exist. This means that in constrast to OOP, CGP inheritance only exist at the "provider"-side for implementations, but not on the "consumer"-side for polymorphic consumption.
+More importantly, CGP and Rust do not support the notion of subtyping. This means that two contexts that "inherit" from the same preset are treated as completely distinct types, and there is no mechanism to "upcast" the values to a common preset "parent type", which does not exist. This means that in constrast to OOP, CGP inheritance only exist at the "provider"-side for implementations, but not on the "consumer"-side for polymorphic consumption.
+
+## `Async` Trait Update
+
+The `Async` trait was defined to be a trait alias to `Send + Sync + 'static`, to make it more easy for users to define abstract types that can be used within async functions that return `impl Future + Send`. However, practical experience has shown that the `'static` bound is not really needed in most cases, and thus removed by [#89](https://github.com/contextgeneric/cgp/pull/89) from the default recommended trait bound.
+
+The removal of `'static` will make it easier to instantiate abstract types with concrete types that do not contain `'static` trait bound. On the other hand, the default inclusion of `Send + Sync` is almost a necessary evil with the current state of async Rust. However, this may soon change when Return Type Notation (RTN) gets stabilized in Rust in the near future in [rust#138424](https://github.com/rust-lang/rust/pull/138424). Once that is stabilized, the `Async` trait itself can entirely be deprecated or removed.
+
+## `#[blanket_trait]` Macro
+
+[#79](https://github.com/contextgeneric/cgp/pull/79) and [#82](https://github.com/contextgeneric/cgp/pull/82) introduces a new `#[blanket_trait]` macro, which can be used to define trait aliases that contain empty body and trivial blanket implementations.
+
+Developers can use the `#[blanket_trait]` macro to define trait aliases, as well as abstract type aliases for more advanced cases. For example, given the following:
+
+```rust
+#[trait_alias]
+pub trait HasAsyncErrorType: Async + HasErrorType<Error: Async> {}
+```
+
+would result in the following blanket implementation to be automatically generated:
+
+```rust
+impl<Context> HasAsyncErrorType for Context
+where
+    Context: Async + HasErrorType<Error: Async> {}
+```
+
+## Personal Updates
+
+Aside from all the feature updates, I also have some personal updates related to the development of CGP.
+
+### Persentation at Leipzig Rust Meetup
+
+I have given a presentation of CGP at the [Leipzig Rust meetup](https://www.meetup.com/rust-modern-systems-programming-in-leipzig/events/303729528/) in February. Although there were no video recording, you can check out the [presentation slides](https://github.com/contextgeneric/cgp-presentations/blob/main/2025/cgp-leipzig-2025-02-18.pdf) if you are interested.
+
+### Bank Transfer Example
+
+Along with the meetup presentation, an example [bank transfer](https://github.com/contextgeneric/cgp-examples/tree/main/transfer) application has been drafted to demonstrate the use of CGP in practical applications. The example code is not yet sufficiently documented, but hopefully it can serve as a sneak preview for readers who would like to see more complex examples of CGP programs.
+
+### More Active Development
+
+It has been 4 months since our last update. It was proven to be challenging to manage a side project, while also juggling with a full time job plus child care without support from the grandparents. On the bright side, I have managed to get a short 3-month sabbatical from May to July, before changing to a new job.
+
+During the next 3 months, you can expect to see much more active development from me to push CGP towards wider adoption. If you have suggestions on what should be developed during this time, or how I can make the project more sustainable, do let me know in the comments.
+
+### Attending RustWeek
+
+I will be attending [RustWeek](https://rustweek.org/) in person next week (May 13-17 2025). Although I did not manage to get a presentation slot, I would love to meet up with Rust developers and discuss about how CGP can be used to solve real world problem in their Rust applications.
+
+If there are interests, I would also like to organize [Hackathon](https://rustweek.org/events/hackathon/) sessions during the last day to have coding sessions for CGP. Otherwise, I might look around and try to apply CGP on one of the Hackathon projects. If you have any suggestions, do let me know.
+
+Lastly, if you read until this point and is attending RustWeek, do ping me on [BlueSky](https://bsky.app/profile/maybevoid.com) and I would love to chat with you.
+
+Thank you for reading, and stay tuned for more updates on CGP!