Bits of Info

Changing Connection String in Lightswitch

2011-11-04T08:52:00.000-07:00

This has been annoying me on my work with Lightswitch, great tool for building business applications. Finally I found this information on a forum. It didn't get a high score there, but it was spot on.

With you want to change the connection strings in debug/release mode, search for Web.Config in project tree under the ServerGenerated folder. There you will find the connection string that is used by Lightswitch in design time.

You will have to close and reopen the solution so the change takes effect...

Thanks to Nehemiah Willis post at: Original forum post

Company Logo

2011-07-22T13:03:00.000-07:00

I am finally in the process of starting my own business. Today, I received the logo/brand name. Here it is.

I am obviously biased, but I think it looks great.

Quicklisp is great!

2011-02-17T15:16:00.000-08:00

After a long time not doing anything Lisp, I decided to check my installation just to see if my code was still OK. It turns out that something was broken with my libraries and its dependencies.

The everyday in Lisp programming.

This time I decided to go look for something different and decided to give Quicklisp a try.
Just for the record, if you haven't tried it yet. Try it now. It exceeded all my expectations.

I was able to get an old project ready in less than 5min with all the right libraries up and running.

So, thank you Zach Beane, for Quicklisp!

Check it out at: http://www.quicklisp.org/

Lisp style

2010-05-13T06:27:00.000-07:00

Consider the following snippets of code:


(let ((probed-path)
(not-found t))
(dolist (registry-expression asdf:*central-registry*) 
(when not-found 
(setf probed-path (eval registry-expression)))
(when (probe-file (merge-pathnames "asd-library.asd" probed-path)) 
(setf not-found nil)))
probed-path)

(first (remove-if #'null 
(mapcar #'(lambda (x) 
(when (probe-file 
(merge-pathnames "asd-library.asd" (eval x))) 
(eval x))) 
asdf:*central-registry*)))

Both codes perform the same task. The first one is more like a procedural/imperative code in style than the more functional second one.

By the way, they return the path for a registered library. It is not very useful since ADSF provides the same thing easily with a single function call:

(asdf:system-relative-pathname :asd-library "")
But I like to get back to it as a reference of lisp styles.



How to make Postmodern ignore incomplete mapped DAO
2010-04-29T01:59:00.000-07:00
Yesterday I was working with a database using Postmodern (http://marijn.haverbeke.nl/postmodern/) and I ran into an issue trying to adding a column to one of my databases. 

According to its current implementation, postmodern raises an error if the DAO and the table scheme are not matching. In order words, the DAO class must have all fields from the table it maps to. 

In a real world environment, a web application running live for example, it might not be acceptable to bring the application down just because a new column was added to the table it uses. 

Sometimes, depending on the database design, a table can contain information from several DAO's, specially if they have a parent-child object relationship. 

In order to remove this validation from postmodern allowing you to have DAO's mapping to a subset of the fields of a table all it is needed is a little patch on the postmodern table.lisp file on the function as follows:

(defun dao-row-reader (class)
  "Defines a row-reader for objects of a given class."
  (row-reader (query-fields)
    (let ((column-map (append *custom-column-writers* (dao-column-map class))))
      (loop :while (next-row)
            :collect (let ((instance (allocate-instance class)))
                       (loop :for field :across query-fields
                             :for writer := (cdr (assoc (field-name field) column-map :test #'string=))
                             :do (etypecase writer
                                   (null (next-field field))
                                   (symbol (setf (slot-value instance writer) (next-field field)))
                                   (function (funcall writer instance (next-field field)))))
                       (initialize-instance instance)
                       instance)))))

Compare with the current version code where if the field is not found it raises an error:

(defun dao-row-reader (class)
  "Defines a row-reader for objects of a given class."
  (row-reader (query-fields)
    (let ((column-map (append *custom-column-writers* (dao-column-map class))))
      (loop :while (next-row)
            :collect (let ((instance (allocate-instance class)))
                       (loop :for field :across query-fields
                             :for writer := (cdr (assoc (field-name field) column-map :test #'string=))
                             :do (etypecase writer
                                   (null (error "No slot named ~a in class ~a. DAO out of sync with table, or incorrect query used."
                                                (field-name field) (class-name class)))
                                   (symbol (setf (slot-value instance writer) (next-field field)))
                                   (function (funcall writer instance (next-field field)))))
                       (initialize-instance instance)
                       instance)))))




Save Lisp and Die
2010-04-09T12:19:00.000-07:00
If you are running SBCL and are using threads, this is the way I found out that works for me to stop the threads before saving the core.

(dolist (thread (sb-thread:list-all-threads)) 
    (unless (eq thread sb-thread:*current-thread*)
      (sb-thread:terminate-thread thread)))
 
then you can run... 

(sb-ext:save-lisp-and-die "core-file")
 
I am using SBCL 1.0.36 64bit on a Linux Ubuntu 9.10 64bit. 



Installing SBCL + SLIME on Ubuntu 9.10
2010-01-20T14:15:00.000-08:00
Today I tried to upgrade my lisp environment that is using clbuild to keep track of the packages just to be annoyed by its failure. I was just trying to check how hard it would be to do that in my everyday environment. Because of the failure I decided to try other alternatives. This time I tried Lispy which is is defined as (from their website) http://common-lisp.net/project/lispy/:

"Lispy is a library manager for Common Lisp, written in Common Lisp. All of its dependencies except for GPG (with which signed maps and releases are verified) are written in portable Common Lisp. With this approach you should only need a Lisp implementation installed to get started. The Lispy project has two goals:
Implement an easy to use, portable library manager.
Provide a wealth of ready to install libraries."
 Ok. I liked the concept. I followed their guide and was able to have it working on my sbcl 1.0.29 version alrady installed on the machine. I only had one issue because it couldn't find the gpg key. I had to serach for it using a different server:

$ gpg --keyserver subkeys.pgp.net --search-key 0x7CF49723

All was well but I decided to also get the latest from sbcl (1.0.34) and slime as well.

Installing sbcl was very straight forward and I had no issues. Installing slime however was a pain. I got it from the cvs and I set it up just like the getting started page suggested but I could not get to the slime-repl buffer. So after searching the page for known issue I found this:
 
The REPL moved to a contrib. Instead of (slime-setup), place
(slime-setup '(slime-fancy slime-asdf)) into your ~/.emacs.
 
So I ended up with a different .emacs file then before:
 
(add-to-list 'load-path "your-path-to-slime")
(require 'slime)
(add-hook 'lisp-mode-hook (lambda () (slime-mode t)))
(add-hook 'inferior-lisp-mode-hook (lambda () (inferior-slime-mode t)))
(setq inferior-lisp-program "sbcl")
(slime-setup '(slime-fancy slime-asdf))
 
Next post I will tell my journey to get a web site running on the good old hunchentoot. 



Connecting to a database from Lisp
2010-01-06T02:53:00.000-08:00
This is another reminder to myself on how to connect to a database on Lisp using cl-sql through odbcunix.

(use-package :cl-sql)
(connect '("dsn" "user" "password") :database-type :odbc)
(query "select * from table_a")



Ubuntu and FreeTDS
2009-12-11T12:39:00.000-08:00
One of the things I have in mind is to be able to connect to a MS SQL database from Lisp in one of my projects. After spending a couple hours searching for a way to get freeTDS and odbcunix to work together, I found this blog in portuguese with a good step by step process.

I have to point out I didn't have to build freeTDS from the source. I got from the repository. I didn't use the tsql tool. Instead I used the isql one. Other than that everything is according to how I proceeded.

How to setup Freetds using Ubuntu


Installing LISP with CLBuild on Ubuntu
2009-10-30T13:39:00.000-07:00
 
http://club-ubuntu.org/blogs/em/getting-started-with-lisp-in-ubuntu

then with your clbuild already installed:

./clbuild update sbcl
./clbuild compile-implementation sbcl
./clbuild install --main-projects
./clbuild install weblocks
./clbuild install cl-prevalence



clbuild and lispbuilder-sdl - update
2009-10-19T09:58:00.000-07:00
I retested the latest version of lispbuilder-sdl, updating and recompiling from cl-build and I am glad to say it is working fine, as expected, now.

Always good to spread good news, isn't it?


clbuild and lispbuilder-sdl
2009-08-21T14:46:00.000-07:00
On my earlier version of the alarm clock I used the cl-sdl library. I was testing clbuild the other day and I tried to use its version of the sdl: lispbuilder-sdl. Unfortunately on my machine I was getting an error everytime the app was about to close the window due to a call to SDL-glue-SDL-Close-Audio method on the cffi part of the lispbuilder-sdl library:


I suppressed this message by calling a method I knew was working and it worked fine so far.

So if you want to try the same thing, look for the glue.lisp file on the clbuild/source
/lispbuilder-sdl/cffi and change this part to the following code:

#+lispbuilder-sdl-audio
(cffi:defcfun ("SDL_CloseAudio"
               SDL-glue-SDL-Close-Audio) :void)

So instead of calling the original method I am using the SDL_CloseAudio and it is working fine so far.


Little Alarm Clock in LISP
2009-08-18T05:54:00.000-07:00
I wrote this code one of these days because I left the food heating a little too long. I actually burned the pan itself. Anyway it was a little fun project. You give set the time you want it to play a song from your hard drive. Using SDL I was able to play the song and also display a little window to notify about  the alarm. You need cl-sdl and cl-sdl-mixer to play the alarm song. If you use ubuntu just install them from the repository using the synaptic package manager.

Here goes the code:

;; Timer   

;; Function to return the current time hour and minute in a list
(defun get-time()
  (multiple-value-bind (x y z) (get-decoded-time)
    (values (list z y) x)))

;; Function to compare if two times are the same
(defun check-time (time-value)
  (if (equalp time-value (get-time)) t nil))

;; Function to check if time1 is before time2
(defun before-time-p (time1 time2)
    (if (or (< (first time1) (first time2))
        (and (equal (first time1) (first time2))
         (< (second time1) (second time2))))
    nil t))

;; Function to play the alarm song and display the window
(defun play-alarm (song-path)
  (sdl:init (logior sdl:+init-audio+ sdl:+init-video+))
  (sdl:set-video-mode 320 240 16 sdl:+resizable+)
  (sdl:wm-set-caption "Alarm ON!" nil)
  (sdl-mix:open-audio 44100 sdl:+audio-s16lsb+ 2 2048)
  (let ((music (sdl-mix:load-mus song-path)))
    (sdl-mix:play-music music 0)
    (sdl:event-loop
     (:key-down (key)
          (when (= key (char-code #\q))
        (progn
          (sdl-mix:halt-music)
          (sdl-mix:close-audio)
          (sdl:quit)
          (return))))
     (:quit ()
        (progn
          (sdl-mix:halt-music)
          (sdl-mix:close-audio)
          (sdl:quit)
          (return))))))

;; Function to start the alarm
(defun start-alarm (time-value song-path)
  (if (not (before-time-p time-value (get-time)))
      nil
      (progn
    (loop for x from 1
       until (check-time time-value)
       do (progn (print (get-time)) (sleep 10)))
    (format t "~%buzzzzzz... it's ~a:~a~%"
        (first time-value)
        (second time-value))
    (play-alarm song-path))))


; sample usage
;(asdf:oos 'asdf:load-op 'sdl-mix)
;(check-time '(9 38))
;(before-time-p '(12 7) '(12 12))
;(play-alarm "alarm.mp3")
;(start-alarm '(12 15) "alarm.mp3")



Setting up SBCL and Emacs on Ubuntu 9.04
2009-07-21T06:31:00.000-07:00
I am always forgetting how to do this and every now and then I am finding myself installing LISP somewhere so here it goes my how-to so I don't have to google for it anymore... Nothing wrong with googling something though.

1) sudo apt-get install emacs22-gtk sbcl slime

2) add the following lines to .emacs on home folder.

(setq inferior-lisp-program "/usr/bin/sbcl")
(add-to-list 'load-path "/usr/share/common-lisp/source/slime/")
(require 'slime)
(slime-setup)

Done.

To test your installation:

1) Open emacs: (Applications -> Accessories -> Emacs 22 (GTK)
2) Press ALT + X
3) type slime 
SBCL will start you should get a prompt like this:
; SLIME 2010-01-19
CL-USER> 
4) On the prompt type "Hello, World."
You should see this:

; SLIME 2010-01-19
CL-USER> "Hello, World."
"Hello, World."
CL-USER>
5) Congratulations! You have just ran the first obligatory application on any language, but in Lisp!
6) To quit SLIME+LISP: press , then type quit 
7) To quit emacs: CTRL+X CTRL+C




Outside-in
2009-05-19T07:03:00.000-07:00
I am trying to read OnLisp  by Paul Graham again and I really liked the turn your imperative code outside-in in chapter 3.

This is almost a reminder to myself.

Let's say I have an imperative function:
(defun imp-fn (x)
(let ((a 2) result)
(setf result (+ x a))
result)

I have seen a lot of code like that.

Turning it outside-in:
1) It returns result what is result?
we can replace it by the expression: (+ x a)
2) what is a?
we can replace it by its expression: (+ x 2)
3) then the result is:
(defun not-so-imp (x)
(+ x 2))

This is a very simple example but the idea remains the same. The OnLisp book has another example which is better than this one, but this one is good enough to show off the idea.


Books on LISP
2008-05-08T08:09:00.001-07:00
Getting back to the subject of what books should I read if I want to learn LISP. Now I have  a better improved list I feel it will make the transition from anywhere to LISP easier.

In the order I would suggest a friend to start:

1) A funny warm up of how fun it is to LISP. 
http://www.lisperati.com/casting.html
2) The beginning of the beginnings (even if not a programmer):
http://www.cs.cmu.edu/~dst/LispBook/index.htm
3) Still on beginning but a day after:
http://www.psg.com/%7Edlamkins/sl/
4) Getting practical:
http://www.gigamonkeys.com/book/
5) Getting deep:
http://www.paulgraham.com/onlisp.html

Good reading!


Weblocks first impressions
2008-03-25T22:30:00.000-07:00
On a previous post I was commenting on how easy it was to prototype a domain model in lisp. This happens primarily due to its REPL (read-eval-print-loop) way of programming.

A few days ago I started playing with weblocks which is, as it is referred on its website, "A continuations-based common lisp web framework". The shift of paradigm from page-centric development to something different at first sounded just like something interesting to learn about. Because of that, I tried it a couple of months ago, without much success, trying to replace a league management system I built using only hunchentoot by itself.

Today, with a little bit more experience in lisp I could manage to build a simple prototype with some of the entities of a domain model I was working on. The results were really impressive, primarily due to the straight forward approach to get the presentation done.

At first, the whole composite widget centric approach seems overwhelming but at some point it sinks in and we can see how easy it is to "compose" the web user interface for an application using weblocks without having to think about pages and getting data back and forth from the web session.

Despite the fact that it is still a work in progress, I really liked the feeling of working on a web application and not having to deal with html or ajax to get a nice presentation in minutes. (In my case, one hour, because I had no clue how to use it...)

Anyway, personally I really like building software without having to work on the UI manually. Auto-generation based on the model or on view definitions seems to be the more productive approach to deliver enterprise based applications.  I wish one day we could have weblocks and cells-gtk, for example working against the same view abstraction and being able to generate desktop and web user interfaces in a seamless way.


Uninstalling on Windows XP without Add Remove Programs
2008-03-03T10:14:00.000-08:00
I really don't like that Add Remove Programs applet. It is really slow and does not have even an option to remove orphan entries  from the registry. Since I tend to install/uninstall the software I develop a lot, it is a pain to go to that sluggish control panel applet.

Well, it was, now I found two great options:

1) C:\windows\installer right-click header and select Author, Title, Comment, find the uninstaller and execute it.

2) Safarp (blazing fast, don't have to install if you don't want too)

There are plenty other options, I know. Check out the original articles where I got this great information from:

Saravana's blog
Download Squad


Why prototype in LISP
2008-02-29T18:18:00.000-08:00
One of the features I like the most in LISP is to be able to change the code in the middle of the running process and to be able to keep evaluating the functions and variables with the new behavior on the fly. This is an extremely powerful tool when you are trying to figure out the right structure for a given problem. You can play with the different structures and still be able to keep the application running and see how it reacts to the changes you make. It is like running in a self-evaluating forever debug mode. But that is exactly what LISP is, isn't it?

I can say that when I think about prototyping at the model designing level I am more and more choosing to do it in LISP and then, when I feel more confident about the model port it to c# than to start straight in C#. It is simply more productive in my opinion.


Lisp project template with Emacs
2008-02-25T18:04:00.001-08:00
In my first post I was describing the environment I had to use Lisp. After a few issues, usually related to the fact that Eclipse is really a memory hungry application. I moved back to the Emacs + Slime combination. The only difference from what I used to do prior using cusp is that now I work with a "project" file, just the way eclipse + cusp does. I like the idea of working with an asd file to define the files and dependencies in my project and it is very effective to load and compile all lisp files from my project and start being productive right away.

In order to get there I created this symbolic link on my .sbcl/system folder to point to my asd file.

By doing this you are able to load your project using asdf.


DDD - Factories and Repositories
2007-12-27T21:14:00.000-08:00
There is this chapter about factories and repositories. The first to create new entities or aggregates. The second to retrieve/store the entities from/to a database.

There is this mysterious  middle ground where you don't have too many associations. Where you normalize but not too much. You create a complex query engine but impose some restrictions to what should be retrieved. I agree, and have been there before, where too many associations tend to cause a graph loading issue. It may appear as too many resources to load an entity by a filter, or even worse, as a lazy initialization - no session in NHibernate. It is very difficult to achieve this middle ground. There is a compromise involved in richness of the model and speed/memory/session handling.  On the other hand, to avoid the use of the associations is a way to kill the domain model completely. Removing its meaning and making it just a set of disconnected types.

I developed this filter type of criteria that uses allows the client to use the model to retrieve objects using a very declarative syntax. With this approach, by encapsulating the ORM framework and abstracting its complexities, I can say we have 90% or more of all needs satisfied. And it seems like the way to go. But the use of traversal to navigate the domain model, implying in an underlying implicit querying mechanism to retrieve the objects, although powerful, brings us too much complexity in terms of the lazy initialization nightmare. We end up loosing too much time trying to figure out how to fix these infrastructure issues then working on the model. When the issue arises, I have to say.

I have a feeling that most of the problems we end up having could be solved by a more DDD approach in terms of the usage of aggregates to encapsulate a group of dependent related entities and maintain its invariants. That would simplify a lot the way we interact with the objects in all business logic code and at the same time it would help us to build more reliable user interfaces.


Domain-Driven Design - Aggregates
2007-12-13T21:08:00.000-08:00
As I go reading this excellent book, the more and more I have to recognize the greatness of this book in terms of its contents.

This chapter is very clear discussing a very hot topic which is how to encapsulate the invariants of a system.

I never really used this aggregate concept in my projects but the need for the very same solution became very clear in a recent project I am working on. There is always a heated debate in terms of if the invariants should be by entity, enforced on the database or even using the document model which is very close to aggregate as I understand, they might even be synonyms  depending on who is talking about them.

The only point I am waiting for a better answer in the next chapters is related to the access of internal aggregate elements: According to Evans, they should be only accessible through the root aggregate entity, but I know many models where one entity from a clear aggregate points to another one on another aggregate. Lets say, details that have links to each other. I tend to think that those type of models might be wrong, and they probably are, but eventually as in the car parts example, one might want to tun a query to get all the cars where the tires needed to be rotated in order to send letters to the customer as a friendly reminder. I will keep on reading and see, I think.


Domain-Driven Design - Modules
2007-12-12T19:46:00.000-08:00
I tend to agree with Eric Evans when he talks about Modules in his book. As before, reading his examples and considerations looks like someone who had seen most of what I have experienced as a programmer.

The technological layer architecture has been used in many of the projects I worked on and is one I always try to push onto the design of my applications, even recent ones. But after the initial benefit we get from the separation of concerns like database access, presentation, services as stateless classes, we end up with a set of layers that really don't like to be extended. Not that they are closed to extension, but the whole concept of the entity is scattered through at least 3 layers and if we use any work flow framework on top of it, we will end up having 5 layers to deal with.

I am eager to finish up this book and start trying out some of the concepts in small scoped projects just to see where it will lead the code in the end.

Anyway, modules should be used as a way to simplify the understand of any big domain-model by restricting a set of concepts based on a commonality between them. By using modules effectively we create this subset of functionality that should be easier to grasp than the whole myriad of disconnected information that is usually mangled together in a uncoordinated way in most of the projects I worked in the past.


Studying Domain-Driven Design
2007-12-11T21:00:00.000-08:00
I started reading the Domain-Driven Design book, by Eric Evans some weeks ago and today I restarted reading the chapter on Entities, Value Objects and Services.

From the first chapter of the book I had the feeling the author really knows what he is talking about. I always had the feeling that Object Oriented design was a problem when applied to a real world application, especially when we ended up having to decide for more then 30 minutes where a method should be implemented from the actual domain model entities. The service concept is perfect to solve this type of problem nicely by the use of those stateless process coordinators. They have the sole purpose of coordinating the execution of an activity that deals with a group of entities.

I used to simplify my projects by avoiding the implementation of almost any behavior on an entity, but I am reconsidering my position after reading this excellent book. I didn't finish yet.

I hope it will give me some light onto this holy grail of software engineering which is to build great software.

By the way, great software for me is a software that does what it is supposed to do, that is easy to maintain and easy to extend.


What tools I use to LISP
2007-11-03T03:23:00.000-07:00
I started to study LISP a while ago and after all this months I am no more than a real beginner, however every time I use LISP I enjoy every piece of code written.

If you want to be easily up and running using LISP and are used to an IDE like I was. I recommend using CUSP with Eclipse. It is very good in terms of productivity and easy to install. Check out this link that teaches step by step how to install it on your system.

How to Install and use CUSP on Eclipse

By the way I use Ubuntu Linux 7.04 hopefully upgrading by the end of the month to the new 7.10.

The LISP implementation I use is SBCL. Make sure you have a link to its manual

I started studying the book Practical Lisp, but couldn't finish the book. The examples at the end weren't appealing to me so I switched to On Lisp which is too deep to me as a beginner and finally to Successful Lisp. In my opinion they are all good books, Successful Lisp and Practical Lisp being the best beginner's books. I hope I will be able to get back to On Lisp when I get more experienced.