ResumeCreator is a OS X application that i wrote and submitted to the App store. It can be found here. This page works as a support page for the application.
Concurrency in Objective-C using Grand Central Dispatch (GCD)
To demonstrate execution of concurrent Objective-C code, I wrote this simple example below. The two functions you have to read about to understand the code are; dispatch_get_global_queue and dispatch_async.
|
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 |
#import <Foundation/Foundation.h> int main(int argc, const char * argv[]) { @autoreleasepool { // 1. Get the handle of the system's predefined global concurrent queue, DISPATCH_QUEUE_PRIORITY_DEFAULT. dispatch_queue_t dispatchQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0); // 2. Enqueue the code to be run asynchronously, to the queue above. dispatch_async(dispatchQueue, ^{ for(int i = 1; i <= 10; i++) { usleep(1000000); NSLog(@"Inside the dispatch async: %d", i); } }); // 3. Lets run the same code on the main thread just to see what will happen. for(int i = 1; i <= 10; i++) { usleep(1000000); NSLog(@"Outside the dispatch async: %d", i); } return 0; } } |
Example of output you may get, may look like this. And notice that the output may vary. To understand what is happeneing, run the code several times.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
2015-08-17 00:15:50.095 gcd_tutorial[943:435948] Inside the dispatch async: 1 2015-08-17 00:15:50.095 gcd_tutorial[943:435846] Outside the dispatch async: 1 2015-08-17 00:15:51.102 gcd_tutorial[943:435948] Inside the dispatch async: 2 2015-08-17 00:15:51.102 gcd_tutorial[943:435846] Outside the dispatch async: 2 2015-08-17 00:15:52.104 gcd_tutorial[943:435846] Outside the dispatch async: 3 2015-08-17 00:15:52.104 gcd_tutorial[943:435948] Inside the dispatch async: 3 2015-08-17 00:15:53.105 gcd_tutorial[943:435948] Inside the dispatch async: 4 2015-08-17 00:15:53.105 gcd_tutorial[943:435846] Outside the dispatch async: 4 2015-08-17 00:15:54.106 gcd_tutorial[943:435948] Inside the dispatch async: 5 2015-08-17 00:15:54.110 gcd_tutorial[943:435846] Outside the dispatch async: 5 2015-08-17 00:15:55.106 gcd_tutorial[943:435948] Inside the dispatch async: 6 2015-08-17 00:15:55.110 gcd_tutorial[943:435846] Outside the dispatch async: 6 2015-08-17 00:15:56.107 gcd_tutorial[943:435948] Inside the dispatch async: 7 2015-08-17 00:15:56.111 gcd_tutorial[943:435846] Outside the dispatch async: 7 2015-08-17 00:15:57.111 gcd_tutorial[943:435846] Outside the dispatch async: 8 2015-08-17 00:15:57.111 gcd_tutorial[943:435948] Inside the dispatch async: 8 2015-08-17 00:15:58.115 gcd_tutorial[943:435948] Inside the dispatch async: 9 2015-08-17 00:15:58.115 gcd_tutorial[943:435846] Outside the dispatch async: 9 2015-08-17 00:15:59.115 gcd_tutorial[943:435846] Outside the dispatch async: 10 2015-08-17 00:15:59.115 gcd_tutorial[943:435948] Inside the dispatch async: 10 |
TDD and JavaScript
I felt that I had to do this for my own good.:) To do TDD, the easiest way is to have nodeJS installed and up and running.
What I shortly did is to create my project skeleton
|
1 2 3 |
$ mkdir first_project |
Then, you have to work in that folder
|
1 2 3 |
$ cd first_project |
Create now two folders lib & test
|
1 2 3 |
$ mkdir lib test |
Bring the package.json to your project by:
|
1 2 3 |
$ npm init |
To do the testing, you will need mocha & chai
|
1 2 3 |
$ npm install --save-dev --save-exact chai mocha |
Now when everything is setup, lets start coding.
Suppose now that We have to implement the class Person, in which the method getFullName() will return concatenated firstName & lastName passed to the class constructor.
Create a test file and place it in the test folder. Also, create the person.js and place it in the lib folder.
|
1 2 3 4 |
$ touch test/person.test.js $ touch lib/person.js |
Lets do the TDD now. The person.test.js may look like this for instance!?
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
var expect = require('chai').expect; var Person = require('../lib/person.js'); describe('Person class', function(){ var person; before(function() { person = new Person("Johnny", "Lewis"); }); after(function() { person = null; }); it('It should create a Person instance', function(){ expect(person).to.be.a('object'); }); }); |
To run the test:
|
1 2 3 |
$ mocha |
The tests will fail for sure. Code your person.js in the lib folder:
|
1 2 3 4 5 6 7 8 9 10 11 |
var Person = (function(){ function Person(firstName, lastName){ this.firstName = firstName; this.lastName = lastName; } return Person; })(); module.exports = Person; |
Now, you have your first passed test case when running:
|
1 2 3 |
$ mocha |
Now you are good to go with the rest. Read the documentation about chai & mocha and write your other test cases!
Writing a wrapper WebSocket client class in JS
I released this custom WebSocketChatServer gem earlier this month and thought that it may be a good idea to wrap the server’s client in a JS class just to make it easier to communicate with the server.
Here is the JS client:
|
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 |
var WebSocketChatClient; WebSocketChatClient = (function() { function WebSocketChatClient(url, username, password) { this.url = url; this.username = username; this.password = password; this.ws = null; this.users = new Set(); } WebSocketChatClient.prototype.sendChatMessage = function(chatMessage){ this.ws.send(JSON.stringify({command: "chat_message", data: chatMessage})); }; WebSocketChatClient.prototype.sendPrivateMessage = function(toUser, privateMessage){ this.ws.send(JSON.stringify({command: "private_message", data: {to_user: toUser, message: privateMessage}})); }; WebSocketChatClient.prototype.banUser = function(userNameToBan){ this.ws.send(JSON.stringify({command: "ban_user", data: userNameToBan})); }; WebSocketChatClient.prototype.connectedUsers = function(){ return(this.users); }; WebSocketChatClient.prototype.connect = function() { var connectionString = this.url + "?username=" + this.username + "&password=" + this.password; var Socket = "MozWebSocket" in window ? MozWebSocket : WebSocket; try{ this.ws = new Socket(connectionString); this.ws.onmessage = function(event) { var data = JSON.parse(event.data); switch(data.command){ case "failed_connection": this.onDisconnected(data.information); break; case "successful_connection": if(data.data !== null){ for(i = 0; i < data.data.length; i++){ this.users.add(data.data[i]); } } this.onSuccessfullConnection(); break; case "new_connection": this.users.add(data.data); this.onNewUserConnected(data.data); break; case "user_disconnected": this.users.delete(data.data); this.onUserDisconnected(data.data); break; case "private_message": this.onNewPrivateMessage(data.data.from_user, data.data.message); break; case "chat_message": this.onNewChatMessage(data.data.from_user, data.data.message); break; case "system_information": this.onSystemInformation(data.data + " :" + data.data.information); break; default: break; } }.bind(this); this.ws.onclose = function(event) { if( this.users.length > 0 ) this.users.clear(); this.onDisconnected("Client disconnected."); }.bind(this); this.ws.onopen = function() { }; } catch(error){ throw new Error(error.message); } }; WebSocketChatClient.prototype.disconnect = function() { this.ws.close(); }; WebSocketChatClient.prototype.onUserDisconnected = function(username){}; WebSocketChatClient.prototype.onSuccessfullConnection = function(){}; WebSocketChatClient.prototype.onDisconnected = function(reason){}; WebSocketChatClient.prototype.onNewUserConnected = function(username){}; WebSocketChatClient.prototype.onNewChatMessage = function(fromUser, message){}; WebSocketChatClient.prototype.onNewPrivateMessage = function(fromUser, message){}; WebSocketChatClient.prototype.onSystemInformation = function(information){}; return WebSocketChatClient; })(); |
And the example of usage:
|
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 |
<html> <head> <script src="websocketchatclient.js" type="text/javascript" charset="utf-8"></script> <script> function init() { var cc = new WebSocketChatClient("ws://localhost:8080", "user00", "secret"); cc.onNewUserConnected = function(data){ console.log("New user connected: " + data); }; cc.onNewChatMessage = function(fromUser, message){ console.log("New message from " + fromUser + ": " + message); }; cc.onNewPrivateMessage = function(fromUser, message){ console.log("New private message from " + fromUser + ": " + message); }; cc.onUserDisconnected = function(username){ console.log("The user " + username + " has been disconnected"); }; cc.onDisconnected = function(reason){ console.log(reason); }; cc.onSuccessfullConnection = function(data){ cc.sendChatMessage("This is a public message."); cc.sendPrivateMessage("user00", "This is a private message"); }; cc.connect(); } </script> </head> <body onload="init();"> </body> </html> |
Getting started with PostgreSQL’s PL/PGSQL
Relational database management system (RDBMS) are more than creating tables and execute SQL-queries against them. PostgreSQL is one of my favourite RDBMS and if you happened to use it in the back end, I suggest that you should look at this feature called PL/PGSQL. As wikipedia says, it is a fully featured programming language, allowing more procedural control than SQL.
And in this blog entry, I’m going to demonstrate a simple example on how the PL/PGSQL can be used. The demonstration comprises an authentication logic executing on the server side within the PostgreSQL server.
So, imagine that with have a table holding the user credentials as in the example below:
|
1 2 3 4 5 6 7 8 9 10 |
CREATE TABLE users ( id bigserial NOT NULL, email character varying(255), passwd character varying(255), fullname character varying(255), CONSTRAINT users_pkey PRIMARY KEY (id) ) |
And we should agree that the email has to be indexed uniquely:
|
1 2 3 4 5 6 |
CREATE UNIQUE INDEX index_email ON users USING btree (email COLLATE pg_catalog."default"); |
What we are doing next is to move the authentication logic to the PostgreSQL server. We simply are going to create a login(email, password) function that is both stored and executed within the PostgreSQL. This function works in a way, in which the passed parameters (email, password) are validated first. If the parameters does not pass the validation, the function will throw an Exception. The next step in the function is to query from the table for the user records based on the passed parameters.
Before listing the login function, we create two functions taking care of the validation of the email and password. These functions are called inside the login() function.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
CREATE OR REPLACE FUNCTION isemail(p_email text) RETURNS boolean AS $BODY$ DECLARE BEGIN IF ($1 ~ E'^[a-zA-Z0-9._-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,4}$') = TRUE THEN RETURN TRUE; END IF; RETURN FALSE; END; $BODY$ LANGUAGE plpgsql VOLATILE |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
CREATE OR REPLACE FUNCTION ispasswordok(p_password text) RETURNS boolean AS $BODY$ DECLARE BEGIN IF ($1 ~ E'^[a-zA-Z0-9]{3,20}$') = TRUE THEN RETURN TRUE; END IF; RETURN FALSE; END; $BODY$ LANGUAGE plpgsql VOLATILE |
Now that we have validation functions, lets do the login:
|
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 |
CREATE OR REPLACE FUNCTION login(p_email text, p_password text) RETURNS users AS $BODY$ DECLARE /* To hold the user's row */ usersrow users%ROWTYPE; BEGIN /* Lets check if the email is valid. If it is NOT, we throw an EXCEPTION. */ IF isemail(p_email) = FALSE THEN RAISE EXCEPTION 'The email format is not valid'; END IF; /* Lets now check if the password is valid. Remember, Otherwise an EXCEPTION is thrown. */ IF ispasswordok(p_password) = FALSE THEN RAISE EXCEPTION 'The password format is not valid'; END IF; /* Lets do the SQL query with the parameters passed it to it */ SELECT * INTO usersrow FROM users WHERE email = p_email AND passwd = p_password LIMIT 1; /* If the row is empty, it means that no such user with the credentials passed exists. It is up to here how you want to handle it. You can either return an empty row or like me just throw an Exception. */ IF usersrow IS NULL THEN RAISE EXCEPTION 'The user does not exist'; END IF; /* Return the user's record */ RETURN usersrow; END; $BODY$ LANGUAGE plpgsql VOLATILE |
To test the method, insert dummy data to the users table:
|
1 2 3 |
INSERT INTO users(email, passwd, fullname) VALUES('foo@bar.iq', 'foobar', 'Johnny Boy'); |
Test now the login() function by:
|
1 2 3 4 5 6 7 |
/* Successful login */ SELECT * from login('foo@bar.iq', 'foobar'); /* Exception thrown */ SELECT * from login('foo@bar.iq', 'SOME_OTHER_PASSWORD'); |
Encrypt text in iPhone & decrypt it in your Rails server
What I did to perform the task is that i used RNCryptor in my IOS application.
|
1 2 3 4 5 6 7 8 9 10 11 12 |
+(NSString*) encryptString:(NSString*) stringToEncrypt withKey:(NSString*) encryptionKey{ NSData *data = [stringToEncrypt dataUsingEncoding:NSUTF8StringEncoding]; NSError *error; NSData *encryptedData = [RNEncryptor encryptData:data withSettings:kRNCryptorAES256Settings password:encryptionKey error:&error]; return [encryptedData base64EncodedStringWithOptions:0]; } |
And I engaged this gem to do the decryption in Rails.
|
1 2 3 4 5 6 7 8 9 |
require 'ruby_rncryptor' require "base64" def decrypt_string(encrypted_string, secret_key) encrypted = Base64.decode64(encrypted_string) RubyRNCryptor.decrypt(encrypted, secret_key) end |
Parsing an URL with Ruby
Can not be easier than this…
|
1 2 3 4 5 6 7 8 9 10 |
require 'uri' parsed_uri = URI.parse('http://localhost:3000/welcome/index') puts parsed_data.scheme # => http puts parsed_data.host # => localhost puts parsed_data.port # => 3000 puts parsed_data.path # => /welcome/index |
Prevent CSRF-attacks in your PHP files using tokens
If you do not know how a CSRF-attack work, read here
This is a simple class for taking care of generating and validating the tokens.
|
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 |
<?php /** * A Session token creator class */ class SessionToken { /** * Holds the session token name * @var string */ private $_tokenName; /** * Class constructor * @param string $tokenName The name of the token to be stored in the session */ public function __construct($tokenName = ""){ if(empty($tokenName)) { throw new \Exception("The token name is empty."); } if (session_id() == "") { throw new \Exception("The session is not started."); } $this->_tokenName = $tokenName; } /** * Creates a new token by storing it in the session * @return string the newly created token */ public function createToken() { $tokenValue = substr(md5(rand()), 0, 7); $_SESSION["$this->_tokenName"] = $tokenValue; return $tokenValue; } /** * Checks if the token is valid or not * @param string $tokenValue The token validate * @return boolean true if the token is valid, otherwise false */ public function isValidToken($tokenValue = "") { if(!isset($_SESSION["$this->_tokenName"])) return false; $sessionTokenValue = $_SESSION["$this->_tokenName"]; if($sessionTokenValue != $tokenValue) return false; return true; } } |
Let’s say that you have login.php in which a form with two text fields and a submission button are included. What you want to do here is to generate an access token and apply it to the login form as a hidden value.
|
1 2 3 4 5 6 |
$sessionToken = new SessionToken("_token"); $token = $sessionToken->createToken(); //inside the form do... print("<input type='hidden' name='_token' value='{$token}'>"); |
To validate the token, apply the code below in the file where the login form has been posted to.
|
1 2 3 4 5 6 |
$sessionToken = new SessionToken("_token"); if(!$sessionToken->isValidToken($_POST["_token"])) { header('HTTP/1.1 500 Internal Server Error'); exit(0); } |
Filter pattern in Rails
Imagine you have an User < ActiveRecord::Base object and you want to apply filtering implementation to it. The filtering will be based on certain criteria like get me all the adult users or all the users that are females or males. That kan be achieved in different ways. One way is using Rails's scoping or by defining class methods.
If you like the idea of the design patterns, it turned out that there is a design pattern for this problem and it is called the Filter design pattern.
And to demonstrate, We will create an interface class to outline the behaviour of our Filtering criteria. This interface can then be extending with concrete criteria classes containing concrete implementation.
This is the domain class I skissed to describe it better:
And the code:
|
1 2 3 4 5 6 7 8 9 10 11 |
# A base class, for which the filter behaviour is defined class UserCriteria # We want to pass an user array to be filtered # Take an User < ActiveRecord::Base as parameter and return # an Array of the filtered users def filter(user) raise 'filter is not implemented' end end |
|
1 2 3 4 5 6 7 8 9 10 |
# Extended from UserCriteria. # This class takes care of filtering the users # with the age over 17 years class AdultCriteria < UserCriteria def filter(user) user.where("age > ?", 17) end end |
|
1 2 3 4 5 6 7 8 9 10 |
# Extended from UserCriteria. # This class will filter all the users # having the gender == 'female' class FemaleCriteria < UserCriteria def filter(user) user.where(:gender => 'female') end end |
|
1 2 3 4 5 6 7 8 9 10 |
# Extended from UserCriteria. # This class will filter all the users # having the gender == 'male' class MaleCriteria < UserCriteria def filter(user) user.where(:gender => 'male') end end |
By doing so, the User class will look cleaner for me…
|
1 2 3 4 |
class User < ActiveRecord::Base end |
To play around with the newly created filters in rails console:
|
1 2 3 4 |
fc = FemaleCriteria.new female_users = fc.filter(User) |
Thank you!
Observer pattern exemplified in Ruby
The observer design pattern is best demonstrated using the broadcaster <-> listener example.
A broadcaster in this example is an object having implementation for attaching listeners to itself. When the broadcaster will broadcast a new message, all the attached listeners are notified.
|
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 |
class Broadcaster attr_reader :message # The class initializer # The @message class member will be accessible to all the listerns # @listeners is a private array holding all the attached listeners def initialize() @message = "" @listeners = Array.new end # We broadcast a message to all the listerns. # Notice that all the listerns will be notified here. def broadcast_message(message) @message = message notify_listeners end # To attach a new listeners def attach_listener(listener) @listeners << listener end private # The attached listeners attr_reader :listeners def notify_listeners() @listeners.each do |listener| listener.message_broadcasted end end end |
A listener class will register the broadcaster to itself so that it can access the message that has been broadcasted by the broadcaster. It will also have a method, which will be called by the broadcaster when notifying.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
require_relative 'broadcaster.rb' class Listener # The class initializer. # The broadcaster will be passed to the instance. # At the same time will attach self to the broadcaster def initialize(broadcaster) @broadcaster = broadcaster @broadcaster.attach_listener(self) end # This method will be called by the broadcaster # when it will notify for a new message def message_broadcasted() puts "A new message received: #{broadcaster.message}" end private attr_reader :broadcaster end |
Let’s play around…
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
require_relative 'broadcaster.rb' require_relative 'listener.rb' # We create 1 Broadcaster object broadcaster = Broadcaster.new # We create 10 listener objects listeners_list = Array.new 1.upto(10) do listeners_list << Listener.new(broadcaster) end # Lets broadcast a new message broadcaster.broadcast_message("Take care of yourselves") # The output will be : A new message received: Take care of yourselves (x10) |