-
Notifications
You must be signed in to change notification settings - Fork 1
/
index.xml
308 lines (253 loc) · 22 KB
/
index.xml
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
<channel>
<title>Brian M Hunt</title>
<link>https://brianmhunt.github.io/</link>
<description>Recent content on Brian M Hunt</description>
<generator>Hugo -- gohugo.io</generator>
<language>en-us</language>
<lastBuildDate>Mon, 23 Mar 2020 00:00:00 +0000</lastBuildDate>
<atom:link href="https://brianmhunt.github.io/index.xml" rel="self" type="application/rss+xml" />
<item>
<title>COVID Exponential Growth Estimator</title>
<link>https://brianmhunt.github.io/post/2020-03-23-covid-calculator/</link>
<pubDate>Mon, 23 Mar 2020 00:00:00 +0000</pubDate>
<guid>https://brianmhunt.github.io/post/2020-03-23-covid-calculator/</guid>
<description>The following is a calculator that can be used to make estimates about the exponential growth phase of the COVID pandemic.
It is purely a mathematical estimator, and has no underlying insight into the disease growth patterns, but can be used as an informational tool for projecting and observing patterns.
Calculate Growth Rate Enter two dates where the number of cases is known, and the respective number of cases, then the result will be shown.</description>
</item>
<item>
<title>Kasparov's Razor</title>
<link>https://brianmhunt.github.io/post/2017-08-19-kasparovs-razor/</link>
<pubDate>Sat, 19 Aug 2017 00:00:00 +0000</pubDate>
<guid>https://brianmhunt.github.io/post/2017-08-19-kasparovs-razor/</guid>
<description>Chess champion Garry Kasparov, famous for competing with IBM supercomputer Deep Blue, gave a speech at DEFCON 25 called The Brain&rsquo;s Last Stand. In it, Kasparov said:
A weak player plus an ordinary machine plus a superior process will be dominant in the game against a strong player, a strong computer, and an inferior process.
For many years I have noted concordant observations of this phenomenon in the legal-technology sphere.</description>
</item>
<item>
<title>How Mortgages Neutered Monetary Policy</title>
<link>https://brianmhunt.github.io/post/2017-05-24-how-mortgages-neutered-monetary-policy/</link>
<pubDate>Wed, 24 May 2017 00:00:00 +0000</pubDate>
<guid>https://brianmhunt.github.io/post/2017-05-24-how-mortgages-neutered-monetary-policy/</guid>
<description>According to the Bank of Canada, monetary policy serves to to preserve the value of money by keeping inflation low, stable and predictable. The Bank goes on to say:
This allows Canadians to make spending and investment decisions with more confidence, encourages longer-term investment in Canada&rsquo;s economy, and contributes to sustained job creation and greater productivity. This in turn leads to improvements in our standard of living.
Unfortunately there&rsquo;s a looming housing crisis in the form of what looks like a housing bubble.</description>
</item>
<item>
<title>Debugging Deep Promises</title>
<link>https://brianmhunt.github.io/post/2016-03-15-master-debugging-promises/</link>
<pubDate>Tue, 15 Mar 2016 00:00:00 +0000</pubDate>
<guid>https://brianmhunt.github.io/post/2016-03-15-master-debugging-promises/</guid>
<description>The Problem Promises are arguably the best mechanism we have for dealing with asynchronous software development, and many folks use them heavily in Javascript.
Promises nonetheless can be problematic to debug. One particularly pernicious problem is “bleeding” of promises from one test to another.
Problem Example Parallel promises, i.e. not those chained by .then, are resolved in an indeterminate order.
A contrived but illustrative scenario:
Promise.resolve().then(aFn).then(() =&gt; console.log(&#39;a&#39;)) Promise.resolve().then(bFn).then(() =&gt; console.</description>
</item>
<item>
<title>ACME + AppEngine ... Simplified</title>
<link>https://brianmhunt.github.io/post/2016-03-05-acme-appengine-simplified/</link>
<pubDate>Sat, 05 Mar 2016 00:00:00 +0000</pubDate>
<guid>https://brianmhunt.github.io/post/2016-03-05-acme-appengine-simplified/</guid>
<description>Following my prior post on Let&rsquo;s Encrypt - Acme on AppEngine, I have rewritten in Python and substantially simplified the process for deploying a challenge with minimal user input.
In particular, the following script will extract the challenge from STDOUT of Let&rsquo;s Encrypt, write the challenges to the given directory, call appcfg.py to upload the challenges, before Let&rsquo;s Encrypt performs its validation. If all goes well, the private key is converted to a format usable by AppEngine and both it and the certificate chain are printed to the terminal.</description>
</item>
<item>
<title>Let's Encrypt - ACME on AppEngine</title>
<link>https://brianmhunt.github.io/post/2016-02-22-let-s-encrypt-acme-on-appengine/</link>
<pubDate>Mon, 22 Feb 2016 00:00:00 +0000</pubDate>
<guid>https://brianmhunt.github.io/post/2016-02-22-let-s-encrypt-acme-on-appengine/</guid>
<description>What is this? This is a bit of process that I use to get TLS keys to use on AppEngine using Let&rsquo;s Encrypt.
Update I have a streamlined process described below, removing dependencies on Node and Javascript, and reducing the amount of user-input needed, as described in my next post.
Why&rsquo;s it matter? There are a number of quirks in Let&rsquo;s Encrypt and TLS on AppEngine that make it more difficult to automate the process.</description>
</item>
<item>
<title>Picking our roots: Between HSTS and public key pins</title>
<link>https://brianmhunt.github.io/post/2015-11-25-picking-our-roots-between-hsts-and-public-key-pins/</link>
<pubDate>Wed, 25 Nov 2015 00:00:00 +0000</pubDate>
<guid>https://brianmhunt.github.io/post/2015-11-25-picking-our-roots-between-hsts-and-public-key-pins/</guid>
<description>The web browser encryption meta-game has stepped up in the wake of the Snowden publications.
One very useful advancement called HTTP Strict Transport Security appears to be catching on. Simply, HSTS tells a browser to remember that the website should always in the future be encrypted. After a browser receives a HSTS header for a website any subsequent connection will fail if it is not encrypted, until the header expires. This means that any misconfiguration or malicious attempt to downgrade a connection from HTTPS to HTTP shall fail.</description>
</item>
<item>
<title>Properly Parsing HTML in HTML5</title>
<link>https://brianmhunt.github.io/post/2015-09-20-properly-parsing-html-in-html5/</link>
<pubDate>Sun, 20 Sep 2015 00:00:00 +0000</pubDate>
<guid>https://brianmhunt.github.io/post/2015-09-20-properly-parsing-html-in-html5/</guid>
<description>Parsing HTML in Javascript is harder than one would expect. You would think that the browser, a HTML parser by its very nature, would give access to easy HTML parsing. But you&rsquo;d be wrong, and here is an example of why:
&gt; d = document.createElement(&#39;div&#39;) &lt;div&gt;&lt;/div&gt; &gt; d.innerHTML = &#39;&lt;tr&gt;&lt;/tr&gt;&#39; &#34;&lt;tr&gt;&lt;/tr&gt;&#34; &gt; d.innerHTML &#34;&#34; // ^^ Uh oh. Where&#39;d it go? The problem is that the &lt;tr&gt; tag in HTML requires a parent of &lt;table&gt; or &lt;tbody&gt; or &lt;thead&gt; or &lt;tfoot&gt;, according to the W3C HTML5 spec.</description>
</item>
<item>
<title>Details on the new Knockout Website</title>
<link>https://brianmhunt.github.io/post/2015-07-29-knockout-website-details/</link>
<pubDate>Wed, 29 Jul 2015 11:11:11 +0000</pubDate>
<guid>https://brianmhunt.github.io/post/2015-07-29-knockout-website-details/</guid>
<description>Here are some things that make the new proposal for a new Knockout website pretty darned cool, in our opinion.
Single-page app Auto-reloading Application Cache Javascript error checking Inline auto-reloading samples These are a selection of the many really cool features that underly the future online presence of Knockout. The ideas and implementation here will hopefully provide a really great user experience, help demonstrate a little of what Knockout can do, and show some techniques that can be used in many other contexts to improve the web.</description>
</item>
<item>
<title>New Knockout Website</title>
<link>https://brianmhunt.github.io/post/2015-07-22-new-knockout-website/</link>
<pubDate>Wed, 22 Jul 2015 00:00:00 +0000</pubDate>
<guid>https://brianmhunt.github.io/post/2015-07-22-new-knockout-website/</guid>
<description>Hi everyone.
Just a quick post to point you to the new Knockout website, currently at brianmhunt.github.io/knockout
Hopefully soon it will be up at beta.knockoutjs.com
You can also follow the relevant Github issue, #1827 or comment on our gitter.
Cheers,
Brian</description>
</item>
<item>
<title>Caching almost everything static on Google App Engine</title>
<link>https://brianmhunt.github.io/post/2015-06-19-caching-almost-everything/</link>
<pubDate>Fri, 19 Jun 2015 00:00:00 +0000</pubDate>
<guid>https://brianmhunt.github.io/post/2015-06-19-caching-almost-everything/</guid>
<description>What is it? An aggressive caching technique.
Why is it important? Caching can save time &amp; resources downloading.
How do we do it? A simple HTML file and a simple tiny loader script (~900 bytes).
Here is the HTML:
&lt;!doctype html&gt; &lt;html&gt; &lt;head&gt; &lt;script src=&#39;/loader.js&#39;&gt;&lt;/script&gt; ... &lt;head&gt; &lt;body&gt; ... &lt;/body&gt; &lt;/html&gt; and annotated loader.js:
(function () { &#34;use strict&#34;; // We build this file on deploy and replace $TIME with the build time.</description>
</item>
<item>
<title>Joining Knockout.js maintainers</title>
<link>https://brianmhunt.github.io/post/2014-12-01-joining-knockout/</link>
<pubDate>Mon, 01 Dec 2014 00:00:00 +0000</pubDate>
<guid>https://brianmhunt.github.io/post/2014-12-01-joining-knockout/</guid>
<description>Hi everyone,
I have joined Steve Sanderson, Michael Best, and Ryan Niemeyer as a core developer of Knockout.js. I thoroughly enjoy working with Knockout.js, and it is a real honour to participate as a maintainer of such a popular and well thought-out library.</description>
</item>
<item>
<title>Opinionated modals with Knockout</title>
<link>https://brianmhunt.github.io/post/2014-09-16-opinionated-modals/</link>
<pubDate>Tue, 16 Sep 2014 00:00:00 +0000</pubDate>
<guid>https://brianmhunt.github.io/post/2014-09-16-opinionated-modals/</guid>
<description>What&rsquo;s this? Highly opinionated modals to achieve a user experience I like:
Demonstration; Repository. Why&rsquo;s it matter? It makes an impression, works with, and demonstrates interesting things in HTML5, Javascript ES6, CSS3 and Knockout.js.
What does it do? There are a few problems Knockout Modal tackles, including:
Modals longer than the viewport height Nesting of modals Concise code (~100 line of Javascript) Happily integrates with code for HTML5 history Accepts thenables (e.</description>
</item>
<item>
<title>Follow along at Airconf 2014</title>
<link>https://brianmhunt.github.io/post/2014-08-13-follow-along-airconf/</link>
<pubDate>Wed, 13 Aug 2014 00:00:00 +0000</pubDate>
<guid>https://brianmhunt.github.io/post/2014-08-13-follow-along-airconf/</guid>
<description>Airconf 2014 I will be presenting at 10:00 AM EST on August 14, 2014 by Google Hangout.
The repository for the presentation is github.com/brianmhunt/Airconf-2014-Knockout.
You can follow the presentation and review snippets used at brianmhunt.github.io/airconf-2014.</description>
</item>
<item>
<title>Taming contentEditable with jQuery</title>
<link>https://brianmhunt.github.io/post/2014-07-18-taming-contenteditable/</link>
<pubDate>Fri, 18 Jul 2014 00:00:00 +0000</pubDate>
<guid>https://brianmhunt.github.io/post/2014-07-18-taming-contenteditable/</guid>
<description>What is it? This is a few examples of how one might extend jQuery to make the contentEditable a more manageable component of the web.
For convenience I am just going to show the web-standards, so one will need workarounds for IE &lt; 9.
A more comprehensive suite (and from whose work I derive many of my answers) is rangy.js by Tim Down.
Why is it important? The contentEditable flag is one of the few ways to get WYSIWYG styling on the web.</description>
</item>
<item>
<title>Knockout observables and Promises</title>
<link>https://brianmhunt.github.io/post/2014-07-09-pubsub-promises/</link>
<pubDate>Wed, 09 Jul 2014 00:00:00 +0000</pubDate>
<guid>https://brianmhunt.github.io/post/2014-07-09-pubsub-promises/</guid>
<description>What is it? This is just a few notes about using Knockout observables with ES6 Promises.
Why is it important? The concepts here are reusable ways for promises and pub/sub systems to interact in a healthy way.
Publish and subscribe and promises are two canonical, widely-supported methods of handling asynchronous flow. The ease at which they communicate with each other makes asynchronicity easier to handle.
Promises to observables Publishing to an observable when a promise completes is trivial.</description>
</item>
<item>
<title>Google App Engine tags for ndb</title>
<link>https://brianmhunt.github.io/post/2014-04-04-ndb-tags/</link>
<pubDate>Fri, 04 Apr 2014 00:00:00 +0000</pubDate>
<guid>https://brianmhunt.github.io/post/2014-04-04-ndb-tags/</guid>
<description>What is it? This is a way to add tags functionality to classes derived from ndb.Model on Google App Engine by way of a mixin.
Why is it important? Adding tags to data models is a popular phenomenon, but there does not appear to be a published way to accomplish the common functionality with ndb. This method ought to be reusable and performant.
How does it work? Get the full gist is gist.</description>
</item>
<item>
<title>Catching Sinon Unmet Requests</title>
<link>https://brianmhunt.github.io/post/2014-02-17-catching-sinon-unmet-requests/</link>
<pubDate>Mon, 17 Feb 2014 00:00:00 +0000</pubDate>
<guid>https://brianmhunt.github.io/post/2014-02-17-catching-sinon-unmet-requests/</guid>
<description>What is it? Track AJAX requests that have not been responded to by the Sinon.JS fake XMLHttpRequest server.
Why is it important? It can be difficult to figure out whether a request has been responded to. Figuring it out can be time consuming and troublesome. This method catches everything.
How do we do it? I am using Mocha and Chai, but this should work as well with other frameworks&rsquo; equivalent hooks.</description>
</item>
<item>
<title>Open Source Exposure</title>
<link>https://brianmhunt.github.io/post/2014-02-16-open-source-exposure/</link>
<pubDate>Sun, 16 Feb 2014 00:00:00 +0000</pubDate>
<guid>https://brianmhunt.github.io/post/2014-02-16-open-source-exposure/</guid>
<description>The concept of exposure comes from my practice as a lawyer on insurance matters. My practice in this area consisted predominantly of plaintiff work and as counsel for the Queen of Canada (England) in her role as an insurance payer of last resort in the province of Ontario. In insurance matters the word exposure is a core concept used on a daily basis. I have found that the lingo and concept of exposure is a handy tool in deciding whether and how to include open source software in a project.</description>
</item>
<item>
<title>Knockout catching errors</title>
<link>https://brianmhunt.github.io/post/2014-02-13-knockout-catching-errors/</link>
<pubDate>Thu, 13 Feb 2014 00:00:00 +0000</pubDate>
<guid>https://brianmhunt.github.io/post/2014-02-13-knockout-catching-errors/</guid>
<description>What is this? A couple tips for identifying issues with Knockout.
Why is it important? Error handling is one of the areas where Knockout could do with some attention. These techniques have saved me quite a bit of time, and I hope you also find them useful.
How&rsquo;s it work? There are two major places where you can really hook in and catch issues:
Custom binding provider Wrapping custom bindings The custom binding provider is called when the bindings are first made, via ko.</description>
</item>
<item>
<title>Knockout Secure Binding</title>
<link>https://brianmhunt.github.io/post/2014-02-02-knockout-plus-content-security-policy/</link>
<pubDate>Sun, 02 Feb 2014 00:00:00 +0000</pubDate>
<guid>https://brianmhunt.github.io/post/2014-02-02-knockout-plus-content-security-policy/</guid>
<description>What is it? Knockout Secure Binding is a custom binding provider for Knockout.
Why does it matter? The regular binding provider calls new Function, which throws an exception when you have a Content Security Policy that prohibits unsafe-eval.
These security policies are mandatory in some circumstances, such as Chrome Web Apps.
How does it work? At its core, KSB is two things:
A parser that interprets data-bind attributes on the DOM elements and text of virtual elements that Knockout reads; and</description>
</item>
<item>
<title>Knockout and foreign keys extender</title>
<link>https://brianmhunt.github.io/post/2014-01-26-knockout-and-foreign-keys/</link>
<pubDate>Sun, 26 Jan 2014 00:00:00 +0000</pubDate>
<guid>https://brianmhunt.github.io/post/2014-01-26-knockout-and-foreign-keys/</guid>
<description>What is this? An extension of Knockout observables, making the observables into keys to another model. The model and its loading status are added as part of a property, .fk, to the observable.
Why is it important? It makes some hard things easy, and some things once impossible just hard. In particular, it makes it easy to define models that load keys, and trivially access the models those keys represent.</description>
</item>
<item>
<title>Storing passwords using Python</title>
<link>https://brianmhunt.github.io/post/2014-01-25-strong-crypto-python-passwords/</link>
<pubDate>Sat, 25 Jan 2014 00:00:00 +0000</pubDate>
<guid>https://brianmhunt.github.io/post/2014-01-25-strong-crypto-python-passwords/</guid>
<description>What is it? An implementation in Python for storing passwords with cryptographically recognized techniques.
Why is it important? Stored passwords get disclosed from time to time. Good examples give us guidance and help us avoid mistakes.
Password disclosure is bad news for users and the authenticator. Worse it undermines the trust the public has in our systems for storing and accessing private, personal services.
When using cryptography it is possible that even if the values stored are disclosed that the secrets they reflect remain opaque, or at least cost ineffective to discover.</description>
</item>
<item>
<title>Importance of typography</title>
<link>https://brianmhunt.github.io/post/2014-01-24-importance-of-typography/</link>
<pubDate>Fri, 24 Jan 2014 00:00:00 +0000</pubDate>
<guid>https://brianmhunt.github.io/post/2014-01-24-importance-of-typography/</guid>
<description>You have no doubt thought about the font you use to communicate your written words. In the absence of any particular insight or authority you have likely chosen a common font such as Times New Roman or Arial or Helvetica. You have probably wondered whether this choice has any impact on the outcome of your written communication. The answer is a definitive yes — the form a writing takes substantially affects the message read, though as we will discuss below it is not just limited to the choice of font.</description>
</item>
<item>
<title>Permanent HTTP caching and busting</title>
<link>https://brianmhunt.github.io/post/2014-01-23-permanent-caching-and-busting/</link>
<pubDate>Thu, 23 Jan 2014 00:00:00 +0000</pubDate>
<guid>https://brianmhunt.github.io/post/2014-01-23-permanent-caching-and-busting/</guid>
<description>What is it? Permanent caching is part of the HTTP protocol, a way to reduce server load and improve the user experience by speeding up load time.
Why does it matter? Caches make us and users happy. We get less load on our servers, and it&rsquo;s a significant speedup for load times.
The busting is important because without it the resource may not be downloaded by a browser even though it has been updated on the server.</description>
</item>
<item>
<title>Asynchronous client-side Javascript page loading</title>
<link>https://brianmhunt.github.io/post/2014-01-22-making-everything-async/</link>
<pubDate>Wed, 22 Jan 2014 00:00:00 +0000</pubDate>
<guid>https://brianmhunt.github.io/post/2014-01-22-making-everything-async/</guid>
<description>What is it? A process for loading our script resources asynchronously, with one &lt;script&gt; tag, like this:
&lt;script async src=&#39;/all.js-{{ cache_buster }}&#39;&gt;&lt;/script&gt; This all.js file loads all our Javascript, external services, templates, and any RESTful resources from our server.
We discuss the cache_buster in the next post.
Why is it important? Having one file for Javascript gives us:
one file to request; improved cachability; parallel requests for our resources; centralizing where we control our loading; fine-grained control of the loading process.</description>
</item>
</channel>
</rss>