		[#19]: https://github.com/killercup/quicli/issues/19

		That sounded pretty awesome and made me really proud:
		Did me library


		But, before blindly agreeing to this,
		I needed to take a step back
		and evaluate what I want quicli to be.

		I just wanted a small framework-like thing
		that made writing CLI apps less of a pain.
		But how exactly do I want to to this?
		Thanks to Garretts' questions and comments


		In its implementation,
		you get what I'd call
		"a small framework around you main function":

		In its implementation,
		you get what I'd call
		"a small framework around you main function":
		quicly's `main!` macro set up some basic things,

		Sadly, for newcomers/forgetful people/drunk programmers/etc.
		they are also _wonderfully complex._

		So, instead of offering the user "everything,"

		So, instead of offering the user "everything,"
		I want to introduce some abstractions that are simple to use,
		and have simple but useful examples.
		Not not get stuck,

		Since then, I've written two more guides,
		and for both I added features to the framework,
		exposed new functionality,
		and thought more about how I want quicly-based code to feel.

		and for both I added features to the framework,
		exposed new functionality,
		and thought more about how I want quicly-based code to feel.
		(More on the aspect of hosting and testing these docs in a future post!)

		It gives you a way of quickly writing CLI programs in Rust.
		(Hence the name.)
		In this post,
		I want to present the ideas and underlaying philosophies of this project.

		In its implementation,
		you get what I'd call
		"a small framework around you main function":
		quicly's `main!` macro set up some basic things,

		(as well as my ergonomic requirements).

		What I want you to end up with is code that is
		concise,

		Sadly, for newcomers/forgetful people/drunk programmers/etc.
		they are also _wonderfully complex._

		So, instead of offering the user "everything,"

		Since then, I've written two more guides,
		and for both I added features to the framework,
		exposed new functionality,
		and thought more about how I want quicly-based code to feel.

		and for both I added features to the framework,
		exposed new functionality,
		and thought more about how I want quicly-based code to feel.
		(More on the aspect of hosting and testing these docs in a future post!)


		I've been writing CLI tools in Rust for a while now.
		It really surprised me how this language
		that works really well for system programming

		["5 Tips for Writing Small CLI Tools in Rust"][cli-tips]
		at the end of August 2017
		that you may have read,
		where I describes some of my take-aways from that

		that you may have read,
		where I describes some of my take-aways from that
		in the form of short tips.
		I've got some great feedback to that post,

		I didn't have the time or concentration
		to sit down and really do this.
		And here's the good news:
		For some reason[^9e-talk],


		[cli-tips]: {% post_url 2017-08-31-rust-cli-tips %}

		[^9e-talk]: Okay, I admit, I promised to give a talk about Rust, and I wanted to present some nice, clean example code. (Of course, in the end I didn't show quicli in the talk.)

		So, instead of offering the user "everything,"
		I want to introduce some abstractions that are simple to use,
		and have simple but useful examples.
		Not to get stuck,

		Indeed, instead of adding any feature flags to this crate
		(that enable additional components to be loaded/exposed),
		I want to have a clear line
		where a user is supposed to stop relying on quicli.

		(that enable additional components to be loaded/exposed),
		I want to have a clear line
		where a user is supposed to stop relying on quicli.
		I'd rather have an "eject" option

		but another important aspect to me is to prove that it is useful
		for writing small tools
		-- even if you've only just started with Rust.
		This is why I initially wrote the Readme file

		for writing small tools
		-- even if you've only just started with Rust.
		This is why I initially wrote the Readme file
		in form of a How To:

		Sadly, for newcomers/forgetful people/drunk programmers/etc.
		they are also _wonderfully complex._

		So, instead of offering the user "everything,"

		I didn't have the time or concentration
		to sit down and really do this.
		And here's the good news:
		For some reason[^9e-talk],

		it is very concise.

		Another aspect of conciseness:
		Instead of using `.unwrap` to deal with errors,

		and good error messages.
		Similarly, you get logging for free,
		and if you add two more lines,
		you also get a `--verbose`/`-v` CLI argument to control the log level

		So, instead of offering the user "everything,"
		I want to introduce some abstractions that are simple to use,
		and have simple but useful examples.
		Not to get stuck,


		[cli-tips]: {% post_url 2017-08-31-rust-cli-tips %}

		[^9e-talk]: Okay, I admit, I promised to give a talk about Rust, and I wanted to present some nice, clean example code. (Of course, in the end I didn't show quicli in the talk.)

		but another important aspect to me is to prove that it is useful
		for writing small tools
		-- even if you've only just started with Rust.
		This is why I initially wrote the Readme file

Almost forgot that!