The Dynamic Programmer

Opa up and running - book review.

2013-05-11T00:00:00-04:00

Disclaimer: I got this book as part of the bloggers review program at O’Reilly.

Overview.

You will learn about how to work with Opa “the framework” and about some of the language features.
The book achieves this with several hands on projects of varies and increasing complexity.
There are only a few chapters that are not practical, ex: explaining the opa type system (chapter 7) and a few short introductory chapters at the beginning of the book. Read those chapters because they are packed with good information on some of Opa’s strong points

The three authors Henri Binsztok ,Adam Koprowski and Ida Swarczewskaja manage to balance the code examples with well written and clear explanations of the code is doing.

The good.

The book is targeted to developers of an intermediate level, without leaving in the dark beginners.

The authors don’t waste to much time describing concepts outside Opa itself, a beginner may have to do some reading on the side to supplement knowledge, but it should be able to get to work with the framework regardless.

I think it’s a good compromise since keep the book focused on the task and keep it short.

The bad.

No tests.

There are no tests at all in the book nor mention of unit test, assertions or testing libraries/modules. For me this is not a good thing. A book written today should (at least), describe how to test your system. Even if it’s in an appendix of the book, so to keep the examples clean.

Conclusion.

Opa is an intriguing framework and I will have to take it for a spin to make my mind about it. The book convinced me that I should at least spend some time with it.

There are a few other things that bother me, but those are regarding the code examples and the framework and may not be really the book to blame (ex: not external templates, to separate html from the view code).

I also recommend taking a look at some of Adam Koprowski’s repos on Github

Mindfulness, meditation for the busy programmer.

2013-05-10T00:00:00-04:00

I only got into mindfulness meditation after listening to this interview to Mark Williams on NPR’s Science Friday a few winters ago.

Mark Williams is professor of clinical psychology at the University of Oxford in England

During the interview, Mr. Williams mentioned multiple studies done in various Universities on how meditation can help reducing depression, migraines, mood swims and reduce stress.

It may sound silly, but knowing that there were actual scientific studies on the effects of meditation was a convincing factor for me.

I decided to get the book, Mindfulness: An Eight-Week Plan for Finding Peace in a Frantic World download the audio guides and get ready to start the program.

At the beginning I had to restart the program a few times. After a while I was able to establish a daily routine and was able to meditate at least once or twice a day. I will say that the key is in understanding the process and don’t get frustrated when things are more difficult that you thought.

The use of the recordings really helped me to keep focus and don’t blame myself every time my mind decided to start thinking on some of the problems of the day. Establishing the routine and taking it easy was the key to stay with it.

I’m so far very happy with the process and the results. It only requires a minimum commitment and once I worked a way to make it part of the daily work-flow is not very difficult to keep it going.
It has helped me to cope and brush off frustrations easily. I still have lots of work ahead of me, for example using some of the meditation techniques to avoid getting frustrated in the first place.

I’m ending up this post with the video of Jon Kabat-Zinn talking about Mindfulness at Google.

Beautiful new typography, the work of Pablo Impallari.

2013-04-21T00:00:00-04:00

I really enjoy nice typography and this interest make me explore some of the several font providers out there. Sometimes for inspiration and other times is just like visiting an art gallery.

I try to keep track of new fonts that I like and I noticed that a few of the fonts I favored have been created by the same typographer.

This on it’s own is not that surprising, I obviously like his style, so is perfectly understandable I like several of his fonts.

The typographer is Pablo Impallari and I will show some of my favorite fonts.

Quattrocento

I like it so much that I use Quattrocento for all the content in this blog (except headers, navigation and cut outs where I choose Gentium Book Basic).

It’s a classy font with a vintage feel without sacrificing readability.

I like the Roman version better than the Sans but of course there is a place for both.

Milonga

I already mentioned this one in a previous post a few days ago.

Dosis, elegant sans-serif

This one come in seven different weights and include a few alternates.
I really like the light and medium weights due to the minimalistic design without losing personality.

Cabin, where the lower case q, e, r, and m make an impression.

A very nice and balance sans. I particularly like the personality in some of the lower case letters.

The stem and termination for the r is fairly unique, as well as the termination of the letter e.

Lobster, a new classic

I leave this one for the end of the post since I’m pretty sure you saw it.
It have been used a lot latelly, specially in the start-up community (Codeacademy, Bayanumba, Camera tag and others).

It’s a very elegant and playful font, probably victim of it’s own success. It have been used so much that I would stay away from it at least for a little while. The font has such personality that jump at you (in a good way).

Check the site to learn more about the process and the inspiration behind it.

State changes, rest APIs and end points based permissions.

2013-04-20T00:00:00-04:00

You are ready to write your new HTTP API (notice I’m not saying REST) and everything goes well until you get the following requirement.

Customer status can be one of “Active, Passive, Enabled or Deleted”.

So far no problem.

Editing customers is available to all back-end roles, but status changes is only available to some roles.

This scenario is the one that most new comers find problematic. Specially if you want to model your permissions at the end point. For example using some kind of middleware.

Customers end points.

You may have the following end-points for the Customer object.



  GET     https://server.com/customers (all customers)
  GET     https://server.com/customers/:id (customer by id)
  POST    https://server.com/customers (create a new customer)
  PUT     https://server.com/customers (update the given customer)
  DELETE  https://server.com/customers/:id (delete the customer)

A few things to notice here. The PUT and POST route may or may not have the id at the end.
The implementation of the DELETE operation can be a logical delete while preserving the data in your data store, but that is not really relevant

In this scenario any update to customers is done via PUT.
We want to grant access to this operation to multiple roles, but we only want a subset of those roles to be able to change the status of the customer.

So we can’t really use this end point to change status without changing how we implement security.

Model Status on it’s own.

At this point of the analysis I like to stop and think what is the status of the customer. It may have started as a String property in the customer object, but it’s usually more than that.

I like to take a page of the DDD book and model the status as a value object.

I start by creating an empty Status object that contains only one String property.

I follow this with the creation of just one end point.



  PUT     https://server.com/customers/:id/status (updates the status for the customer with the payload)

Conclusion and home work.

Modeling the API in this manner will also allow us to add links to the customer object that represent some operations.

I think that implementing security at the end points and only at the end points help you with how you model the API and the underlaying model. A nice side effect is that your code will be more modular and easy to maintain.

Fonts inspired by Buenos Aires signage.

2013-04-19T00:00:00-04:00

Montserrat

I came across Montserrat a few months ago while researching fonts for a new project.

Montserrat is an old neighbourhood in Buenos Aires where I spend a few years of my life while finishing secondary school.

Julieta Ulanovsky has this to say

The old posters and signs in the traditional neighborhood of Buenos Aires called Montserrat inspired me to design a typeface that rescues the beauty of urban typography from the first half of the twentieth century.

Milonga

Milonga is a newish font (I think) from Pablo Impallari.

The font is inspired on the hand painted lettering and decorations that used to be very prominent in Buenos Aires called fileteado porteño and that sadly have been replaced recently for more modern and cosmopolitan signage.

You can see the influence in the termination and some of the ligatures. I really like this font for headings, branding and anything that needs to be highlighted.
Upper-case letters are particularly beautiful.

La porteña

A very delicate script with hints of fileteado. La porteña

Tanguera

Also from sudtipos, Tanguera brings some of the style from older signs you can see in Avenida de Mayo y San Telmo.

oEmbed-node, consuming oEmbed providers with node.js.

2013-04-07T00:00:00-04:00

During the winter I build a very simple website to curate ski videos from Vimeo and YouTube for my own personal use.

While working on it I needed to deal with the oEmbedd APIs of these two providers.

The result is this simple but extensible node.js module to easily consume oEmbed API’s from multiple providers.

At the moment it ~~only~~ supports YouTube and Vimeo but you can easily extend it to work with others via custom providers.

UPDATE: Version 0.2.0 adds support for Revision3, Justin.tv and yFrog. It also fix a bug when processing YouTube urls that contain multiple parameters in the querystring.

Usage



  var oembed = require('oembed-node').init();
  oembed.get({url: "https://vimeo.com/62584176"}, getVideo);
  function getVideo(err, result) {

  }

The result will be a literal object with the properties returned by the provider. The library adds a video_url property to the object.
This property is not the url you entered but the “proper” url to embed a video. For example for YouTube you should use the http://youtu.be url to call the oEmbed API but the provider can deal with any url from youtube and “returns” the proper one.

Custom providers

The init method of the library takes a literal object that’s a map from host names to functions. Each of those functions is the handler that will return a proper oEmbed end point.

For example a custom provider for vimeo would be like this:



  var customProviders = {
    "vimeo.com" : {
      init: function (urlStr) {
        return {
          getUrls: function () {
            return {
              embed: "http://vimeo.com/api/oembed.json?url=" + urlStr,
              video: urlStr
            };
          }
        };
      }
    }
  };

And you can pass it to the init function of the module.



    var oembed = require('oembed-node').init(customProviders);

You can use the same handler for multiple host names, just associate it to other keys in the hash.

Effective monitoring and alerting - book review.

2013-04-02T00:00:00-04:00

Disclaimer: I got this book as part of the bloggers review program at O’Reilly.

I’m having a hard time with this book. The author is clearly knowledgeable and experienced and the book is well written.

But I don’t think I’m the intended audience.

If you are new to metrics, this book is a good primer that goes deep into some of the practices and tools to use to capture and interpret those metrics.

I was expecting more of a cookbook with different tools I could leverage to capture those metrics. The book only deals with tools in the appendix and only deals with OpenTSDB a time series data base.

So, if you are looking for a good and deep book on time series analysis that can help you to read and understand all those metrics you are capturing, this is the book.

There are extensive case studies of different scenarios that will show you how to interpret those time series and find the problem in that stubborn web server that (should) be working well.

If instead you want to learn how to capture those metrics and what tools to use, this is probably not the book you should be reading just yet, but keep it in your list and make sure to read it soon after you have your metrics set.

Windows PowerShell Cookbook - book review.

2013-01-23T00:00:00-05:00

Disclaimer: I got this book as part of the bloggers review program at O’Reilly.

Lee Holmes takes the cookbook approach to help us discover the incredible power at our fingertips with PowerShell.

It starts with a high level tour of PowerShell. How to get it (installed with most Windows distributions) and how to start playing with it.

You will learn about some of the conventions and common commands available to you and how to explore them.
How it integrates with .NET, using it for rapid prototyping or as a REPL and much more.

After the introduction, the book takes the form of multiple recipes for common tasks. The tasks grow in difficulty.

The fundamentals section contains a series of recipes that will help you to get comfortable with the shell, customize the command prompt, invoke commands, get to know your session history, learn about aliases, etc.

After that you will take on more serious programming, parsing and working with data, how to pipe commands together to create powerful scripts, interact with environment variables, variables, work with .NET objects, COM and pretty much anything you need to know.

The book is extensive, coming shy of 1600 pages in the iPad version, but the cookbook format make it easy to use and you don’t need to read it in order.

If you are new to PowerShell I would recommend that at least you read the introduction and the Fundamentals sections. They will help you to get things done faster.

Conclusion

If you work with a Windows machine I would certainly recommend it. Start using PowerShell today and start automating your workflow with it.

Newsify, my new choice on RSS reader for the iPad.

2013-01-16T00:00:00-05:00

I do a lot of reading in my iPad and I’m currently subscribe to a few hundred feeds. I use Google reader to manage all my RSS subscriptions but I like to have a good off-line reader while traveling or commuting.

For the longest time I used Byline and I have been happy with it. The problem is that I also use Buffer to share links to articles I found interesting and Byline doesn’t have integration with Buffer, so I had to open the article on Safari to share it.

This is a minor inconvenience but last night, I saw that Buffer integrates with a few RSS readers, so I decided to take them for a spin.

I end up installing the free version of Newsify and after just a few minutes, go the full version for just $0.99 cents.

This is a slick and stylish RSS reader, with a great design and flawless integration with Buffer.

The application present all articles in a magazine style view instead of a vanilla list, and it just looks so much appealing.

You can easily get an overview of all the unread feeds and it makes for a much better experience.

If you have a setup similar to mine, go ahead and give it a try.

You need the full version to share with Buffer and a few other applications

Codemash 2.0.1.3, another great conference.

2013-01-15T00:00:00-05:00

Say that Codemash doesn’t disappoint is an understatement. Codemash is great!
Even with the conference continuously growing year after year, it have managed to keep true to it’s identity.

When everything was over, a new CD was added to The Womack Family Band collection, an XBox won and new knowledge was acquired.

And probably most important, new friends were made and all friendships rekindle.

This time I was able to manage the Codemash blues much better than previous years, but I’m already looking forward to Codemash 2.0.1.4

Thursday sessions

After a hearty breakfast I head over Ben Callahan session on “Web design process in a responsive world”, where he explored the new processes that Sparkbox is using to tackle the challenges presented when working on responsive sites, specifically how to work in multidisciplinary teams and how roles are changing.

You can follow the process in the open while the Sparkbox team redesign their own website

I follow up with some hardware session and a very entertainment “Raspberry Pi deep dive” by Gary Short where he show us how to leverage Mono, C# and VistaDB to create a simple application and deploy it to the Pi.

After lunch, I decided to head over Jimmy Bogard session on “Functional testing with ASP.NET MVC”. I wasn’t sure about it but it was a great session with good solid examples. It reflects my own experience when using similar tools and I learned about some helpers inside MVC Contrib I wasn’t aware off. A solid presentation.

Carl Franklin introduced us to his GesturePack product, that allow recording and playing back gestures with the Kinect. It was a very interactive presentation and he was very open on some of the processes he followed while creating the library, some of the challenges and limitations and where he want to take it.

The last session of the day was probably the highlight of the conference. Brian Sherwin presented together with his son Stephen on the journey they started five years ago when they started playing with a Netduino, a robot and a Kinect controller.
They were extremely well prepared in what is a very difficult presentation, not only compiling code live but also interacting with a robot.
They show us the first project they took on with the Arduino and how they evolved taking on a new challenge and going a bit further each time.

I just noticed that Thursday was a very .NET day for me. Strange, I guess not doing .Net for a living for the last 2 years may have something to do with it. In any case, they were all really good sessions.

Friday sessions

After Thursday night party I started Friday at Joshua Smith session on the Go language. A few weeks prior to Codemash I started to (again) hear references to Go in multiple conversations. This was a good presentation to get a 10000 feet overview of some of the interesting features of the language.

I kept the “languages” theme with “Dick Wall” session on “SubCut” an IOC container for Scala.

After lunch another Jimmy Bogard session; this time on “Building external DSLs”. After a quick overview on DSLs and the differences betwen internal and external DSLs, Jimmy showed how to use Irony to help on building the language, with lot’s of code examples.

For the last session of the day (and the conference) I head over to John Lindquist introductory session on AngularJS.

Thanks for another great Codemash

Once again, many thanks to all the volunteers, organizers and sponsors that make this possible, as well as everybody at the Kalahari that is “so” nice.

For the last four years, I have been using the end of Codemash as my “official” new years day from a professional point of view.

So, let the new year begin.

Codemash 2.0.1.3 precompilers.

2013-01-09T00:00:00-05:00

We are half way through Codemash 2.0.1.3 since this year we got two days of precompilers.

I think I choose fairly well but as usual I had to leave out some sessions that looked really good. Nothing I can do about that.

Choose your own application

I wasn’t very sure to attend or not the “Choose your own application” session. It looked very interesting in paper, but I was worry since I had been using those frameworks for a while.

I’m glad I did it anyway, the session was really good and the amount of work both Dennis Burton and Brian Genisio put behind it is impressive.

I will recommend you visit their site http://chooseyourownapplication.com sign up and follow the instructions.

You will be making some decisions along the way, choosing the language to use, the different technologies and libraries and even deployment platform, getting new badges with each complete “level”.

It should take you a few hours to complete it, but once you are done, you will have a single page application with a basic back end.

The exercise finish leaving a list of things you could do to make the application a bit more “real world” and robust.

Even when the application you will work on is very simple, it deals with several common scenarios that apply to more complex apps of this nature.

I thinks is a very good resource for understanding single page apps, and even more, since you can go back and start again and make different decisions, it’s also a good way to evaluate and compare the different technologies.

Atomic Scala

Dianne Marsh and Bruce Eckel put together a condensed version of their seminar specially for Codemash, all based on their upcoming book of the same title.

The idea is to teach Scala step by step, introducing each feature in order.

From their website:

We present each Atom (chapter) in the book as a very short lecture, followed by an exercise period. Atomic concepts make learning Scala easy and fun.

It’s a nice approach to learn a new language and is a gentle introduction to Scala, that can be a bit scary if you come from traditional OO languages.

I had a good time pairing and doing the exercises, sadly I had to leave after lunch but I plan to complete the book later tonight.

I recommend keeping an eye once the book is finally released and get yourself a copy if you want to get into Scala.

Behind the scenes of building Roslyn

I wasn’t planning to attend this session, I poke my head into the room and I got hook. It’s not a secret that I like languages, compilers and also “processes”, so been able to learn how Roslyn was build was very interesting and educational.

Roslyn is an impressive project, a compiler for very well established languages like C# and VB, integrated deep inside a non trivial products like VS (and WebMatrix).

The process, testing (both unit and functional) and performance considerations and how the team addressed each of those problems was very revealing.

Both Kevin Pilch-Bisson and Brian Rasmussen made what can sound like a boring and arid subject into a very good and engaging presentation.

I gain a better appreciation of the complexities involved while working on a project of these level of complexity and visibility.

Building Mobile Applications with PhoneGap

Ray Camden gave a good presentation/workshop.

I particularly enjoyed the first part of the session where he introduced PhoneGap and the different ways to use it, some of the common pitfalls and the different work-flows recommended to get your application out the door in good shape.

He was very entertaining and well prepared and I took a few tips from it that will certainly save me some time in the future.

First pull request for curling, increasing buffer size.

2013-01-06T00:00:00-05:00

Just four days after releasing curling I got the first pull request from romansky that increases the buffer size.

These changes have been included in curling v0.3.0 available now via npm. There are no changes to the API so just run npm update to get the new version and everything should work as normal.

Jump start CoffeeScript - book review.

2013-01-05T00:00:00-05:00

Disclaimer: I got this book as part of the bloggers review program at O’Reilly.

There are possible two types of technical books I really enjoy, the ones dealing with process and general programming and the ones that tell a story while teaching something new.

Earle Castledine’s book does the later and it does it very well.

The author paints the picture of a somehow dysfunctional team set to build a 2D game as part of a coding competition where the developer decides to write the game using CoffeeScript even when he has little knowledge of the language.

This setup works very well to show case all the features of the language in the frame of a non trivial application.

The narrative is great and keep the pace very well.

Three books on one.

The book not only deals with coffee-script but takes on teaching some Canvas and basics game mechanics.

What it’s even better, it manage to do all this in just a bit over 200 pages.

Page count of the ePub version on an iPad2

You can get all the code from the book to follow along, specially some of the assets for the game that you may not be able (or incline to) do by yourself.

I really enjoyed reading it and coding along; even when I was familiar with the language I gain a better appreciation for it.

Conclusion

Absolutely recommendable, you can’t go wrong with this book.

Who are you, private/public key authentication for connect.

2013-01-03T00:00:00-05:00

Who-are-you, reads a series of http headers and authorize (or not) the caller to access the API.

Usage

Provide the client with a private and public key.
Create names (or use the defaults) for the http headers the client will use to make the request.
Choice a public value that will be used to generate the hash with the private key.
At the moment it uses sha1 to generate the (hash) token.

Example

Given the keys:

apiKey: 90ijUhj88uY
secretKey: ppKJHnmm09Iu564ghfB=

And using the default custom http headers:

The client should send a request with the following headers:



  x-api-key: 90ijUhj88uY
  x-request-time: '1357169907984'
  x-token: 'a001880c10e2a61231311b1b56cecd98c71a7fe4'

The hash is calculated (in node) using the crypto module.



  var hash = crypto.createHmac('sha1', 'ppKJHnmm09Iu564ghfB=')
      .update('1357169907984')
      .digest('hex');

On the server application you can add the module as usual:



  var whoareyou = require('whoareyou');
  server.use(whoareyou.privatePublicKey(accountStore, null));

If you want to use custom headers use an options argument as this:



  var whoareyou = require('whoareyou');
  var options = {
    "apiKey": "x-key",
    "dateTime": "x-date",
    "token": "x-hash"
  };
  server.use(whoareyou.privatePublicKey(accountStore, options));

The accountStore is expected to have one method get(apiKey, cb) the callback takes two arguments and error and an account object.
The account object is expected to have at least one property secretKey that contains exactly that.

The middleware will add two properties to the request authenticated a boolean indicating if the authentication have been succesful and currentAccount that contains a clone of the account object returned by the accountStore.get method.

Introducing curling, a simple node wrapper for curl.

2013-01-01T00:00:00-05:00

Another of those libraries that I’m tired to write again and again, so here it goes, up to npm.

It has a very simple API that exports only two methods `connect` and `run`.

Install or get the code.


  npm install curling

Or download the code from github

run(command, cb)

You shouldn’t have to use `run` but is in there just as a convenience or if you need to do something crazy that is not possible to do via the connection object.

It pretty much allow you to send any command with any option to curl. It used internally by connect and the connection object.


  var curl = require('curling');
  curl.run("--GET http://www.cnn.com", function (err, result) {
    console.log(result.payload); // should output the html for the cnn page to console.
    console.log(result.stats);   // should output some of the statistics on downloading the page
  });

connect(options)

This method takes an `options` object with general options that will be re-used in each command.


  var options = {user: "hernan:secret"};

It returns a connection object.

Connection object API

It has five methods, each corresponding to an HTTP verb. They all have the same signature: `method(url, options, cb)`. The method are:

head();
get();
post();
put();
del(); //DELETE

The callback takes two parameters `cb(err, result)` where the result is a `curl-result` object.

curl-result

It has two properties, `payload` and `stats`. The payload contains the data returned in the stdout by curl while the stats is an object that parse as the content of stderr.

Stats is of the form:

{ totalSize: 0, received: 0, xferd: 0, averageDownloadSpeed: 0, averageUploadSpeed: 0, totalTime: 0, timeSpent: 0, timeLeft: 0, currentSpeed: ‘0 Kb’ }

The time properties are converted to milliseconds, the rest of the properties are of type `Number` in the same units as returned by curl except for the `currentSpeed` that is a string with the unit at the end (again as returned by curl).

Passing options.

There are two ways to pass options and data to a request.
You can use the `options` for the `connect` method and this options will be used in each and every request.
You can also use the `options` object in each of the verb methods.

The `options` object is actually a hash where the keys should be the name of the flag in a curl command, for example to set an Accept header and pass some data you could pass an `options` as the following.

var options = { header: “Accept: text/html”, data: [“name=hernan”, “last=garcia”] };

The keys in an `options` object can be one of the following types, String, Array or null.

Strings are useful when you only need to set a single value, arrays are used to pass multiple values, like data, header and so. Null is a special case and is used for empty flags, like `—false`.

Get started with Arduino, A hands-on introductory workshop - video review.

2012-12-31T00:00:00-05:00

Disclaimer: I got this video as part of the bloggers review program at O’Reilly.

In less than 3 hours Philip Lindsay will get show you the basics on working and programming Arduino.

The video is organized in 23 little segments that can be watched independently.

It starts with the basics on what is Arduino the components and the layout of the circuit, what tools and components you will need to complete the tutorial and how to install the development environment in your computer.

They cover Windows, Mac OX and Linux

You will learn how to create a series of simple projects that make some LEDs blinks or take inputs from pushing buttons, but those projects are the basics for any other from of interaction with the Arduino.

One of the videos that I particularly enjoyed was Exploring the hardware ecosystem to give you an idea of the depth and breath of the Arduino world.

If you have any background on electronics you may find yourself skipping some parts, ex: explanation on reading resistors code, how a led works, etc.
At the same time those, basics make for a set of nice videos to share with the youngsters in the family that may want to get into electronics.

You will work on four projects in total, increasing the level of difficulty just a bit in each one, while introducing a new concept.

The production of the videos is very good, with nice long sequences taking from the top of the circuit where you can easily follow the connections and what’s going on in each project.

Conclusion

I certainly would recommend the series as a good way to get started.

node-resources helping modularize your Restify or Express application.

2012-12-30T00:00:00-05:00

node-resources

When working on Restify or ExpressJS applications you usually see a file structure based on routes, models and views.



  |_app.js
  |_routes
  | |_hello.js
  |_models
  | |_hello.js
  |_views
    |_hello
      |_index.ejs
      |_edit.ejs

This structure is very common to other MVC frameworks as well.

I found that this structure works well for small or medium size projects but after a while it can get a bit out of control. The main problem is that code that belong together and is relate is split all over the place what makes developing small modules in isolation very complicate.

I prefer the following code organization.



  |_app.js
  |_resources
    |_hello
      |_index.js
      |_handlers.js
      |_models
      | |_hello.js
      |_views
        |_index.ejs
        |_edit.ejs

This approach makes each module self contained.

Caveats

You want to make sure that inter-dependency between this modules is keep to a minimum.

Usage

Install as usual via npm

npm install node-resources

To use the structure above you should do the following.



  var resources = require('node-resources');
  resources.registerRoutes(server, {path: __dirname + "/resources"});

Api

The module exports only one method registerRoutes(server, options)
The options argument can have two properties.

options.path

This is mandatory and if not passed it should throw an Error.

options.pattern

You can use this property to specify a pattern to search for a file inside the module to require. This is useful if you don’t want to use an index.js file in each module or if you want to give use for something different.

Ex: given you have the following module.



  |_cars
    |_cars.routes.js
    |_handlers.js
    |_models
    | |_cars.js
    |_views
      |_list.ejs

Your options.pattern should be [folder].routes.js.
The [folder] token is the only one accepted in the pattern and will be replaced by the folder name at the root of the module.

Coming soon…

Adding dependency management and injection to the routers.
Maybe even doc generation for the application API, routes, methods and parameters.

DynProg.Validation now available on NuGet

2012-12-27T00:00:00-05:00

A bit of history

I wrote this library for the first time 6 or 7 years ago.

During all this time I keep improving it and enhancing it, sometimes even duplicating the effort on a different code base. For a few years now it has been sitting on my personal GitHub repository with a bunch of other small projects.

During the holidays, while working on a new side project, I was ready to add the library to the project the old fashion way, copy the DLL into a libs folder and add a reference.

It’s evident that this is not the way of doing things in .Net anymore and since we (.Net developers) finally have a package manager it was time to move this library into NuGet.

After a few hours of fiddling around with the code, cleaning up a few things and moving it into it’s own repository I published and now is available for everybody via NuGet.

You can install via NuGet or inside VS using the NuGet Package Manager.

Why another validation library?

DynProg.Validation is intended to replace the countless checks for null argument and argument formatting and provide a simple and easy to use interface.

It’s not a replacement for other popular libraries like FluentValidation or DataAnnotations.

It should replace code like this:



    public string setValue(string key, string value)
    {
        if (String.IsNullOrEmpty(key) || key.length < 5 || key.length > 20)
        {
            throw new ArgumentException("key");
        }
        if (String.IsNullOrEmpty(value))
        {
            throw new ArgumentException("value");
        }
        // the actual code goes here
    }

with something like this…



    public string setValue(string key, string value)
    {
      var validator = new Validator();
      validator.CheckThat(() => key).IsNotNullOrEmpty()
          .LengthIsBetween(5, 20);
      validator.CheckThat(() => value).IsNotNullOrEmpty();
      validator.Throw();
      //the actual code goes here
    }

It doesn’t looks like much but let’s examine some of the niceties in the API and some of the facilities it provides.

General usage

We create a validator instance per method and you call the CheckThat method. This method takes a func that access and returns the parameter that we want to check.

This is a little weird but the reason is that we use this to internally get the name of the parameter that in turn we use to generate the Exception message. This save you of passing a string with the parameter name that can get out of sync at the first refactoring of your code.

The CheckThat method returns one of many CheckConditions based on the type of the parameter.

These CheckConditions expose a series of method suitable to check multiple aspects of the parameter.

You can chain multiple conditions together to check several attributes of the parameter.

Specific Exception per check

All methods of the CheckConditions have a “typeless” interface that will generate a generic Exception based on what condition is checking, parameter type and name.

They also have a “Generic” interface that take an Exception type. This interface takes the same parameters of the “typeless” one plus an array of object as the arguments that Exception type is expecting.

Managing exceptions.

Although (at the moment) the validation is run on runtime no Exceptions will be thrown or values returned unless you call one of the following methods.

List()
Throw()
Throw<T>()
ThrowFirst()

These methods can be called on an instance of the Validator object or in any of the CheckConditions.

The ThrowFirst method will throw the first exception in case one or more exceptions where found.

The Throw method will throw an ErrorsCollectionException if at least one error was found.

ErrorsCollectionException inherits from Exception and contains methods to access the list of exceptions generated during validation.

The Throw<T> method will throw an Exception of type T if at least one error was found.

Finally List will return the ErrorsCollectionException even if empty.

API documentation

I put together a quick site using gh-pages with the complete API.

More code examples coming soon, or just check the tests.

CSS considerations with widget development.

2012-12-22T00:00:00-05:00

When working on scripts that will modify the DOM of third party pages you will have to apply custom styles to those elements.

This can cause problems in the host application and you need to be mindful of that.

Rarely use ids.

I’m very tempted to say “NEVER” use ids, but I know better than to be absolute about these things anymore.

Id’s on elements should be unique per page, so using ids will prevent you from including multiple widgets in the same page.

If you have to use ids, make sure the name is unique. EX: dynamic-prog-widget.

Close your tags.

You never know about the DOCTYPE of the page you will be modifying, so a good rule of thumb is to close all your tags and write HTML that should validate as XHTML transitional.

Your script could check the page DTD and generate HTML accordingly but this will increase the script difficulty considerable.

You can also have several versions of your widget (good luck maintain that), or indicate clearly what HTML version you are compatible with.

In-line styles.

We all know that we shouldn’t in-line styles in our pages and always define then in style sheets.

This rule is usually broken when working with embedded widgets. You will see this approach in some of Google widgets, like the embedded search.

The advantage of this approach is that there is no risk of interfering with the styles of the application.

The disadvantage is that it makes life very difficult for the host application to modify the styling of your widget due to the CSS precedence rules.
It also can increase code size significantly if the widget needs to be inserted multiple times in the same page.

“Namespace” your rules.

If you use classes make sure you don’t use the CSS !important rule in any of your classes.

Don’t apply rules to HTML elements or ids (well you shouldn’t be using ids anyway).

Make sure your classes have some unique name, you can use a prefix, like the name of your application. Ex: .dynamic-prog-widget-container

External fonts.

This is a fairly new(est) concern. We are starting to use web-fonts more and more nowadays, specially for icons. Even when the possibility of clashing is minimal you can still override a font name by mistake, so make sure you use similar naming conventions as mentioned in the previous paragraph.

Navigation.

Make sure that links either point to new windows, or you allow for the user to configure this behaviour as wanted.

An easy way to open a new window is using target=“_blank” in your links.

Last thoughts.

Try to avoid resizing as much as possible. Since you don’t know the code that will surround your widget, resizing it may cause odd behaviour and make for a poor user experience.

And most of all, be mindful of any interaction the user may have with your widget.

Web, Cloud and Mobile solutions with F# - book review.

2012-12-21T00:00:00-05:00

Disclaimer: I got this book as part of the bloggers review program at O’Reilly.

Daniel Mohl’s book had the distinctive quality to make F# really approachable.

Some of those F# characteristics are: functional / OO paradigm, messaging, records and immutability.

I think that the secret lies in the approach the author took in showing us how we can use F# and it’s distinct capabilities to write better solutions in a world where high availability and scale is a major concern.

There are multiple examples on writing services with different technologies, not just Microsoft products but also open source frameworks. You will learn about a number of F# libraries that will make your life easier in a day to day use in real world projects.

The author makes an effort to show different ways to solve similar problems, ex: using records and classes to interact with databases and queues, while at the same time indicating what is the preferred way in F#.

Some of my favorite sections of the book: Using NancyFX and WebApi with F# to create HTTP services. Interacting with Azure services and how to combine F# with NoSQL databases like Mongo, Raven and CouchDB.

There is also a really good example on using Web Sockets with a library called Fleck that I wasn’t familiar with.

Conclusion

I found the book a really enjoyable read and the reason to try to use F# soon in some side project.
I feel that makes F# very approachable and is really good on showing why you should care. It’s not just another language, or a language that should be used only when doing lots of data processing or scientific work, but a tool that can help even when dealing more pedestrian, but still complex, tasks.