Kor mange linjer kode produserer dei i timen?

[siDDis]

Kor mange linjer kode produserer ein gjennomsnitts utvikler i timen?

Hørte rykter om at det var faktisk *bare* 5 linjer. Stemmer det?

[dayslepr]

55 linjer delt på, hm .. tja.. 3-4 timer nå tror jeg .. rundt 15.74 linjer pr. time da -- men i dag har jeg vært mye mer produktiv enn vanlig da ..

 

 

her er resultatet:

 

swtransaction.lisp:

 

;;;; http://nostdal.org/SWTransaction/;;;;

(defpackage SWTransaction
 (:use :cl)
 (:nicknames :SWT))

(in-package :SWT)


(defvar *revoke-operations* nil)


(defmacro revokable ((&body operations) (&body how-to-revoke))
 "Meant to be used in a `withTransaction'-context.
`how-to-revoke' is the code to revoke or cancel the side-effects of the code in `operations'"
 `(progn
 ;; TODO: Optimize this by merging these functions to a single one in a transaction-context.
    (push (lambda () ,@how-to-revoke) *revoke-operations*)
    ,@operations))
(export 'revokable)

 

 

transaction.lisp:

 

;;;; http://nostdal.org/SWTransaction/;;;;

(in-package :SWT)


(defvar *transaction* nil
 "The current transaction") (export '*transaction*)

(defvar *failed-transactions* nil
 "A list of failed transactions. Most recently failed first.")
(export '*failed-transactions*)


(defmethod revoke ()
 (dolist (revoke-operation *revoke-operations*)
   (funcall revoke-operation)))
(export 'revoke)


(defmacro withTransaction (transaction &body body)
 `(let ((*transaction* ,transaction))
    (restart-case
        (progn
          ,@body)
      (skip-transaction ()
        :report "Skip this transaction."
        (revoke))
      (skip-transaction-but-store-it ()
        :report "Skip this transaction but place it first in the list `*failed-transactions*' for inspection later."
        (unwind-protect
             (push *transaction* *failed-transactions*)
          (revoke))))))
(export 'withTransaction)

 

 

..og en test, for å bekrefte at det fungerer (selv om jeg ikke er 100% sikker ennå):

 

SWT> (progn

      (defparameter a 1234)

      (handler-bind ((t (lambda ©

                          (declare (ignore c))

                          (invoke-restart 'skip-transaction))))

        (withTransaction nil

          (let ((old-a a))

            (revokable

              ((setf a "new"))

              ((setf a old-a)))

            (format t "a is now: ~A~%" a))

          (let ((old-a a))

            (revokable

              ((setf a "even newer"))

              ((setf a old-a)))

            (format t "a is now: ~A~%" a))

          (error "some error")))

      (format t "after condition and failed transaction, the sane state of a is preserved still: ~A~%" a))

a is now: new

a is now: even newer

after condition and failed transaction, the sane state of a is preserved still: 1234

nil

 

edit:

oppdatert kode til denne tingen ligger nå til en hver tid her: http://nostdal.org/~lars/programming/lisp/swtransaction/ ..om noen skulle være interesserte

Endret 24. april 2006 av dayslepr

[___]

Kor mange linjer kode produserer ein gjennomsnitts utvikler i timen?

Hørte rykter om at det var faktisk *bare* 5 linjer. Stemmer det?

5976062[/snapback]

 

 

Jeg mener å ha hørt at det bare var to linjer.

 

En linje kode i dag har vel mye mer "impact" enn den hadde for noen år siden. Før i tiden måtte man jo programmere det meste selv, både forretningslogikk, I/O, GUI, osv osv. I dag er jo det meste pakket inn i systembiblioteker, og det som tok 1000 linjer å skrive den gang tar kanskje bare 10 linjer å skrive i dag.

 

OOP, (Object Oriented Programming) har jo også vært med på å redusere antall kodelinjer.

 

Og mindre skal det bli. Med AOP (Aspect Oriented Programming) trenger man omtrent bare å konsentrere seg om forretningslogikk. Ting som lagring, transaksjoner osv kan så "injectes" inn i objektene. Til gjengjeld blir det endel konfigurering. (I XML-filer osv)

 

Werner