-
Notifications
You must be signed in to change notification settings - Fork 0
/
Copy pathindex.xml
489 lines (489 loc) · 67 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
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
<channel>
<title>David Haney - Blogging About .NET Core & Engineering Management</title>
<link>https://www.davidhaney.io/</link>
<description>Recent content on David Haney - Blogging About .NET Core & Engineering Management</description>
<generator>Hugo</generator>
<language>en</language>
<copyright>David Haney</copyright>
<lastBuildDate>Fri, 11 Oct 2024 17:38:25 -0400</lastBuildDate>
<atom:link href="https://www.davidhaney.io/index.xml" rel="self" type="application/rss+xml" />
<item>
<title>Configuring .NET Core Data Protection For Azure</title>
<link>https://www.davidhaney.io/configuring-net-core-data-protection-for-azure/</link>
<pubDate>Fri, 11 Oct 2024 09:25:18 -0400</pubDate>
<guid>https://www.davidhaney.io/configuring-net-core-data-protection-for-azure/</guid>
<description><p>Recently in <a href="https://www.codesession.io" target="_blank" rel="noopener">CodeSession</a>
 I encountered the following logged warning:</p>
<blockquote>
<p>No XML encryptor configured. Key {6848a46f-d0d6-49a6-b035-0f30f5448f9d} may be persisted to storage in unencrypted form.</p>
</blockquote>
<p>This was totally new to me, so I started Googling. There I learned all about <a href="https://learn.microsoft.com/en-us/aspnet/core/security/data-protection/introduction?view=aspnetcore-8.0" target="_blank" rel="noopener">.NET Core&rsquo;s Data Protection</a>
 API.</p>
<p>After reading the MS docs, this was still confusing. The documentation states that this API is used for things like .NET Authorization, but CodeSession doesn&rsquo;t use that functionality. So why was this happening?</p></description>
</item>
<item>
<title>Leaving Stack Overflow and Building CodeSession</title>
<link>https://www.davidhaney.io/leaving-stack-overflow-and-building-codesession/</link>
<pubDate>Mon, 07 Oct 2024 09:23:18 -0400</pubDate>
<guid>https://www.davidhaney.io/leaving-stack-overflow-and-building-codesession/</guid>
<description><p>It&rsquo;s amazing how quickly 4 years can go by. But I&rsquo;m back to blogging, and promise to follow this post with more regular entries going forward. In fact, I already have a technical topic scheduled for later this week, and plan to return to Engineering Management topics in the coming weeks as well.</p>
<p>So what have I been doing since my last blog post over 4 years ago? <strong>LOTS</strong>. Let&rsquo;s talk about it.</p></description>
</item>
<item>
<title>About David Haney</title>
<link>https://www.davidhaney.io/about/</link>
<pubDate>Sun, 29 Sep 2024 00:00:00 +0000</pubDate>
<guid>https://www.davidhaney.io/about/</guid>
<description><p>Hi, I&rsquo;m David Haney. I currently live in the Detroit Metropolitan Area of Michigan with my family. We moved here in late 2023. Prior to Michigan, I lived in Florida for 14 years. Prior to that, I was born and raised in Canada.</p>
<p>I have been programming most of my life. We didn&rsquo;t have a lot of disposable income, but my dad was given a home computer for his day job which was quite the luxury. It was a <a href="https://en.wikipedia.org/wiki/Macintosh_SE/30" target="_blank" rel="noopener">Macintosh SE/30</a>
 with an 80 MB HDD. I can still remember all the unique and quirkly sounds it made. Fun fact: to this day, turning on any Apple computer still makes the same warm-toned &ldquo;Happy Mac&rdquo; chime.</p></description>
</item>
<item>
<title>.NET Core MVC - How to Access appsettings.json</title>
<link>https://www.davidhaney.io/net-core-mvc-access-appsettings-json/</link>
<pubDate>Mon, 09 Nov 2020 00:00:00 -0500</pubDate>
<guid>https://www.davidhaney.io/net-core-mvc-access-appsettings-json/</guid>
<description><p>Well, once again I&rsquo;ve fallen off of the blogging wagon. And once again I am now getting back on said aforementioned wagon. Let&rsquo;s try and make this a more regular thing than once a year or so, shall we?</p>
<p>I recently built a quick little hobby site / side project with .NET Core MVC. I have a lot of experience with ASP.NET MVC but I was totally new to .NET Core MVC. As a result, I had to teach myself the new ways of doing old things.</p></description>
</item>
<item>
<title>Sabbatical Week One</title>
<link>https://www.davidhaney.io/sabbatical-week-one/</link>
<pubDate>Sun, 08 Sep 2019 00:00:00 -0500</pubDate>
<guid>https://www.davidhaney.io/sabbatical-week-one/</guid>
<description><p>Sabbatical week one is complete, and I&rsquo;m finally finding some time to blog about it!</p>
<p>I had a pretty active week. It started with hurricane preparations as Dorian burled toward Florida, however in the end we suffered a very light glancing blow. In short, we got off easy.</p>
<p>The Bahamas did not get so lucky, however, and got pretty messed up. I&rsquo;d love for you to take a moment to donate to their recovery here: <a href="https://www.bahamas.com/relief" target="_blank" rel="noopener">https://www.bahamas.com/relief</a>
.</p></description>
</item>
<item>
<title>Sabbatical Begins</title>
<link>https://www.davidhaney.io/sabbatical-begins/</link>
<pubDate>Sat, 31 Aug 2019 00:00:00 -0500</pubDate>
<guid>https://www.davidhaney.io/sabbatical-begins/</guid>
<description><p>One of the most amazing perks of working at Stack Overflow is the sabbatical. After 5 years of FT employment, you are entitled to 20 paid days off (outside of normal vacation) that you can spend however you please. My sabbatical officially begins on Tuesday (as Monday is a holiday).
Practically speaking, I am out from Aug 31 - Sept 30, returning to work Oct 1st. This is an amazing opportunity and benefit, and I can&rsquo;t thank Stack Overflow enough for how well they treat employees.</p></description>
</item>
<item>
<title>.NET Core Azure Functions Tutorial</title>
<link>https://www.davidhaney.io/net-core-azure-functions-tutorial/</link>
<pubDate>Mon, 19 Nov 2018 00:00:00 -0500</pubDate>
<guid>https://www.davidhaney.io/net-core-azure-functions-tutorial/</guid>
<description><p>In this post I&rsquo;d like to show you how I ported an Azure Classic Cloud Service application (which cost me $16 USD a month by the way) to a .NET Core Azure Function, and now host it in Azure for $0 a month! That&rsquo;s right - Azure Functions are both awesome and (usually) free!</p>
<h1 id="introducing-realdonaldtron">Introducing realDonaldTron</h1>
<p>So back in late 2016, when our dear leader was elected president, I decided to have a little fun at his expense. I created a <a href="https://www.twitter.com/realDonaldTron" target="_blank" rel="noopener">Twitter account</a>
 and generated API keys. I then created an Azure Classic Cloud Service and
wrote a quick and dirty Twitter bot. This bot consumes 1000s of the most recent tweets from Donald Trump, cleans up his grammar and punctuation a little (because he can&rsquo;t write words good), generates a <a href="https://en.wikipedia.org/wiki/Markov_chain" target="_blank" rel="noopener">Markov Chain</a>

from the Tweets, and then schedules a .NET Timer to generate and publish a new Tweet at the top of every hour.</p></description>
</item>
<item>
<title>New Blog Name and Domain</title>
<link>https://www.davidhaney.io/new-blog-name-and-domain/</link>
<pubDate>Fri, 03 Aug 2018 00:00:00 -0400</pubDate>
<guid>https://www.davidhaney.io/new-blog-name-and-domain/</guid>
<description><p>It&rsquo;s been a while since I changed things up, so I decided on a new Twitter handle and blog domain.</p>
<p>This site is now hosted at <a href="https://www.davidhaney.io" target="_blank" rel="noopener">davidhaney.io</a>
 and called &ldquo;David Haney&rdquo; which in my opinion is a much better (and more descriptive and maybe even more egotistical) domain than <a href="http://www.haneycodes.net" target="_blank" rel="noopener">haneycodes.net</a>
 and the old name of &ldquo;Haney Codes .NET&rdquo;</p>
<p>Don&rsquo;t worry - haneycodes.net deep links will redirect properly for years to come, so you won&rsquo;t miss anything at all. I&rsquo;ve told Google&rsquo;s search engine all about the change too, so links should work properly in results there as well.</p></description>
</item>
<item>
<title>Writing a Great Junior Tech Résumé</title>
<link>https://www.davidhaney.io/writing-a-great-junior-tech-resume/</link>
<pubDate>Tue, 24 Jul 2018 00:00:00 -0400</pubDate>
<guid>https://www.davidhaney.io/writing-a-great-junior-tech-resume/</guid>
<description><p>A few weeks back I wrote this tweet:</p>
<blockquote class="twitter-tweet" data-dnt="true"><p lang="en" dir="ltr">I did a presentation / speaking thing last week that got me thinking: would it be useful to blog about how to build a resume as someone new to tech, from the perspective of a hiring manager? I might whip that up today or tomorrow if people like the idea.</p>&mdash; David Haney hachyderm.io/@haney (@haneytron) <a href="https://twitter.com/haneytron/status/1016417664766443520?ref_src=twsrc%5Etfw">July 9, 2018</a></blockquote>


<p>43 likes later, it&rsquo;s clear to me that this topic is in-demand. So, let&rsquo;s skip over the pleasantries and talk about how you can create a great technical résumé as a junior developer, from the perspective of me (a hiring manager).</p></description>
</item>
<item>
<title>New Blog & Hiring Needs</title>
<link>https://www.davidhaney.io/new-blog-and-hiring-needs/</link>
<pubDate>Sat, 09 Jun 2018 13:56:24 -0400</pubDate>
<guid>https://www.davidhaney.io/new-blog-and-hiring-needs/</guid>
<description><p>Well I failed badly in my mission to blog every week of 2017. I guess life and stuff just got in the way in the end. I&rsquo;ll try to be more consistent in the second half of 2018.</p>
<p>Anyway, I bring some news: I have a new blog engine, and we are hiring at Stack Overflow!</p>
<h1 id="new-blog-engine">New blog engine</h1>
<p>I was previously using WordPress but had many issues and concerns with it. One of the biggest concerns was that the site was not mobile friendly, and making it responsive was next to impossible.</p></description>
</item>
<item>
<title>On Hiring: Developers Are Like Stocks</title>
<link>https://www.davidhaney.io/on-hiring-developers-are-like-stocks/</link>
<pubDate>Fri, 10 Feb 2017 11:11:30 +0000</pubDate>
<guid>https://www.davidhaney.io/on-hiring-developers-are-like-stocks/</guid>
<description><p>This post is for those of you who hire developers, and also junior developers who want to be hired. Let’s talk about how developers are just like individual stocks in the stock market. Time for a little role-playing: you’re now a stock market investor.</p>
<p>As a financial advisor, your company has given you $2,000,000 USD to invest in the stock market. It’s made very clear that the future of the company depends on the return on investment (herein called ROI) – “gains” – that your investments bring to the company. Your decisions will have a major impact on the company’s future. Given that kind of pressure, what’s your investment strategy for success? Begin by reviewing the kinds of stocks available to invest in.</p></description>
</item>
<item>
<title>GitLab Data Loss: A Discussion</title>
<link>https://www.davidhaney.io/gitlab-data-loss-a-discussion/</link>
<pubDate>Thu, 02 Feb 2017 11:33:02 +0000</pubDate>
<guid>https://www.davidhaney.io/gitlab-data-loss-a-discussion/</guid>
<description><p>In case you missed the big news in the industry this week, <a href="https://about.gitlab.com/2017/02/01/gitlab-dot-com-database-incident" target="_blank" rel="noopener">a GitLab employee accidentally deleted a ton of production data</a>
 and took their platform down for hours. It was only when everything was on fire and they were in deep trouble that they turned to their backup systems… only to find that none of them actually worked.</p>
<h1 id="backup-prod-data-regularly">Backup Prod Data Regularly</h1>
<p>Not exactly a groundbreaking statement, right? Everybody <em>knows</em> this. If there was a “working in corporate IT 101” manual it would have a chapter on this concept. It’s common sense.</p></description>
</item>
<item>
<title>Dev Team Interactions: Conducting Good Code Reviews</title>
<link>https://www.davidhaney.io/dev-team-interactions-conducting-good-code-reviews/</link>
<pubDate>Fri, 27 Jan 2017 10:03:20 +0000</pubDate>
<guid>https://www.davidhaney.io/dev-team-interactions-conducting-good-code-reviews/</guid>
<description><p>In part 2 of my series on dev team interactions, I’d like to talk about conducting good code reviews. Most dev teams will find themselves in a situation where code reviews are necessary, and in my experience many do them very poorly. I’ve even worked in companies that had such a negative code review culture that people left the review sessions upset, even considering quitting. With a few easy adjustments, you can quickly learn to conduct excellent and positive code reviews with your team.</p></description>
</item>
<item>
<title>Dev Team Interactions: Accountability & Blame</title>
<link>https://www.davidhaney.io/dev-team-interactions-accountability-blame/</link>
<pubDate>Fri, 20 Jan 2017 13:20:59 +0000</pubDate>
<guid>https://www.davidhaney.io/dev-team-interactions-accountability-blame/</guid>
<description><p>As a developer working for a company, you probably work on a team. The interactions on these teams are sometimes pleasant, and other times hostile. What’s interesting to me is that a lot of the time, a hostile interaction could have been a pleasant one if only approached differently. Hostile teams are created by the actions of the people on them, not by the situations they encounter. One such hostile action is blame.</p></description>
</item>
<item>
<title>Custom ASP.NET MVC Action Result Cache Attribute</title>
<link>https://www.davidhaney.io/custom-asp-net-mvc-action-result-cache-attribute/</link>
<pubDate>Tue, 10 Jan 2017 09:07:15 +0000</pubDate>
<guid>https://www.davidhaney.io/custom-asp-net-mvc-action-result-cache-attribute/</guid>
<description><p>If you’re working on an application built using ASP.NET MVC, you’re hopefully aware of the <a href="https://msdn.microsoft.com/en-us/library/system.web.mvc.outputcacheattribute%28v=vs.118%29.aspx" target="_blank" rel="noopener">OutputCacheAttribute</a>
 attribute which can be used to statically cache your dynamic web pages. By adding this attribute to a controller or action method, the output of the method(s) will be stored in memory. For example, if your action method renders a view, then the view page will be cached in memory. This cached view page is then available to the application for all subsequent requests (or until the item expires out of the cache), which can retrieve it from the memory rather than redoing the work to re-create the result again. This is the essence of caching: trading memory for performance.</p></description>
</item>
<item>
<title>Our Industry Needs Compassion</title>
<link>https://www.davidhaney.io/our-industry-needs-compassion/</link>
<pubDate>Tue, 03 Jan 2017 12:37:39 +0000</pubDate>
<guid>https://www.davidhaney.io/our-industry-needs-compassion/</guid>
<description><p>Well, I’ve utterly failed to blog at regular intervals, writing <a href="https://www.davidhaney.io/developer-compensation-stack-overflow-doesnt-stack-rank" target="_blank" rel="noopener">only</a>
 <a href="https://www.davidhaney.io/npm-left-pad-have-we-forgotten-how-to-program" target="_blank" rel="noopener">three</a>
 <a href="https://www.davidhaney.io/lets-talk-about-rock-stars-egos" target="_blank" rel="noopener">posts</a>
 in 2016. Ouch. To be fair, one of those posts is insanely famous (the one about NPM and left-pad.js), but still, I’ve really let my readers – and myself – down.</p>
<p>So, I resolve to write a blog post every single week of 2017, starting today. This will probably mean that I write slightly shorter posts, and maybe even multi-part series posts. My traditional style has been “come upon something that is really bothering me or is really tricky, and proceed to blog about it in great detail writing thousands of words for all to benefit from” which doesn’t really scale well. Instead I plan to take the approach of “write about a new or interesting topic each week, and see what people like and what they don’t like” which will hopefully be better.</p></description>
</item>
<item>
<title>Let's Talk About Rock Stars & Egos</title>
<link>https://www.davidhaney.io/lets-talk-about-rock-stars-egos/</link>
<pubDate>Fri, 17 Jun 2016 17:02:13 +0000</pubDate>
<guid>https://www.davidhaney.io/lets-talk-about-rock-stars-egos/</guid>
<description><h1 id="on-plumbers">On Plumbers</h1>
<p>Picture this situation: you woke up this morning to find that there’s no water coming through your valves and taps. No sink water. No shower water. Having no plumbing experience, you call around for a plumber.</p>
<h2 id="plumber-1">Plumber #1</h2>
<p>Plumber #1, let’s call him Mario, tells you he can’t be bothered to come check out your issue because it’s minor and he’s very important and too busy for it. You explain that you really need a plumber, and he explains he’ll do it for 1.5x what everybody else costs, and only if you have lunch and coffee ready for him when he arrives. You have no water, keep in mind, so making coffee is an extra special effort.</p></description>
</item>
<item>
<title>NPM & left-pad: Have We Forgotten How To Program?</title>
<link>https://www.davidhaney.io/npm-left-pad-have-we-forgotten-how-to-program/</link>
<pubDate>Wed, 23 Mar 2016 18:01:52 +0000</pubDate>
<guid>https://www.davidhaney.io/npm-left-pad-have-we-forgotten-how-to-program/</guid>
<description><h1 id="intro">Intro</h1>
<p>Okay developers, time to have a serious talk. As you are probably already aware, this week React, Babel, and a bunch of other high-profile packages on NPM broke. The reason they broke is rather astounding:</p>
<p>A simple NPM package called <a href="https://www.npmjs.com/package/left-pad" target="_blank" rel="noopener">left-pad</a>
 that was a dependency of their code.</p>
<p>left-pad, at the time of writing this, <a href="https://github.com/azer/left-pad" target="_blank" rel="noopener">has 11 stars on GitHub</a>
. The entire package is <a href="https://github.com/azer/left-pad/blob/master/index.js" target="_blank" rel="noopener">11 simple lines that implement a basic left-pad string function</a>
. In case those links ever die, here is the entire code of the left-pad package:</p></description>
</item>
<item>
<title>Developer Compensation: Stack Overflow Doesn't Stack Rank</title>
<link>https://www.davidhaney.io/developer-compensation-stack-overflow-doesnt-stack-rank/</link>
<pubDate>Fri, 26 Feb 2016 14:05:41 +0000</pubDate>
<guid>https://www.davidhaney.io/developer-compensation-stack-overflow-doesnt-stack-rank/</guid>
<description><h1 id="are-developers-good-negotiators">Are Developers Good Negotiators?</h1>
<p>Developers come from all walks of life, and have many unique interests, passions, and hobbies. Often the only thing that developers have in common is their love for programming. It follows that some are good negotiators; others get the double digit percentage finance rate at the dealership when they go in to buy that new car.</p>
<h1 id="how-does-your-company-determine-compensation">How Does Your Company Determine Compensation?</h1>
<p>When you hire developers, how do you decide on their salary? Do you allow for negotiations to take place? Is there a strategy in place where you offer a low value, expecting the candidate to counter with a higher number? Are you pleased when they don’t counter, and you get good talent for cheap?</p></description>
</item>
<item>
<title>Diversity Is Really Freaking Hard</title>
<link>https://www.davidhaney.io/diversity-is-really-freaking-hard/</link>
<pubDate>Thu, 24 Sep 2015 11:23:38 +0000</pubDate>
<guid>https://www.davidhaney.io/diversity-is-really-freaking-hard/</guid>
<description><h1 id="background">Background</h1>
<p>I’m going to discuss an important topic that affects everybody in tech: diversity.</p>
<p>No, this won’t be some preachy post about how diversity is great and how you should be a better human being. Rather, I’m going to tell you about the things I’ve experienced working on diversity – particularly the interesting events of the last few days that happened internally at Stack Overflow.</p>
<p>It’s no secret that the tech industry is not that diverse. It’s mostly dominated by white males, with a few women and minorities making appearances. Those who do enter the industry as a minority often feel marginalized and excluded.</p></description>
</item>
<item>
<title>Developer Turned Manager</title>
<link>https://www.davidhaney.io/developer-turned-manager/</link>
<pubDate>Mon, 03 Aug 2015 14:18:02 +0000</pubDate>
<guid>https://www.davidhaney.io/developer-turned-manager/</guid>
<description><p>In February of 2015, I was promoted to Engineering Manager at Stack Overflow. <a href="https://en.wikiquote.org/wiki/The_Hitchhiker%27s_Guide_to_the_Galaxy#Chapter_1_2" target="_blank" rel="noopener">This has made a lot of people very angry and been widely regarded as a bad move</a>
.</p>
<p>There are tons of things I’ve learned so far, some of which I’ve learned the hard way. There’s also a world of difference between managing code, and managing people who code. Your day to day work routine changes completely. You define success differently. You feel a little bit like you just rebooted your career and are starting over at the bottom of the skills ladder. It’s intimidating.</p></description>
</item>
<item>
<title>Developers Shouldn't Measure Twice, Cut Once</title>
<link>https://www.davidhaney.io/developers-shouldnt-measure-twice-cut-once/</link>
<pubDate>Wed, 15 Apr 2015 16:25:02 +0000</pubDate>
<guid>https://www.davidhaney.io/developers-shouldnt-measure-twice-cut-once/</guid>
<description><p>I was working on my fireplace this past weekend. Specifically I had just finished ripping down the old surface to the red brick, and then preparing the brick surface with a layer of thinset for tiling. I spent all of Saturday cutting tiles and then placing them on the fireplace surround and hearth. Even with help it took 11 hours to do, and about 8 hours of it was measuring and cutting tiles.</p></description>
</item>
<item>
<title>On Secretly Terrible Engineers - A Rebuttal</title>
<link>https://www.davidhaney.io/on-secretly-terrible-engineers-a-rebuttal/</link>
<pubDate>Mon, 09 Mar 2015 18:32:37 +0000</pubDate>
<guid>https://www.davidhaney.io/on-secretly-terrible-engineers-a-rebuttal/</guid>
<description><p>Today an article was brought to my attention. One that, at the time of writing this post, had hit the front page of various sites (including Hacker News) and had been shared over 2,600 times. The article is <a href="http://techcrunch.com/2015/03/08/on-secretly-terrible-engineers/" target="_blank" rel="noopener">On Secretly Terrible Engineers</a>
, which is a criticism of the tech industry and the mentality which it holds towards hiring both new and experienced developers/engineers.</p>
<p><strong>Spoiler:</strong> I strongly disagree with most of this article. If you aren’t open to debates and discussion, quit reading here and return to your normal activities.</p></description>
</item>
<item>
<title>The Recruiting Competitive Advantage</title>
<link>https://www.davidhaney.io/the-recruiting-competitive-advantage/</link>
<pubDate>Fri, 23 Jan 2015 12:04:37 +0000</pubDate>
<guid>https://www.davidhaney.io/the-recruiting-competitive-advantage/</guid>
<description><h1 id="a-job-listing">A Job Listing</h1>
<p>Let’s say you were walking down a street one day and noticed an ad for help wanted. It is posted in the window of a bakery. It reads:</p>
<blockquote>
<p>HELP WANTED:<br>
Need a baker for FT work. Must be familiar with modern baking methods such as ovens, barbecuing, and deep fryers. 5+ years experience with the Super 6 commercial baking oven required (aside: came out in 2014). Nice to haves include experience with butcher’s blocks, chopping meat, and making candles.</p></description>
</item>
<item>
<title>On Credentialism In Software Development</title>
<link>https://www.davidhaney.io/on-credentialism-in-software-development/</link>
<pubDate>Mon, 29 Dec 2014 16:00:27 +0000</pubDate>
<guid>https://www.davidhaney.io/on-credentialism-in-software-development/</guid>
<description><h1 id="intro">Intro</h1>
<p>We’re just two days from a brand new year and yet the primary measurement of a developer’s skill seems to be the same as it was 20 years ago. The most important classification to most companies is job title, as I talked about in great detail in <a href="https://www.davidhaney.io/the-trouble-with-job-titles" target="_blank" rel="noopener">my last post</a>
. The job title is acquired via working for a veritable slough of credentialist companies whose HR departments break it down very simply:</p></description>
</item>
<item>
<title>The Trouble With Job Titles</title>
<link>https://www.davidhaney.io/the-trouble-with-job-titles/</link>
<pubDate>Fri, 17 Oct 2014 18:41:14 +0000</pubDate>
<guid>https://www.davidhaney.io/the-trouble-with-job-titles/</guid>
<description><h1 id="intro">Intro</h1>
<p>I’ve had a good career so far. I began working full-time as a programmer in 2008. At that time my title was <strong>Junior Developer</strong>. I had a decent boss and cool co-workers, and I cut my teeth on Java and .NET. It was a good experience. After 2 years at that gig, I felt that it was time to move on.</p>
<p>I contacted recruiters, and one eventually found me a promotion: <strong>Systems Analyst</strong>. It came with a decent pay bump and so forth, as well as the luxury of dropping “<strong>Junior</strong>” from my job title. As this was a good deal all around, I took the offer.</p></description>
</item>
<item>
<title>iPhone 6: Style Over Substance</title>
<link>https://www.davidhaney.io/iphone-6-style-over-substance/</link>
<pubDate>Tue, 09 Sep 2014 19:22:53 +0000</pubDate>
<guid>https://www.davidhaney.io/iphone-6-style-over-substance/</guid>
<description><h1 id="intro">Intro</h1>
<p>Like many of you, today I watched the Apple media event in which they announced both the iPhone 6 and Apple Watch. I’m not going to talk about the watch, but instead about the phone.</p>
<p>For years Apple has been a true cachet brand. They are a luxury item that is sought after for status and image. I don’t blame anyone for owning an iPhone: they’re reasonably sexy and you get to show off the Apple branding. Good on you.</p></description>
</item>
<item>
<title>How I Got A Job At Stack Exchange</title>
<link>https://www.davidhaney.io/how-i-got-a-job-at-stack-exchange/</link>
<pubDate>Fri, 20 Jun 2014 16:59:10 +0000</pubDate>
<guid>https://www.davidhaney.io/how-i-got-a-job-at-stack-exchange/</guid>
<description><h1 id="intro">Intro</h1>
<p>Almost exactly 1 month ago today I found myself on a video call with Joel Spolsky. It feels insane to write that, even now, as it was a banner moment in my career. For me it was the equivalent of meeting a movie star who I had idolized since I was old enough to know what movies were. There had always been this Joel Spolsky guy throughout my career that I regularly read about and whose opinions on software development agreed with mine, and suddenly I was talking with him face to face. It was awesome.</p></description>
</item>
<item>
<title>How To Guarantee Dev Team Failure</title>
<link>https://www.davidhaney.io/how-to-guarantee-dev-team-failure/</link>
<pubDate>Wed, 07 May 2014 13:27:35 +0000</pubDate>
<guid>https://www.davidhaney.io/how-to-guarantee-dev-team-failure/</guid>
<description><h1 id="the-problem">The Problem</h1>
<p>I think that most devs would agree when I state that the definition of success in the corporate world of development places less emphasis on “good” code and more emphasis on “working” code. Working code is code that can be released to production on or before the deadline, regardless of performance or even bugs in most cases. As a developer, you ultimately feel as if you’ve failed when you toil for nights on end to meet steep deadlines and churn out crappy code. As a business, however, you’ve succeeded when you hit the deadline. My experience tells me that the typical metric upon which development teams are measured is often not quality of code or unit tests or even performance, but instead ability to meet deadlines and deliver solutions to clients. You’ve failed when you do not meet the deadlines and thus piss off the clients/customers. Your job has become a veritable boolean result with the outcomes of true and false. Deadline met? True. Deadline missed? False.</p></description>
</item>
<item>
<title>To Node.js Or Not To Node.js</title>
<link>https://www.davidhaney.io/to-node-js-or-not-to-node-js/</link>
<pubDate>Mon, 24 Mar 2014 16:41:25 +0000</pubDate>
<guid>https://www.davidhaney.io/to-node-js-or-not-to-node-js/</guid>
<description><h1 id="intro">Intro</h1>
<p><strong>Node.js – it has rapidly become the “new hotness” in the tech start-up realm.</strong> With each passing day, the fan base of Node lovers grows larger, spreading their rhetoric like a religion. How do you spot a Node.js user? Don’t worry, they’ll let you know.</p>
<p>One day you’re at a regular user group meeting, sipping soda and talking with some colleagues, when the subject turns to Node. “Have you guys tried Node.js?” asks one of the people in your group. “It’s all the rage. All of the cool kids in Silicon Valley are using it!” “What does it do?” you ask, only to be bombarded with a sales pitch worthy of the best of used car lots. “Oh, it’s amazing!” they reply, sipping their diet coke and shuffling their hipster fedora and backpack with MacBook Pro in it (or something like that), “It’s server side JavaScript. It runs on a single thread and it can do 100,000 web requests a second!” They glance at the group for the oohs and ahhs, but most people just stare back with amazement in their eyes. Then, your hipster Node-loving friend drops the words that start wars: <strong>“It’s way better than .NET”</strong> – and just like that, your group is hooked. They go home, download the Node.js tools, write “Hello World”, and suddenly they’re on their way to the next user group meeting to talk about how great Node is.</p></description>
</item>
<item>
<title>C# Probably Getting New "Safe Navigation" Operator "?."</title>
<link>https://www.davidhaney.io/c-probably-getting-new-safe-navigation-operator/</link>
<pubDate>Fri, 28 Feb 2014 11:47:08 +0000</pubDate>
<guid>https://www.davidhaney.io/c-probably-getting-new-safe-navigation-operator/</guid>
<description><p><a href="http://visualstudio.uservoice.com/forums/121579-visual-studio/suggestions/3990187-add-operator-to-c-?tracking_code=594c10a522f8e9bc987ee4a5e2c0b38d">It looks as if the Visual Studio dev team may be implementing a new operator in a future .NET release.</a> This is due in large part to community demand, which is pretty cool because it shows that the VS team is listening to their customer base; a key part of a successful product.</p>
<p>This new operator is likely going to take the syntax of <code>?.</code> and is known as the <strong>Safe Navigation Operator</strong>.</p></description>
</item>
<item>
<title>Trigger IValidatableObject.Validate When ModelState.IsValid is false</title>
<link>https://www.davidhaney.io/trigger-ivalidatableobject-validate-when-modelstate-isvalid-is-false/</link>
<pubDate>Wed, 05 Feb 2014 15:55:40 +0000</pubDate>
<guid>https://www.davidhaney.io/trigger-ivalidatableobject-validate-when-modelstate-isvalid-is-false/</guid>
<description><p>I recently came across an ASP.NET MVC issue at work where the validation for my Model was not firing correctly. The Model implemented the <code>IValidatableObject</code> interface and thus the <code>Validate</code> method which did some specific logic to ensure the state of the Model (the <code>ModelState</code>). This Model also had some <code>DataAnnotation</code> attributes on it to validate basic input.</p>
<p>Long story short, the issue I encountered was that when <code>ModelState.IsValid == false</code> due to failure of the <code>DataAnnotation</code> validation, the <code>IValidatableObject.Validate</code> method is not fired, even though I needed it to be. This problem arose due to a rare situation in which <code>ModeState.IsValid</code> was initially false but was later set to true in the Controller’s Action Method by some logic that removed errors from the <code>ModelState</code>.</p></description>
</item>
<item>
<title>Interview with InfoQ on SimplSockets</title>
<link>https://www.davidhaney.io/interview-with-infoq-on-simplsockets/</link>
<pubDate>Wed, 11 Dec 2013 10:54:43 +0000</pubDate>
<guid>https://www.davidhaney.io/interview-with-infoq-on-simplsockets/</guid>
<description><p><a href="http://www.infoq.com/author/Jonathan-Allen">Jonathan Allen of InfoQ</a> conducted an interview with me about one of my open source initiatives, <a href="https://github.com/haneytron/simplsockets">SimplSockets</a>. We discussed the value of TCP over HTTP and why Sockets are still relevant to programming.</p>
<p>I’d like to thank Jonathan and InfoQ for the opportunity – it was a great discussion. Check it out here: <a href="http://www.infoq.com/news/2013/12/SimplSockets"><a href="http://www.infoq.com/news/2013/12/SimplSockets" target="_blank" rel="noopener">http://www.infoq.com/news/2013/12/SimplSockets</a>
</a></p></description>
</item>
<item>
<title>MVC4 Conditional HTML Attributes</title>
<link>https://www.davidhaney.io/mvc4-conditional-html-attributes/</link>
<pubDate>Wed, 27 Nov 2013 00:34:25 +0000</pubDate>
<guid>https://www.davidhaney.io/mvc4-conditional-html-attributes/</guid>
<description><p>MVC4 made one simple and yet awesome improvement to View rendering that I don’t think many people are aware of.</p>
<p>Have you ever had to conditionally add an attribute to an HTML element in your MVC View based on the presence of a variable? The typical use case is applying a CSS class to a div. Most of the time that code looks something like this:</p>
<pre><code>&lt;div @(myClass == null ? &quot;&quot; : &quot;class=\&quot;&quot; + myClass + &quot;\&quot;&quot;)&gt;&lt;/div&gt;
</code></pre>
<p>What a pain – not only to write but to read… This destroys the View’s readability and clutters the HTML up big time!</p></description>
</item>
<item>
<title>Automatically Generate POCOs From DB With T4</title>
<link>https://www.davidhaney.io/automatically-generate-pocos-from-db-with-t4/</link>
<pubDate>Wed, 16 Oct 2013 21:35:51 +0000</pubDate>
<guid>https://www.davidhaney.io/automatically-generate-pocos-from-db-with-t4/</guid>
<description><p>The T4 template engine is insanely powerful. I didn’t really realize just how powerful it was until I had a use case for it today. I stood up a database with about 40 tables in it, and planned to use an ORM to access the database. To use the ORM, I needed POCOs (Plain Old C# Objects) that represented my database. Some of these tables had 30-50 or so columns and I didn’t want to code all of this by hand – it would take literally days.</p></description>
</item>
<item>
<title>Web API Mapping QueryString/Form Input</title>
<link>https://www.davidhaney.io/web-api-mapping-querystringform-input/</link>
<pubDate>Wed, 24 Jul 2013 17:55:12 +0000</pubDate>
<guid>https://www.davidhaney.io/web-api-mapping-querystringform-input/</guid>
<description><p>If you’re using the Web API as part of the MVC4 framework, you may encounter a scenario in which you must map parameters of strange names to variables for which characters of the name would be illegal. That wasn’t very clear, so let’s do this by example. Consider part of the Facebook API:</p>
<blockquote>
<p>Firstly, Facebook servers will make a single HTTP GET to your callback URL when you try to add or modify a subscription. A query string will be appended to your callback URL with the following parameters:</p></description>
</item>
<item>
<title>Generic Comparer</title>
<link>https://www.davidhaney.io/generic-comparer/</link>
<pubDate>Mon, 22 Apr 2013 14:53:17 +0000</pubDate>
<guid>https://www.davidhaney.io/generic-comparer/</guid>
<description><p>Have you ever had to write a comparer for a specific type, only to be frustrated when you needed to write a second and third comparer for other types? Fear not, a generic comparer can take care of this for you!</p>
<pre><code>/// &lt;summary&gt;
/// Compares two objects of any type.
/// &lt;/summary&gt;
/// &lt;typeparam name=&quot;T&quot;&gt;The type to be compared.&lt;/typeparam&gt;
public class GenericComparer&lt;T&gt; : IComparer&lt;T&gt;
{
 // The compare method
 private readonly Func&lt;T, T, int&gt; _compareMethod = null;

 /// &lt;summary&gt;
 /// The constructor.
 /// &lt;/summary&gt;
 /// &lt;param name=&quot;compareMethod&quot;&gt;The compare method.&lt;/param&gt;
 public GenericComparer(Func&lt;T, T, int&gt; compareMethod)
 {
 // Sanitize
 if (compareMethod == null)
 {
 throw new ArgumentNullException(&quot;compareMethod&quot;);
 }

 _compareMethod = compareMethod;
 }

 /// &lt;summary&gt;
 /// Compares two objects.
 /// &lt;/summary&gt;
 /// &lt;param name=&quot;x&quot;&gt;The first object.&lt;/param&gt;
 /// &lt;param name=&quot;y&quot;&gt;The second object.&lt;/param&gt;
 /// &lt;returns&gt;Less than 0 if x is less than y, greater than 
 /// 0 if x is greater than y, 0 if they are equal.&lt;/returns&gt;
 public int Compare(T x, T y)
 {
 return _compareMethod(x, y);
 }
}
</code></pre>
<p>Just pass a method to the constructor that takes 2 objects of type T and returns an int, and you’re all set!</p></description>
</item>
<item>
<title>One More Thing About List Binary Search</title>
<link>https://www.davidhaney.io/one-more-thing-about-list-binary-search/</link>
<pubDate>Sat, 30 Mar 2013 15:36:24 +0000</pubDate>
<guid>https://www.davidhaney.io/one-more-thing-about-list-binary-search/</guid>
<description><p>I wanted to point people to this link at DotNetPearls:</p>
<p><a href="http://www.dotnetperls.com/binarysearch"><a href="http://www.dotnetperls.com/binarysearch" target="_blank" rel="noopener">http://www.dotnetperls.com/binarysearch</a>
</a></p>
<p>They do an excellent, quick demonstration of <code>List&lt;T&gt;.BinarySearch</code> and show a graph that really drives home how much faster it is for large lists than a regular traversal!</p></description>
</item>
<item>
<title>Make Mostly Read, Seldom-Written Lists Much More Efficient</title>
<link>https://www.davidhaney.io/make-mostly-read-seldom-written-lists-much-more-efficient/</link>
<pubDate>Fri, 15 Mar 2013 17:11:42 +0000</pubDate>
<guid>https://www.davidhaney.io/make-mostly-read-seldom-written-lists-much-more-efficient/</guid>
<description><p>One of the many things that I do at work is run a full-blown Search Engine which I also developed from scratch. This Search Engine feeds all product related information to our websites. A search index consists of a pre-computed collection of products, their properties, a list of words that are correctly spelled, and some pre-computed faceted/guided navigation. A search index, until this week, took up approximately 10.7 gigs of memory. This was becoming too large as we added new products every single day.</p></description>
</item>
<item>
<title>A Better MIME Mapping Stealer!</title>
<link>https://www.davidhaney.io/a-better-mime-mapping-stealer/</link>
<pubDate>Tue, 12 Feb 2013 12:07:12 +0000</pubDate>
<guid>https://www.davidhaney.io/a-better-mime-mapping-stealer/</guid>
<description><p>In the interest of self-improvement and sharing knowledge, I felt that I should share an update to my last post. I discovered a slightly better way to create the GetMimeMapping delegate/method via reflection that involves less casting and overhead, and is more Object Oriented in a sense. It allows the signature of the reflected method to be Func&lt;string, string&gt; instead of MethodInfo. Code below, note the use of <a href="http://msdn.microsoft.com/en-us/library/53cz7sc6.aspx">Delegate.CreateDelegate(Type, MethodInfo)</a>:</p>
<pre><code>/// &lt;summary&gt;
/// Exposes the Mime Mapping method that Microsoft hid from us.
/// &lt;/summary&gt;
public static class MimeMappingStealer
{
 // The get mime mapping method
 private static readonly Func&lt;string, string&gt; _getMimeMappingMethod = null;

 /// &lt;summary&gt;
 /// Static constructor sets up reflection.
 /// &lt;/summary&gt;
 static MimeMappingStealer()
 {
 // Load hidden mime mapping class and method from System.Web
 var assembly = Assembly.GetAssembly(typeof(HttpApplication));
 Type mimeMappingType = assembly.GetType(&quot;System.Web.MimeMapping&quot;);
 _getMimeMappingMethod = 
		 (Func&lt;string, string&gt;)Delegate.CreateDelegate(typeof(Func&lt;string, string&gt;), 
			 mimeMappingType.GetMethod(&quot;GetMimeMapping&quot;, 
 BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public |
 BindingFlags.NonPublic | BindingFlags.FlattenHierarchy));
 }

 /// &lt;summary&gt;
 /// Exposes the hidden Mime mapping method.
 /// &lt;/summary&gt;
 /// &lt;param name=&quot;fileName&quot;&gt;The file name.&lt;/param&gt;
 /// &lt;returns&gt;The mime mapping.&lt;/returns&gt;
 public static string GetMimeMapping(string fileName)
 {
 return _getMimeMappingMethod(fileName);
 }
}</code></pre></description>
</item>
<item>
<title>Determine MIME Type from File Name</title>
<link>https://www.davidhaney.io/determine-mime-type-from-file-name/</link>
<pubDate>Mon, 11 Feb 2013 15:15:46 +0000</pubDate>
<guid>https://www.davidhaney.io/determine-mime-type-from-file-name/</guid>
<description><p>I recently had a need, in an ASP.NET MVC3 application, to read raw HTML, CSS, JS, and image files from disk and return them to the user… A sort of “pass-through” if you will. Normally I’d have simply routed to a custom HTTP handler per file type or just allowed MVC3 to map existing files to supply its own .NET HTTP handlers and do all of this work for me, but in this case I needed the mapped “directory” to switch behind the scenes based on Session settings… So I ultimately had to feed these files through a Controller and Action Method to gain access to the Session.</p></description>
</item>
<item>
<title>Published by Red Gate</title>
<link>https://www.davidhaney.io/published-by-red-gate/</link>
<pubDate>Fri, 18 Jan 2013 15:10:04 +0000</pubDate>
<guid>https://www.davidhaney.io/published-by-red-gate/</guid>
<description><p>As of today I’ve been published in an e-Book offered for free by <a href="http://www.red-gate.com">Red Gate!</a> It is called 50 Ways to Avoid, Find and Fix ASP.NET Performance Issues and contains many useful performance tips which have been contributed by various members of the .NET community. Many tips are ASP.NET MVC specific which is also a plus.</p>
<p>My tip is #3 and has to do with debugging Microsoft symbols.</p>
<p><a href="http://www.red-gate.com/products/dotnet-development/ants-performance-profiler/entrypage/avoid-find-fix-asp-problems">Get a free copy here – it has already taught me a few things I had never thought to consider!</a></p></description>
</item>
<item>
<title>But it Didn't Happen in DEV or QA!</title>
<link>https://www.davidhaney.io/but-it-didnt-happen-in-dev-or-qa/</link>
<pubDate>Sun, 02 Dec 2012 17:22:20 +0000</pubDate>
<guid>https://www.davidhaney.io/but-it-didnt-happen-in-dev-or-qa/</guid>
<description><p>Most of us have been there: you’ve written a fantastic application that performs perfectly in your Development and/or QA environments, but in Production something goes wrong. Your application spins out of control, utilizing 100% of your CPU. Maybe it simply stops responding as if it were deadlocked. Or maybe it simply crashes randomly. What now?</p>
<p>Logic tells you that you have a problem in the code somewhere that is only encountered in a Production-like environment… and if you could JUST get into the Production box, install Visual Studio (or at least the Remote Debugger), and debug the application, you’d be able to solve the problem. However, you can’t (because it’s Production!), and you can’t replicate the problem in any other environment. Maybe it’s because of stale Development or QA environment data compared to live Production data. Maybe it’s something else. You have no idea where to look to find and fix the problem in your application. For lack of eloquence: you’re screwed.</p></description>
</item>
<item>
<title>Visual Studio 2012 Intellisense Not Working - SOLVED</title>
<link>https://www.davidhaney.io/visual-studio-2012-intellisense-not-working-solved/</link>
<pubDate>Tue, 20 Nov 2012 21:12:41 +0000</pubDate>
<guid>https://www.davidhaney.io/visual-studio-2012-intellisense-not-working-solved/</guid>
<description><p>So, this post is about our beloved IDE instead of actual code.</p>
<p>I recently upgraded my home PC from Visual Studio 2010 and 11 Beta to Visual Studio 2012. The very first thing I noticed was that after about 10 minutes of programming my Intellisense quit working and never came back. I thought to myself “what the hell Visual Studio? 2010 didn’t have these problems?!” and then, after a swig of beer, proceeded to exercise my Google-Fu to solve this issue.</p></description>
</item>
<item>
<title>Static vs Instance string.Equals Benchmark</title>
<link>https://www.davidhaney.io/static-vs-instance-string-equals-benchmark/</link>
<pubDate>Wed, 24 Oct 2012 16:57:14 +0000</pubDate>
<guid>https://www.davidhaney.io/static-vs-instance-string-equals-benchmark/</guid>
<description><p>A friend of mine commented on my last post asking about how much faster the static string.Equals method is than the instance string.Equals method. To satiate both of our curiosities, I have created this benchmarking application:</p>
<pre><code>static void Main(string[] args)
{
 var stopwatch = new Stopwatch();

 string a = &quot;hello&quot;;
 string b = &quot;hi&quot;;

 stopwatch.Start();
 for (int i = 0; i &lt; 10000000; i++)
 {
 a.Equals(b);
 }
 stopwatch.Stop();

 Console.WriteLine(&quot;Instance string.Equals over 10,000,000 iterations: &quot; 
	 + stopwatch.ElapsedMilliseconds + &quot; ms&quot;);

 stopwatch.Reset();

 stopwatch.Start();
 for (int i = 0; i &lt; 10000000; i++)
 {
 string.Equals(a, b);
 }
 stopwatch.Stop();

 Console.WriteLine(&quot;Static string.Equals over 10,000,000 iterations: &quot;
	 + stopwatch.ElapsedMilliseconds + &quot; ms&quot;);

 Console.ReadKey();
}
</code></pre>
<p>The results of 5 runs, where “I” is the instance method and “S” is the static method, and the times are in milliseconds:</p></description>
</item>
<item>
<title>Static vs Instance string.Equals</title>
<link>https://www.davidhaney.io/static-vs-reference-string-equals/</link>
<pubDate>Mon, 22 Oct 2012 14:57:14 +0000</pubDate>
<guid>https://www.davidhaney.io/static-vs-reference-string-equals/</guid>
<description><p>As you may or may not know, <a href="http://stackoverflow.com/a/2142088">static methods are usually faster than instance methods</a>. This alone should be a good enough reason to use the <a href="http://msdn.microsoft.com/en-us/library/1hkt4325.aspx">static string.Equals method</a> in .NET, but if that doesn’t do it for you, allow me to present a simple example.</p>
<pre><code>string a = &quot;hello&quot;;
string b = &quot;hi&quot;;
bool result = a.Equals(b);
</code></pre>
<p>What is the expected result of these lines? A boolean value of false, of course. And it’d be true if the strings were identical. It’s also false if b is null. But what if a is null?</p></description>
</item>
<item>
<title>The Joel Test Really is Meaningful</title>
<link>https://www.davidhaney.io/the-joel-test-really-is-meaningful/</link>
<pubDate>Sun, 14 Oct 2012 22:10:54 +0000</pubDate>
<guid>https://www.davidhaney.io/the-joel-test-really-is-meaningful/</guid>
<description><p>Well, it’s been nearly 2 months since my last post… I’m learning that if you want a blog to be successful, you have to carve time out of your busy life and make it happen. So, with renewed focus, I re-enter the fray.</p>
<p><a href="http://www.joelonsoftware.com/articles/fog0000000043.html">The Joel Test</a> is a curious and honest thing. It has been around since the year 2000 and was invented by a guy named Joel Spolsky, as the name might imply. In short, it’s a very brief questionnaire that evaluates the quality of your software development team, and implicitly their happiness as well.</p></description>
</item>
<item>
<title>Published by MDSN UK Blog</title>
<link>https://www.davidhaney.io/published-by-mdsn-uk-blog/</link>
<pubDate>Sun, 26 Aug 2012 23:49:41 +0000</pubDate>
<guid>https://www.davidhaney.io/published-by-mdsn-uk-blog/</guid>
<description><p>This isn’t a very technical post, but I was published by Microsoft recently via their MSDN UK Blog! The article is on creating and maintaining a successful User Group.</p>
<p><a href="http://blogs.msdn.com/b/ukmsdn/archive/2012/08/23/user-groups-lidnug-49-000-strong-and-growing.aspx">Click here to read the article!</a></p></description>
</item>
<item>
<title>TPL and Error Handling & Continuation Tasks</title>
<link>https://www.davidhaney.io/tpl-and-error-handling-continuations/</link>
<pubDate>Sun, 12 Aug 2012 23:21:30 +0000</pubDate>
<guid>https://www.davidhaney.io/tpl-and-error-handling-continuations/</guid>
<description><p>Two of my colleagues (one from work and one from a user group) kindly pointed out to me that in my last post I omitted <a href="http://msdn.microsoft.com/en-us/library/ee372288.aspx">Continuation Tasks</a> as a means of Error Handling for the TPL. As such, I will expand upon my last post with an example of handling errors via a Continuation Task.</p>
<p>Continuing where we left off last, the following code will utilize a Task Continuation to handle errors within Tasks.</p></description>
</item>
<item>
<title>TPL and Error Handling</title>
<link>https://www.davidhaney.io/tpl-and-error-handling/</link>
<pubDate>Sun, 05 Aug 2012 13:39:38 +0000</pubDate>
<guid>https://www.davidhaney.io/tpl-and-error-handling/</guid>
<description><p>As of .NET 4.0, the TPL or Task Parallel Library is king when it comes to parallelization. It allows for smooth, easy multi-threading for any application. There is a slight learning curve, however, and a major part of this is understanding how Exceptions bubble-up while using the TPL.</p>
<p>Let’s partake in a simple example. This code will create and run a task that throws an Exception, and then attempt to catch it:</p></description>
</item>
<item>
<title>Compiler Tricks - Inferred Types</title>
<link>https://www.davidhaney.io/compiler-tricks-inferred-types/</link>
<pubDate>Mon, 16 Jul 2012 00:33:54 +0000</pubDate>
<guid>https://www.davidhaney.io/compiler-tricks-inferred-types/</guid>
<description><p>The .NET compiler is a terrific thing… After all, it turns your C# into an executable program!</p>
<p>One nice feature of the .NET compiler, which is becoming better each release, is inferred typing. I’d like to lay out a few short examples that might help you develop your programming standards and practices.</p>
<p>Inferring a type when creating an array.</p>
<pre><code>// Create and initialize an array
var myArray = new int[] { 1, 2, 3 };
</code></pre>
<p>Becomes:</p></description>
</item>
<item>
<title>Custom Output Caching with MVC3 and .NET 4.0 - Done Properly!</title>
<link>https://www.davidhaney.io/custom-output-caching-with-mvc3-and-net-4-0-done-right/</link>
<pubDate>Wed, 20 Jun 2012 00:47:52 +0000</pubDate>
<guid>https://www.davidhaney.io/custom-output-caching-with-mvc3-and-net-4-0-done-right/</guid>
<description><p>I came across a need at work today to re-implement some of the Output Caching for our MVC3 application which runs under .NET 4.0. I wanted to use standard Output Caching (via the <a href="http://msdn.microsoft.com/en-us/library/system.web.mvc.outputcacheattribute(v=vs.98).aspx">OutputCacheAttribute</a> class, why re-invent the well-working wheel?) but due to some of our requirements I needed more control over how my objects were cached. More specifically, I needed to cache them with a custom Cache Dependency. With a little bit of Google-Fu, <a href="http://weblogs.asp.net/scottgu/archive/2010/01/27/extensible-output-caching-with-asp-net-4-vs-2010-and-net-4-0-series.aspx">I was delighted to learn of the Output Cache Provider functionality introduced in ASP.NET 4.</a> I implemented a custom <a href="http://msdn.microsoft.com/en-us/library/system.web.caching.outputcacheprovider.aspx">OutputCacheProvider</a>, registered it in my Web.config file as the Default Cache Provider, and I was well on my way.</p></description>
</item>
<item>
<title>LINQ and Deferred Execution</title>
<link>https://www.davidhaney.io/linq-and-deferred-execution/</link>
<pubDate>Mon, 11 Jun 2012 00:57:15 +0000</pubDate>
<guid>https://www.davidhaney.io/linq-and-deferred-execution/</guid>
<description><p>As of .NET 3.0, LINQ (and the often related Lambda Expressions) have been available for our use and abuse. LINQ stands for Language INtegrated Query, and is a method of modelling OO data in a more or less relational sense that is not unlike databases. And just like databases, it comes with a cost.</p>
<p>To offset this cost, LINQ uses Deferred Execution. Deferred Execution means that the code is not executed until it is needed. This means that the LINQ code that you write is not actually executed until you NEED to execute it – typically during an enumeration of the results.</p></description>
</item>
<item>
<title>Make Your Debugging Life Easier</title>
<link>https://www.davidhaney.io/make-your-debugging-life-easier/</link>
<pubDate>Fri, 25 May 2012 20:25:36 +0000</pubDate>
<guid>https://www.davidhaney.io/make-your-debugging-life-easier/</guid>
<description><p>Sorry for the delay in posts, May has been a very busy month.</p>
<p>In order to accurately debug or profile an external assembly or library (AKA one you’re not directly compiling), you need the associated <b>PDB files</b> to accompany each of the DLLs. These files give the debugger some information about the compiled assembly so that your debugger or profiler can become aware of function names, line numbers, and other related meta data.</p></description>
</item>
<item>
<title>Who Loves Interns?</title>
<link>https://www.davidhaney.io/who-loves-interns/</link>
<pubDate>Wed, 02 May 2012 23:50:20 +0000</pubDate>
<guid>https://www.davidhaney.io/who-loves-interns/</guid>
<description><p>The topic at hand is interning. More specifically, string interning.</p>
<p>“What is string interning?” you ask? Good question. As you may or may not know, strings are immutable reference types. This means that they are read-only and a pointer will refer to the string’s location on the heap. Typically, a new string is created and stored within your application’s memory each time that you assign a string – <em>even if the same string is defined repeatedly.</em> What this means is that you can define the same string N times and have it take up the string’s memory N times. This sucks when dealing with repeating string data.</p></description>
</item>
<item>
<title>What is a Virtual Method, Anyway?</title>
<link>https://www.davidhaney.io/what-is-a-virtual-method-anyway/</link>
<pubDate>Sun, 29 Apr 2012 23:26:41 +0000</pubDate>
<guid>https://www.davidhaney.io/what-is-a-virtual-method-anyway/</guid>
<description><p>Something which I feel carries a lot of confusion in the .NET realm is virtual methods. During interviews, I tend to ask candidates about virtual methods: why and when they’d use one, what the purposes is, how a virtual method “works” under the hood, and how it differs from “shadowing”. Surprisingly, in what has probably been over one hundred interviews with senior-ish candidates, I don’t believe that more than one or two of them have answered anything about virtual methods correctly. From this I conclude that the understanding of virtual methods is not strong among the typical developer… And so, let us dive in.</p></description>
</item>
<item>
<title>Why Use Interfaces?</title>
<link>https://www.davidhaney.io/why-use-interfaces/</link>
<pubDate>Thu, 26 Apr 2012 23:51:18 +0000</pubDate>
<guid>https://www.davidhaney.io/why-use-interfaces/</guid>
<description><p>I’m a bit tipsy at the moment, so hopefully this post goes well.</p>
<p>A question that I like to ask while interviewing individuals is: “why would you want to use an interface?” I get a ton of answers that span the supposed gamut of programming; some are good and some are of course terrible, however I’d like to share some input on what I feel is the importance of interfaces.</p></description>
</item>
<item>
<title>An Overview of Generic Constraints</title>
<link>https://www.davidhaney.io/an-overview-of-generic-constraints/</link>
<pubDate>Tue, 24 Apr 2012 21:46:41 +0000</pubDate>
<guid>https://www.davidhaney.io/an-overview-of-generic-constraints/</guid>
<description><p>This is my first post. I hope that it doesn’t suck.</p>
<p>As of .NET 2.0, Microsoft introduced the concept of generics. Generics is a concept that allow you to “template” methods and types such as classes and interfaces in a (generally) type-safe way. Upon compilation, generic type metadata is stored in IL, and JIT’d as you reference the generic method or class with an actual type at runtime. Value types each get their own “copy” of the JIT’d generic code, whereas reference types share a single instance of the code. This is because the generic implementation is identical for reference types – they’re all just pointers.</p></description>
</item>
<item>
<title></title>
<link>https://www.davidhaney.io/manifest.json</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://www.davidhaney.io/manifest.json</guid>
<description></description>
</item>
<item>
<title></title>
<link>https://www.davidhaney.io/search/_index.de/</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://www.davidhaney.io/search/_index.de/</guid>
<description></description>
</item>
<item>
<title></title>
<link>https://www.davidhaney.io/search/_index.es/</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://www.davidhaney.io/search/_index.es/</guid>
<description></description>
</item>
<item>
<title></title>
<link>https://www.davidhaney.io/search/_index.fr/</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://www.davidhaney.io/search/_index.fr/</guid>
<description></description>
</item>
<item>
<title></title>
<link>https://www.davidhaney.io/search/_index.hi/</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://www.davidhaney.io/search/_index.hi/</guid>
<description></description>
</item>
<item>
<title></title>
<link>https://www.davidhaney.io/search/_index.jp/</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://www.davidhaney.io/search/_index.jp/</guid>
<description></description>
</item>
<item>
<title></title>
<link>https://www.davidhaney.io/search/_index.nl/</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://www.davidhaney.io/search/_index.nl/</guid>
<description></description>
</item>
<item>
<title></title>
<link>https://www.davidhaney.io/search/_index.pl/</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://www.davidhaney.io/search/_index.pl/</guid>
<description></description>
</item>
<item>
<title></title>
<link>https://www.davidhaney.io/search/_index.ru/</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://www.davidhaney.io/search/_index.ru/</guid>
<description></description>
</item>
<item>
<title></title>
<link>https://www.davidhaney.io/search/_index.zh-cn/</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://www.davidhaney.io/search/_index.zh-cn/</guid>
<description></description>
</item>
</channel>
</rss>