Mittra Software Blog

MobCur v1.0

2017-04-24T16:34:00.001-05:00

MobCur is a shorthand for "Mobile Currency", which is a simple proxy app that connects to the Bitso API that retrieves current prices (in Mexican Pesos) for Bitcoin and Ethereum.

Version 1.0 is a very simple app, it shows the current price, a small 5 minutes candlestick graph, the last 100 transactions, and both sides of the order book.

Later on, if time allows, I will expands its capabilities for other currencies and exchanges, as well as a AppleTV version of it.

I hope you enjoy.

OAuth 1.0a for ETrade API using Haskell

2016-05-27T21:22:00.001-05:00

Lately, I have been interested in creating a market quotes receiver which later on, using a DB and ML algorithms, will analyze the market movements and provide suggestions for better investments. But initially, I had to connect to an API provided, for which I found ETrade, which is an Online Broker stablished in the USA which has a REST API to request quotes, account data or even place orders to the Stock Exchange.

I have been long time fan of Haskell, but I had never engaged with a long term project to learn more about the language, the platform and all its possibilities, although I have a book pending to continue writing about Haskell FRP for Game development, this project seems like a good time/learn investment for long term goals: apply category theory, learn to trade stocks, explore Machine Learning algorithms and many more.

For all that, I started doing authentication to the platform, considering that I had to email ETrade customer service to request a Auth public/private key, then later with those in file, I created this script which will perform all necessary steps to retrieve a access token, which would allow me to query everything within the Sandbox: so here is the code:

{-# LANGUAGE OverloadedStrings #-}

module Network.Authenticate.ETradeOAuth
where

import           Data.ByteString         as BS
import           Data.ByteString.Char8   as C8 (pack, unpack)
import           Data.List               as ML
import           Data.Maybe
import           Network.HTTP.Client
import           Network.HTTP.Client.TLS
import           Network.HTTP.Types.URI
import           System.Environment
import           System.IO               ()
import           Web.Authenticate.OAuth
import           Web.Browser

authToken :: ByteString
authToken = "oauth_token"

-- OAuth Object to use when communicating with
-- ETrade developer API. Also, it must define
-- the two fields: oauthConsumerKey and oauthConsumerSecret
-- to be able to stablish a succesful communication.
-- For more information:
-- https://developer.etrade.com/ctnt/dev-portal/getArticleByCategory?category=Documentation
oa :: OAuth
oa = newOAuth {
    oauthServerName      = "ETrade"
  , oauthRequestUri      = "https://etws.etrade.com/oauth/request_token"
  , oauthAccessTokenUri  = "https://etws.etrade.com/oauth/access_token"
  , oauthAuthorizeUri    = "https://us.etrade.com/e/t/etws/authorize"
  , oauthSignatureMethod = HMACSHA1
  , oauthVersion         = OAuth10a
  , oauthConsumerKey     = undefined
  , oauthConsumerSecret  = undefined
  , oauthCallback        = Just "oob"
  }

-- We use a tlsManager to communicate using HTTPS
mgr :: IO Manager
mgr = newManager tlsManagerSettings

-- OAuth can construct automatically the authorization
-- URL, however ETrade uses another structure, which
-- is depicted as follows:
-- https://us.etrade.com/e/t/etws/authorize?key={oauth_consumer_key}&token={oauth_token}
etradeAuthUri :: OAuth -> Credential -> ByteString
etradeAuthUri oa crd = BS.concat [authUri, "?key=", consumerKey, "&token=", token]
    where
        authUri = C8.pack $ oauthAuthorizeUri oa
        token = urlEncode True $ findAuth $ unCredential crd
        consumerKey = urlEncode True $ oauthConsumerKey oa

-- Helper function to find the OAuth token out of a temporal credential
findAuth :: [(ByteString, ByteString)] -> ByteString
findAuth x = snd $ fromJust findAction
    where
        findFunction a = authToken == fst a
        findAction = ML.find findFunction x

-- This will innitiate the OAuth process, using an OAuth object and
-- a TLS Manager to asking for a temporary credential, with which it
-- will redirect the user to a ETrade webpage in which access is
-- authorized and a confirmation string is provided
doInitialAuth :: OAuth -> Manager -> IO Credential
doInitialAuth oa m = do
    temp <- --="" -="" ::="" able="" access="" all="" an="" are="" as="" authurl="" c8.unpack="" confirmation="" doaccessauth="" for="" gettemporarycredential="" in="" let="" m="" make="" oa="" oauth="" openbrowser="" place="" platform="" request="" return="" string="" subsequently="" temp="" the="" to="" token="" use="" we="" which="" will="" with=""> Manager -> ByteString -> Credential -> IO Credential
doAccessAuth oa m verifier tempCred = getAccessToken oa cred m
    where cred = injectVerifier verifier tempCred

main :: IO Credential
main = do
    print "This script will request an OAuth Token and Open the browser"
    m <- a="" answer="" bs.getline="" bs.null="" code="" confirm="" confirmation="" continue="" cred="" do="" doaccessauth="" doinitialauth="" else="" if="" m="" mgr="" newcredential="" oa="" ot="" print="" requests:="" return="" rovide="" string="" temp="" the="" then="" to="" uth="" valid="">

Of course, the source could be found in Github with a GPL v3 license.

In general terms, we need to install and import the following libraries:

bytestring
authenticate-oauth
http-client
http-client-tls
open-browser

With those already in place, it would be as simple as replace the values "oauthConsumerKey" and "oauthConsumerSecret" for those provided by ETrade or any other OAuth 1.0a service. Of course, if using other service, request URIs needs to be replaced.

After that, it is as simple as running this line:

runhaskell ETrade-OAuth-Example.hs.hs

That will automatically run main, which creates a TLS manager, request a token, opens the native OS browser to authorize the application and waits for the access code to finally request an access token from the API. All these steps were simplified using the OAuth library and the code snippet.

Of course, I am open to suggestion on how to improve this code is handled to make it more approachable to other interests.

Further Reading:

Github Source Code Link
Etrade Developer Documentation
OAuth Authentication process

Confidencialidad

2016-03-22T19:59:00.003-06:00

Bajo este rubro, la idea es mantener los mensajes e información secretos, confidenciales. Por ejemplo, utilizando los personajes de la comunicación, hacer que Ana o Juan se comuniquen sin que Eva o María descifren la información que comparten.

Para conseguir confidencialidad, la mayoría de los sistemas utilizan algún tipo de cifrado de tal manera que, si el texto es entremezclado, se aplica una función inversa que recupere el mensaje como originalmente fue creado.

Existe también una distinción entre codificar y cifrar; la primera solo modifica la representación inicial, y cualquiera que conozca el método de codificación debería ser capaz de leer los datos. En el segundo caso, cuando los mensajes son cifrados utilizando llaves digitales, se logra confidencialidad ya que es necesario poseer tal acceso para descifrar los contenidos originales.

A su vez se tienen técnicas de estenografía, la cual utiliza métodos inusuales de comunicación como pueden ser imágenes o audio, en donde se utilizan las repeticiones de, por ejemplo, la letra “A”, para representar un cierta información, y así transmitir, confidencialmente, el mensaje; esto se logra mientras el “adversario” desconozca los patrones utilizados por el algoritmo. Por supuesto, estas técnicas no son tan sólidas en comparación con el cifrado.

Otro ejemplo de confidencialidad se encuentra en el control de acceso, con archivos “ultra secretos” que solo cierto personal puede acceder; también la visualización parcial en bases de datos, donde, a las requisiciones de los usuarios se les provee de información digerida de acuerdo al acceso en vez de a toda la tabla en bruto, manteniendo la confidencialidad de las demás entradas en la base de datos.

Autorización

2016-03-17T21:52:00.000-06:00

El video anterior se hablaba de los métodos para descubrir con quién se estaba comunicando, ahora bien, el objetivo primordial de la autorización es determinar que las actividades que cierta entidad reconocida son legítimas, en otras palabras, que las acciones a ejecutar en un sistema son validas para los permisos que se tengan como usuario del sistema.

Un ejemplo sencillo como el siguiente: se tiene a un usuario autentificado en el sistema (Ana), una vez se tiene una sesión válida, ella quiere ejecutar un archivo en una sección solo “autorizada” para administradores, entonces el Sistema Operativo lleva a cabo una verificación por medio de la “Lista de Control de Acceso”, en la cual se comparan los permisos de Ana para comprobar si forma parte del grupo “administradores” y así permitirle ejecutar dicho programa.

Listas de Control de Acceso

A continuación se tiene un ejemplo básico de una lista donde las columnas determinan las categorías que impactan en el sistema; las hileras permiten identificar a los usuarios con los permisos asociados a su sesión.

Usuario | Recurso | Rol | Privilegio
Maria | /home/maria/* | usuario | Lectura, escritura, ejecución
Juan | /home/juan/* /* | administrador | Lectura, escritura, ejecución

Como podemos identificar, María puede leer, escribir o ejecutar únicamente en directorios derivados de su directorio de acceso; por otro lado, Juan puede hacer lo mismo tanto con su folder de inicio como en la raíz del sistema, lo cual también es derivado del rol asignado, como se muestra, un usuario normal o un administrador.

Modelos de Control de Acceso

Obligatorio: el sistema operativo determina exactamente quién tiene acceso a cuáles recursos.
Discrecional: Como en Sistemas UNIX, los usuarios autorizados determinan que otros usuarios acceden a los archivos o recursos que pueden crear, usar y mantener.
Basado en Roles: Al contrario del discrecional, aquí se generan roles, a los cuales los usuarios se adhieren para determinar los privilegios de acceso.

Derivado de esta clasificación, se tiene uno en particular llamado el Modelo Bell-LaPadula; muy popular su uso en entornos militares, es no discrecional y permite clasificar los recursos a proteger en: Ultra Secreto, Secreto, Confidencial o desclasificado, los cuales son asignados tanto a usuarios como objetos dentro del sistema y se siguen 3 reglas básicas:

Propiedad simple: Un usuario no puede acceder a los recursos con clasificaciones mayores a las asignadas a su rol. También se le conoce como “sin lectura superior”.
Propiedad estrella (de confinamiento): Recursos creados en cierta clasificación solo pueden ser leídos por usuarios con acceso del mismo tipo o mayor, o también “regla de no escritura inferior”.
Propiedad de tranquilidad: No se le permite a ningún objeto cambiar su nivel de clasificación a menos que no haya algún otro lector o escritor de tal documento en el sistema.

Este modelo permite reducir fugas de información cuando lo usuarios respetas reglas del sistema.

Autenticación

2016-03-10T21:11:00.004-06:00

En futuras entradas, vamos a utilizar a los siguientes personajes para explicar como se establece comunicación entre partes:

Ana & Juan - Chicos buenos
Eva - Chismosa pasiva
María - Chismosa activa
Tomas - Ana & Juan confían en él

Autenticación

Nos permite verificar la identidad de una persona ante un sistema computacional. Para esto es necesario asegurar que la comunicación entre Ana & Juan es verificada sin que terceras partes (Eva o María) sustituyan la identidad de alguno. Básicamente podemos clasificar a las formas genéricas en tres:

- Algo que “Sabes” (por ejemplo, contraseñas).
- Algo que “Tienes” (por ejemplo, token).
- Algo que “Eres” (por ejemplo, biométricos).

Algo que “Sabes”

El ejemplo clásico son las “Contraseñas”: Son fáciles de implementar ya que su uso generalizado permite a las personas entender su utilización. En contra pueden darse a conocer si tienen pocos caracteres o si son utilizados en muchos sitios y alguno de ellos es comprometido.

Algo que “Tienes”

Esta forma permite generar información dinámica con respecto a un elemento al que se tiene acceso, por ejemplo un mensaje SMS enviado al teléfono celular, también se tienen tokens digitales, “Smart Cards” o aplicaciones generadoras de PIN. Esto permite incrementar la dificultad para que un atacante sea autentificado.

Algo que “Eres”

Existen varios métodos que permiten identificar a un usuario por medio de los parámetros biométricos que son parte de la persona, por ejemplo un escáner retinal, detector de huellas dactilares o reconocimiento facial, entre otros. Aquí se tiene como principal ventaja el hecho de incrementar la seguridad del sistema; por otro lado, los datos obtenidos puede generar un alto número de falsos positivos, así como gozar de menor popularidad entre usuarios cuando tienden a ser muy intrusivos (escáner de iris).

Es importante recordar los siguientes casos:

- Falso Positivo: Un usuario auténtico es rechazado como tal.
- Falso Negativo: Un impostor es autentificado.

Notas importantes

Diferentes formas genéricas de autenticación pueden ser utilizadas al mismo tiempo para aumentar la seguridad del sistema. También se debe considerar al tipo de usuario que se quiere autorizar, si es persona a computadora ó entre computadoras. Esto nos permite diferenciar tres tipos:

- Clientes: Un servidor verifica el identificador del cliente
- Servidores: Un cliente verifica el identificador del servidor
- Mutua: Ambas partes verifican la autenticidad del otro.

Una vez que el usuario a sido autentificado, se le considera “Principal”.

Objetivos de Seguridad

2016-03-07T20:15:00.000-06:00

La seguridad se debe tratar desde una perspectiva holística, en otras palabras, es necesario cumplir varios requisitos antes de considerar un entorno de Tecnologías de la Información “seguro”.

Muchísimos detalles pueden resultar en imprevistos inesperados que afecten la continuidad de un servicio, en su mayoría relacionados con tecnología. De forma genérica, es posible clasificar en tres: entorno físico, tecnología, políticas y procedimientos. Es típico contar con estos elementos si lo que se busca como prioridad seguridad de un sistema.

Seguridad Física

Un atacante siempre va a buscar la manera más fácil de acceder a información protegida en base a la ley del menor esfuerzo, por lo mismo, se tiene que proteger la ubicación de las instalaciones, limitando acceso al espacio de trabajo, centro de datos o cuales quiera sean los activos a resguardar.

Otro ejemplo se encuentra en los documentos que se tiran a la basura sin verificar si la información que portan es destruida, ya que personal no autorizado podría acceder a su contenido, tan simple como triturar los papeles disminuiría las probabilidades de fuga de información.

Seguridad Tecnológica

Primordialmente orientado a la protección de la información digital, ya que existen diversas capas en la forma de proveer datos, en otras palabras, “seguridad de la aplicación”: procesos de identificación, validación de privilegios, configuración de servidores o la interpretación de contenido externo.

Así también, se consideran bajo esta categoría otras aplicaciones o librerías que interactúan con el software principal, el sistema operativo sobre el cual es ejecutado, seguridad en la red local - extendida o herramientas de detección de intrusos o cortafuegos.

Políticas y Procedimientos

Aquí englobamos ataques de ingeniería social, donde un hacker puede contactar con un empleado con suficientes privilegios de lectura u/o escritura a recursos resguardados, en el cual se permite “trabajar” a la persona para que ceda claves de acceso y así provocar intrusiones ilícitas. Para protegerse, es necesario establecer políticas corporativas que marquen la pauta en como debe tratarse la información pública y privada, así como los procedimientos a seguir para tareas genéricas.

Es necesario mantener a los empleados conscientes, educados y vigilantes del entorno así del como tratar los activos de la compañía, por medio de cursos de introducción que generen una cultura de resguardo de activos físicos o digitales.

Para todo esto, es primordial el considerar minuciosamente estos tipos de seguridad (física, tecnológica, políticas y procedimientos), ya que los atacantes van a tomar ventaja de cualquier debilidad y así poder acceder a la información.

PuzzleGony

2015-11-05T20:24:00.000-06:00

This is the first app I have developed in years as freelancer, a very simple game targeted for Apple Devices: Mac, iOS and Apple TV

Word capitalization with Haskell

2013-11-22T20:41:00.002-06:00

We have this problem, given a string of words, capitalize just the first letter, but the main trouble here is the lack of a common pattern to distinguish between one and another, for example:

"helloanyonethere" -> "HelloAnyoneThere"
"himartin" -> "HiMartin"
"hellorange" -> "HelloRange"
"thereach" -> "TheReach"

Well, the trouble can be addressed using Haskell, list and the always opportune recursion. The input information would be a dictionary that contains all possible words and the string to analyze; the output should be an string with the capitalized letters.

Now, lets explain the code step by step, first we need a function that search a string in a list of strings, which is simple, just tell me if the element is contained in the list.


isInDic :: String -> [String] -> Bool
isInDic str dic = elem str dic

Next, the magic happens with two big (but equally structured) functions, one that considers as priority bigger words and another that starts from smaller words (dropMaxDic <-> dropMinDic). The only difference between these two functions is the comparison of the current index N, if it is less or equal to the maximum allowed word size or, in the other hand, greater than or equal to the minimum allowed word size.


dropMaxDic :: Int -> String -> [String] -> [String]
dropMaxDic n str dic 
    | n == minWordSize    = []
    | otherwise = 
        if  (foundInDic == True)
        then
            capitalize : dropMaxDic maxWordSize removed dic
        else
            dropMaxDic (n - 1) str dic
    where
        wordToSearch = take n str
        capitalize = toUpper (wordToSearch!!0) : drop 1 wordToSearch
        foundInDic = isInDic wordToSearch dic
        removed = drop n str

Apart from that, they just recursively call, have you found a word, then concatenate the first capital along with the rest of the word and continue searching for more given a Mix/Max size. On the main loop we just load the british english dictionary, parse it so that bigger words are at the beginning and call the desired function on each test. The output of this program is shown as follows:


*CameCase> main
["Hello","Anyone","There"]
["Him","Art","In"]
--- Martin is not part of the
--- dictionary, that is why it
--- is split into "Art" & "In"
["Hello","Range"]
["There"]  
--- Here, it was more important to catch
--- "There" than "The","Reach"

--- This section goes from
--- Min to Max
["Hell"]
["Him","Ar","Ti"]
["Hell","Or","An","Ge"]
["The","Re","Ac"]

As we can see, the second section (Min -> Max) do not show any of the desired strings as output, this is mainly restricted to the use of the dictionary. Of course, this procedure is not efficient at all!!, I am aware of that, because it behaves (in the worst case scenario) as O(n^n), first because every word (either Max or Min) makes "n" searches to the dictionary, then if nothing is found, continue with the following iteration (Min + 1 | Max - 1). n searches for n possible words it is not efficient at all!!, but there are some improvements that could take place:

Have a dictionary with a reduced set of words, those that are probabilistically more precise to appear.
Parse the dictionary and transform it into a tree, where a lookup can take just O(n log n) to search for an entry.
Parse the string as a "trie" structure, where the alphabet would mean the first entries and possible words could be constructed out of the connected leafs to the root.
Execute Max and Min concurrently and merge the end results. This would only output more accurate results but perform badly still.
Use a bullet proof library for parsing strings.

Become a better programmer and design well from the beginning :).

Therefore, for now and as an educational improvement on Haskell usage, this seems to be a fair program. Links:

Pentagonal Numbers in Haskell

2013-11-20T21:30:00.001-06:00

As part of my refresh on algorithms, data structures and programming, I found this interesting mathematic problem:

Pentagonal numbers are generated by the formula, P_n=n(3n1)/2. The first ten pentagonal numbers are:
1, 5, 12, 22, 35, 51, 70, 92, 117, 145, ...
It can be seen that P₄ + P₇ = 22 + 70 = 92 = P₈. However, their difference, 70 22 = 48, is not pentagonal.
Find the pair of pentagonal numbers, P_j and P_k, for which their sum and difference are pentagonal and D = |P_k P_j| is minimised; what is the value of D?

Then, I decided to elaborate a program in Haskell that would find the number D. Of course, you can find the code in Github.

Unbalanced Balances...

2013-11-08T15:01:00.001-06:00

Once again, I found a challenge in a very common webpage that said the following:

You have a room-full of balances and weights. Each balance weighs ten pounds and is considered perfectly balanced when the sum of weights on its left and right sides are exactly the same. You have placed some weights on some of the balances, and you have placed some of the balances on other balances. Given a description of how the balances are arranged and how much additional weight is on each balance, determine how to add weight to the balances so that they are all perfectly balanced.

There may be more than one way to balance everything, but always choose the way that places additional weight on the lowest balances.

The input file will begin with a single integer, N, specifying how many balances there are.
Balance 0 is specified by lines 1 and 2, balance 1 is specified by lines 3 and 4, etc...
Each pair of lines is formatted as follows:

WL < balances >
WR < balances >

WL and WR indicate the weight added to the left and right sides, respectively. < balances > is a space-delimited list of the other balance that are on that side of this balance. < balances > may contain zero or more elements.

Then, I took this example and developed an approach using Haskell, which of course, you can find the whole source code in Github. Now let explain what is happening starting in the main:


main = do
    zz <- readFile "input001.txt"
--    zz <- getLine
    print zz
    let z = map strToInt $ tail $ lines zz
    print z
--    let inc = increment z
--    print inc
--    let x = missing z
    let allBalances = clasifyBalance 0 z
    print $ map showBalance allBalances
    let x = orderBalance allBalances allBalances 
    print x 
--    writeFile "output.txt" $ show x

Using the same schematic procedure as before, we read from the file "input001.txt" and set parse it to the variable zz, then we split it in lines, cut the first element, then transform the remainder into an array with a list of integers. After that, we transform the raw data into a more structured form: (balance #, WL, WR, Index Left, Index Right) : ...

So, a balance is structured this way, the first value will represent its place in the whole list, then the weights in each side, and a list of indexes to which balances are being put on each side. This structure is not efficient at all, because it requires to provide the list every single time one balance is analyzed, but it worked for learning purposes.

And the following line does what the program is expected to do, call a function that orders all the balances from the input file. The function orderBalance takes two list of organized balances and provides back the list with all of them perfectly weighted, if a balance has this structure: (4, 3, 0, [], [1]):(1,0,0,[],[]), it means that it has assigned the number four, on its left side has weights for 3 pounds and the right side carries the balance number 1. A perfectly weighted object would be: (4, 7, 0, [], []), because we would want this balance to have the same proportion, then adding 7 to the left side would equilibrate the problem. Then we analyze orderBalance:


orderBalance :: [Balance] -> [Balance] -> [Balance]
orderBalance [] _ = []
orderBalance _ [] = []
orderBalance ordered balances = balanceTheBalance 
         (headZeroBal ordered) balances : 
           orderBalance (tailZero ordered) balances

Simple, if you have an ordered balance array, distribute the weight of the first element, and continue with the remaining in the list. If it is is empty in either side, just return that emptiness to the caller. Then we arrive to the interesting method to analyze, balanceTheBalance:


balanceTheBalance :: Balance -> [Balance] -> Balance
balanceTheBalance (num,x,y,xs,ys) bals =
    if (leftWeight == rightWeight)
    then (num,x,y,xs,ys) 
    else        
        if (leftWeight > rightWeight)
        then (num, 0, difference, xs, ys)
        else (num, difference, 0, xs, ys)   
    where
        leftWeight = (x + totalBalance xs bals)
        rightWeight = (y + totalBalance ys bals)
        difference = abs (leftWeight - rightWeight)

Here, if your sides have the same value, then return yourself, if not, verify which side is causing troubles ¿left?¿right? and from there calculate how much is missing and return that difference back to the caller, simple, isn't it?? Of course, at the time of this writing, I spotted a problem, if your balance is like (1,3,3,[2],[4,5]), this function would fail, because the balance is not necessarily balanced, even if 4 and 5 do not have anything on their own, we would still have 13 on one side and 23 on the other side, but this trouble could be fixed in a 1.1v of this program.

First Haskell Published Program: Arithmetic Progression

2013-11-02T21:57:00.000-06:00

I find Haskell a challenging language, one that let you express yourself in different ways as procedural or object oriented programming allows you to do it. I knew about it quite a few months ago, but I have never had the time to concentrate to develop any example using it. As I found in the Facebook challenge example, I considered was a good opportunity to create a program with the current knowledge of Haskell (minimal) and still learn a lot using what I take for granted in other languages (C++ or Objective C).

At first, it is really a change of paradigm to start thinking about functions instead of variables that you declare at the beginning and use them as the program executes. Here those do not exist in the same way, as it does for loops (while or for) and the list are fundamental for data manipulation, you will notice my tries to force the language to behave as a procedural language, which I am aware it is not the best practice, but for the first steps I consider it is ok.

The statement of the test is the following:

The first line contains an Integer N, which is the number of terms which will be provided as input.
This is followed by N consecutive Integers, with a space between each pair of integers. All of these are on one line, and they are in AP (other than the point where an integer is missing).

Sample Input
5
1 3 5 9 11

Sample Output
7

Explanation
You are provided with 5 integers. As you can can observe, they have been picked from a series, in which the starting term is 1 and the common difference is 2. The only abberration, i.e. the missing term (7), occurs between 5 and 9. This is the missing element which you need to find.

Constraints
3 <= N <= 2500 All integers in the series will lie in the range [-10^6,+10^6].

Initially, the allowed time frame lies under 45min, but it took me around 5 hours to figure out a solution, having considered that I learned how to read files, read form STD, write (all with monads); recursions, "where" clauses, list comprehension, pattern matching and a little refresh of arithmetic progressions :), if you are interested in the full solution, the code is here. Let's start explaining function by function:


main = do
--    zz <- readFile "input.txt"
    zz <- getLine
    let z = strToInt zz
--    print z
--    let inc = increment z
--    print inc
    let x = missing z
    print x 
--    writeFile "output.txt" $ show x

The main, as in many other languages, is going to be the starting execution point. The "do" keyword states that what comes next is going to have IO actions, as "getLine" does: retrieve all input from the STDIO, then "bind" whatever comes from it to the "variable" (which is not exactly a variable but a ¿function?). The "let" keyword allows to "transform" the "IO String" to a simple "String" and "Purify" the IO action to a more common argument that takes place into the "strToIn" function. Lastly, "z" becomes the input of the function "missing" which is in charge of finding the missing number in the progression.


strToInt :: String -> [Int]
strToInt = (map read) . tail . words

As a simple explanation, the function "strToInt" transforms an String into a list of Integers doing "Function Composition" (cascade of input - output function calls). First it takes the implicit argument and splits it into words, which will be determined by a space, then discards the first element of the list, because in the challenge the input has first the number of elements and then the full progression. Then the resulting list is going to be mapped to the function read and transform each element into an integer, simple and concise, right??


initial :: (Int, Int)
initial = (0, 1)

missing :: [Int] -> Int
missing [] = 0
missing ys = (head ys) + (snd val - 1) * (fst val)
        where 
            val = pairSum ys initial

Now, initial is just a simple macro that defines a tuple that works as a starting point of saying (difference, position). Missing is going to be recursive function over a list of integers that returns the missing value in the progression, which first checks, is this an empty list, then the value is 0, otherwise I will apply the general formula of progression once I know the (difference, position) tuple from pairSum using the initial macro.


pairSum :: [Int] -> (Int, Int) -> (Int, Int)
pairSum [] _ = (0, 0)
pairSum (x:[]) (u, v) = (u, v)
pairSum (x:y:ys) (u, v) = 
    if (u /= 0 && diff /= u)
    then
        if (v > 2)
        then
            (u, v + 1)
        else
            (diff, v)
    else
        pairSum (y:ys) (diff, v + 1)
    where
        diff = abs(x - y)

Here some cases take place. Are you an empty list, then return a tuple of 0's. If you only have a list of one element, then we are not looking anymore for any pair of values. Then, the list can be decomposed into three elements, the head (x), the next element (y) and the rest of the list (ys); with this we are going to verify that at least we calculate a difference (u /= 0) and that previous and next difference match in order to continue searching, when this case does not happen, we see if the position of the missing number (v) is not in the second position of the list, in order to return the tuple "(difference, missing element position)".

This approach allows the algorithm to loop the list just once, determine where the missing element is and then calculate it using the general formula; this would create a complexity of O(n-m) where n is the number of elements in the list and m the position of the missing element, with a worst case of O(n) and best of O(1) if the element is in the first position of the list.

Deferred Lighting: The backdoor, Part 2

2013-10-29T21:43:00.002-06:00

In the first part of this article, we covered the a little theory of what this technique means as well as we set the foundations of code that started its execution on main. Now, the functional parts that are needed to create magic are going to be explained as follows.

When the Renderer class is allocated, also the constructor method is called, and here many preparations take place; in the following order: load each necessary CG shader, initialize the sphere lights (8) and place them across the heightmap, create the projection matrix and the root scene node to render objects, load the splash screen as a mesh, and set some configuration of the GCM. It is important to have considered the mesh "Sphere", this object will be the one in charge of draw into the scene the values of each light, in other words, the light will affect only on the area this sphere is colliding with, nothing else, process that differs from a ray tracing procedure. The code for what was explained before is here:

Renderer::Renderer(void)
{
        rotation = 0.0f;

        lightVert = new VertexShader(LIGHT_VERTEX_SHADER);
        lightFrag = new FragmentShader(LIGHT_FRAGMENT_SHADER);

        basicVert = new VertexShader(BASIC_VERTEX_SHADER);
        basicFrag = new FragmentShader(BASIC_FRAGMENT_SHADER);

        skyboxVert = new VertexShader(SKYBOX_VERTEX_SHADER);
        skyboxFrag = new FragmentShader(SKYBOX_FRAGMENT_SHADER);

        sceneVert = new VertexShader(SCENE_VERTEX_SHADER);
        sceneFrag = new FragmentShader(SCENE_FRAGMENT_SHADER);
        
        pointLightVert = new VertexShader(POINT_VERTEX_SHADER);
        pointLightFrag = new FragmentShader(POINT_FRAGMENT_SHADER);
        
        combineVert = new VertexShader(COMBINE_VERTEX_SHADER);
        combineFrag = new FragmentShader(COMBINE_FRAGMENT_SHADER);
        
        texturedVert = new VertexShader(TEXTURED_VERTEX_SHADER);
        texturedFrag = new FragmentShader(TEXTURED_FRAGMENT_SHADER);

        this->SetCurrentShader(*basicVert,*basicFrag);

    light = new Light[LIGHTS * LIGHTS];
    for(int x = 0; x < LIGHTS; ++x)
    {
        for(int z = 0; z < LIGHTS; ++z)
        {
            Light &l = light[(x * LIGHTS) + z];
            float xPos = (RAW_WIDTH * HEIGHTMAP_X
                         / ( LIGHTS - 1)) * x;
            float zPos = (RAW_HEIGHT * HEIGHTMAP_Z 
                        / ( LIGHTS - 1)) * z;
            l.position = Vector3(xPos, 200.0f, zPos);

            float r = 0.5f + (float)(rand()%129) / 128.0f;
            float g = 0.5f + (float)(rand()%129) / 128.0f;
            float b = 0.5f + (float)(rand()%129) / 128.0f;
            l.colour = Vector4(r, g, b, 1.0f);
            l.radius = (RAW_WIDTH * HEIGHTMAP_X / LIGHTS);
        }
    }

        projMatrix = Matrix4::perspective(
                     0.7853982, screen_ratio, 1.0f, 10000.0f);

        root = new SceneNode();
        root->SetTransform(Matrix4::identity());

        initMesh = Mesh::GenerateQuad();
        CellGcmTexture *initScreen = 
                        GCMRenderer::LoadTGA(INIT_SCREEN, false);
        initMesh->SetDefaultTexture(*initScreen);

        sphere = new OBJMesh(SPHERE_OBJ);
        
        cellGcmSetDepthTestEnable(CELL_GCM_TRUE);
        cellGcmSetCullFaceEnable(CELL_GCM_TRUE);
        cellGcmSetBlendEnable(CELL_GCM_TRUE);
        cellGcmSetDepthFunc(CELL_GCM_LESS);

        
        cellGcmSetDitherEnable(CELL_GCM_TRUE);
}

After the initialization, every time a new frame is processed, the RenderScene method is executed to perform all calculations. It is simple, but it implies some technique. First, it refresh the aspect ratio and screen space on the "set_viewport()" method. After, all the buffers are cleared and set to 0, this is to remove all the information from the previous frame or to flush any garbage data that comes at initialization. The "drawSkybox()" function generates a huge cube that encloses the scene and gives the illusion of a background. The last method listed, "swap_buffers()" removes the current frame on screen and replaces it with an updated frame. Then the three methods in the middle that take place are:

- fillBuffers(): This is just a simple pass, where all the objects are drawn as normal, with no affect of light whatsoever; the output of this calculation is transformed into a texture and used in the combine phase.
- drawPointLights(): Here all lights are drawn considering variables as radiance or specular, but also the normals and depths that took place in the previous stage. Consider again that each light will only affect the area of the sphere mesh.
- combineBuffers(): The color of the lights and the positions of the objects are combined to form the final screen image. Special consideration takes place with the matrices, that are set to identity because the input data is used as "textures", only having the projection matrix as ortographic to have everything managed as plane objects.

void Renderer::RenderScene()
{
        set_viewport();
        clear_buffer();

        drawSkybox();

        fillBuffers();
        drawPointLights();
        combineBuffers();
        
        swap_buffers();
}

The method textureFromSurface deserves special consideration, because of how the PS3 manages frame objects, this function transforms into a texture a GCM surface or, in OpenGL words, frame buffer. As you can see, it is used in many places in the class to transform the output of the first pass to information that can be used in the second and the third pass.

Deferred Lighting: The backdoor, Part 1

2013-10-25T22:52:00.001-05:00

Today, I was asked about the theory behind the Deferred Lighting procedure, of which, to be honest, I was starting to forget (too much Functional programming lately); but what is well learned, is never forgotten.

The main idea behind this technique is to delay as much as possible the calculations of light over the objects on the scene, only those that deserve to be rendered will be performed, otherwise will be discarded. This also relies on "several" passes, which also means, the first time an scene is going to be rendered as normal: vertex positions, its normals and the material for each surface and instead of sending it to the screen it is transformed into a "texture" with information of the depth, normals and specular. This last texture becomes the input for the next step, where lighting takes place using the information from the variables from the previous phase. And then one "last" pass calculates all objects in the scene once again but this time it combines the color from the texture with the emissive and ambient light. The image below shows graphically how they are all added:

I would like to publish the whole project, but due to NDA constraints that I signed with the university in order to be able to access the SCE SDK, I will only release the main and renderer classes that I used on the PS3 SDK. Those files can be found in here: https://github.com/rhvall/PS3DeferredLighting.

I am going to explain some parts of the code that are important and that could be useful for others, if there are questions, that what comments are for :).

       SceneNode *root = renderer.getRootNode();
#ifdef DEFERRED_LIGHTING
        Physics *physx = new Physics(root);
#endif
        HeightMap *heightMap = new HeightMap(HEIGHTMAP_RAW);
        heightMap->setDefaultTexture(HEIGHTMAP_TEXTURE);
        heightMap->setBumpTexture(HEIGHTMAP_BUMPMAP);
        SceneNode *heightMapNode = new SceneNode(heightMap, 
                Vector3(1), Vector3(1), HEIGHTMAP);
        heightMapNode->invInertia = Matrix4(0);
        heightMapNode->mass = 1000.0f;
        root->AddChild(*heightMapNode);
        renderer.height = heightMapNode;

General initialization is performed, first the root node, which is the one that is going to help us manage any object on the scene as well as make the respective calls to be rasterized when appropriate. The Physics is the part of the engine in charge of any collision detection as well as the forces calculating repulsion, mostly with the HeightMap, which also has textures, a position and physics variables. As any object in the scene, is referenced to the root node.

        OBJMesh *aSheep = new OBJMesh(SHEEP_OBJ);
        aSheep->setDefaultTexture(SHEEP_TEXTURE);
        aSheep->setBumpTexture(SHEEP_BUMPMAP);

        static unsigned short NUMBER_OF_SHEEP = 3;
        SceneNode *sheepsArray[NUMBER_OF_SHEEP];

        for(int i = 0; i < NUMBER_OF_SHEEP; i++)
        {
                SceneNode *sphereNode = 
                        new SceneNode(aSheep, 
          HEIGHTMAP_MIDDLE + Vector3(i * 100.0f, 200.0f, i * 50.0f),
          Vector3(100.0f, 100.0f, 100.0f), SPHERE);
                sphereNode->collisionable = true;
                sheepsArray[i] = sphereNode;
                root->AddChild(*sphereNode);
        }

        Input::SetPadFunction(INPUT_CROSS, crossButton, 
                static_cast(&(sheepsArray[0]->force)));

        OBJMesh *aCube = new OBJMesh(CUBE_OBJ);
        //aCube->setDefaultTexture("/Resources/CubeTexture.tga");
        SceneNode *cubeNode = new SceneNode(aCube, 
                HEIGHTMAP_MIDDLE, CUBE_SCALE, CUBE);
        cubeNode->invInertia = Matrix4(0);
        cubeNode->mass = 1000.0f;
        cubeNode->boundingRadius = 1;
        root->AddChild(*cubeNode);

This section create two things: the sheeps on the screen that interact with the user, and the classic transparent wall that 99.99% of the games use to prevent a character to fall from within allowed limits. Also, we send function pointers to the Input class to perform an action when a push on a button is detected (coff coff Delegates coff coff).

                Input::UpdateJoypad();        
                float msec = (float)gameTime.GetTimedMS();
                renderer.rotation = msec * 0.005f;
                physx->update(msec);
                root->Update(msec);
                renderer.RenderScene();

Everything before this piece of code is less relevant, because it takes charge of playing a sound and initialize a threaded network server to receive notifications from the desktop version. Later on, there are stages where the main screen is shown and waits for the user to continue the execution. But what is really interesting is the loop which repeats every frame, and that one is above: first, receive any notification from the joypad and execute the functions that we set previously. Get the time from the system, perform a little rotation on the lights (which will matter later on), update the physics engine according to the passed mili seconds, update the objects in the scene according to their position and lastly render everything once more.

Up until now, nothing had to be with the deferred lighting technique, everything was about initialization and later on the render loop. The real magic is built in the Renderer class, the one in charge of setting the puzzle altogether, lights and shaders calls, calculating everything per pixel/vertex. It seems like a good time to go for a chocolate and then come back to the number 2 of these articles; meanwhile, you can appreciate the video here:

To know more about this technique:

Deferred Lighting Rendering Path
Deferred shading

SSH and Sudoers

2013-10-09T21:14:00.003-05:00

After I had set up the server to connect to my internet source, the next step to cover was a way to communicate to it without using the User Interface. As there are many solutions, one of the most common, safe and secure is the SSH protocol (Secure SHell).

In order to archive this in the Ubuntu Server, I followed this tutorial:

 # sudo apt-get install openssh-client openssh-server

Just one command line does the job, but that is not enough. Because I knew which computers were going to connect, also I set up the SSH to trust those connections coming from a certified key, also I followed this tutorial. Those are easy steps, first create a certificate on the client (1), transfer the public key from the client to the server (2) and add the definition to the file of "Authorized keys" (3)

 (1) Client # ssh-keygen -t rsa
 (2) C -> S # CP rsa_pub -> ~/.ssh/
 (3) Server # cat rsa_pub >> authorized_keys

With that, the next time you are trying to authenticate, if everything went right, it will automatically prompt the console of the remote server.

With this in place, the only missing part was to have a script that automatically reseted the Wlan0 everytime it would (re)start the OS. To archive this, I started searching for the SUDOers and how to execute scripts on init, this is what I found:

 # sudo nano /etc/sudoers
 (TO THE END OF THE FILE)

- Cmnd_Alias SHUTDOWN_CMDS = /sbin/shutdown, 
      /sbin/halt, /sbin/reboot
- USER_NAME ALL=(ALL) NOPASSWD: SHUTDOWN_CMDS
# The user can the control machine's reset/shutdown
- USER_NAME ALL=(ALL) NOPASSWD: /etc/network/wlanStart.sh  
# The script on this folder can be SUDOer

And then set up the script to run on startup.

Easy, not??

Sources:

DNSCrypt on Ubuntu

2013-08-04T15:31:00.001-05:00

After setting up a shared wireless connection, I started to be worried about the "plainness" of the transmissions, that everything which would go through the air and the router could be simply read by another received and use that information to another purpose. Of course, there is the always reliable TOR network, but due to a quite high latency already increased, then I decided to skip it. Nonetheless, I still wanted something running on every request and that would increase a little the privacy, then I found DNSCryopt. In other words:

DNSCrypt encrypts all DNS traffic between your computer and the OpenDNS servers (so you'll be using OpenDNS) and can protect you from man-in-the-middle attacks, spying, resolver impersonation, can prevent Internet service providers from blocking various websites and more.

But theory is boring, let's go practice, first Download the package from internet, at the time of writing the lastest version was 1.3.2, but better check them here, also it depends on Libsodium 0.42

 # wget http://download.dnscrypt.org/dnscrypt-proxy/dnscrypt-proxy-1.3.2.tar.gz 
 # wget http://download.libsodium.org/libsodium/releases/libsodium-0.4.2.tar.gz
 # sudo apt-get update & sudo apt-get upgrade
 # tar -xvzf libsodium-0.4.2.tar.gz
 # cd libsodium-0.4.2/ && ./configure && make && make install
 # sudo ldconfig
 # cd..
 # tar -xvzf dnscrypt-proxy-1.3.2.tar.gz
 # cd dnscrypt-proxy-1.3.2/ && ./configure && make && make install

With all the commands before, DNSCryot should be installed and ready to run in the folder /usr/local/sbin/dnscrypt-proxy by default. Then it is time to configure it. First we edit the the DNS file:

 # cd /etc/resolvconf/resolv.conf.d
 # sudo cp -p head head.orig  # "backup copy, always do this"
 # sudo nano head
Add this to the end of the file: nameserver 127.0.0.2
 # sudo resolvconf -u

This should append this new direction at which we will forward all request. Then, to profit out of the convenience methods used by the "service" command, here was an script created in the WebUp8 Blog that I modified in order to help us call the command and initiate the application when the server restarts:

 description "dnscrypt startup script"

start on (local-filesystems and started dbus and stopped udevtrigger)
stop on runlevel [016]

script
        exec dnscrypt-proxy -a 127.0.0.2 --daemonize --pidfile=/run/dnscrypt-proxy.pid --edns-payload-size=4096
end script

And with the file saved, then everything is moved to the right place:

 # sudo cp dnscrypt.conf /etc/init/
 # sudo ln -s /lib/init/upstart-job /etc/init.d/dnscrypt
 # sudo service start dnscrypt

If everything worked as expected, then at the end you will be able to visit the webpage of OpenDNS and see this screen:

At the end, you can follow these instructions to see how the packages are encrypted: How to check if DNS is encrypted?

Sources:

Configure an Ubuntu "Gateway"

2013-07-16T23:20:00.000-05:00

The original title was going to be:

Configure an Ubuntu "Gateway" using two wireless devices and one server

But it was going to be long and boring. Ok, everything started because I have moved to a new location and I was not going to have internet in a long time nor willing to get a two year contract with a company again. So, connection from my supporting neighbor was provided, the only thing I had to do is to create an extension to his wireless AP. Easily enough I could had bought a WiFi extender, but no fun was going to be out of there and of course, if he would like to sniff what was going trough, well you know the history.

Fortunately I have this hardware ready to be set up:

VIA ARTiGO Pico-ITX Builder Kit A1000
Alfa AWUS036NH
WiDrive DX325

I could explain the network, but better seen graphically:

It still needs an explanation: There is an Access Point (AP) in the neighbor house connected to internet, for this case the name will be NAP01 with a WEP key abcde12345. The Alpha AWUS036NH connects directly to this AP as normal, then it is assigned an IP address with the number 192.168.2.7. The Via Artigo receives all data through one USB 2.0 port and then shares its connection to the ethernet port, in other words wlan0 ->> eth0. After this, the WiDrive receives its connection from the eth0 to its WAN port and creates another AP called "Internal" with a WPA key "abcabc".

In summary:

wlan0 - 192.168.1.5 (DHCP)
eth0 - 192.168.10.2 (STATIC)
wan - 192.168.10.5 (STATIC)

With everything prepared in the hardware side, let's get our hands dirty.

Get internet in the Artigo

 # ifconfig wlan0 up  
 # iwlist wlan0 scan
 # iwconfig wlan0 essid NAP01 key abcde12345   
 # dhclient3 wlan0

 # ifconfig wlan0
wlan0     Link encap:Ethernet  HWaddr 00:01:01:01:01:01  
          inet addr:192.168.1.7  Bcast:192.168.1.255  
          Mask:255.255.255.0

Set Static IP for the eth0 port

 # sudo nano /etc/network/interfaces

auto lo
iface lo inet loopback

auto eth0
iface eth0 inet static
        address 192.168.10.2
        network 192.168.10.0 # different network
        netmask 255.255.255.0
        broadcast 192.160.10.255
        gateway 192.168.1.7  
# take especial consideration to the gateway
# because it is the same IP address that was 
# assigned by the router to the
# wlan0

 # sudo apt-get remove dhcp-client
 # sudo /etc/init.d/networking restart

Set Up the Internet Sharing using IPTables

 # sudo iptables -A FORWARD -o wlan0 -i eth0 \
 -s 192.168.10.0/24 -m conntrack --ctstate NEW -j ACCEPT
 # sudo iptables -A FORWARD -m conntrack \
 --ctstate ESTABLISHED,RELATED -j ACCEPT
 # sudo iptables -t nat -A POSTROUTING  \
 -s 192.168.10.0/24 -o wlan0 -j MASQUERATE
 # sudo iptables -t nat -A POSTROUTING \
 -o wlan0 -j MASQUERADE

 # sudo iptables-save | sudo tee /etc/iptables.sav
 # sudo nano /etc/rc.local

iptables-restore < /etc/iptables.sav

 # sudo sh -c "echo 1 > /proc/sys/net/ipv4/ip_forward"
 # sudo nano /etc/sysctl.conf

net.ipv4.ip_forward=1
net.ipv4.conf.all.forwarding=1
net.ipv4.conf.default.forwarding=1

 # sudo /etc/init.d/networking restart

Set an Static IP for the WAN port

This last command might help in case you have this error: "status: Unknown parameter: INTERFACE" when trying to query the network interfaces:

 # service network-interface restart INTERFACE=eth0

The last part is the important bit. And I almost forgot, here are the links of the references that helped me create these steps:

How to Geek - Assign an static IP

Help Ubuntu - Internet Sharing

Geek Peek - Sharing WiFi

Lindesk - Enable IP Forwarding

BCFG - status: Unknown parameter: INTERFACE

Scalability and consistency in Server Based Network Gaming

2013-04-10T22:19:00.000-05:00

While I was doing the MSc in Newcastle, we needed to create an academic paper for the Game Networking module. So, now I am doing it public so other people, and specially researchers, can see that I have strong academic background and I am able to write papers. Of course, I am open to comments and always learning new ways to do it better ;)

This paper describes the capabilities of a Server based communication between two or many PS3 consoles as a way to efficiently transfer data using the TCP/IP protocols with the hardware embedded (Ethernet Cable and Wireless 802.11G). Also, it coves the common problems arising with the inclusion of more systems in the same network in order to keep communication consistency as well as some performance efficacy under different scenarios where low and high data transfer is required in between systems, whilst just one active server socket is kept open. When low demand applications are running and as highly bandwidth consuming case both are presented, in order to estimate how many consoles could be brought into the same network without a hit on game accomplishment.

Playstation 3 (PS3) systems are computer machines designed by Sony Computer Entertainment to serve as a video game console as well as a multimedia center, capable of displaying various media content from standard to full definition (video, images), as well as stay connected to a network using the standard stack protocols TCP/IP, resulting in a continuously communicated device not only in a local scope, also internet is considered as a content provider (PlayStation Network, HTML Browser or DLNA servers, among others).

¿¿More?? Find the full report here: http://es.scribd.com/doc/135278843/Scalability-and-Consistency-in-Peer-To-Peer-Based-Network-Gaming

Constraint Functional Programming using Heterogenous Architectures

2013-03-17T16:47:00.000-06:00

What a fancy name for just do this:

Have a Constraint Satisfaction Problem, then program it using Haskell and exploit multicore capabilities, what I mean with this, that user should not worry if they have 1, 10 or 1000 processing units, he/she would see an automatic performance increase just by running on a platform where more resources are available.

But you might wonder, why use Haskell if there are thousands of libraries already written for C++ or other languages?? Well the only reason is because functional programming is a high level - abstract approach to implement any mathematical statement, and due to AI heavily reling on logic, then it is a good start.

If you would like to see it further, here is the preliminary draft of the document that states which would be the outcome of such research. And yes, I would like to study a PhD program ;)

http://es.scribd.com/doc/130920180/PhD-Proposal-CFProg

Voxel Render Engine for PS3 SDK

2013-03-02T16:59:00.001-06:00

Hello Everyone!!

Long time I have not been here, not even to check if someone is trying to spam comments all around. Well, the good news it is that today I wanted to release my Master Thesis, which was about a way to display voxelized models using the PS3 SDK.

I did not do it before because I was "under NDA", an agreement between Newcastle University and SCE Europe. however I think by this time, they do not care anymore about releasing key points and ideas about what my document is about.

Another motivation of doing it was my pursuit towards a PhD program; this way if you are a researcher, you would be able to get an sneak peak of what I did during the program (1 year) the time of dissertation (3 months) and with a publishable format (10 - 15 pages).

And to get you not bored, here are some images that are related to it and how I was able to deploy it as well in other platforms (Windows, iOS)

Cheers!! (as NCL used to say)

Dissertation
http://www.openthesis.org/documents/Sparse-Voxel-Octree-Rendering-Engine-601379.html

iOS Simulator

PS3 Screen

Windows OpenGL

Deferred Lighting on PS3

2012-03-23T18:11:00.000-06:00

After almost 4 weeks trying to work out Deferred lighting on the PS3, we did it!! Thanks to the help and knowledge of almighty Richard, we were able to render to multiple phases and output the results on a PS3, something quite similar to what is shown on the initial image.

But less words, more action:

As explained in Richard's tutorial, the deferred lighting for the PS3 uses the same idea but instead of OpenGL, we use GCM, so changes from FrameBuffers to Surfaces or GLSL to Nvidia's CG language where among few inconveniences we encounter to make this demo work, but we never gave up.

I'll make another post with more details about many experiences we had during development.

MSc in Computer Game Engineering @ NCL

2012-03-19T18:04:00.000-06:00

Hello Everyone!!

I know I've been far away from blogging in a long time, more precisely since September 9 2011, when today it's March 19, 2012. Before you get angrier with me, let me explain why I've been so faraway lately:

In late September I started master degree program in the United Kingdom, at the Newcastle University, then right now I'm studying MSc in Computer Game Engineering, where I've learnt so much about programming in C++, OpenGL, Maths for Graphics, Memory Management, even how to program for the PS3 using the Sony Official SDK, isn't it so exciting??

That's my main reason for being so distant from my blog, another was the overhear that was moving from México City to Newcastle Upon Tyne: baggages, computers, clothes and almost my entire life, however I forgot my tennis shoes back home.

Just as simple like this: if you want to start developing the core engine of video games, this master program is such a really good start!!, not only you will learn how to program for real, also you will have the experience of real academia from research and industry as their best flavors, if you don't believe me, look at these profiles: Graham Morgan, Gary Ushaw, Richard Davison, this last one such a real guru in graphics and programming.

And for you to believe me, here are two videos that execute code using part of Richard's framework into the PS3 Dev Kit:

This was the first demo that I did:

Not to forget the coursework that I did for Graphics in, of course, an iPad!!:

And also a physics simulation for the Tech subject:

Also you could visit the webpage we did for our team project in the semester two:

http://homepages.cs.ncl.ac.uk/2011-12/csc8506-Team5/index.html

By the way, I am searching for projects to do in summer, sending CV's to many companies, if you'd like to know more about my work, email me and I'll try to get back as soon as possible.

11 Tips for Mobile Software Development

2011-09-09T19:05:00.000-05:00

More than 99 million smartphones shipped in just the first quarter of this year, says analyst firm IDC. Many of them are winding up in the hands of business users, including your employees and business partners. That trend means, sooner or later, you’ll have to develop smartphone apps. Here are 11 tips:

1. Track market shares.
It’s critical to keep up with trends in smartphone platforms, where the only constant is change. Sure, BlackBerry has long been synonymous with business, but it now lags both Android and Apple’s iOS in the race for market share, which affects what your company uses. In fact, Android is a case study in how quickly a platform’s fortunes can change: Between late 2009 and late 2010, Android’s market share grew 615 percent -- enough to leapfrog into first place, says analyst firm Canalys.

MeeGo and Windows Mobile are two other platforms to monitor. And don’t overlook Symbian, especially if your company has a lot of employees based outside of North America.

2. Learn the language.
Platform companies try to build market share by using programming languages and equipment that developers already know. For example, Windows Mobile lets developers reuse their existing Visual Studio and .NET development skills and server infrastructure to extend their applications to mobile devices. Meanwhile, iOS requires Objective-C development. Partnerships and outsourcing are two ways to develop for platforms that use unfamiliar languages.

3. Develop for multiple platforms.
Cross-platforming requires time and resources, but it ensures that your app’s fate isn’t tied to a single platform. One obvious way is by creating a separate app for each platform. But some developers say it can be cheaper, easier and faster to use CSS to recode Web apps to fit small screens, and then use JavaScript to control the events. The downside is that you might lose access to some of the device’s features, such as an accelerometer.

4. Look beyond smartphones.
Android and iOS now run on tablets too. The good news is that apps originally developed for smartphones can typically run on tablets without modification. But be aware that tablet users increasingly expect developers to create versions that take advantage of their devices’ larger screens and often faster processors. So identify tablet-specific features and leverage those when developing a tablet-only version of your app.

5. Strive for consistency.
It can be challenging to develop an app so it has the same look and feel across all Android or BlackBerry devices, let alone across multiple platforms or across both smartphones and tablets. But it’s still a goal worth pursuing, because most enterprises have a mix of devices. For starters, create a database of all of your company’s approved devices and their features -- particularly screen size, resolution and aspect ratio -- and whether they have a physical or virtual keyboard. Then, design your app to ensure that every function provides at least a basic, user-friendly experience for each device’s user group.

6. Identify integration needs.
If your app needs to tap into another system, such as your company’s CRM and other back-office systems, it’s never too early to figure out how your app will get that access. Just as important, ensure that it gets access in a way that doesn’t leave data in the open and doesn’t create back doors for hackers. Once you’ve got a beta app, test it to verify that the integration works.

7. Don’t hog the CPU and memory.
Sure, many of today’s smartphones have 1 GHz or faster processors and are connected to networks with speeds north of 1 Mbps. But many don’t, so it’s important to develop apps that provide a good user experience even on midrange handsets and older, slower networks. Most of today’s mobile platforms now support some level of multitasking, meaning your app will likely compete with several others for processing, memory and battery power. But be aware that no two platforms support multitasking quite the same way. For example, check whether a platform allows your app to do everything you need it to when it’s running in the background.

8. Be aware of carrier restrictions.
Wireless carriers have the power to block apps, such as those that compete with their fee-based services, or use what they deem as excessive amounts of bandwidth. Learn about these concerns and respect them rather than trying to do an end run. Be aware that even low-bandwidth apps can clog up cellular networks -- and sap batteries -- by constantly generating unnecessary signaling traffic. For example, an overly chatty IM app almost single-handedly crashed T-Mobile’s network in 2009.

9. Respect enterprise concerns.
Design apps so they use bandwidth sparingly, which helps users stay under their rate plan’s monthly usage cap and avoids the need for putting all mobile employees on a pricey unlimited-use plan. Bandwidth efficiency also helps extend battery life. Ideally, your app should not be the reason why a tablet or smartphone can’t go an entire workday before it needs charging.

10. Register with app stores and developer networks.
Registering with developer networks gets you access to their SDKs, while registering as a publisher ensures you get paid. Even if you’re outsourcing development, you can still register as the publisher so you can manage the sales revenue.

11. Certify.
Some app stores require certification, a process that includes vetting at both the platform and network usage levels. Certification often takes longer than developers expect, so don’t build your business model around the assumption that your app will be ready for employees the day after it’s finished.

By: Tim Kridel

LG Optimus 3D: Tri-dual

2011-09-08T20:23:00.000-05:00

LG Electronics (LG) today officially launched the long-awaited LG Optimus 3D, an innovative new smartphone featuring second generation dual core technology and an advanced "Tri-Dual" architecture. First unveiled at Mobile World Congress (MWC) in Barcelona in February, the LG Optimus 3D offers a full 3D experience -- recording, viewing, sharing -- in a smartphone form factor.

The LG Optimus 3D takes the smartphone experience into new territory with its Tri-Dual configuration -- dual-core, dual-channel and dual-memory -- which allows for improved performance when multi-tasking, enjoying a movie or playing graphicsintensive games. This LG smartphone is also a major step forward in the utilization of full 3D functionality in everyday life - users can record and immediately view content in 3D without the need for special glasses.

"Tri-Dual architecture opens up a whole new world in smartphone performance," said Dr. Jong-seok Park, President and CEO of LG Mobile Communications Company. "As the latest offering in our Optimus line-up, we expect there will be significant interest from those who seek the very latest in smartphone technology and are excited about 3D as the next big frontier in mobile devices." As always, here are the Technical Specifications of this cellphone:

Quad-band GSM and 3G support
21 Mbps HSDPA and 5.76 Mbps HSUPA 4.3″
16M-color capacitive LCD stereoscopic touchscreen of WVGA resolution (480 x 800 pixels)
Android OS v2.2 Froyo with LG 3D UI (Gingerbread upgrade coming around October)
Dual-core 1GHz ARM Cortex-A9 proccessor, PowerVR SGX540 GPU, TI OMAP4430 chipset
512 MB RAM
8GB internal storage
Dual 5 MP autofocus cameras, LED flash; stereoscopic 3 MP pictures, face detection and geotagging
1080p@30fps video recording, stereoscopic 720p@30fps videos
Wi-Fi b/g/n and DLNA GPS with A-GPS
MicroSD slot up to 32GB
Accelerometer, proximity sensor and an auto-brightness sensor
Front facing camera with video calls
Standard 3.5 mm audio jack microUSB port (charging) and stereo Bluetooth v3.0
microHDMI port
Smart dialing, voice dialing DivX/XviD video support
Office document editor
Innovative gesture controls
Adobe Flash 10.3 support
Dolby Mobile and SRS sound enhancement

More info:

iPad + Kinnect = Augmented Reality

2011-09-01T23:04:00.000-05:00

According to Apple this is the year of the iPhone 2, for many of us there is no doubt about it. However, the tablet is not the only technological character of our time, because it must share the stage with other products that are making a breakthrough regarding interactions with electronic devices. Augmented reality, the three dimensions and Kinect are other geek device working to be kings of the universe today. What if they all join in a single experiment?

As you can see, that's what the guys of Laan Labs have done, a company that develops applications for the IOS (DJ Tap is one of his creations). They happened to record a three-dimensional video recognition system using Microsoft's Kinect and then used it to display the recorded video on the iPad using augmented reality. Cool huh??

Droid vs iOS

2011-08-26T12:18:00.001-05:00

Technology history has always been full of constant friction between users of different platforms, programming languages, operating systems, etc. And mobile technology has no exception, and is currently users of iOS and Android keep a dispute "according to each" who owns the best and most popular mobile operating system at the time.

We can see those discussions on forums, social networks, websites, always favor some comments about the other carrying the stereotypes of each and making a mockery of the weaknesses of each operating system. But really what does it say the operating system you use you? This is what we try to solve the following graphics by Hunch.