<?xml version="1.0" encoding="utf-8" standalone="yes" ?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
  <channel>
    <title>Posts on hwc::blog</title>
    <link>https://blog.hwc.io/posts/</link>
    <description>Recent content in Posts on hwc::blog</description>
    <generator>Hugo -- gohugo.io</generator>
    <managingEditor>hello@hwc.io (hwc)</managingEditor>
    <webMaster>hello@hwc.io (hwc)</webMaster>
    <lastBuildDate>Wed, 30 Dec 2020 12:54:48 -0500</lastBuildDate>
    
	<atom:link href="https://blog.hwc.io/posts/index.xml" rel="self" type="application/rss+xml" />
    
    
    <item>
      <title>Introducing Tophat</title>
      <link>https://blog.hwc.io/posts/introducing-tophat/</link>
      <pubDate>Wed, 30 Dec 2020 12:54:48 -0500</pubDate>
      <author>hello@hwc.io (hwc)</author>
      <guid>https://blog.hwc.io/posts/introducing-tophat/</guid>
      <description>Overview Tophat is a small, pragmatic, and flexible async http server library for Rust.
Its main points:
 no async runtime dependencies (user provides runtime). works with AsyncRead/AsyncWrite. Fn(Request, ResponseWriter) -&amp;gt; ResponseWritten instead of Fn(Request) -&amp;gt; Response allows more observability of response lifecycle.  For a quick example, go to bottom of this post.
I want to first thank the Rust async and web community for all the work they&amp;rsquo;ve done.</description>
    </item>
    
    <item>
      <title>Rust futures: thread::sleep and blocking calls inside async fn</title>
      <link>https://blog.hwc.io/posts/rust-futures-threadsleep-and-blocking-calls-inside-async-fn/</link>
      <pubDate>Mon, 25 Nov 2019 10:24:11 -0500</pubDate>
      <author>hello@hwc.io (hwc)</author>
      <guid>https://blog.hwc.io/posts/rust-futures-threadsleep-and-blocking-calls-inside-async-fn/</guid>
      <description>Lately, I&amp;rsquo;ve been seeing some common misconceptions about how Rust&amp;rsquo;s futures and async/await work (&amp;ldquo;blockers&amp;rdquo;, haha). There&amp;rsquo;s an influx of new users excited for the major improvements that async/await brings, but stymied by basic questions. Concurrency is hard, even with async/await. Documentation is still being fleshed out, and the interaction between blocking/non-blocking can be tricky. Hopefully this article will help.
(This blog is mostly about specific pain points; for an overview of async programming in rust, go to the book)</description>
    </item>
    
    <item>
      <title>Rust 2020</title>
      <link>https://blog.hwc.io/posts/rust-2020/</link>
      <pubDate>Thu, 31 Oct 2019 10:31:16 -0400</pubDate>
      <author>hello@hwc.io (hwc)</author>
      <guid>https://blog.hwc.io/posts/rust-2020/</guid>
      <description>Every year there&amp;rsquo;s a call for blogs reflecting on goals for Rust for the upcoming year.
For me, the theme is &amp;ldquo;Community First&amp;rdquo;.
As I mentioned in last year&amp;rsquo;s post, people and the community are the driving forces behind Rust the language and Rust the ecosystem. Without the energy of developers, documenters, testers, users, Rust will wither away, regardless of its technical merits.
I still feel the same way.
Community building efforts are key.</description>
    </item>
    
    <item>
      <title>Rust 2019: Go Slow</title>
      <link>https://blog.hwc.io/posts/rust-2019/</link>
      <pubDate>Sun, 16 Dec 2018 15:39:32 -0500</pubDate>
      <author>hello@hwc.io (hwc)</author>
      <guid>https://blog.hwc.io/posts/rust-2019/</guid>
      <description>Here are some quick thoughts on priorities for Rust 2019. Perhaps the thoughts are a little scattered, and some not fully-formed. But I wanted to get the gist of these ideas out there before I get derailed on some other project.
I have many technical wishes for Rust, the language, in 2019. However, I&amp;rsquo;m not going to mention any in particular in this post. In fact, I can almost say that I&amp;rsquo;d prefer for there to not be a focus on achieving technical milestones in the next year.</description>
    </item>
    
    <item>
      <title>Dataframes: Traits, Enums, Generics, and Dynamic Typing</title>
      <link>https://blog.hwc.io/posts/dataframe1/</link>
      <pubDate>Wed, 28 Mar 2018 09:57:53 -0400</pubDate>
      <author>hello@hwc.io (hwc)</author>
      <guid>https://blog.hwc.io/posts/dataframe1/</guid>
      <description>tldr: I&amp;rsquo;m attempting to build a dataframe in Rust. I implemented a pattern using traits, generics, and enums in conjunction to deal with columns of different datatypes while allowing runtime reflection for accessing the data stored in a column.
 background constraints and motivation llamas2 (the dataframe PoC I&amp;rsquo;m building now)  initial attempts emulating dynamic types  llamas 1 and beetl  A quick guide for different readers:</description>
    </item>
    
  </channel>
</rss>