A daemon, classically on most Unix™ systems, first closes the three main I/O streams: stdin, stdout and stderr, then the fork(2) system call is used, creating an image of the current process, once the call is made, an exit(1) call is made on the parent process, and the child process keeps working in background. Due to the Python philosophy of being a productive language, this not so complex process is already implemented in the daemon module, so with this module you can create a daemon program.

import os
import sys
import daemon
import atexit

def main():
    """
    Main Program
    """

    install_signal_handler()
    atexit.register(at_exit_handler)

    opts = parse_opts()
    config = parse_config(opts)
    if not opts.cwd:
        print("No Working Directory")
        sys.exit(0)

    with daemon.DaemonContext():
        os.chdir(opts.cwd)
        install_signal_handler()
        start_schedule(config, opts)

""" Executes the main() Function """
if __name__ == '__main__':
    main()

If you observe the code, it changes the working directory using os.chdir() function, because once a daemon is created, its working directory is automatically changed to the root directory or /. Some daemons or servers like the Apache HTTP server, have a precompiled working directory, but it also allows to use chroot directory to make it work outside the precompiled working directory. Also, it is installing signal handlers, to allow signal processing, like SIGHUP and SIGCHLD. The parse_opts() and parse_config() functions, are functions to parse daemon arguments and daemon configuration using the optparse and ConfigParser modules respectively.

The atexit module is used to ensure that most program resources — like files, connections and similar stuff — are released or closed, once the daemon process terminates. So, the following atexit example shows a routine releasing resources.

from django.db import connections
import atexit

def at_exit_handler():
    """
    At Exit Function (close all connections)
    """
    for con in connections.all():
        try:
            con.close()
        except Exception, exc:
            log().error(exc)
    log().close()

The signal handler have very similar behaviour, it register a processing callback, which is executed using each time a signal is received. For example on the SIGHUP signal, I am doing a daemon rehash, rather than doing a daemon termination.

import signal as sig
import traceback as tb

def rehash_daemon():
    """
    Rehash the daemon, reading configurations again.
    """
    global DAEMON_CONFIG
    DAEMON_CONFIG = parse_config()

def install_signal_handler():
    """
    Signal Handler Installer
    """
    try:
        sig.signal(sig.SIGHUP, rehash_daemon)
    except Exception, exc:
        log().error(repr(exc))
        log().error(tb.format_exc(exc))
        return False

This will allow you to create a robust daemons, capable to handle signals, resource releasing on the exit event and similar stuff. Remember that as any language with a garbage collector, Python has the disadvantage of leaking memory if you do not cut the object references properly, due to the reference counting used by the garbage collector inside the GIL cycles. Your daemon design should be optimal.

© dmw for coder . cl, 2012. | Permalink | No comment | Add to del.icio.us
Post tags:

Attribution-NonCommercial-ShareAlike 3.0 Unported (CC BY-NC-SA 3.0)

The architectural pattern should be simple. Most people is thinking on the MVC architectural pattern as the most proper architectural for any application. But really the MVC pattern was designed with very old basis and mostly with the idea of generalizing the user interface of desktop applications. Currently, Web Applications are build on top of many technologies, not RDBMS engines only, so you should start using the proper architectural pattern, where technology diversity should follow the maximum cohesion principle, rather than coupling application components.

We have as key principle of design «minimum coupling, maximum cohesion», but I would like to add «proper generalization». So, finally we should have «minimum coupling, maximum cohesion & proper generalization» as design basis. If we observe, generalizations are older than software, we can stage that the term comes from Maths, where a generalization is a concept that can be applied to multiple problems and solve them using that concept. Cohesion is the principle of independent components that can work together, and coupling is a design which cannot separate its components. One of the best and classical examples of maximum cohesion on its design is Unix, where there are many small tools that can work together without coupling its functionalities.

A good generalization comes with from a good model, and any good generalization usually is able to solve multiple problems at once. Object Oriented programming provides a rich interface for abstractions, where the generalization is one of the most powerful ones, but in words of real generalization, I can proudly say that Monads are one of the best abstractions and mostly generalization that I ever seen.

• Haskell Programmer: Hey Java programmer, you know how just about everything is represented by a class?
• Java Programmer: Yea…
• HP: Even stuff no business being a class
• JP: Well, it is our fundamental abstraction for anything larger than a function. It may be clumsy, but it can be used to implement any other design pattern we need.
• HP: Well Monads serve the same role for us.
• JP: Nulls?
• HP: Maybe Monad
• JP: I/O?
• HP: IO Monad
• JP: Exceptions and error handling?
• HP: We have several ways, but mostly Maybe Monad
• JP: List comprehension?
• HP: Again, Monads
• JP: Mutable data structures?
• HP: That would be the State Monad_[2]

With the proper generalization you can make your design to be consistent, robust and reliable. But you must leave the generalization concept just as hierarchy problem. It should be stated globally as computational problem rather than design problem only. A generalization as computation can be applied to multiple problems, where applying computational generalizations we can find mapping functions that can be globally used. This can be reached combining the IPO model and Object Oriented models properly, working together.

Software design is not easy. An UML class model is not enough, where it can only display structures, probably with a sequence models and communication models you can reach a good IPO design, but not without the proper knowledge about the implementation. So, any analyst who does not knows how to program, is just wasting your money and time, with the obvious further reimplementation and redesign of the software product.

And you should start adding the proper generalizations as computations to your design, working together with your hierarchical generalizations, so they can bring you the proper quality along the time.

[2] This is an excerpt from a discussion on a programming forum.

© dmw for coder . cl, 2012. | Permalink | No comment | Add to del.icio.us
Post tags:

Attribution-NonCommercial-ShareAlike 3.0 Unported (CC BY-NC-SA 3.0)

As you know I am currently solving the Project Euler problem set, just as toy project, to practice some Haskell code with some not so complex problems. And yesterday I have implemented the solution for the problem 104, which is trying to find first pandigital digits from 1 to 9 on the last and first digits of a Fibonacci number. So, the Fibonacci should have more than 9 digits to solve this problem. You can see the code of the solution on this link.

If you observe the code, you will see that it is respecting the Haskell tail call convention, where you must use closures to ensure that the compiled code will be using guarded recursions. Otherwise the functions will become standard recursive functions, rather being compiled as guarded recursions — which are similar to tail calls.

-- | Calculates the Fibonacci Term N
fib :: Int                      -- ^ Term to calculate.
       -> Integer               -- ^ Fibonacci Term as Result.
fib n = snd . foldl' fib' (1, 0) . dropWhile not $
        [testBit n k | k < - let s = bitSize n in [s - 1, s - 2 .. 0]]
  where
    fib' (f, g) p
      | p         = (f * (f + 2 * g), ss)
      | otherwise = (ss, g * (2 * f - g))
      where ss = f * f + g * g

Also it defines two functions to check if the number meets the pandigital requirement, where isValidDig is not called immediately from the checkRange recursive function, instead of calling that function, it calls the isValidPan function, where it is called with the constant expression [1..9], avoiding consecutive List instantiation, and using `seq` to avoid lazy evaluations and further stack overloading.

-- | Checks if the given number x have valid last n digits
-- and last n digits
isValidDig :: Integer           -- ^ Number to Check.
              -> [Integer]      -- ^ Sequence to Check.
              -> Bool           -- ^ Is valid or not.
isValidDig x xs
  | length (digits 10 x) < length xs = False
  | otherwise = let ds = digits 10 x
                    l = length xs
                    s = sort xs
                    r = sort $ take l ds
                    t = sort $ take l $ reverse ds
                in r == s && t == s

-- | Checks sequentially if the given range covers the
-- problem of pandigital sequence of digits using the reqDigs
-- sequence.
isValidPan :: Int               -- ^ Number to check.
              -> Bool           -- ^ True when is valid.
isValidPan x = r `seq` isValidDig r [1..9]
               where r = fib x

This allows the usage of a small stack space once it is called, due to strict evaluation, where all List instances are not kept in memory, and similar structures are only evaluated once, without keeping that memory in use, and being released once those non recursive functions are finished. Finally we can use isValidPan on a guard, without the risk of overloading the stack.

-- | Checks sequentially if the given range covers the
-- problem of pandigital problem.
checkRange :: Int                   -- ^ Starting number.
              -> Int                -- ^ End number
              -> Int                -- ^ Returning Number (-1 on failure).
checkRange m n = sCheckRange m n m
  where sCheckRange x y z
          | z >= y = -1
          | isValidPan z = z
          | otherwise = let r = z + 1
                        in r `seq` sCheckRange x y r

The closure used on the checkRange function makes the compiler to start using the tail call as it is required by this kind of functions where you must keep very well controlled the evaluation of the program expressions. Any mistake on the evaluation of the program will lead you to use more memory that it is really required, leading to slowness and delayed evaluations where your code could crash with stack overflows.

Problem 104 Example Memory Usage

As you see on the cost centre chart above, the program is using almost a constant amount of memory along its execution, evaluating Fibonacci terms from 1000 to 9000, in 12 seconds approximately. So, the keys of a good memory usage in Haskell is to use evaluation expressions and guarded recursions properly.

Another example is the problem #255 in the Project Euler. This code is using Haskell tail calls to ensure the optimal memory allocation. For example the function used to calculate the rounded square root using the Heron Operation as follows.

-- | Applies the Heron Operation recursively until it returns
-- the round square root and the number of iterations as tuple.
heronOpRec :: Integer                 -- ^ Heron Operation to Apply
           -> (Integer, Integer)      -- ^ Pair (RSR, Iterations)
heronOpRec a = heronOp a a (digitBase $ numDigits a) 0
  where heronOp o n m a
          | o == 0 = (0, 0)
          | o == 1 = (1, 1)
          | o == 2 = (1, 1)
          | o == 3 = (2, 1)
          | n == m = (m, a)
          | otherwise = let x = fromIntegral m
                            y = fromIntegral o / x
                            s = round ((x + y) / 2)
                            t = a + 1
                        in heronOp o m s t

And the application of this kind of recursive calls can be seen in the following chart.

Problem 255 Example Memory Usage

If you compare both charts and see how both problem solutions are programmed, you will see that they keep a very low limit on memory usage. The problem #255 is using numbers purely, and where problem #104 solution is using lists to hold the digits of the number to be checked as pandigital, that is why it has some peaks on the isValidDig function, but once the program exits that function that memory is deallocated by the garbage collector.

© dmw for coder . cl, 2012. | Permalink | One comment | Add to del.icio.us
Post tags:

Attribution-NonCommercial-ShareAlike 3.0 Unported (CC BY-NC-SA 3.0)

You as programmer probably know about that — but only if you have gained expertise on certain programming language — where you have learned more stuff than it was shown to you on a classroom or course. Because you know that to reach a good level on any programming language requires more than courses. It requires book reading, exercising, reasoning on that programming language, learning about its features, its limits and how it is implemented. This clearly avoids many programming errors and reasoning errors. A code monkey, does many failed attempts to solve problems guessing which call should be used on a block of code, rather than reasoning and using the right calls where they are required. There is an old phrase that you will remember, and it is not told as joke I think: «Read The Fucking Manual». RTFM is probably one of the oldest phrases on the Internet. Almost all specifications and user manuals are public documents, you can read them online, print a copy if you want and mainly you can learn from them.

The classical example is how is being used the garbage collector on Java and similar programming languages. There are many applications reaching the OutOfMemoryError, due to memory leaks. Because many programmers are misunderstanding the concepts behind what really does a garbage collector, and they are mostly based on reference counting. So, any memory related problems on applications where the language uses a garbage collector, is just a subject of misunderstanding what really does its garbage collector. Other two errors are heap overflow and stack overflow errors, if you reach them, you still need to know in deep the programming language that you are using. So, any programmer reaching that kind of errors still requires more knowledge to be called expert. But that knowledge is public, there is no black box and there is no black magic behind those errors, you just need to read the programming manuals and related documentation. So, there is not excuse to reach that kind of errors.

So, for me if the language or the environment brings me an error, I start researching about that error until I get it solved. For me is not a subject of increasing hardware resources or similar stuff until I get a real proof that it is really required. An error for me need to be solved from my code first, not the environment, because my code is my responsibility, not the environment. An example of almost bug free software is pyxser, it does not have memory leaks in its code and it is safe to be used in production environments, you can do up to 1.000.000.000 of continuous and parallel serializations-deserializations with pyxser, without leaking the computer memory, you just need to use the proper calls. A product with that quality was obtained only because I was very strict and self-criticising. So I have created a serializer that does not crashes with cross references and circular references — which is not implemented in other XML serializers — and it is very robust because I was a self-criticising programmer. You can try to serialize, for example, a Django Model class instance (object), and you will not be able to do it with other serializers like simplejson. So, being self-criticising is not bad as you think…

© dmw for coder . cl, 2012. | Permalink | No comment | Add to del.icio.us
Post tags:

Attribution-NonCommercial-ShareAlike 3.0 Unported (CC BY-NC-SA 3.0)

My set of rules on handling projects and jobs related to programming are mainly related to payment methods, rates, methodologies and who is hiring me. So, non serious proposals are not handled by me. If you come telling me that you need a web page, just forget hiring me, I will not attend you, because I develop applications, not web pages.

refuse fixed price projects

Every software project without a well defined specification and clear requirements, is subject of changes, handling fixed price project is subject of spending unpaid work hours. So, my rates are monthly and hourly, depending on how is agreed the payment method. Fixed price projects which does not have a very consistent specification and requirements, will not be handled.

refuse projects with the wrong technology

As PHP projects, they will be refused. I cannot handle projects that cannot be properly integrated with other tools and languages that do not have strictly necessary tools like static analyzers and style checkers. PHP, Node JS and similar ones which has that kind of lacks, will not be accepted.

refuse projects where I did not made the estimation

Every software where I did not have made the estimation will be refused, I cannot handle projects where the estimation is not subject of concise methodologies like PERT. So, your compromise is not my compromise if you have made the estimation.

refuse projects without version control

Every project where you are not using version control, will be refused. I cannot stay sending tarballs with my code, creating messy products, everything should be properly branched and tagged on each milestone.

refuse projects without issue tracking

Every project should be using issue tracking software, agile or not, but I need that kind of tools to track each development stage, where everything should be clearly specified.

refuse projects without continuous integration

I cannot work with projects where you are not properly checking the code. The code should stay clean from its origin, with the proper style and avoiding common errors.

do not work with novice programmers

I do not work with novice programmers which are not capable to read a specification and they are not able to handle some basic stuff, like server configuration, command line tools, server administration, and the proper knowledge of the environment where are you working. If you want me as tutor or mentor, just hire me as tutor or mentor, it is a separate job.

You must have all those points in mind before hiring me or calling me for a project proposal. Those rules were created due to some failed project — two to be more precise.

© dmw for coder . cl, 2012. | Permalink | No comment | Add to del.icio.us
Post tags:

Attribution-NonCommercial-ShareAlike 3.0 Unported (CC BY-NC-SA 3.0)

Is nice to work with Haskell, you may know that you can work with a very wide variety of technologies in Haskell. Also, the Glasgow Haskell Compiler or GHC, is able to compile machine byte code, creating native executables for its runtime. Since all Project Euler problems are very nice to solve, I have created a github repository with my solutions, to share them, probably you can use them to examine some Haskell code and see if you want to learn it.

The problem 102 is related to triangles and point positions, and it can be seen in this link. The main goal of the problem is to indicate the number of triangles which are containing the origin or point , where I have used the Cross Product to solve this problem.

First I have defined plane points and triangles as data types in Haskell, deriving the Num type class instance on the LPt data type which represents a point in a two dimensional space.

data LPt = LPt (Int, Int)
         deriving (Eq, Show, Ord)

data LTrg = LTrg {
  tA        :: LPt
  , tB      :: LPt
  , tC      :: LPt
  } deriving (Eq, Show, Ord)

instance Num LPt where
  x + y = LPt (fstp x + fstp y, sndp x + sndp y)

  x - y = LPt (fstp x - fstp y, sndp x - sndp y)

  x * y = LPt (fstp x * fstp y, sndp x * sndp y)

  abs x = LPt (abs (fstp x), abs (sndp x))

  fromInteger x = LPt (fromInteger x, fromInteger x)

  signum x | fstp x < 0 && sndp x < 0 = -1
  signum x | fstp x > 0 && sndp x > 0 = 1
  signum x = 0

crossPt :: LPt -> LPt -> LPt
crossPt x y = LPt (0, fstp x * sndp y - sndp x * fstp y)

Then is easy to reach the solution. Where I have plain text file parsing triangle points using the following functions.

mkTriangle :: String -> LTrg
mkTriangle s = LTrg { tA = head g, tB = g !! 1, tC = last g }
               where g = fmap (\x -> LPt (head x, last x) )
                         $ splitEvery 2 ln
                     ln = fmap (read . strip) $ splitOn "," s

mkTriangles :: String -> Int -> Int -> [LTrg]
mkTriangles s l h = drop l
                    $ take h
                    $ fmap mkTriangle
                    $ filter (\ x -> length x > 0 )
                    $ fmap strip
                    $ lines s

So, my solution do not creates all triangles on the file, rather than creating all triangles, it just takes a given segment of the file, and renders their position in the OpenGL windows.

trgColor :: LTrg -> IO ()
trgColor xs | trgContained zeroPt xs = colorCyan
trgColor xs = colorGreen

displayTriangle :: LTrg -> IO ()
displayTriangle xs = do _ <- renderPrimitive Polygon $ do
                          trgColor xs
                          mapM ptToGlPt [tA xs, tB xs, tC xs]
                        flush

displayTriangles :: [LTrg] -> F.Font -> IO ()
displayTriangles xs f = do clear [ ColorBuffer, DepthBuffer ]
                           mapM_ displayTriangle xs
                           trgTextCont xs f
                           flush

Where the call to the trgContained in the guard at the trgColor function is what indicates if the triangle contains or not the point or zeroPt. So, you can see two sample results as follows.

Project Euler: Problem 102 Visualization Sample 1

./problem102 triangles.txt 70 90

Project Euler: Problem 102 Visualization Sample 2

./problem102 triangles.txt 23 48

© dmw for coder . cl, 2012. | Permalink | No comment | Add to del.icio.us
Post tags:

Attribution-NonCommercial-ShareAlike 3.0 Unported (CC BY-NC-SA 3.0)

The most common job position in the last decade in software development is the Web Development. Almost everyone wants a Web Application, something that can run on a browser, without doing too much effort porting an application to desktop applications and similar stuff. So, most software development contracts are based on the Web. If you study something related to Informatics Engineering or Computer Science related topics, you cannot expect that they will prepare you for an immediate job position, and even you cannot expect that you will finish studying that career knowing everything related to it. Studying a career has the intention to get the basic knowledge on certain subject, enough to understand books that will bring you the proper expertise on that subject. Then you can do an MSc and you will be an expert on a small subset of topics covered by your career, also you can do a PhD, and you will be an expert discovering new stuff on a very specific subject of interest. You can read this wonderful article entitled «The illustrated guide to a Ph.D.» and you will see what I am referring to.

But if you do your stuff without interests, you will not learn, and you cannot drag any guilty to your environment about not learning enough to reach a good level. Everything is subject of interests, getting a graduate level on any career is not subject of decorating your room with a nice diploma, or showing a good position in your resume.

So, if you decide to get employed as Software Engineer on a Web Developer role, at least I am expecting from you that you will be able to read the Hypertext Transfer Protocol Specification and solve almost anything related to that protocol. A small team in one of those companies was working with a very specific service, mounted over HTTP/1.0 over a standard Apache Tomcat server. Rather than using SOAP or similar protocols, the service was working with HTTP POST parameters, and returning XML as content response. But they were stuck two days trying to solve a small problem. The HTTP client library that they were using was keeping the connections open and not closed, leaving many HTTP connections open on subsequent requests. If you know a little about browsers, probably you know that they are using — almost all of them — Keep-Alive connections. So, if you want to research what makes an HTTP client to use Keep-Alive connections, you should start searching for keep-alive and negotiation keywords over the document.

An HTTP/1.1 server MAY assume that a HTTP/1.1 client intends to maintain a persistent connection unless a Connection header including the connection-token “close” was sent in the request. If the server chooses to close the connection immediately after sending the response, it SHOULD send a Connection header including the connection-token close. [Hypertext Transfer Protocol -- HTTP/1.1, Section 8.1.2.1 Negotiation, first paragraph]

So, the right header to search for is Connection, which controls the HTTP/1.1 behaviour during the protocol negotiation. This is not CURL, which uses a closing connection negotiation due to its nature, which is not the nature of a common HTTP client which uses the standard specification.

HTTP/1.1 defines the “close” connection option for the sender to signal that the connection will be closed after completion of the response. [Hypertext Transfer Protocol -- HTTP/1.1, Section 14.10 Connection]

Finally, took me two hours to solve the problem reading the HTTP client library documentation and the HTTP/1.0 specification. The previous hack of destroying the client instance to avoid open connections was removed and the client library started its works using the proper standard behaviour. So, everything is subject of interest. The server was working with the right behaviour, not as some team members were thinking about bugs on the server. All those headaches were subject of a lack of interest on the issues to be solved. I just imagined how many lines of code were dropped and inserted trying to reach the proper solution guessing which API call would close the connection, trying to use many API calls, and just one extra line of code has solved the problem.

httpRequest.setHeader("Connection", "close");

Getting confused if you are under pressure is natural, I accept that. Also I accept that here in Chile being a programmer — now called Software Engineer — is not one of the most coolest job positions on the market. It will never will be well paid as manager position. But the lack of interest is not subject of where did you have studied. Probably making a complex career which requires reasoning, reading and effort, is something boring with pressure and not well paid job positions is causing that lack of interest, where most Software Engineers do not work on that job position for a long time. And this problem is not subject to be treated on a classroom, they just will bring you the basis. Reading and enhancing skills is your own responsibility.

© dmw for coder . cl, 2012. | Permalink | No comment | Add to del.icio.us
Post tags:

Attribution-NonCommercial-ShareAlike 3.0 Unported (CC BY-NC-SA 3.0)

If we see my solution, there is a function pair to solve the problem where heronOp is the main recursive function to solve the iterations, avoiding state. On Haskell, thanks to its main functional abstraction called Monad, you can implement state machines and similar tasks using the State Monad, but states are not really required to solve anything in Haskell.

module Main (main) where

import Data.Digits (digits)
import System.Environment (getArgs)

digitBase :: Int -> Int
digitBase n | odd n = round ((2 * 10) ** ((fromIntegral n - 1) / 2))
digitBase n = round ((7 * 10) ** ((fromIntegral n - 2) / 2))

heronOp :: Int -> Int -> Int -> Int
heronOp o n m | n == m = m
heronOp o n m = heronOp o m (round ((x + y) / 2))
                where x = fromIntegral m
                      y = fromIntegral o / x

main :: IO ()
main = do [x] <- getArgs
          print
            $ heronOp (read x) (read x)
            $ digitBase $ length $ digits (read x) 10

There is — among other interesting approaches — a paper where the authors are writing about writing operating systems entirely in Haskell [«A principled approach to operating system construction in Haskell»], despite it is a functional language, it has solved the stack usage problems along recursive calls using tail calls, so you do not need to worry about recursion in almost all code, you just need to make your recursive calls lazy enough to ensure a good stack usage.

© dmw for coder . cl, 2012. | Permalink | No comment | Add to del.icio.us
Post tags:

Attribution-NonCommercial-ShareAlike 3.0 Unported (CC BY-NC-SA 3.0)

Take any natural number n. If n is even, divide it by 2 to get n / 2. If n is odd, multiply it by 3 and add 1 to obtain 3n + 1. Repeat the process (which has been called “Half Or Triple Plus One”, or HOTPO[4]) indefinitely. The conjecture is that no matter what number you start with, you will always eventually reach 1. The property has also been called oneness.

It was proposed as problem as part of the Project Euler and by Eduardo Díaz on his blog, I have implemented my solution in Haskell, because I want to enhance my skills with this language, to reach the most professional coding on it.

My first solution is as follows, is using recursion and if statements. Where if statements should be avoided, also the colmax function can be reduced and eliminated.

module Main (main) where

import System.Environment

collatz :: Int -> [Int] -> [Int]
collatz 1 xs = xs ++ [1]
collatz n xs = if even n
                  then collatz (n `div` 2) $ xs ++ [n]
               else collatz (n * 3 + 1) $ xs ++ [n]

colmax :: [Int] -> Int -> Int -> Int
colmax [] _ m = m
colmax (x:xs) n m = let r = length $ collatz x []
                        in if r > n
                              then colmax xs r x
                           else colmax xs n m

main :: IO ()
main = do [x] <- getArgs
          print $ colmax [1..(read x)] 0 0

My second solution uses the Haskell features to avoid if statements and some reductions to allow more concise code, mainly due to the lazyness of used functions.

module Main (main) where

import System.Environment
import Data.List
import Data.Ord
import Data.Function

collatz :: Int -> [Int] -> [Int]
collatz n xs | n == 1 = xs ++ [1]
             | even n = collatz (n `div` 2) $ xs ++ [n]
             | otherwise = collatz (n * 3 + 1) $ xs ++ [n]

main :: IO ()
main = do [x] <- getArgs
          print $ fst $ maximumBy (comparing length `on` snd)
            $ fmap (\ x -> (x, collatz x []) ) [1..(read x)]

This code looks really well, and seems to be more clear to understand, mainly due to the inline pointfree lambda expression comparing length `on` snd. So, the code is easy to understand and clear enough. Without if statements and using guards rather than if.

© dmw for coder . cl, 2012. | Permalink | One comment | Add to del.icio.us
Post tags:

Attribution-NonCommercial-ShareAlike 3.0 Unported (CC BY-NC-SA 3.0)

Currently most VCSs are made with the intention of concurrent development, with many developers modifying the source tree — including modifications over the same file. With a VCS you can track and expose the modifications over a source tree with a very clear idea of what is happening to the source code, you can see the difference between two commits, where each commit is a modification to the source tree placed on the central repository. Also, most VCSs actually can allow you to create branches, where each branch can be seen as a separate version of the same source code, but with those changes made by an individual developer, and those changes can be merged into the main branch.

Typical VCS

Once all changes are verified and tested, and the software is ready for a base line, the master branch or a separate branch is tagged, to mark a software release. Software releases are made based on how the team manages the source tree and the VCS, probably using well defined milestones and goals for each release, allowing well organized structure of the software. Some VCS are allowing those tags to be exported as packages, for example if you have some repositories on Github, you already know that you can create a tag once you have properly verified your software revision and that will allow that tag to be fully downloaded as package, rather than using git itself to checkout the source tree.

So, using separate files to send changes or even using FTP or similar software to maintain a source tree is not an option, you should start using a VCS as your primary repository tool.

© dmw for coder . cl, 2012. | Permalink | No comment | Add to del.icio.us
Post tags:

Attribution-NonCommercial-ShareAlike 3.0 Unported (CC BY-NC-SA 3.0)