There are various types of companies, I think that the biggest market is owned by outsourcing companies. But on outsourcing companies you will not grow enough to reach a management position or software architect position, because those companies using outsourcing services have their own architects and managers. Probably you can grow at least as lead developer, but usually those big companies using outsourcing services will not offer any stable position to you due to the contract that was signed by both parts of the sold service.

On that kind of companies, the fact that their programming language usage is restricted only to those languages supported by other well known companies, so that number languages is very limited, and probably you will only find Java, C# NET, Visual Basic NET, ABAP4, Cobol, and on very strange cases standard C under POSIX or SUSv2/3 platforms. Big corporations do no like those languages that are considered academic like OCaml or Haskell — but this is only an ignorant point of view because those languages commonly have a Scientific usage, so they are not really academic languages, because you can see distributed models — including job queues — implemented over those languages. Probably other big companies are using languages like PHP but for small tasks, rather than enterprise applications, and rarely other languages like Erlang.

Some languages like Python and Ruby, are really productive due to its syntax and multi-paradigm approach. We have various of those cool languages running over the Java Virtual Machine and NET runtime, for example on the Java side we have Jython, JRuby, Scala, Clojure among other languages that can make your development tasks really effective. On the NET side we have IronPython, IronRuby, F# and similar languages. The problem is the fact that there are very few companies using those variants, and those companies commonly use the basic implementation of standard C# NET and standard Java. The reason is simple, the lack of interest from developers to learn new languages are making the usage of any other language impossible due to the lack of developers supporting that language. For example there are some companies leaving all their C language programs and changing them by Java programs due to the lack of developers supporting the C language.

«What is the kind of problems handled on those companies?». Another good question. The fact that depending on which language will be used in your projects, will determine the kind of problems that you will be solving. If you are an algorithm lover, you are lost as Java or NET developer. Most applications are Web Based applications consuming a SOA architecture, so you will have the job of consuming those services and you will probably never see the real logic of those problems that are solved by those services, because they rely on a Cobol or ABAP4 backends very far from you. So, your real job will be data insertion and extraction with technology related to XML and JSON, where both are hard to understand if you are not able to handle data structures like trees once you need to process an XML tree or a JSON tree recursively. Remember that you cannot use parallel programming or similar stuff on application containers, because that problem is already solved and most problems are reduced to problems with time and complexity.

Due to the lack of risk assumption, those companies will never use a product which is not supported by another well known company, so, probably you will never see Apache Hadoop and some cool MapReduce implementation, and even you will not see a cool implementation of a MapReduce task in a cloud based environment like Amazon Elastic MapReduce, because most data managed by those companies is private.

So, the remaining companies are medium and small companies if you do not want to participate of that mechanic process and you want to use almost all your knowledge to solve problems. There are companies which are stuck on Web Development. Those companies are building dynamic web sites based on FOSS projects like content managers or blogs. That is not an option if you really want to develop applications and apply your knowledge. So, leave those jobs for people that well paid mechanic tasks, and non-well paid but lazy tasks. The next question is «where are present algorithmic problems»? and «where can I work»?. Well, the answer seems to be easy to solve. Algorithmic problems are present on those companies making products, a company that sell products — no matter if those products are desktop or SaaS products — they always need a good and creative programmer to solve hard problems.

Medium and small sized companies are using Message Queues, Job Queues and similar software, including architectures like OpenMP for parallel solutions. Every day we have more data to process, we have integration with social networks, third party services among too much stuff should be handled by real applications, not simple content managers. So we must take advantage of that software that can allow us to solve real problems in less time than linear processing, so we usually implement parallel or distributed processing reducing the computing time. I think that the best example are startups, once a startup grows and its processing requirement grow and they become useful applications for their customers, the amount of data requires a bigger processing capacity.

Also there are some good medium companies selling FOSS technologies allowing that kind of processing to their customers, which are usually big companies. They are doing a good job I think because they are introducing relatively new technology into their business process, allowing parallel and distributed processing, shortening processing time and getting early results due to their applications implementation. So, take advantage of the interview and ask for some technology of your interest, if the company rely on plain C# or Java, your job will probably be a boring job…

some illustrating anti-examples

case A, the implementer: on one of those big companies I’ve seen an algorithm implementation with complexity searching a value on a string cube due to searching algorithm used — with a very basic approach on searching algorithms and lack of knowledge on newer algorithms. So, seems to be common for some programmers to get stuck on that knowledge that was acquired when they were studying.

case B, the cpu can do it architect: there was a software architect solving a algorithm in linear time. That’s OK, but for a very small , once that has grown, the process got stuck for hours. So, no parallel programming or distributed computing was used to solve that problem. They cannot use relatively new technology like MapReduce because it is not still supported by any big corporations yet, and probably there was not enough knowledge to apply.

some illustrating good examples

case A, the mapreduce architect: on one of those service oriented companies they have decided to create a product, very specific for a customer, their architect was capable to solve a hard problem using Apache Hadoop and non linear time algorithms, the resulting solution was fast enough to be integrated with web services with almost real time responses, but with asynchronous requests due to the problem complexity, and they have a good account manager capable to sell Apache Hadoop as part of their product, both with good knowledge of distributed and parallel solutions.

case B, the polyglot programmer: there was application build on top of FOSS technologies, and the architect have designed a good application, and a big problem was required to be solved, a new hardware provide has sent a new device and they were requiring add support for that device on Linux. They were luck, because most of their programmers were polyglot programmers knowing C as part of their known programming languages. They do not missed their customer and they were able to make a new business bringing support for that new PKI device.

Copyright © 2012 Daniel Molina Wegener
Atribución-No Comercial-Sin Derivadas 2.0 Chile

© Daniel Molina Wegener for coder . cl, 2012. | Permalink | No comment
Post tags:

(defun dmw-haskell-pointfree-region ()
  "Executes the Haskell pointfree too on the marked region."
  (interactive)
  (let ((pfcmd (format "pointfree %s"
                       (shell-quote-argument (buffer-substring-no-properties
                                              (region-beginning)
                                              (region-end))))))
    (message (format "%s" (shell-command-to-string pfcmd)))))

(defun dmw-haskell-pointfree-replace ()
  "Replaces the marked region with the Haskell pointfree evaluation."
  (interactive)
  (let ((pfcmd (format "pointfree %s"
                       (shell-quote-argument (buffer-substring-no-properties
                                              (region-beginning)
                                              (region-end))))))
    (shell-command-on-region (region-beginning) (region-end) pfcmd t)))

(defun dmw-haskell-hlint-buffer ()
  "Runs hlint on the currently edited file."
  (interactive)
  (set (make-local-variable 'compile-command)
       (let ((file (file-name-nondirectory buffer-file-name)))
         (format "hlint %s" file)))
  (message compile-command)
  (compile compile-command))

(defun dmw-haskell-mode-hook ()
  "Haskell Mode Hook."
  (setq haskell-program-name "/usr/bin/ghci"
        indent-tabs-mode nil)
  (turn-on-haskell-doc-mode)
  (turn-on-haskell-indentation)
  (turn-on-haskell-decl-scan)
  (capitalized-words-mode t)
  (define-key haskell-mode-map "\C-c\C-p" 'dmw-haskell-pointfree-region)
  (define-key haskell-mode-map "\C-c\C-r" 'dmw-haskell-pointfree-replace)
  (define-key haskell-mode-map "\C-c\C-c" 'dmw-haskell-hlint-buffer)
  (message ">>> done dmw-haskell-mode-hook..."))

So, some nice thing about this mode-hook, is the fact that it can search for documentation on each function using C-c M-/ and find definitions using C-c M-.. With two custom commands which can allow you to use Pointfree — which can be installed using cabal — and Hlint — which can be found usually under your operating system without problems and can be installed using cabal too. So, to use Hlint with this hook, you can start it with C-c C-c or C-c C-v, and you can see if there is a point free style replacement for the selected expression — using Emacs region selection — with the binding C-c C-p, and if you like the point free style replacement, you can replace the selected region with the point free style expression using the binding C-c C-r.

I will try to add more nice stuff to my Haskell hook, probably something like searching modules and ordering imports, because would be nice to have similar stuff running under Emacs, to allow more easy to handle Haskell edition under Emacs. Enjoy!

Copyright © 2012 Daniel Molina Wegener
Atribución-No Comercial-Sin Derivadas 2.0 Chile

© Daniel Molina Wegener for coder . cl, 2012. | Permalink | No comment
Post tags:

Your challenge today is to write a program that can find the amount of anagrams within a .txt file. For example, “snap” would be an anagram of “pans”, and “skate” would be an anagram of “stake”.

module Main where

import Data.Char
import Data.List
import Data.Maybe
import Data.String.Utils
import System.Environment

liftLine :: String -> [Int]
liftLine l = fmap ord $ strip l

matchWord :: [Int] -> [Int] -> Maybe [Int]
matchWord w1 w2 = if sort w1 == sort w2
                     then Just w2
                     else Nothing

findMatches :: [Int] -> [[Int]] -> [String]
findMatches x xs = fmap (fmap chr . fromJust)
                   $ filter (/= Nothing)
                   $ fmap (matchWord x) xs

main :: IO ()
main = do [n, w] <- getArgs
          f <- readFile n
          let words = fmap liftLine $ lines f
              wmatch = liftLine w
              in mapM_ putStrLn $ findMatches wmatch words

Where the code above can be compiled using ghc --make prog.hs -o prog or can be executed using runghc prog.hs text-file word. With the text file bellow:

snap
pans
skate
stake
takes
kates
tekas
ketas

Its output is as follows:

13:02 [dmw@www:0 exercises]$ ./challenge20120213 challenge20120213.txt kates
skate
stake
takes
kates
tekas
ketas

Enjoy…

Copyright © 2012 Daniel Molina Wegener
Atribución-No Comercial-Sin Derivadas 2.0 Chile

© Daniel Molina Wegener for coder . cl, 2012. | Permalink | 4 comments
Post tags:

Today, your challenge is to create a program that will take a series of numbers (5, 3, 15), and find how those numbers can add, subtract, multiply, or divide in various ways to relate to each other. This string of numbers should result in 5 * 3 = 15, or 15 /3 = 5, or 15/5 = 3. When you are done, test your numbers with the following strings:

• 4, 2, 8
• 6, 2, 12
• 6, 2, 3
• 9, 12, 108
• 4, 16, 64

For extra credit, have the program list all possible combinations.
for even more extra credit, allow the program to deal with strings of greater than three numbers. For example, an input of (3, 5, 5, 3) would be 3 * 5 = 15, 15/5 = 3. When you are finished, test them with the following strings.

• 2, 4, 6, 3
• 1, 1, 2, 3
• 4, 4, 3, 4
• 8, 4, 3, 6
• 9, 3, 1, 7

Here is the full solution in Haskell, just to practice a little. Compile it using ghc --make prog.hs -o prog or run it using runghc prog.hs input.txt

module Main where

import Data.String.Utils
import Data.List
import Data.Maybe
import Math.Combinat.Sets
import System.Environment
import Text.Printf

data OperationResult = OperationResult {
     oper              :: Int -> [Int] -> Bool
     , msg             :: String
}

availableOperations :: [OperationResult]
availableOperations =
                    [
                    OperationResult { oper = testMatchMul,
                                      msg = "mul" },
                    OperationResult { oper = testMatchDiv,
                                      msg = "div" },
                    OperationResult { oper = testMatchSum,
                                      msg = "add" },
                    OperationResult { oper = testMatchSub,
                                      msg = "sub" }
                    ]

liftLine :: String -> [Int]
liftLine l = sort $ fmap ( read . strip ) $ split "," l

matchMessage :: String -> [Int] -> Int -> String
matchMessage s xs n = printf "%s does %s with %s"
                      s ( show n ) ( show xs )

testMatchMul :: Int -> [Int] -> Bool
testMatchMul n xs = n == foldr (*) 1 xs

testMatchDiv :: Int -> [Int] -> Bool
testMatchDiv n xs = dm == n && dr == 0
                    where (dm,dr) = divMod ( head xs ) ( last xs )

testMatchSum :: Int -> [Int] -> Bool
testMatchSum n xs = n == foldr (+) 0 xs

testMatchSub :: Int -> [Int] -> Bool
testMatchSub n xs = n == foldr (-) 0 xs

applyOperation :: [Int] -> Int -> OperationResult -> Maybe String
applyOperation xs x y = if oper y x xs
                           then Just $ matchMessage ( msg y ) xs x
                           else Nothing

matchOperation :: [OperationResult] -> [Int] -> Int -> [Maybe String]
matchOperation ops xs x = fmap (applyOperation xs x) ops

findMatch :: [Int] -> [Int] -> [String]
findMatch rs xs = fmap fromJust
                  $ filter ( /= Nothing )
                  $ join []
                  $ fmap (matchOperation availableOperations rs) xs

createCombinations :: [[Int]] -> [[Int]]
createCombinations xs = join [] $ fmap (choose 2) xs

procResults :: [String] -> IO ()
procResults = foldr ((>>) . putStrLn) (putStrLn "End!")

main :: IO ()
main = do [i] <- getArgs
          f <- readFile i
          let rows = fmap liftLine $ lines f
              comb = createCombinations rows
              oset = join [] $ nub $ join []
                     $ fmap (\ x -> fmap (findMatch x) rows ) comb
              in procResults oset
                 >> print comb

Where having a sample input file with three numbers per line as follows:

4, 2, 8
6, 2, 12
6, 2, 3
9, 12, 108
4, 16, 64

Should be processed as follows:

08:21 [dmw@www:1 exercises]$ ghc --make challenge20120212.hs -o challenge20120212
[1 of 1] Compiling Main             ( challenge20120212.hs, challenge20120212.o )
Linking challenge20120212 ...
08:21 [dmw@www:1 exercises]$ ./challenge20120212 ./challenge20120212.txt
mul does 8 with [2,4]
add does 6 with [2,4]
mul does 16 with [2,8]
add does 12 with [4,8]
add does 8 with [2,6]
mul does 12 with [2,6]
mul does 6 with [2,3]
add does 9 with [3,6]
mul does 108 with [9,12]
mul does 64 with [4,16]
End!
[[2,4],[2,8],[4,8],[2,6],[2,12],[6,12],[2,3],[2,6],[3,6],[9,12],[9,108],[12,108],[4,16],[4,64],[16,64]]

Also, this program can process files with lines containing up to 4 numbers, no matter how many of them are present on the file, it will try all combinations thanks to the Math.Combinat.Sets module which is used to create the proper permutations with each line which are converted to Int lists with the liftLine function. Probably this is a kind of very basic MapReduce and non distributed implementation where you have various sets of unique permutations — or antisymmetric power of each list — and operations to check whether are executed.

Copyright © 2012 Daniel Molina Wegener
Atribución-No Comercial-Sin Derivadas 2.0 Chile

© Daniel Molina Wegener for coder . cl, 2012. | Permalink | 6 comments
Post tags:

we all know the classic «guessing game» with higher or lower prompts. lets do a role reversal; you create a program that will guess numbers between 1-100, and respond appropriately based on whether users say that the number is too high or too low. Try to make a program that can guess your number based on user input and great code!

And here is my solution — where it has some validations to avoid the wrong input.

module Main where

import System.IO.Unsafe
import Text.Printf

promptOptions :: String
promptOptions = "[Yes (y), Higher (h), Lower (l)]"

queryNumber :: Int -> String
queryNumber n = printf "Is your number %s? %s"
                       ( show n ) promptOptions

printNumber :: Int -> String
printNumber n = printf "Your number is %s"
                       ( show n )

promptNumber :: Int -> IO String
promptNumber n = putStrLn ( queryNumber n ) >> getLine

reduceList :: String -> Int -> [Int] -> [Int]
reduceList m n xs | m == "h" = filter (> n) xs
                  | m == "l" = filter (< n) xs
                  | m == "y" = [n]
                  | otherwise = xs

searchNumber :: [Int] -> IO ()
searchNumber m = let ln = length m `div` 2
                     nm = m !! ln
                     mn = unsafePerformIO $ promptNumber nm
                     rs = reduceList mn nm m
                     in case length rs of
                             1 -> putStrLn $ printNumber $ head rs
                             _ -> searchNumber rs

main :: IO ()
main = do putStrLn "Is your number odd (o) or even (e)?"
          x <- getLine
          case x of
               "e" -> searchNumber $ filter odd [ 1 .. 100 ]
               "o" -> searchNumber $ filter even [ 1 .. 100 ]
               _   -> main

To compile this program with GHC, try ghc --make prog.hs -o prog, also it works with runghc prog.hs.

Copyright © 2012 Daniel Molina Wegener
Atribución-No Comercial-Sin Derivadas 2.0 Chile

© Daniel Molina Wegener for coder . cl, 2012. | Permalink | One comment
Post tags: