-
Notifications
You must be signed in to change notification settings - Fork 0
/
atom.xml
483 lines (386 loc) · 31.1 KB
/
atom.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
<?xml version="1.0" encoding="utf-8"?>
<feed xmlns="http://www.w3.org/2005/Atom">
<title><![CDATA[Fernando Correia's Blog]]></title>
<link href="http://www.fernandocorreia.info/atom.xml" rel="self"/>
<link href="http://www.fernandocorreia.info/"/>
<updated>2012-08-10T21:50:14-03:00</updated>
<id>http://www.fernandocorreia.info/</id>
<author>
<name><![CDATA[Fernando Correia]]></name>
<email><![CDATA[fernandoacorreia@gmail.com]]></email>
</author>
<generator uri="http://octopress.org/">Octopress</generator>
<entry>
<title type="html"><![CDATA[Learning Dojo Toolkit: Hello World]]></title>
<link href="http://www.fernandocorreia.info/blog/2012/08/10/learning-dojo-toolkit-hello-world/"/>
<updated>2012-08-10T20:55:00-03:00</updated>
<id>http://www.fernandocorreia.info/blog/2012/08/10/learning-dojo-toolkit-hello-world</id>
<content type="html"><![CDATA[<p>After updating myself on the current situation of the <a href="http://dojotoolkit.org/">Dojo Toolkit</a>,
my first practical step to start learning it was to follow along the first tutorial,
<a href="http://dojotoolkit.org/documentation/tutorials/1.7/hello_dojo/">Hello Dojo!</a>.</p>
<p>That tutorial gives a few basic pointers on including Dojo from a CDN and on basic application
structure. It’s well-written and easy to follow along. It covers the creation
of several variations of a page and, although it has links to see the pages running online, it
doesn’t have a link to get the complete code, with modules, styles and all.</p>
<p>As an exercise, I decided to create my own variation of this Hello World application and, simple
as it is, host it in a <a href="https://github.com/fernandoacorreia/blog-samples/tree/master/dojo/hello-dojo">repository</a>.</p>
<!-- more -->
<figure class='code'><figcaption>dojo/hello-dojo/index.html <a href='https://github.com/fernandoacorreia/blog-samples/blob/master/dojo/hello-dojo/index.html'>GitHub</a></figcaption>
<div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
<span class='line-number'>15</span>
<span class='line-number'>16</span>
<span class='line-number'>17</span>
<span class='line-number'>18</span>
<span class='line-number'>19</span>
<span class='line-number'>20</span>
<span class='line-number'>21</span>
<span class='line-number'>22</span>
<span class='line-number'>23</span>
<span class='line-number'>24</span>
<span class='line-number'>25</span>
<span class='line-number'>26</span>
<span class='line-number'>27</span>
<span class='line-number'>28</span>
<span class='line-number'>29</span>
<span class='line-number'>30</span>
<span class='line-number'>31</span>
<span class='line-number'>32</span>
<span class='line-number'>33</span>
<span class='line-number'>34</span>
<span class='line-number'>35</span>
<span class='line-number'>36</span>
<span class='line-number'>37</span>
<span class='line-number'>38</span>
<span class='line-number'>39</span>
<span class='line-number'>40</span>
<span class='line-number'>41</span>
<span class='line-number'>42</span>
<span class='line-number'>43</span>
<span class='line-number'>44</span>
<span class='line-number'>45</span>
</pre></td><td class='code'><pre><code class='html'><span class='line'><span class="cp"><!DOCTYPE html></span>
</span><span class='line'><span class="nt"><html></span>
</span><span class='line'><span class="nt"><head></span>
</span><span class='line'> <span class="nt"><meta</span> <span class="na">charset=</span><span class="s">"utf-8"</span><span class="nt">></span>
</span><span class='line'> <span class="nt"><title></span>Hello Dojo<span class="nt"></title></span>
</span><span class='line'> <span class="nt"><link</span> <span class="na">rel=</span><span class="s">"stylesheet"</span> <span class="na">href=</span><span class="s">"style/demo.css"</span><span class="nt">></span>
</span><span class='line'> <span class="nt"><script></span>
</span><span class='line'> <span class="c1">// Instead of using data-dojo-config, we’re creating a dojoConfig object</span>
</span><span class='line'> <span class="c1">// *before* we load dojo.js; they’re functionally identical.</span>
</span><span class='line'> <span class="kd">var</span> <span class="nx">dojoConfig</span> <span class="o">=</span> <span class="p">{</span>
</span><span class='line'> <span class="nx">async</span><span class="o">:</span> <span class="kc">true</span><span class="p">,</span>
</span><span class='line'> <span class="c1">// This code registers the correct location of the "app" package</span>
</span><span class='line'> <span class="c1">// so we can load Dojo from the CDN whilst still being able to</span>
</span><span class='line'> <span class="c1">// load local modules</span>
</span><span class='line'> <span class="nx">packages</span><span class="o">:</span> <span class="p">[{</span>
</span><span class='line'> <span class="nx">name</span><span class="o">:</span> <span class="s2">"app"</span><span class="p">,</span>
</span><span class='line'> <span class="nx">location</span><span class="o">:</span> <span class="nx">location</span><span class="p">.</span><span class="nx">pathname</span><span class="p">.</span><span class="nx">replace</span><span class="p">(</span><span class="sr">/\/[^/]+$/</span><span class="p">,</span> <span class="s1">''</span><span class="p">)</span> <span class="o">+</span> <span class="s1">'app'</span>
</span><span class='line'> <span class="p">}]</span>
</span><span class='line'> <span class="p">};</span>
</span><span class='line'> <span class="nt"></script></span>
</span><span class='line'> <span class="c"><!-- load Dojo --></span>
</span><span class='line'> <span class="nt"><script </span><span class="na">src=</span><span class="s">"//ajax.googleapis.com/ajax/libs/dojo/1.7.2/dojo/dojo.js"</span><span class="nt">></script></span>
</span><span class='line'><span class="nt"></head></span>
</span><span class='line'><span class="nt"><body></span>
</span><span class='line'> <span class="nt"><h1</span> <span class="na">id=</span><span class="s">"greeting"</span><span class="nt">></span>Hello, world!<span class="nt"></h1></span>
</span><span class='line'> <span class="nt"><script></span>
</span><span class='line'> <span class="c1">// Require the module we created, plus dojo/fx, and wait for DOM ready</span>
</span><span class='line'> <span class="nx">require</span><span class="p">([</span><span class="s2">"app/myModule"</span><span class="p">,</span> <span class="s2">"dojo/fx"</span><span class="p">,</span> <span class="s2">"dojo/domReady!"</span><span class="p">],</span> <span class="kd">function</span><span class="p">(</span><span class="nx">myModule</span><span class="p">,</span> <span class="nx">fx</span><span class="p">){</span>
</span><span class='line'> <span class="c1">// Use our module to change the text in the greeting</span>
</span><span class='line'> <span class="nx">myModule</span><span class="p">.</span><span class="nx">setText</span><span class="p">(</span><span class="s2">"greeting"</span><span class="p">,</span> <span class="s2">"Hello, Dojo!"</span><span class="p">);</span>
</span><span class='line'>
</span><span class='line'> <span class="nx">fx</span><span class="p">.</span><span class="nx">slideTo</span><span class="p">({</span>
</span><span class='line'> <span class="nx">top</span><span class="o">:</span> <span class="mi">100</span><span class="p">,</span>
</span><span class='line'> <span class="nx">left</span><span class="o">:</span> <span class="mi">200</span><span class="p">,</span>
</span><span class='line'> <span class="nx">node</span><span class="o">:</span> <span class="nx">greeting</span>
</span><span class='line'> <span class="p">}).</span><span class="nx">play</span><span class="p">();</span>
</span><span class='line'>
</span><span class='line'> <span class="c1">// After a few seconds, restore the text to its original state</span>
</span><span class='line'> <span class="nx">setTimeout</span><span class="p">(</span><span class="kd">function</span><span class="p">(){</span>
</span><span class='line'> <span class="nx">myModule</span><span class="p">.</span><span class="nx">restoreText</span><span class="p">(</span><span class="s2">"greeting"</span><span class="p">);</span>
</span><span class='line'> <span class="p">},</span> <span class="mi">3000</span><span class="p">);</span>
</span><span class='line'> <span class="p">});</span>
</span><span class='line'> <span class="nt"></script></span>
</span><span class='line'><span class="nt"></body></span>
</span><span class='line'><span class="nt"></html></span>
</span></code></pre></td></tr></table></div>
</figure>
<p>The application’s HTML page defines a Dojo configuration object (<code>dojoConfig</code>) that activates
asynchronous module loading and sets the location of the <code>app</code> module (which will be defined below).
This last step is necessary because Dojo will be loaded from a CDN and the application itself won’t be hosted
in that domain, so Dojo has to know where our module can be found.</p>
<p>The script section inside the body references the modules it needs, which Dojo will load automatically
and asynchronously. The last referenced module is the <code>dojo/domReady!</code> plugin, which will have the effect of
making the application wait for the DOM ready event before continuing.
Next, it calls the <code>setText</code> function in our application’s module to set the text of a greeting,
uses a transition from the <code>dojo/fx</code> module to reposition this greeting on the page and sets a timeout that,
after a few seconds, will reset the text of the greeting using the <code>restoreText</code> function in our application’s
module.</p>
<figure class='code'><figcaption>dojo/hello-dojo/app/myModule.js <a href='https://github.com/fernandoacorreia/blog-samples/blob/master/dojo/hello-dojo/app/myModule.js'>GitHub</a></figcaption>
<div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
<span class='line-number'>15</span>
<span class='line-number'>16</span>
<span class='line-number'>17</span>
<span class='line-number'>18</span>
<span class='line-number'>19</span>
<span class='line-number'>20</span>
<span class='line-number'>21</span>
<span class='line-number'>22</span>
<span class='line-number'>23</span>
<span class='line-number'>24</span>
<span class='line-number'>25</span>
<span class='line-number'>26</span>
<span class='line-number'>27</span>
<span class='line-number'>28</span>
<span class='line-number'>29</span>
<span class='line-number'>30</span>
<span class='line-number'>31</span>
</pre></td><td class='code'><pre><code class='js'><span class='line'><span class="c1">// In app/myModule.js (which means this code defines</span>
</span><span class='line'><span class="c1">// the "app/myModule" module):</span>
</span><span class='line'>
</span><span class='line'><span class="nx">define</span><span class="p">([</span>
</span><span class='line'> <span class="c1">// The dojo/dom module is required by this module, so it goes</span>
</span><span class='line'> <span class="c1">// in this list of dependencies.</span>
</span><span class='line'> <span class="s2">"dojo/dom"</span>
</span><span class='line'><span class="p">],</span> <span class="kd">function</span><span class="p">(</span><span class="nx">dom</span><span class="p">){</span>
</span><span class='line'> <span class="c1">// Once all modules in the dependency list have loaded, this</span>
</span><span class='line'> <span class="c1">// function is called to define the app/myModule module.</span>
</span><span class='line'> <span class="c1">//</span>
</span><span class='line'> <span class="c1">// The dojo/dom module is passed as the first argument to this</span>
</span><span class='line'> <span class="c1">// function; additional modules in the dependency list would be</span>
</span><span class='line'> <span class="c1">// passed in as subsequent arguments.</span>
</span><span class='line'>
</span><span class='line'> <span class="kd">var</span> <span class="nx">oldText</span> <span class="o">=</span> <span class="p">{};</span>
</span><span class='line'>
</span><span class='line'> <span class="c1">// This returned object becomes the defined value of this module</span>
</span><span class='line'> <span class="k">return</span> <span class="p">{</span>
</span><span class='line'> <span class="nx">setText</span><span class="o">:</span> <span class="kd">function</span><span class="p">(</span><span class="nx">id</span><span class="p">,</span> <span class="nx">text</span><span class="p">){</span>
</span><span class='line'> <span class="kd">var</span> <span class="nx">node</span> <span class="o">=</span> <span class="nx">dom</span><span class="p">.</span><span class="nx">byId</span><span class="p">(</span><span class="nx">id</span><span class="p">);</span>
</span><span class='line'> <span class="nx">oldText</span><span class="p">[</span><span class="nx">id</span><span class="p">]</span> <span class="o">=</span> <span class="nx">node</span><span class="p">.</span><span class="nx">innerHTML</span><span class="p">;</span>
</span><span class='line'> <span class="nx">node</span><span class="p">.</span><span class="nx">innerHTML</span> <span class="o">=</span> <span class="nx">text</span><span class="p">;</span>
</span><span class='line'> <span class="p">},</span>
</span><span class='line'> <span class="nx">restoreText</span><span class="o">:</span> <span class="kd">function</span><span class="p">(</span><span class="nx">id</span><span class="p">){</span>
</span><span class='line'> <span class="kd">var</span> <span class="nx">node</span> <span class="o">=</span> <span class="nx">dom</span><span class="p">.</span><span class="nx">byId</span><span class="p">(</span><span class="nx">id</span><span class="p">);</span>
</span><span class='line'> <span class="nx">node</span><span class="p">.</span><span class="nx">innerHTML</span> <span class="o">=</span> <span class="nx">oldText</span><span class="p">[</span><span class="nx">id</span><span class="p">];</span>
</span><span class='line'> <span class="k">delete</span> <span class="nx">oldText</span><span class="p">[</span><span class="nx">id</span><span class="p">];</span>
</span><span class='line'> <span class="p">}</span>
</span><span class='line'> <span class="p">};</span>
</span><span class='line'><span class="p">});</span>
</span></code></pre></td></tr></table></div>
</figure>
<p>The <code>app/myModule.js</code> file defines our application’s module, which is referred to in <code>index.html</code>.
This module declares an array to store values, and two functions: one to set the innerHTML
of a DOM element, and another to restore it to the value it had before.</p>
<p>So, that’s the basic structure of a Dojo application that does a lot of things:</p>
<ul>
<li>loads the library from a CDN;</li>
<li>asynchronously loads modules on demand from the same CDN;</li>
<li>loads a custom module defined by our application;</li>
<li>manipulates DOM elements;</li>
<li>applies a visual effect.</li>
</ul>
<p>Even in such a small example, it’s obvious that the module system can scale to efficiently support
large and complex applications.</p>
<p>If you want to better understand what’s going on I suggest you read the
<a href="http://dojotoolkit.org/documentation/tutorials/1.7/hello_dojo/">official tutorial</a> itself.</p>
<p>You’ll find my code on <a href="https://github.com/fernandoacorreia/blog-samples/tree/master/dojo/hello-dojo">GitHub</a>.</p>
]]></content>
</entry>
<entry>
<title type="html"><![CDATA[I should pay more attention to Dojo Toolkit]]></title>
<link href="http://www.fernandocorreia.info/blog/2012/08/10/i-should-pay-more-attention-to-dojo-toolkit/"/>
<updated>2012-08-10T08:01:00-03:00</updated>
<id>http://www.fernandocorreia.info/blog/2012/08/10/i-should-pay-more-attention-to-dojo-toolkit</id>
<content type="html"><![CDATA[<p>I’ve been doing a lot of research on JavaScript frameworks for developing rich client-side line-of-business applications.
So far Sencha’s <a href="http://www.sencha.com/products/extjs/">ExtJS</a> is the one I prefer for heavy-duty projects. But I’m constantly
looking around for alternatives and, more recently, <a href="http://angularjs.org/">AngularJS</a> caught my attention as a great choice
for structuring web apps.</p>
<p>Browser application technology is blooming and, recently, Steven Sanderson wrote an
<a href="http://blog.stevensanderson.com/2012/08/01/rich-javascript-applications-the-seven-frameworks-throne-of-js-2012/">excellent review</a> comparing several frameworks. There was a remarkable absence, though, as one commenter said:</p>
<blockquote><p>What happened to Dojo? It advocated lot of these principles years back. Was it ahead of time?</p><footer><strong>Geeth</strong> <cite><a href='http://blog.stevensanderson.com/2012/08/01/rich-javascript-applications-the-seven-frameworks-throne-of-js-2012/#comment-23446'>blog.stevensanderson.com/2012/…</a></cite></footer></blockquote>
<!-- more -->
<p>It’s been many years since I last thought about <a href="http://dojotoolkit.org/">Dojo</a>.
In my mind it seemed to have fallen by the wayside. But that comment
picked my interest, so I went up and updated myself on the current state of Dojo affairs.</p>
<p>I found out that not only Dojo pioneered many of the techniques being applied today in several frameworks, but it has also evolved
considerably. For instance, version 1.7 introduced an improved module system, and version 1.8 modernizes the MVC structure, among a plethora of other improvements that benefit rich client applications.</p>
<p>Dojo seems to be very mature, complete and up-to-date. It has a steeper learning curve than other, smaller approaches, though,
and historically documentation and guidance for newcomers has been lacking. By the way, this is being actively worked on as well.</p>
<p>David Walsh wrote a <a href="http://net.tutsplus.com/tutorials/javascript-ajax/10-reasons-why-your-projects-should-use-the-dojo-toolkit/">very interesting article</a> on what Dojo has going for it. I recommend reading it if you’re interested
in JavaScript frameworks, specially for larger applications.</p>
<p>For now, I’ve decided to invest some time in learning Dojo and I’ll be sharing my experience as I go.</p>
<blockquote><p>Don’t start you next project without checking out all of the features Dojo has to offer!</p><footer><strong>David Walsh</strong> <cite><a href='http://net.tutsplus.com/tutorials/javascript-ajax/10-reasons-why-your-projects-should-use-the-dojo-toolkit/'>10 Reasons Why Your Projects Should Use the Dojo Toolkit</a></cite></footer></blockquote>
]]></content>
</entry>
<entry>
<title type="html"><![CDATA[The impact of organizational model in innovation]]></title>
<link href="http://www.fernandocorreia.info/blog/2012/07/30/the-impact-of-organizational-model-in-innovation/"/>
<updated>2012-07-30T12:22:00-03:00</updated>
<id>http://www.fernandocorreia.info/blog/2012/07/30/the-impact-of-organizational-model-in-innovation</id>
<content type="html"><![CDATA[<p>Throughout my career I’ve been part of several innovation projects focused on applying emerging technologies to bring
new or improved products to the market. One recent example, still ongoing, is leveraging cloud computing to develop
cost-effective software-as-a-service offerings for the SMB (small and medium businesses) market segment.</p>
<p>The business management software is undergoing a deep change from monolithic, massive products that enforce rigid
business processes and are sold for costly up-front licensing fees towards more specialized, streamlined and flexible
solutions offered as a service and billed according to usage.</p>
<!-- more -->
<p>David Yarnold speaks of this trend:</p>
<blockquote><p>SAP’s walls are beginning to crumble, their armor is getting weak and cloud-based enterprise applications are no longer just for small businesses.</p><footer><strong>David Yarnold</strong> <cite><a href='http://www.forbes.com/sites/ciocentral/2011/10/24/for-enterprise-it-time-to-move-beyond-sap/'>For Enterprise IT, Time to Move Beyond SAP</a></cite></footer></blockquote>
<p>While small startups and more established new companies such as Workday and Salesforce.com are quickly innovating and
increasing their market share from the bottom up, traditional companies are slower, sometimes rehashing their
legacy products and offering them as hosted services.</p>
<p>One of the reasons is that incumbent companies are optimized for catering to their existing customer base and for
sustainable innovation, while disruptive innovation requires a different mindset and orientation.</p>
<blockquote><p>Established companies have the resources — the engineers, money, and technology — required to succeed at both sustaining and disruptive technologies. But their processes and values constitute disabilities in their efforts to succeed at disruptive innovation.</p><footer><strong>Clayton M. Christensen and Michael E. Raynor</strong> <cite><a href='http://www.amazon.com/The-Innovators-Solution-Sustaining-Successful/dp/1578518520'>The Innovator’s Solution</a></cite></footer></blockquote>
<p>So the lesson I take is that, at this point, business management software companies need to apply distinct processes and values
to their disruptive innovation projects, or face being disrupted themselves.</p>
]]></content>
</entry>
<entry>
<title type="html"><![CDATA[Static websites are more resilient and cost-effective]]></title>
<link href="http://www.fernandocorreia.info/blog/2012/07/27/static-websites-are-more-resilient-and-cost-effective/"/>
<updated>2012-07-27T20:04:00-03:00</updated>
<id>http://www.fernandocorreia.info/blog/2012/07/27/static-websites-are-more-resilient-and-cost-effective</id>
<content type="html"><![CDATA[<p>Dave Cole, from Development Seed, wrote a
<a href="http://developmentseed.org/blog/2012/07/27/build-cms-free-websites/">comprehensive article</a>
on their journey from developing
sites with heavy-duty CMSs, through dynamic client-side pages, to “devising a process by which we build static sites
dynamically”. He explains how they leverage single-purpose web applications, existing or custom-made, to make that
easier.</p>
<p>One of the chief benefits he mentions is:</p>
<blockquote><p>We can deploy our projects on practically any web server and not worry about whether it has the right software to run our application or the technical resources to handle high traffic.</p><footer><strong>Dave Cole</strong> <cite><a href='http://developmentseed.org/blog/2012/07/27/build-cms-free-websites/'>How We Build CMS-Free Websites</a></cite></footer></blockquote>
<!-- more -->
<p>That makes sense to me and I can see this model working for many websites. This reminds me of old-school stuff
like Microsoft Frontpage… But those sites tended to be too static. Combining static content with web services and
weaving all that with client-side JavaScript can be a powerful strategy.</p>
<p>Each component does what it does best, whether it’s
serving static files (possibly through a CDN), providing single-purpose dynamic content (such as pictures, video or
comments) or implementing client-side customization and functionality.</p>
<p>This blog follows this approach: it’s built with Octopress, it’s hosted on GitHub Pages and it uses services like
Google Search, Twitter and Disqus for interactivity.</p>
]]></content>
</entry>
<entry>
<title type="html"><![CDATA[Static sites are worry-free]]></title>
<link href="http://www.fernandocorreia.info/blog/2012/07/27/static-sites-are-worry-free/"/>
<updated>2012-07-27T12:18:00-03:00</updated>
<id>http://www.fernandocorreia.info/blog/2012/07/27/static-sites-are-worry-free</id>
<content type="html"><![CDATA[<p>Today I was reading a few more articles about the experience of using static pages instead of a dynamic engine
to host a blog or a content site. One quote caught my attention:</p>
<blockquote><p>There are no entry points to hack and there is no live webapp to go down.</p><footer><strong>Young Hahn</strong> <cite><a href='http://developmentseed.org/blog/2011/09/09/jekyll-github-pages/'>Using Jekyll and GitHub Pages for Our Site</a></cite></footer></blockquote>
<!-- more -->
<p>Static sites are worry-free. It’s a whole lot less surface area with potential
vulnerabilities. It’s one less piece of software to worry about security patches. It’s one less vector of attack.</p>
<p>For the sake of security, I don’t usually host a blog on the same server I have other stuff I care about.
But I might host a static site.</p>
<p>In this sense, using Octopress for my blog can make my life simpler.</p>
]]></content>
</entry>
<entry>
<title type="html"><![CDATA[Installing rbenv on Ubuntu]]></title>
<link href="http://www.fernandocorreia.info/blog/2012/07/26/installing-rbenv-on-ubuntu/"/>
<updated>2012-07-26T12:52:00-03:00</updated>
<id>http://www.fernandocorreia.info/blog/2012/07/26/installing-rbenv-on-ubuntu</id>
<content type="html"><![CDATA[<p>I chose Octopress to publish this blog. When I was reading on how to install it, I learned that it required Ruby 1.9.2.
Octopress’ documentation recommends installing it through a Ruby environment manager: either RVM or rbenv.</p>
<p>The last time I was dabbling with Ruby was a few years ago, before these tools were introduced. So I didn’t have a
favorite to pick. To choose one I
searched Google, read a little bit and came to the conclusion that rbenv is lighter and possibly simpler, while RVM
is more complex and more powerful. I’m not developing in Ruby so light and simple suits me. At the same time, RVM
messes with the builtin <code>cd</code> command and I’d rather leave it alone. So I picked rbenv.</p>
<!-- more -->
<p>Ubuntu has has a rbenv package, so I went for it first. I quickly had rbenv running but when I tried to install the
ruby-build rbenv plugin I couldn’t get it to work. I could have used an alternate route to install ruby-build
but I prefer the path of less resistance. I don’t like fighting the tools.</p>
<p>So I uninstalled Ubuntu’s rbenv package (which, by the way, was several versions out-of-date) and did a manual install
of rbenv from its project site.</p>
<p>These are the commands I used to install rbenv in Ubuntu 12.04 LTS (Precise Pangolin):</p>
<div><script src='https://gist.github.com/3177482.js?file='></script>
<noscript><pre><code># pre-reqs
sudo apt-get install git-core build-essential libssl-dev libreadline-dev zlib1g-dev libxml2-dev libxslt-dev
# rbenv
cd
git clone https://github.com/sstephenson/rbenv.git .rbenv
echo 'export PATH="$HOME/.rbenv/bin:$PATH"' >> ~/.bashrc
echo 'eval "$(rbenv init -)"' >> ~/.bashrc
exec $SHELL
# ruby-build
mkdir -p ~/.rbenv/plugins
cd ~/.rbenv/plugins
git clone https://github.com/sstephenson/ruby-build.git
# install some rubies
cd
rbenv install 1.9.2-p290
rbenv install 1.9.2-p320
rbenv install 1.9.3-p194
rbenv rehash
# set a global ruby
rbenv global 1.9.2-p290</code></pre></noscript></div>
<p>Installing Ruby takes some time, between a large download and setup, but everything went smoothly and worked as
advertised. A great experience.</p>
]]></content>
</entry>
<entry>
<title type="html"><![CDATA[A New Blog]]></title>
<link href="http://www.fernandocorreia.info/blog/2012/07/25/a-new-blog/"/>
<updated>2012-07-25T20:43:00-03:00</updated>
<id>http://www.fernandocorreia.info/blog/2012/07/25/a-new-blog</id>
<content type="html"><![CDATA[<p>In the last few years I created a few blogs focused in different audiences:
an <a href="http://fernandoacorreia.wordpress.com/">English-language blog</a>,
a <a href="http://blogdofernandocorreia.wordpress.com/">Portuguese-language one</a>,
a blog focusing on <a href="http://plataformanuvem.wordpress.com/">cloud computing</a> and another specifically about
<a href="http://pensandoazure.wordpress.com/">Windows Azure</a>.</p>
<p>Having blogs for specific subjects or audiences has its advantages; the content is more coherent. Also there’s the
question of language: writing in Portuguese I reach people around me more easily, but writing in English I can be part
of the ongoing global exchange of information about computing.</p>
<p>But the paradox is that I found out that with so many blogs, I was writing less often.
Having posts spread all over the place makes it more difficult to manage an online presence.</p>
<!-- more -->
<p>After spending some time writing about a subject, it gets awkward to post in another
blog that looks abandoned. So I’ve decided to experiment with having a single, default place to write about any
subject that raises my interest at any given time.</p>
<p>I’ve also decided to write mostly in English. The Brazilians that value their career in computing
know that they need to be able to read English proficiently. After all, English is the lingua franca of Computer
Science. And Google Translator is getting surprisingly accurate…</p>
<p>I’m using <a href="http://octopress.org/">Octopress</a> to publish this blog on GitHub. There’s a lot to like about this:</p>
<ul>
<li>The blog source is text-based.</li>
<li>It uses markdown.</li>
<li>It’s stored in a git repository.</li>
<li>It’s fully versioned.</li>
<li>I have a backup of my blog on my laptop and another as a GitHub repository.</li>
<li>It’s hosted on <em>the</em> social network for programmers.</li>
<li>It has many good options for source code snippets.</li>
<li>It can handle any ammount of traffic.</li>
<li>I can use a custom domain.</li>
<li>And I have control over the blog’s structure and appearance.</li>
</ul>
]]></content>
</entry>
</feed>