airekans

(define flatten (seq)
  (cond (((null? seq) '())
         ((pair? (car seq)) (append (flatten (car seq))
                                    (flatten (cdr seq))))
         (else (cons (car seq) (flatten (cdr seq)))))))

(define append (l1 l2)
  (if (null? l1)
      l2
      (cons (car l1) (append (cdr l1) l2))))

tmoertel

# Transforming the vanilla recursive fib into the iterative DP version
# through a series of mechanical steps.
#
# For more on converting recursive algorithms into iterative ones, see:
# http://blog.moertel.com/posts/2013-05-11-recursive-to-iterative.html


# original function

def fib(n):

miyukino

;; same as the merge function in MergeSort.scm
(define (insert L M)
	(if (null? L) M
		(if (null? M) L
			(if (< (car L) (car M))
				(cons (car L) (insert (cdr L) M))
				(cons (car M) (insert (cdr M) L))))))

;; another insert function
;; need to modify the first para in insertionsort function to (car L)

avescodes

Check out README.md to get started editing Clojure with Emacs.

RyanKung

;;By Jhen Kung, [email protected]
;;app.rkt

#lang racket(require web-server/servlet
         web-server/servlet-env
         "router.rkt")

(serve/servlet mordor
               #:port 8080
               #:servlet-path "/"

yang-qu

;run in chez scheme 8.4
;http://programmingpraxis.com/2013/01/15/translate-csv-to-html/
;TODO: read csv file
;      parse csv file to a list
(define (string-split sep str)
  (define (f cs xs) (cons (list->string (reverse cs)) xs))
  (let loop ((ss (string->list str)) (cs '()) (xs '()))
    (cond ((null? ss) (reverse (if (null? cs) xs (f cs xs))))
          ((char=? (car ss) sep) (loop (cdr ss) '() (f cs xs)))
          (else (loop (cdr ss) (cons (car ss) cs) xs)))))

tototoshi

-- http://stackoverflow.com/questions/1124603/grouped-limit-in-postgresql-show-the-first-n-rows-for-each-group
-- http://www.postgresql.jp/document/9.2/html/tutorial-window.html

CREATE TABLE empsalary (
  depname varchar(10) not null
  , empno integer not null
  , salary integer not null
);

INSERT INTO empsalary (depname, empno, salary) VALUES ('develop', 11, 5200);

practicingruby

Models, Roles, Decorators, and Interactions

A modest alternative to DCI that might be worth further thought

One of the problems with advancing the discussion on DCI is that we lack a comparable alternative pattern that has the same goals, but favors a low ceremony approach. The closest thing we have to that is Rails concerns, but they are more like distant relatives of the DCI concepts rather than first cousins, and that makes comparisions between the two approaches not especially fruitful.

I am considering the idea of experimenting with my own paradigm that captures the intent and purity of DCI, but with the convenience of concerns. Please note that this is just the starting point of a conversation, it is NOT a promise of comercially available cold fusion or a cure for cancer. It's just a gist with an idea on it I'd like to hear your thoughts on.

What if we had a top-level topology that was split into Models, **Rol

keighl

# Speed things up by not loading Rails env
config.assets.initialize_on_precompile = false

a-chernykh

# 1st way - do it automatically
# AR decides if it's better to use JOIN or separate query
User.includes(:profile)
# -> join or separate query

# 2nd way - always use JOIN
User.eager_load(:profile)
# -> SELECT `users`.`id` AS t0_r0, ..., `profiles`.`user_id` AS t1_r1, ... FROM `users` LEFT OUTER JOIN `profiles` ON `profiles`.`user_id` = `users`.`id`

# 3rd way - always do separate query