id
int64 0
45.1k
| file_name
stringlengths 4
68
| file_path
stringlengths 14
193
| content
stringlengths 32
9.62M
| size
int64 32
9.62M
| language
stringclasses 1
value | extension
stringclasses 6
values | total_lines
int64 1
136k
| avg_line_length
float64 3
903k
| max_line_length
int64 3
4.51M
| alphanum_fraction
float64 0
1
| repo_name
stringclasses 779
values | repo_stars
int64 0
882
| repo_forks
int64 0
108
| repo_open_issues
int64 0
90
| repo_license
stringclasses 8
values | repo_extraction_date
stringclasses 146
values | sha
stringlengths 64
64
| __index_level_0__
int64 0
45.1k
| exdup_ids_cmlisp_stkv2
sequencelengths 1
47
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
38,393 | points.lisp | fvnu_lsisp/points.lisp | ;; Defines a point of single-floats, with elements given as a list ELEMENTS
(defun make-point (&rest elements) (map 'list #'(lambda (x) (float x 1.0s0)) elements))
(defun point-line-distance (p a b c)
(/ (abs (+ (* a (nth 0 p)) (* b (nth 1 p)) c)) (sqrt (+ (expt a 2) (expt b 2)))))
(defun point-line-closest (p a b c)
(let ((x (nth 0 p))
(y (nth 1 p))
(d (+ (expt a 2) (expt b 2))))
(make-point (/ (- (* b (- (* b x) (* a y))) (* a c)) d)
(/ (- (* a (- (* a y) (* b x))) (* b c)) d))))
;; Defines a point sum operation
(defun point+ (p1 p2) (map 'list #'(lambda (e1 e2) (+ e1 e2)) p1 p2))
;; Defines a point scaling operation
(defun point-scale (p scale) (map 'list #'(lambda (e) (* scale e)) p))
;; Defines a point rotation operation, clockwise, in two dimensions
(defun point-rotate2 (p angle)
(let ((x (nth 0 p)) (y (nth 1 p)))
(make-point (+ (* x (cos angle)) (* y (sin angle))) (- (* y (cos angle)) (* x (sin angle))))))
;; Defines a shear operation relative to some line,
;; A x + B y + c = 0
;; which defaults to y=0, i.e., a shear relative to the x-axis.
;; The magnitude of the shear is SHEAR*(distance from the line)
;; The direction of the shear is that of the unit vector (B -A).
(defun point-shear (p shear &optional (a 0) (b 1) (c 0))
(point+ p (point-scale (make-point b (- a))
(* (point-line-distance p a b c)
shear
(/ (sqrt (+ (expt a 2) (expt b 2))))))))
;; Defines a stretching operating relative to some line,
;; A x + B y + c = 0
;; which defaults to x=0, i.e., a stretching relative to the y-axis.
;; The magnitude of the stretch is STRETCH*(distance from the line)
(defun point-stretch (p stretch &optional (a 1) (b 0) (c 0))
(point+ (point-scale p stretch)
(point-scale (point-line-closest p a b c) (- 1 stretch))))
;; Defines a reflection operation relative to some line,
;; A x + B y + c = 0
;; which defaults to x=0, i.e., a reflection across the y-axis
(defun point-reflect (p &optional (a 1) (b 0) (c 0))
(point+ (point-scale (point-line-closest p a b c) 2) (point-scale p -1)))
;; Applies a function FUNCTION, with arguments FUNCTION-ARGUMENTS, to POINTS, where each element
;; of POINTS is a point as defined by MAKE-POINT
(defun transform-points (points function &rest function-arguments)
(map 'list #'(lambda (x) (apply function x function-arguments)) points))
| 2,352 | Common Lisp | .lisp | 44 | 51.159091 | 98 | 0.63403 | fvnu/lsisp | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:44:42 AM (Europe/Amsterdam) | 20364ba1116bc1f6d9fb698daac3964102b785a1c1a83978f5b40a29dcc8ffb2 | 38,393 | [
-1
] |
38,410 | csv.lisp | equwal_CSV/csv.lisp | (in-package :csv)
(defun make-escapep (prev curr)
(char= #\" prev curr))
(defun end-tokenp (prev curr)
(declare (ignore curr))
(char= #\" prev))
(defun openp (prev curr)
(declare (ignore curr))
(char= #\" prev))
(defun str->list (str)
(labels ((inner (str acc len)
(if (= 0 len)
(nreverse acc)
(inner (subseq str 1) (cons (elt str 0) acc) (1- len)))))
(inner str nil (length str))))
(let ((in nil)
(escape nil))
(setf (fdefinition 'switches)
(lambda (prev curr str)
(let ((str (if (array-has-fill-pointer-p str)
str
(make-array (length str)
:fill-pointer 0
:adjustable t
:element-type 'character
:initial-contents (str->list str)))))
(if (null curr)
(progn (setf in nil escape nil) str)
(if in
(if escape
(progn (toggle escape) (push-on prev str))
(if (make-escapep prev curr)
(progn (toggle escape) str)
(if (end-tokenp prev curr)
(progn (toggle in) (push-on #\Nul str))
(push-on prev str))))
(if (openp prev curr)
(progn (toggle in) str)
str)))))))
(defun splice (str)
(labels ((inner (str acc!)
(if (string= "" str)
(nreverse acc!)
(let ((res (search (string #\Nul) str)))
(inner (subseq str (1+ res)) (push (subseq str 0 res) acc!))))))
(inner str nil)))
(make-reader my-csv (stream #\# #\!)
(macrolet ((once (&body body) ``',,@body))
(do ((prev #1= (read-char stream nil nil) curr)
(curr #1# #1#)
(str (make-array 0 :adjustable t :element-type 'character)
(switches prev curr str)))
((and (char= curr #\#)
(char= prev #\!)) (once (splice (switches nil nil str)))))))
(defun read-to-string (stream)
(with-output-to-string (s)
(dolines (line stream)
(princ line s)
(format s "~%"))))
(defun slurp-csv (path)
"Read in a CSV file to string. Resource intensive."
(with-open-file (s path)
(concatenate 'string "#!" (read-to-string s) "!#")))
(defun dequote (list)
(if (eql 'quote (car list))
(cadr list)
list))
(defun slurp (path)
"Read in a CSV file to list. Resource intensive."
(dequote (read-from-string (slurp-csv path))))
| 2,466 | Common Lisp | .lisp | 70 | 26.528571 | 83 | 0.52379 | equwal/CSV | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:44:42 AM (Europe/Amsterdam) | ed5d35b4b9019e4364433c52386172e5f0470b05cf1cd5c641c114f4ee5efdc3 | 38,410 | [
-1
] |
38,411 | utils.lisp | equwal_CSV/utils.lisp | (in-package :csv)
(defmacro dolines ((var stream) &body body)
`(do ((,var #1=(read-line ,stream nil nil) #1#))
((null ,var))
,@body))
(defmacro with-gensyms (symbols &body body)
"Create gensyms for those symbols."
`(let (,@(mapcar #'(lambda (sym)
`(,sym ',(gensym))) symbols))
,@body))
(defmacro make-reader (name (stream-var dispatch-1 dispatch-2) &body body)
"Simplify the reader macro creation process in most cases."
(with-gensyms (sub-char numarg)
`(progn (defun ,name (,stream-var ,sub-char ,numarg)
(declare (ignore ,sub-char ,numarg))
,@body)
(set-dispatch-macro-character ,dispatch-1 ,dispatch-2 #',name))))
(defun push-on (elt stack)
(vector-push-extend elt stack) stack)
(define-modify-macro toggle () not "Flipping vars.")
| 796 | Common Lisp | .lisp | 20 | 35.75 | 74 | 0.657216 | equwal/CSV | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:44:42 AM (Europe/Amsterdam) | 91dda91efd033d0c7bd49cddfc6beec75693d7cdd1a640075286b3c964204149 | 38,411 | [
-1
] |
38,412 | csv.asd | equwal_CSV/csv.asd | (asdf:defsystem :csv
:version "0.1.0"
:description "Read CSV into lists natively. Convert CSV into lists dangerously."
:author "Spenser Truex spensertruex.com"
:serial t
:license "GNU GPL, version 3"
:components ((:file "package")
(:file "utils")
(:file "csv")))
| 329 | Common Lisp | .asd | 9 | 30.444444 | 83 | 0.590625 | equwal/CSV | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:44:42 AM (Europe/Amsterdam) | 143421c04b6d3423be147392cdd638e208ea3f779ec79eea2e2e956b84cb8ed8 | 38,412 | [
-1
] |
38,430 | simplet-test.lisp | noloop_simplet/test/simplet-test.lisp | (in-package #:cl-user)
(defpackage #:noloop.simplet-test
(:use #:common-lisp)
(:nicknames #:simplet-test)
(:import-from #:simplet
#:create-test
#:create-suite
#:run-suites
#:reporter
#:test
#:test-only
#:test-skip
#:suite
#:suite-only
#:suite-skip
#:run))
(in-package #:noloop.simplet-test)
(defun test-run ()
(test-suite
(test-case "Test create-test" #'test-create-test)
(test-case "Test suite-test" #'test-create-suite)
(test-case "Test run-suites" #'test-run-suites)
(test-case "Test reporter" #'test-reporter)
(test-case "Test interface" #'test-interface)
(test-case "Test interface-suite-pending" #'test-interface-suite-pending)
(test-case "Test interface-test-pending" #'test-interface-test-pending)
(test-case "Test interface-suite-only" #'test-interface-suite-only)
(test-case "Test interface-test-only" #'test-interface-test-only)
(test-case "Test interface-suite-skip" #'test-interface-suite-skip)
(test-case "Test interface-test-skip" #'test-interface-test-skip)
(test-case "Test interface-suite-only-and-skip" #'test-interface-suite-only-and-skip)
(test-case "Test interface-test-only-and-skip" #'test-interface-test-only-and-skip)))
(defun test-case (stg test-fn)
(let ((result (funcall test-fn)))
(format t "~a: ~a~%" stg result)
result))
(defun test-suite (&rest results)
(format t "~%Tests result: ~a~%~%"
(every #'(lambda (el) (equal t el)) results)))
(defun fix-passing-test (num)
(create-test
(concatenate 'string "Test-" (string num))
#'(lambda () (= 1 1))))
(defun test-create-test ()
(let* ((test-1 (fix-passing-test "1"))
(list-test-1 (funcall test-1)))
(and (string= "Test-1" (car list-test-1))
(cadr list-test-1))))
(defun test-create-suite ()
(let* ((suite-1 (create-suite "Suite-1"
(list (fix-passing-test "1")
(fix-passing-test "2"))))
(list-suite-1 (funcall suite-1))
(suite-description (car list-suite-1))
(suite-tests (cadr list-suite-1))
(suite-result (caddr list-suite-1)))
(and (string= "Suite-1" suite-description)
(= 2 (length suite-tests))
suite-result)))
(defun test-run-suites ()
(let* ((suite-1 (create-suite "Suite-1"
(list (fix-passing-test "1")
(fix-passing-test "2"))))
(suite-2 (create-suite "Suite-2"
(list (fix-passing-test "1")
(fix-passing-test "2"))))
(suites (list suite-1 suite-2))
(runner-result (run-suites suites)))
(and (cadr runner-result))))
(defun test-reporter ()
(let* ((suite-1 (create-suite "Suite-1"
(list (fix-passing-test "1")
(fix-passing-test "2"))))
(suite-2 (create-suite "Suite-2"
(list (fix-passing-test "1")
(fix-passing-test "2"))))
(suites (list suite-1 suite-2))
(runner-result (run-suites suites))
(expected-stg (format nil "~a~%~a~%~a~%~a~%~a~%~a~%~a~%~a~%~a~%~a~%~a~%~a~%~a~%~a~%"
"#...Simplet...#"
""
"Test-1: T"
"Test-2: T"
"-----------------------------------"
"Suite-1: T"
""
"Test-1: T"
"Test-2: T"
"-----------------------------------"
"Suite-2: T"
""
"Runner result: T"
""))
(actual-stg ""))
(setf actual-stg (reporter runner-result :return-string-p t))
(string= expected-stg actual-stg)))
(defun test-interface ()
(let* ((actual-stg "")
(expected-stg (format nil "~a~%~a~%~a~%~a~%~a~%~a~%~a~%~a~%~a~%~a~%~a~%~a~%~a~%"
"#...Simplet...#"
""
"Test-1: T"
"Test-2: T"
"-----------------------------------"
"Suite-1: T"
""
"Test-1: T"
"-----------------------------------"
"Suite-2: T"
""
"Runner result: T"
"")))
(suite "Suite-1"
(test "Test-1" #'(lambda () (= 1 1)))
(test "Test-2" #'(lambda () (= 1 1))))
(suite "Suite-2"
(test "Test-1" #'(lambda () (= 1 1))))
(setf actual-stg (run :return-string-p t))
(simplet::clear-suites)
(string= actual-stg expected-stg)))
(defun test-interface-suite-pending ()
(let* ((actual-stg "")
(expected-stg (format nil "~a~%~a~%~a~%~a~%~a~%~a~%~a~%"
"#...Simplet...#"
""
"-----------------------------------"
"Suite-1: PENDING"
""
"Runner result: T"
"")))
(suite "Suite-1")
(setf actual-stg (run :return-string-p t))
(simplet::clear-suites)
(string= actual-stg expected-stg)))
(defun test-interface-test-pending ()
(let ((actual-stg "")
(expected-stg (format nil "~a~%~a~%~a~%~a~%~a~%~a~%~a~%~a~%~a~%"
"#...Simplet...#"
""
"Test-1: T"
"Test-2: PENDING"
"-----------------------------------"
"Suite-1: T"
""
"Runner result: T"
"")))
(suite "Suite-1"
(test "Test-1" #'(lambda () (= 1 1)))
(test "Test-2"))
(setf actual-stg (run :return-string-p t))
(simplet::clear-suites)
(string= actual-stg expected-stg)))
(defun test-interface-suite-only ()
(let ((actual-stg "")
(expected-stg (format nil "~a~%~a~%~a~%~a~%~a~%~a~%~a~%~a~%~a~%"
"#...Simplet...#"
""
"Test-1: T"
"Test-2: PENDING"
"-----------------------------------"
"Suite-1: T"
""
"Runner result: T"
"")))
(suite-only "Suite-1"
(test "Test-1" #'(lambda () (= 1 1)))
(test "Test-2"))
(suite "Suite-2"
(test "Test-1" #'(lambda () (= 1 1)))
(test "Test-2" #'(lambda () (= 1 1))))
(setf actual-stg (run :return-string-p t))
(simplet::clear-suites)
(string= actual-stg expected-stg)))
(defun test-interface-test-only ()
(let ((actual-stg "")
(expected-stg (format nil "~a~%~a~%~a~%~a~%~a~%~a~%~a~%~a~%~a~%~a~%~a~%~a~%"
"#...Simplet...#"
""
"Test-3: T"
"-----------------------------------"
"Suite-1: T"
""
"Test-1: T"
"-----------------------------------"
"Suite-2: T"
""
"Runner result: T"
"")))
(suite-only "Suite-1"
(test "Test-1" #'(lambda () (= 1 1)))
(test "Test-2")
(test-only "Test-3" #'(lambda () (= 1 1))))
(suite "Suite-2"
(test-only "Test-1" #'(lambda () (= 1 1)))
(test "Test-2" #'(lambda () (= 1 1))))
(setf actual-stg (run :return-string-p t))
(simplet::clear-suites)
(string= actual-stg expected-stg)))
(defun test-interface-suite-skip ()
(let ((actual-stg "")
(expected-stg (format nil "~a~%~a~%~a~%~a~%~a~%~a~%~a~%~a~%~a~%"
"#...Simplet...#"
""
"Test-1: T"
"Test-2: T"
"-----------------------------------"
"Suite-2: T"
""
"Runner result: T"
"")))
(suite-skip "Suite-1"
(test "Test-1" #'(lambda () (= 1 1)))
(test "Test-2"))
(suite "Suite-2"
(test "Test-1" #'(lambda () (= 1 1)))
(test "Test-2" #'(lambda () (= 1 1))))
(setf actual-stg (run :return-string-p t))
(simplet::clear-suites)
(string= actual-stg expected-stg)))
(defun test-interface-test-skip ()
(let ((actual-stg "")
(expected-stg (format nil "~a~%~a~%~a~%~a~%~a~%~a~%~a~%~a~%"
"#...Simplet...#"
""
"Test-2: T"
"-----------------------------------"
"Suite-2: T"
""
"Runner result: T"
"")))
(suite-skip "Suite-1"
(test "Test-1" #'(lambda () (= 1 1)))
(test "Test-2")
(test-skip "Test-3" #'(lambda () (= 1 1))))
(suite "Suite-2"
(test-skip "Test-1" #'(lambda () (= 1 1)))
(test "Test-2" #'(lambda () (= 1 1))))
(setf actual-stg (run :return-string-p t))
(simplet::clear-suites)
(string= actual-stg expected-stg)))
(defun test-interface-suite-only-and-skip ()
(let ((actual-stg "")
(expected-stg (format nil "~a~%~a~%~a~%~a~%~a~%~a~%~a~%~a~%~a~%"
"#...Simplet...#"
""
"Test-1: T"
"Test-2: T"
"-----------------------------------"
"Suite-2: T"
""
"Runner result: T"
"")))
(suite-skip "Suite-1"
(test "Test-1" #'(lambda () (= 1 1)))
(test "Test-2"))
(suite-only "Suite-2"
(test "Test-1" #'(lambda () (= 1 1)))
(test "Test-2" #'(lambda () (= 1 1))))
(setf actual-stg (run :return-string-p t))
(simplet::clear-suites)
(string= actual-stg expected-stg)))
(defun test-interface-test-only-and-skip ()
(let ((actual-stg "")
(expected-stg (format nil "~a~%~a~%~a~%~a~%~a~%~a~%~a~%~a~%~a~%"
"#...Simplet...#"
""
"Test-1: T"
"Test-2: PENDING"
"-----------------------------------"
"Suite-1: T"
""
"Runner result: T"
"")))
(suite-only "Suite-1"
(test "Test-1" #'(lambda () (= 1 1)))
(test "Test-2")
(test-skip "Test-3" #'(lambda () (= 1 1))))
(suite "Suite-2"
(test-skip "Test-1" #'(lambda () (= 1 1)))
(test "Test-2" #'(lambda () (= 1 1))))
(setf actual-stg (run :return-string-p t))
(simplet::clear-suites)
(string= actual-stg expected-stg)))
| 12,151 | Common Lisp | .lisp | 283 | 26.130742 | 93 | 0.366045 | noloop/simplet | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:44:50 AM (Europe/Amsterdam) | 28456ca5b383e6f70224d8fdc0159186aed6c7745de68826b8dd7cc37df350ad | 38,430 | [
-1
] |
38,431 | package.lisp | noloop_simplet/src/package.lisp | (defpackage #:noloop.simplet
(:use #:common-lisp)
(:nicknames #:simplet)
(:import-from #:simplet-asdf
#:test-file)
(:export #:test
#:test-only
#:test-skip
#:suite
#:suite-only
#:suite-skip
#:run))
| 280 | Common Lisp | .lisp | 12 | 15.416667 | 30 | 0.496269 | noloop/simplet | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:44:50 AM (Europe/Amsterdam) | cf660d32d027b0355528dfed8469eb89f4694f7e0bc59bd9f8bde6eaae24358a | 38,431 | [
-1
] |
38,432 | simplet.lisp | noloop_simplet/src/simplet.lisp | (in-package #:noloop.simplet)
;; TEST
(defun create-test (description fn &key only skip)
(lambda ()
(list description
(if (null fn)
"PENDING"
(funcall fn))
only skip)))
;; SUITE
(defun create-suite (description tests &key only skip)
(lambda ()
(if (null (car tests))
(list description '() "PENDING")
(create-list-suite-result description tests only skip))))
(defun create-list-suite-result (description tests only skip)
(let* ((test-results (mapcar #'(lambda (i) (funcall i)) tests))
(suite-result (every
#'(lambda (i) (or (equal t (cadr i))
(equalp "PENDING" (cadr i))))
test-results))
(tests-only (collect-tests-only test-results)))
(if tests-only
(progn (setf test-results tests-only)
(setf only t)))
(setf test-results (remove-if #'cadddr test-results))
(list description test-results suite-result only skip)))
;; RUNNER
(defun run-suites (suites)
(let* ((suite-results
(mapcar #'(lambda (i) (funcall i)) suites))
(suites-only (collect-suites-only suite-results)))
(if suites-only
(setf suite-results suites-only))
(setf suite-results (remove-if #'(lambda (i)
(if (cadr (cdddr i))
i))
suite-results))
(list suite-results
(every #'(lambda (i) (or (equal t (caddr i))
(equalp "PENDING" (caddr i))))
suite-results))))
(defun collect-suites-only (suites)
(remove nil (mapcar #'(lambda (i) (if (cadddr i) i))
suites)))
(defun collect-tests-only (tests)
(remove nil (mapcar #'(lambda (i) (if (caddr i) i))
tests)))
;; REPORTER
(defun reporter (runner-result &key return-string-p)
(let ((suite-results (car runner-result))
(end-result (cadr runner-result))
(epilogue ""))
(dolist (suite suite-results)
(dolist (test (cadr suite))
(setf epilogue
(concatenate 'string
epilogue
(format nil "~a: ~a~%" (car test) (cadr test)))))
(setf epilogue
(concatenate 'string
epilogue
(format nil "-----------------------------------~%" )
(format nil "~a: ~a~%~%" (car suite) (caddr suite)))))
(setf epilogue
(concatenate 'string
epilogue
(format nil "Runner result: ~a~%~%" end-result)))
(if return-string-p
(format nil "#...Simplet...#~%~%~a" epilogue)
(format t "#...Simplet...#~%~%~a" epilogue))))
;; INTERFACE
(let ((suites '()))
(defun get-suites ()
suites)
(defun clear-suites ()
(setf suites '()))
(defun test (description &optional (fn nil))
(create-test description fn))
(defun test-only (description &optional (fn nil))
(create-test description fn :only t))
(defun test-skip (description &optional (fn nil))
(create-test description fn :skip t))
(defun suite (description &rest tests)
(push (create-suite description tests) suites))
(defun suite-only (description &rest tests)
(push (create-suite description tests :only t) suites))
(defun suite-skip (description &rest tests)
(push (create-suite description tests :skip t) suites))
(defun run (&key return-string-p)
(let ((runner-result (run-suites (nreverse suites))))
(clear-suites)
(handler-case
(if return-string-p
(reporter runner-result :return-string-p t)
(reporter runner-result))
(error (c)
(clear-suites)
(error c))))))
| 3,895 | Common Lisp | .lisp | 99 | 29.040404 | 79 | 0.54266 | noloop/simplet | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:44:50 AM (Europe/Amsterdam) | 27ca8e0de8fc0780f6446a5bde14fbe35cee5c09518e71a65dab39f11fd8557d | 38,432 | [
-1
] |
38,433 | asdf.lisp | noloop_simplet/src/asdf.lisp | (in-package #:cl-user)
(defpackage #:simplet-asdf
(:nicknames #:simplet-asdf)
(:use #:common-lisp
#:asdf)
(:export #:test-file))
(in-package #:simplet-asdf)
(defclass test-file (cl-source-file) ())
(defmethod operation-done-p ((op load-op) (c test-file)) nil)
(defmethod operation-done-p ((op compile-op) (c test-file)) t)
(import 'test-file :asdf)
| 365 | Common Lisp | .lisp | 11 | 30.727273 | 62 | 0.681818 | noloop/simplet | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:44:50 AM (Europe/Amsterdam) | 79130fe5da1990d6843b7987c9e46743b3181aa6d34022c785140e272e1f7920 | 38,433 | [
-1
] |
38,434 | simplet.asd | noloop_simplet/simplet.asd | ;;;; -*- Mode: Lisp; Syntax: ANSI-Common-Lisp; Base: 10 -*-
(defsystem :simplet
:author "noloop <[email protected]>"
:maintainer "noloop <[email protected]>"
:license "GPLv3"
:version "1.2.0"
:homepage "https://github.com/noloop/simplet"
:bug-tracker "https://github.com/noloop/simplet/issues"
:source-control (:git "[email protected]:noloop/simplet.git")
:description "Simple test runner in Common Lisp."
:components ((:module "src"
:components
((:file "asdf")
(:file "package" :depends-on ("asdf"))
(:file "simplet" :depends-on ("package")))))
:long-description
#.(uiop:read-file-string
(uiop:subpathname *load-pathname* "README.md"))
:in-order-to ((test-op (test-op "simplet/test"))))
(defsystem :simplet/test
:author "noloop <[email protected]>"
:maintainer "noloop <[email protected]>"
:license "GPLv3"
:description "simplet Test."
:depends-on (:simplet)
:components ((:module "test"
:components
((:file "simplet-test"))))
:perform (test-op (op system) (funcall (read-from-string "simplet-test::test-run"))))
| 1,145 | Common Lisp | .asd | 29 | 33.586207 | 87 | 0.63139 | noloop/simplet | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:44:50 AM (Europe/Amsterdam) | 875ff03e4ef38451b188b2ce4f2f3285bc553b00b128a92e109dfc7fe0070194 | 38,434 | [
-1
] |
38,455 | conf-test.lisp | noloop_conf/test/conf-test.lisp | (in-package #:cl-user)
(defpackage #:noloop.conf-test
(:use #:common-lisp)
(:nicknames #:conf-test)
(:import-from #:conf
#:init-conf
#:set-conf-directory
#:get-conf-directory
#:set-conf-file
#:get-conf-file
#:get-conf-full-path
#:replace-conf
#:get-conf-hash))
(in-package #:noloop.conf-test)
;; Simple Test Runner
(defun run ()
(let ((results '()))
(conf::save-file "/tmp/conf-test.conf" "(:field-1 \"value1\"
:field-2 \"value2\")")
(format t "Test set-conf-directory and get-conf-directory: ~a~%"
(push (test-set-conf-directory) results))
(format t "Test set-conf-file and get-conf-file: ~a~%"
(push (test-set-conf-file) results))
(format t "Test get-conf-full-path: ~a~%"
(push (test-get-conf-full-path) results))
(format t "Test get-conf-hash: ~a~%"
(push (test-get-conf-hash) results))
(format t "~%Test save-conf-file: ~a~%"
(push (test-save-conf-file) results))
(delete-file "/tmp/conf-test.conf")
(format t "Test result: ~a" (every #'(lambda (el) (equal t el)) results))))
(defun test-set-conf-directory ()
(let ((conf (init-conf "~/.conf/" "some.conf")))
(set-conf-directory conf "/tmp/")
(and (cl-fad:pathname-equal "/tmp/" (get-conf-directory conf)))))
(defun test-set-conf-file ()
(let ((conf (init-conf "~/.conf/" "some.conf")))
(set-conf-file conf "conf-test.conf")
(and (cl-fad:pathname-equal "conf-test.conf" (get-conf-file conf)))))
(defun test-get-conf-full-path ()
(let ((conf (init-conf "~/.conf/" "some.conf")))
(set-conf-directory conf "/tmp/")
(set-conf-file conf "conf-test.conf")
(and (cl-fad:pathname-equal "/tmp/conf-test.conf" (get-conf-full-path conf)))))
(defun test-get-conf-hash ()
(let ((conf (init-conf "~/.conf/" "some.conf"))
(expected-hash (make-hash-table)))
(set-conf-directory conf "/tmp/")
(set-conf-file conf "conf-test.conf")
(setf (gethash :field-1 expected-hash) "value1"
(gethash :field-2 expected-hash) "value2")
(and (equalp expected-hash (get-conf-hash conf)))))
;;; I do not know how to test the "replace-conf" function
;;; because it requires user interaction when using "read-line",
;;; so I will simply test the built-in functions that make it up.
(defun test-save-conf-file ()
(let ((conf (init-conf "~/.conf/" "some.conf"))
(expected-hash (make-hash-table)))
(set-conf-directory conf "/tmp/")
(set-conf-file conf "conf-test.conf")
(setf (gethash :field-1 expected-hash) "value1"
(gethash :field-2 expected-hash) "value2")
(conf::save-conf-file conf expected-hash)
(and (equalp expected-hash (get-conf-hash conf)))))
| 2,819 | Common Lisp | .lisp | 64 | 37.609375 | 83 | 0.609534 | noloop/conf | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:44:50 AM (Europe/Amsterdam) | ef7b2b2da055ba4000190061ddf4d87923be36f9765050576a26435fb6c64310 | 38,455 | [
-1
] |
38,456 | package.lisp | noloop_conf/src/package.lisp | (defpackage #:noloop.conf
(:use #:common-lisp)
(:nicknames #:conf)
(:import-from #:cl-fad
#:merge-pathnames-as-file)
(:export #:init-conf
#:set-conf-directory
#:get-conf-directory
#:set-conf-file
#:get-conf-file
#:get-conf-full-path
#:replace-conf
#:get-conf-hash))
| 367 | Common Lisp | .lisp | 13 | 19.461538 | 42 | 0.525424 | noloop/conf | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:44:50 AM (Europe/Amsterdam) | e0b83249f25ec96a401222ce70523ab875806180f151cac7e7cd9686a25be706 | 38,456 | [
-1
] |
38,457 | conf.lisp | noloop_conf/src/conf.lisp | (in-package #:noloop.conf)
#|
Configuration file example(my-file.conf):
(:author "Unknown"
:maintainer ":AUTHOR"
:license "UNLICENSED"
:version "0.0.0"
:git-service "github")
|#
(defun init-conf (directory file-name)
(reverse (pairlis (list :conf-file-directory :conf-file-name)
(list directory file-name))))
(defun set-conf-directory (conf new-directory)
(setf (cdr (assoc :conf-file-directory conf)) new-directory))
(defun get-conf-directory (conf)
(cdr (assoc :conf-file-directory conf)))
(defun set-conf-file (conf new-file-name)
(setf (cdr (assoc :conf-file-name conf)) new-file-name))
(defun get-conf-file (conf)
(cdr (assoc :conf-file-name conf)))
(defun get-conf-hash (conf)
(load-conf-file-for-hash-table conf))
(defun replace-conf (conf)
(let ((new-conf (load-conf-file-for-hash-table conf)))
(replace-conf-fields new-conf)
(save-conf-file conf new-conf)))
(defun load-conf-file-for-hash-table (conf)
(list-for-hash-table
(load-file (get-conf-full-path conf))))
(defun get-conf-full-path (conf)
(merge-pathnames-as-file
(get-conf-directory conf)
(get-conf-file conf)))
(defun replace-conf-fields (your-hash)
(maphash #'(lambda (key value)
(let ((input (read-field (string key) value)))
(cond ((string-not-equal "" input)
(setf (gethash key your-hash) input)))))
your-hash))
(defun save-conf-file (conf conf-hash)
(save-file (get-conf-full-path conf)
(hash-table-for-string conf-hash)))
(defun read-field (field-name actual-value)
(format t "~a?(actual ~a) " field-name actual-value)
(read-line))
(defun list-for-hash-table (your-list)
(do ((i 0 (+ 2 i))
(new-list your-list (cddr new-list))
(new-hash (make-hash-table)))
((<= (length your-list) i) new-hash)
(let ((key (first new-list)) (value (second new-list)))
(setf (gethash key new-hash) value))))
(defun hash-table-for-string (your-hash)
(let ((stg "") (i 0))
(maphash #'(lambda (key value)
(setf stg (concatenate 'string stg
":" (string key) " "
"\"" (string value) "\" "
(if (< i (- (hash-table-count your-hash) 1))
'(#\newline))))
(incf i))
your-hash)
(concatenate 'string "(" (string-trim '(#\space) stg) ")")))
(defun save-file (file-name stg)
(with-open-file (out file-name
:direction :output
:if-exists :supersede)
(with-standard-io-syntax
(format out "~a" stg)))
(format t "~%File saved successfully.~%"))
(defun load-file (file-name)
(with-open-file (in file-name)
(with-standard-io-syntax
(read in))))
| 2,865 | Common Lisp | .lisp | 74 | 31.135135 | 84 | 0.592352 | noloop/conf | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:44:50 AM (Europe/Amsterdam) | 19a49fb370ad0a063cd7ddb3f233d6c8f52d92c5be267b78ea61ca0dcb8e040a | 38,457 | [
-1
] |
38,458 | conf.asd | noloop_conf/conf.asd | ;;;; -*- Mode: Lisp; Syntax: ANSI-Common-Lisp; Base: 10 -*-
(defsystem :conf
:author "noloop <[email protected]>"
:maintainer "noloop <[email protected]>"
:license "GPLv3"
:version "1.0.1"
:homepage "https://github.com/noloop/conf"
:bug-tracker "https://github.com/noloop/conf/issues"
:source-control (:git "[email protected]:noloop/conf.git")
:description "Simple configuration file manipulator for projects."
:depends-on (:cl-fad)
:components ((:module "src"
:components
((:file "package")
(:file "conf" :depends-on ("package")))))
:in-order-to ((test-op (test-op "conf/test"))))
(defsystem :conf/test
:author "noloop <[email protected]>"
:maintainer "noloop <[email protected]>"
:license "GNU General Public License v3.0"
:description "conf Test."
:depends-on (:conf)
:components ((:module "test"
:components
((:file "conf-test"))))
:perform (test-op (op system) (funcall (read-from-string "conf-test::run"))))
| 1,022 | Common Lisp | .asd | 26 | 33.730769 | 79 | 0.633803 | noloop/conf | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:44:50 AM (Europe/Amsterdam) | bb0db58de05e9f5f75c90d2c2d1e7e25231e94949cc0317954a0869119dfbb8f | 38,458 | [
-1
] |
38,477 | util.lisp | wsgac_cl-swiss/src/util.lisp | (defpackage cl-swiss.util
(:use :cl :circular-streams))
(in-package :cl-swiss.util)
;; blah blah blah.
(defun caesar-cipher (text shift)
(loop
with cap-lo = (char-code #\A)
with min-lo = (char-code #\a)
with range = (- (char-code #\Z)
(char-code #\A)
-1)
for c across text
if (char<= #\A c #\Z)
collect (code-char (+ (mod (+ (- (char-code c) cap-lo) shift) range) cap-lo)) into caesar
else if (char<= #\a c #\z)
collect (code-char (+ (mod (+ (- (char-code c) min-lo) shift) range) min-lo)) into caesar
else
collect c into caesar
finally (return (coerce caesar 'string))))
(defun letter-frequency (text)
(loop
with hash = (make-hash-table)
for c across text
if (or (char<= #\A c #\Z)
(char<= #\a c #\z))
do (incf (gethash (char-downcase c) hash 0))
finally (let (alist)
(maphash #'(lambda (k v) (push (cons k v) alist)) hash)
(return (sort alist #'> :key #'cdr)))))
(defmacro %polyalphabetic-process (codeword text step)
`(with-output-to-string (s)
(loop
with cw-len = (length ,codeword)
with offsets = (loop
for cc across (string-downcase ,codeword)
collect (- (char-code cc)
(char-code #\a)) into res
finally (return (apply #'vector res)))
with i = 0
for c across (string-downcase ,text)
if (char<= #\a c #\z)
do (write-char (code-char (+ (mod (,step (- (char-code c)
(char-code #\a))
(aref offsets (mod i cw-len))) 26)
(char-code #\a))) s)
(incf i))))
(defun polyalphabetic-encode (codeword text)
(%polyalphabetic-process codeword text +))
(defun polyalphabetic-decode (codeword text)
(%polyalphabetic-process codeword text -))
| 2,020 | Common Lisp | .lisp | 50 | 29.6 | 94 | 0.516802 | wsgac/cl-swiss | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:44:50 AM (Europe/Amsterdam) | 8844040065299f386ee3f39e8c880b94719695338bb82d8220446f5ae1772c11 | 38,477 | [
-1
] |
38,478 | sailfish.lisp | wsgac_cl-swiss/src/sailfish.lisp | (defpackage cl-swiss.sailfish
(:use :cl :cl-swiss.util :inferior-shell :bt)
(:nicknames :sailfish-util)
(:documentation "This package contains assorted utilities for
communicating with Sailfish OS."))
(in-package :cl-swiss.sailfish)
;; dbus-send --system --print-reply --dest=org.ofono /ril_0 org.ofono.MessageManager.SendMessage string:"+48601789679" string:"A jednak do 20:00"
(defun send-sms (sailfish-host recipient message-text)
"Send an SMS message composed of MESSAGE-TEXT to
RECIPIENT (specified as a telephone number). The function requires SSH
access to a Sailfish OS device, available at SAILFISH-HOST. It
currently only supports synchronous command execution, which is a
limitation of the underlying INFERIOR-SHELL."
(run/ss (format nil "dbus-send --system --print-reply \\
--dest=org.ofono /ril_0 org.ofono.MessageManager.SendMessage \\
string:\"~a\" \\
string:\"~a\"" recipient message-text)
:host sailfish-host))
| 953 | Common Lisp | .lisp | 18 | 50.555556 | 145 | 0.762876 | wsgac/cl-swiss | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:44:50 AM (Europe/Amsterdam) | 611aa5b2e414e4063683443d73f7524bfaf61d253c8ada5bf9bb0a9d418b2eba | 38,478 | [
-1
] |
38,479 | cl-swiss.lisp | wsgac_cl-swiss/src/cl-swiss.lisp | (defpackage cl-swiss
(:use :cl))
(in-package :cl-swiss)
;; blah blah blah.
| 78 | Common Lisp | .lisp | 4 | 17.75 | 22 | 0.684932 | wsgac/cl-swiss | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:44:50 AM (Europe/Amsterdam) | b31d05f6e3e82541e51c4df890795142c3b21b9087775147081be6ba3735ac0b | 38,479 | [
-1
] |
38,480 | gopher.lisp | wsgac_cl-swiss/src/gopher.lisp | (defpackage cl-swiss.gopher
(:use :cl :usocket))
(in-package :cl-swiss.gopher)
(defparameter *gopher-port* 70)
(defun list-server-contents (host &key directory (port *gopher-port*))
"Get listing of DIRECTORY at a particular Gopher HOST. If DIRECTORY
is not specified, display root directory contents."
(with-client-socket (socket stream host port)
(when magic-string
(write-string magic-string stream))
(write-char #\newline stream)
(force-output stream)
(loop
for line = (read-line stream nil)
while line
collect line into lines
finally (return lines))))
| 614 | Common Lisp | .lisp | 17 | 31.705882 | 70 | 0.712605 | wsgac/cl-swiss | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:44:50 AM (Europe/Amsterdam) | af8a1dbb080993f00931e4732bac794b89e8e8fd96dc2a6166457935f79f9d0d | 38,480 | [
-1
] |
38,481 | machine-independent-graphics.lisp | wsgac_cl-swiss/src/machine-independent-graphics.lisp | (defpackage cl-swiss.machine-independent-graphics
(:use :cl)
(:nicknames :cl-swiss.mig :cl-swiss.mi-graphics)
(:use :xlib))
(in-package :cl-swiss.mi-graphics)
;;;; This is an implementation of machine-independent graphics
;;;; utilities adapted from Mark Watson's book "Common LISP Modules:
;;;; Artificial Intelligence in the Era of Neural Networks and Chaos
;;;; Theory".
(defparameter *plot-window* nil)
(defparameter *graphics-context* nil)
;; Some CLX examples: http://www.cawtech.demon.co.uk/clx/simple/examples.html
(defun init-plot (&key (title "Plot Window") (x-size 500) (y-size 500))
"Initialize an emtpy Xorg window. Return the window object."
(let* ((display (open-default-display))
(screen (car (display-roots display)))
(root-window (screen-root screen))
(white (screen-white-pixel screen)))
(setf *plot-window*
(create-window :parent root-window
:x 0
:y 0
:width x-size
:height y-size
:background white
))
(change-property *plot-window*
:wm_name title
:string 8)
(map-window *plot-window*)
(display-finish-output display)
(init-graphics-context)
*plot-window*))
(defun init-graphics-context ()
(let* ((display (open-default-display))
(screen (car (display-roots display)))
(black (screen-black-pixel screen))
(white (screen-white-pixel screen)))
(setf *graphics-context*
(create-gcontext
:drawable *plot-window*
:foreground white
:background black))))
(defun plot-fill-rect (x y xsize ysize pattern)
(declare (ignorable x y xsize ysize pattern)))
(defun plot-size-rect (x y xsize ysize val)
(declare (ignorable x y xsize ysize val)))
(defun clear-plot (&key (window *plot-window*))
(clear-area window
:width (drawable-width window)
:height (drawable-height window)))
(defun pen-width (nibs)
(declare (ignorable nibs)))
(defun plot-frame-rect (x y xsize ysize)
(declare (ignorable x y xsize ysize)))
(defun plot-line (x1 y1 x2 y2)
""
(let* ((display (open-default-display))
(screen (car (display-roots display)))
;; (white (screen-white-pixel screen))
(black (screen-black-pixel screen)))
(map-window *plot-window*)
(setf (gcontext-foreground *graphics-context*) black)
(event-case (display :force-output-p t
:discard-p t)
(:exposure ()
(break)
(draw-line *plot-window*
*graphics-context*
x1 y1 x2 y2)
nil)
(:button-press () t)
(:key-press (code state) (char= #\Space (xlib:keycode->character display code state))))
(display-finish-output display)
(close-display display)))
(defun show-plot ())
(defun plot-string (x y str &optional (size 10))
(declare (ignorable x y str size)))
(defun plot-string-bold (x y str &optional (size 12))
(declare (ignorable x y str size)))
(defun plot-string-italic (x y str)
(declare (ignorable x y str)))
(defun plot-mouse-down ())
#+nil
(defun test ()
(show-plot)
(clear-plot)
(dotimes (i 6)
(plot-fill-rect
(* i 9)
(* i 9)
8 8
i)
(plot-frame-rect (* i 9) (* I 9) 8 8))
(dotimes (i 50)
(plot-size-rect
(+ 160 (random 200)) (random 100) (random 20) (random 20) (random 5)))
(dotimes (i 4)
(plot-string (* i 10) (+ 150 (* i 22)) "Mark's plot utilities ...."))
(plot-string-bold 20 260 "This is a test... of BOLD")
(plot-string-italic 20 280 "This is a test ... of ITALIC"))
| 3,597 | Common Lisp | .lisp | 101 | 29.891089 | 93 | 0.63456 | wsgac/cl-swiss | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:44:50 AM (Europe/Amsterdam) | 96a33f79377e08f603811aefb4fc768bc3ba8fe6470f13cd1e095a0d68aa901f | 38,481 | [
-1
] |
38,482 | util.lisp | wsgac_cl-swiss/src/onlisp/util.lisp | (defpackage cl-swiss.onlisp.util
(:use :cl :alexandria)
(:nicknames :onlisp-util))
(in-package :cl-swiss.onlisp.util)
#+nil
(defun something (n m)
(macrolet ((with-binding (a b)
(let ((g (gensym)))
`(progn
(setf (symbol-function ,g) #'(lambda (x) (+ x ,a)))
(,g ,b)))))
(with-binding n m)))
(defun find2 (fn lst)
"Find the first element in LST for which the application of FN
returns non-NIL and return both the element and result as values."
(when lst
(let ((val (funcall fn (car lst))))
(if val
(values (car lst) val)
(find2 fn (cdr lst))))))
(defun last1 (lst)
"Return the CAR of the last cons i.e. the last element of a list."
(declare (inline))
(car (last lst)))
(defun single (lst)
"Check if LST is a singleton."
(declare (inline))
(and (consp lst) (not (cdr lst))))
(defun append1 (lst obj)
"Non-destructively append OBJ to the end of LST."
(declare (inline))
(append lst (list obj)))
(defun nconc1 (lst obj)
"Destructively append OBJ to the end of LST."
(declare (inline))
(nconc lst (list obj)))
(defun mklist (obj)
"Ensure that OBJ is a list."
(declare (inline))
(if (listp obj) obj (list obj)))
(defun longer (x y)
"Check if X is longer than Y. If both are lists, use a
short-circuiting approach rather than computing full length."
(labels ((compare (x y)
(and (consp x)
(or (null y)
(compare (cdr x) (cdr y))))))
(if (and (listp x) (listp y))
(compare x y)
(> (length x) (length y)))))
(defun filter (fn lst)
"Return a list of non-NIL results of applying FN to elements of
LST."
(let ((acc nil))
(dolist (el lst)
(let ((val (funcall fn el)))
(if val
(push val acc))))
(nreverse acc)))
(defun group (lst n)
"Group elements of LST into lists of N elements. The last list might
contain fewer elements."
(assert (integerp n))
(if (zerop n) (error "Zero length"))
(labels ((rec (lst acc)
(let ((rest (nthcdr n lst)))
(if (consp rest)
(rec rest (cons (subseq lst 0 n) acc))
(nreverse (cons lst acc))))))
(when lst (rec lst nil))))
;; Already defined in :alexandria
#+nil
(defun flatten (x)
"Make X into a completely flat list."
(labels ((rec (x acc)
(cond ((null x) acc)
((atom x) (cons x acc))
(t (rec (car x) (rec (cdr x) acc))))))
(rec x nil)))
(defun prune (test tree)
"Prune TREE by applying TEST to each leaf."
(labels ((rec (tree acc)
(cond ((null tree) (nreverse acc))
((consp (car tree))
(rec (cdr tree)
(cons (rec (car tree) nil) acc)))
(t (rec (cdr tree)
(if (funcall test (car tree))
acc
(cons (car tree) acc)))))))
(rec tree nil)))
(defun before (x y lst &key (test #'eql))
""
(and lst
(let ((first (car x)))
(cond ((funcall test first y) nil)
((funcall test first x) lst)
(t (before x y (cdr lst) :test test))))))
(defun after (x y lst &key (test #'eql))
""
(let ((rest (before y x lst :test test)))
(and rest (member x rest :test test))))
(defun duplicate (obj lst &key (test #'eql))
""
(member obj (cdr (member obj lst :test test)) :test test))
(defun split-if (fn lst)
""
(let ((acc nil))
(do ((src lst (cdr src)))
((or (null src) (funcall fn (car src)))
(values (nreverse acc) src))
(push (car src) acc))))
(defun most (fn lst)
""
(if (null lst)
(values nil nil)
(let* ((wins (car lst))
(max (funcall fn wins)))
(dolist (obj (cdr lst))
(let ((score (funcall fn obj)))
(when (> score max)
(setq wins obj
max score))))
(values wins max))))
(defun best (fn lst)
""
(if (null lst)
nil
(let ((wins (car lst)))
(dolist (obj (cdr lst))
(if (funcall fn obj wins)
(setq wins obj)))
wins)))
(defun mostn (fn lst)
""
(if (null lst)
(values nil nil)
(let ((result (list (car lst)))
(max (funcall fn (car lst))))
(dolist (obj (cdr lst))
(let ((score (funcall fn obj)))
(cond ((> score max)
(setq max score
result (list obj)))
((= score max)
(push obj result)))))
(values (nreverse result) max))))
;; Mapping functions
(defun map-> (fn start test-fn succ-fn)
"Apply FN to each item of the sequence starting with START, ending
when TEST-FN yields T, with successive elements generated by applying
SUCC-FN."
(do ((i start (funcall succ-fn i))
(result nil))
((funcall test-fn i) (nreverse result))
(push (funcall fn i) result)))
(defun mapa-b (fn a b &optional (step 1))
""
(map-> fn a
(rcurry #'> b)
(curry #'+ step)))
(defun map0-n (fn n)
""
(mapa-b fn 0 n))
(defun map1-n (fn n)
""
(mapa-b fn 1 n))
;; Already defined in :alexandria
#+nil
(defun mappend (fn &rest lsts)
""
(apply #'append (apply #'mapcar fn lsts)))
(defun mapcars (fn &rest lsts)
""
(let ((result nil))
(dolist (lst lsts)
(dolist (el lst)
(push (funcall fn el) result)))
(nreverse result)))
(defun rmapcar (fn &rest args)
""
(if (some #'atom args)
(apply fn args)
(apply #'mapcar
#'(lambda (&rest args)
(apply #'rmapcar fn args))
args)))
(defun readlist (&rest args)
""
(values (read-from-string
(concatenate 'string "(" (apply #'read-line args) ")"))))
(defun prompt (&rest args)
""
(apply #'format *query-io* args)
(read *query-io*))
(defun break-loop (fn quit &rest args)
""
(format *query-io* "Entering break-loop.~%")
(loop
(let ((in (apply #'prompt args)))
(if (funcall quit in)
(return)
(format *query-io* "~A~%" (funcall fn in))))))
(defun mkstr (&rest args)
""
(with-output-to-string (s)
(dolist (a args) (princ a s))))
(defun symb (&rest args)
""
(values (intern (apply #'mkstr args))))
(defun reread (&rest args)
""
(values (read-from-string (apply #'mkstr args))))
(defun explode (sym)
""
(map 'list #'(lambda (c)
(intern (make-string 1
:initial-element c)))
(symbol-name sym)))
;; Chapter 5
(defvar *!equivs* (make-hash-table)
"Hash table for storing destructive counterparts of functions.")
(defun ! (fn)
"Retrieve destructive counterpart of function FN. Requires previous
association to be established by DEF!."
(or (gethash fn *!equivs*) fn))
(defun def! (fn fn!)
"Establish FN! as a destructive counterpart of FN."
(setf (gethash fn *!equivs*) fn!))
(defun memoize (fn)
(let ((cache (make-hash-table :test #'equal)))
#'(lambda (&rest args)
(multiple-value-bind (val win) (gethash args cache)
(if win
val
(setf (gethash args cache)
(apply fn args)))))))
(defun fif (if then &optional else)
"Functional IF. Return a function, whose argument gets passed
through an IF-like expression, applying IF, THEN and ELSE to that
argument."
#'(lambda (x)
(if (funcall if x)
(funcall then x)
(if else (funcall else x)))))
;; Paul Graham's version
#+nil
(defun fint (fn &rest fns)
(if (null fns)
fn
(let ((chain (apply #'fint fns)))
#'(lambda (x)
(and (funcall fn x) (funcall chain x))))))
;; My version using EVERY
(defun fintersection (&rest fns)
"Functional intersection. Return a predicate function checking if
all the functions FN and FNS evaluate to T on its argument."
#'(lambda (x)
(every #'(lambda (f) (funcall f x)) fns)))
(defun funion (&rest fns)
"Functional intersection. Return a predicate function checking if
all the functions FN and FNS evaluate to T on its argument."
#'(lambda (x)
(some #'(lambda (f) (funcall f x)) fns)))
(defun lrec (rec &optional base)
""
(labels ((self (lst)
(if (null lst)
(if (functionp base)
(funcall base)
base)
(funcall rec (car lst)
#'(lambda ()
(self (cdr lst)))))))
#'self))
(setf (fdefinition 'list-recurser) #'lrec)
(defun ttrav (rec &optional (base #'identity))
""
(labels ((self (tree)
(if (atom tree)
(if (functionp base)
(funcall base tree)
base)
(funcall rec (self (car tree))
(if (cdr tree)
(self (cdr tree)))))))
#'self))
(setf (fdefinition 'tree-traverser) #'ttrav)
(defun trec (rec &optional (base #'identity))
(labels
((self (tree)
(if (atom tree)
(if (functionp base)
(funcall base tree)
base)
(funcall rec tree
#'(lambda ()
(self (car tree)))
#'(lambda ()
(if (cdr tree)
(self (cdr tree))))))))
#'self))
(setf (fdefinition 'tree-recurser) #'trec)
| 9,529 | Common Lisp | .lisp | 303 | 24.042904 | 71 | 0.544355 | wsgac/cl-swiss | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:44:50 AM (Europe/Amsterdam) | 23ce7a211c77a90a69e5db1fd204c34925ba4af4db66c655393b77a211017d57 | 38,482 | [
-1
] |
38,483 | cl-swiss.lisp | wsgac_cl-swiss/tests/cl-swiss.lisp | (defpackage cl-swiss-test
(:use :cl
:cl-swiss
:prove))
(in-package :cl-swiss-test)
;; NOTE: To run this test file, execute `(asdf:test-system :cl-swiss)' in your Lisp.
(plan nil)
;; blah blah blah.
(finalize)
| 231 | Common Lisp | .lisp | 9 | 22.222222 | 84 | 0.66055 | wsgac/cl-swiss | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:44:50 AM (Europe/Amsterdam) | e6b417495b23f892c54d59805e01c69b94d3e53038bbfde7fa1f83bee3c553e6 | 38,483 | [
-1
] |
38,484 | cl-swiss.asd | wsgac_cl-swiss/cl-swiss.asd | #|
This file is a part of cl-swiss project.
Copyright (c) 2019 Wojciech S. Gac ([email protected])
|#
#|
Author: Wojciech S. Gac ([email protected])
|#
(defsystem "cl-swiss"
:version "0.1.0"
:author "Wojciech S. Gac"
:license "GPLv3"
:depends-on ("cl-ppcre"
"alexandria"
"clx"
"usocket"
"ironclad"
"flexi-streams"
"circular-streams"
"inferior-shell"
"bordeaux-threads"
"chanl")
:components ((:module "src"
:components
((:module "onlisp"
:components
((:file "util")))
(:file "util")
(:file "cl-swiss")
(:file "machine-independent-graphics")
(:file "gopher")
(:file "sailfish"))))
:description "An effort to build a personal library of useful Common
Lisp utilities (Swiss Army knife)"
:long-description
#.(read-file-string
(subpathname *load-pathname* "README.md"))
:in-order-to ((test-op (test-op "cl-swiss-test"))))
| 1,097 | Common Lisp | .asd | 37 | 21.432432 | 70 | 0.548204 | wsgac/cl-swiss | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:44:50 AM (Europe/Amsterdam) | 60ea9e36d1e7d207668c10508b38c83dad4ee35f5618c2c3f013549de91a2997 | 38,484 | [
-1
] |
38,485 | cl-swiss-test.asd | wsgac_cl-swiss/cl-swiss-test.asd | #|
This file is a part of cl-swiss project.
Copyright (c) 2019 Wojciech S. Gac ([email protected])
|#
(defsystem "cl-swiss-test"
:defsystem-depends-on ("prove-asdf")
:author "Wojciech S. Gac"
:license "GPLv3"
:depends-on ("cl-swiss"
"prove")
:components ((:module "tests"
:components
((:test-file "cl-swiss"))))
:description "Test system for cl-swiss"
:perform (test-op (op c) (symbol-call :prove-asdf :run-test-system c)))
| 498 | Common Lisp | .asd | 15 | 27.733333 | 73 | 0.62578 | wsgac/cl-swiss | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:44:50 AM (Europe/Amsterdam) | 911c03ab744947b9e463f03a48d919d534592c2757ab2d0322046dcc8142c5f0 | 38,485 | [
-1
] |
38,510 | misc-utils.lisp | unsigned-nerd_un-utils/un-utils/misc-utils.lisp | (defpackage :un-utils.misc-utils
(:use :common-lisp :cl-ppcre)
(:export
#:parse-decimal
#:prompt-for-input
#:utf16-to-char
#:with-interned-symbols))
(in-package :un-utils.misc-utils)
;
; Convert string into decimal. in-str can be a Lisp expression. So, user can tamper with the
; program which can be a good or bad thing depending on the situation.
;
(defun parse-decimal (in-str)
(with-input-from-string (in in-str)
(read in)))
;
; Prompt for input from the command-line. Input can be Lisp expression. So, user can tamper with
; the program which can be a good or bad thing depending on the situation.
;
(defmacro prompt-for-input (prompt-message &optional var)
`(progn
(format t ,prompt-message)
(finish-output)
,(if (null var)
`(read-line)
`(setf ,var (read-line)))))
;
; When we write a macro that is an anaphoric macro, use with-interned-symbols to intern all symbols
; that will be available to the caller. This will solve problem that comes from the usage of
; package.
;
; https://stackoverflow.com/questions/44199651/exporting-anaphoric-macros-in-common-lisp-packages
;
(defmacro with-interned-symbols (symbol-list &body body)
"Interns a set of symbols in the current package to variables of the same (symbol-name)."
(let ((symbol-list (mapcar (lambda (s) (list s `(intern (symbol-name ',s)))) symbol-list)))
`(let ,symbol-list ,@body)))
| 1,421 | Common Lisp | .lisp | 37 | 35.540541 | 99 | 0.717596 | unsigned-nerd/un-utils | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:44:58 AM (Europe/Amsterdam) | 55e209a6608d9c523e8b6f7ac75ffccdc8300ef163d08cc50b0a3d128baffc4d | 38,510 | [
-1
] |
38,511 | simple-syntax.lisp | unsigned-nerd_un-utils/un-utils/simple-syntax.lisp | ; I am a newbie. I prefer simpler syntaxes.
(defpackage :un-utils.simple-syntax
(:use :common-lisp)
(:export
#:for-each-$line-in #:print-line #:while #:with-gensyms))
(in-package :un-utils.simple-syntax)
;
; Loop through the file input stream line by line.
;
; Anaphoric macro, intentional variable capture
;
; $line - each line in the input stream
;
; Example:
;
; (for-each-$line-in *standard-input*
; (print-line "- ~A" $line))
;
(defmacro for-each-$line-in (in-stream &rest body)
(let (($line (intern (symbol-name '$line))))
`(let (,$line)
(loop for ,$line = (read-line ,in-stream nil 'eof)
until (eq ,$line 'eof)
do
,@body))))
; Print the specified text with a newline to *standard-output*
(defmacro print-line (formatted-string &rest args)
`(format t ,(concatenate 'string formatted-string "~%") ,@args))
; Example:
;
; (let ((x 0))
; (while (< x 10)
; (princ x)
; (incf x)))
;
(defmacro while (test &rest body)
`(do ()
((not ,test))
,@body))
;
; Used when writing a macro. Use to create multiple local variables without having to call gensym
; multiple times.
;
; Example:
;
; (defmacro foo ()
; (with-gensyms (a b c)
; (setf a 2 b 3 c 4)
; `(+ ,a ,b ,c)))
;
(defmacro with-gensyms (syms &body body)
`(let ,(mapcar #'(lambda (s) `(,s (gensym)))
syms)
,@body))
| 1,405 | Common Lisp | .lisp | 54 | 23.240741 | 98 | 0.612639 | unsigned-nerd/un-utils | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:44:58 AM (Europe/Amsterdam) | 5e7c3be34352c2a242d6590133da668045d63ea8923a415460895a1ca8cd8c7c | 38,511 | [
-1
] |
38,512 | simple-syntax-loop-thru-stdin.lisp | unsigned-nerd_un-utils/sample/simple-syntax-loop-thru-stdin.lisp | ; {{{ boilerplate
; load tools that will help us code easier
(load "~/quicklisp/setup.lisp") ; tool to load external systems
(require "asdf") ; tool to load local systems
(asdf:load-system "un-utils")
(use-package :un-utils.simple-syntax) ; always use simple-syntax because we are newbies
; }}}
(for-each-$line-in *standard-input*
(print-line "each line is: ~A" $line))
| 374 | Common Lisp | .lisp | 9 | 40.111111 | 87 | 0.727273 | unsigned-nerd/un-utils | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:44:58 AM (Europe/Amsterdam) | 36081d91a378a7659ddb421546cf7d55f6d654d1f13c0989bc790f7ae9513f10 | 38,512 | [
-1
] |
38,531 | tree_patterns.cl | hizircanbayram_gLang/parser/tree_patterns.cl |
;*********************************************************** TREE PATTERNS ***********************************************************
; This is a print function for writing the tree to a file
(defun write-lexem(text)
(with-open-file (fileName "parse.tree"
:direction :output
:if-exists :append
:if-does-not-exist :create)
(format fileName text))
)
; It prints the tree that is created for storing the program text.
(defun printAST (ast)
(write-lexem (string (car ast)))
(write-lexem "~%")
(printASTprivate (cdr ast) 2))
; This is the main function for printing the tree. It makes some recursion calls based on the expression that it is delivered.
(defun printASTprivate (ast spaceAmn) ; printEXPI gibi oldu bu biraz, lol. printEPBI da ayri yazmak gerekecek gibi.
(if (null ast)
()
(if (listp (car ast))
(goDeep ast spaceAmn)
(if (or (equal (car ast) "EXPI") (equal (car ast) "VALUES") (equal (car ast) "LISTVALUE") (equal (car ast) "EXPLISTI")
(equal (car ast) "EXPB") (equal (car ast) "EXPB") (equal (car ast) "IDLIST") (equal (car ast) "INPUT"))
(writeTYPE ast spaceAmn)
(writeOTHER ast spaceAmn)))))
; If the expression contains more than one expression, flow of the program makes a call to this function.
(defun goDeep (ast spaceAmn)
(printASTprivate (car ast) spaceAmn)
(printASTprivate (cdr ast) spaceAmn))
; If what will be written isn't the main type, this function is invoked so as to print it on the screen.
(defun writeTYPE (ast spaceAmn)
(printSpaces spaceAmn)
(write-lexem (string (car ast)))
(write-lexem "~%")
(printASTprivate (cdr ast) (+ spaceAmn 2)))
; If what will be written isn't the other type, this function is invoked so as to print it on the screen.
(defun writeOTHER (ast spaceAmn)
(printSpaces spaceAmn)
(write-lexem (string (car ast)))
(write-lexem "~%")
(printASTprivate (cdr ast) spaceAmn))
; Print given amount of white space characters.
(defun printSpaces (n)
(write-lexem " ")
(if (> n 0)
(printSpaces (- n 1))))
| 2,073 | Common Lisp | .cl | 45 | 42.355556 | 142 | 0.655909 | hizircanbayram/gLang | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:44:58 AM (Europe/Amsterdam) | 18fa79588c9b258736adb89c06c096683e78b8ecd4421a84df0dd57525db40fc | 38,531 | [
-1
] |
38,532 | query.cl | hizircanbayram_gLang/parser/query.cl |
;*********************************************************** QUERY FUNCTIONS ***********************************************************
; Checks if next expression is type of an EXPI or not. Then it is decided that the flow of a program is going to which finite automata. This function is based on the given grammar.
(defun isEXPI ()
(cond
((and (equal (carcdrCheck *lexems*) "(") (equal (carcdrCheck2 *lexems*) "+")) (+ 0 1))
((and (equal (carcdrCheck *lexems*) "(") (equal (carcdrCheck2 *lexems*) "-")) (+ 0 1))
((and (equal (carcdrCheck *lexems*) "(") (equal (carcdrCheck2 *lexems*) "*")) (+ 0 1))
((and (equal (carcdrCheck *lexems*) "(") (equal (carcdrCheck2 *lexems*) "/")) (+ 0 1))
((equal (carcar *lexems*) "identifier") (+ 0 1))
((and (equal (carcdrCheck *lexems*) "(") (equal (carcdrCheck2 *lexems*) "set")) (+ 0 1))
((and (equal (carcdrCheck *lexems*) "(") (equal (carcdrCheck2 *lexems*) "deffun")) (+ 0 1))
((and (equal (carcdrCheck *lexems*) "(") (equal (carcar2Check *lexems*) "identifier")) (+ 0 1))
((and (equal (carcdrCheck *lexems*) "(") (equal (carcdrCheck2 *lexems*) "defvar")) (+ 0 1))
((and (equal (carcdrCheck *lexems*) "(") (equal (carcdrCheck2 *lexems*) "if")) (+ 0 1))
((and (equal (carcdrCheck *lexems*) "(") (equal (carcdrCheck2 *lexems*) "while")) (+ 0 1))
; ((equal (carcar *lexems*) "integer") (+ 0 1)) integer'i LISTVALUE kabul ettigimizden beri burasi yorumda. Bakalim ileride ne olacak.
((and T T) (+ 0 0))))
; Checks if next expression is type of an VALUES or not. Then it is decided that the flow of a program is going to which finite automata. This function is based on the given grammar.
(defun isVALUE ()
(if (equal (car (car *lexems*)) "integer")
(+ 1 0)
(+ 0 0)))
; Checks if next expression is type of an LISTVALUES or not. Then it is decided that the flow of a program is going to which finite automata. This function is based on the given grammar.
(defun isLISTVALUE ()
(cond
((equal (carcdrCheck *lexems*) "null") (+ 1 0))
((and (equal (carcdrCheck *lexems*) "'") (equal (carcdrCheck2 *lexems*) "(")) (+ 1 0))
((+ 1 0) (+ 0 0))))
; Checks if next expression is type of an IDLIST or not. Then it is decided that the flow of a program is going to which finite automata. This function is based on the given grammar.
(defun isIDLIST ()
(cond
((and (equal (carcdrCheck *lexems*) "(") (equal (carcar2Check *lexems*) "identifier")) (+ 1 0))
((+ 1 0) (+ 0 0))))
; Checks if next expression is type of an EXPLISTI or not. Then it is decided that the flow of a program is going to which finite automata. This function is based on the given grammar.
(defun isEXPLISTI ()
(cond
((and (equal (carcdrCheck *lexems*) "(") (equal (carcdrCheck2 *lexems*) "concat")) (+ 1 0))
((and (equal (carcdrCheck *lexems*) "(") (equal (carcdrCheck2 *lexems*) "append")) (+ 1 0))
((> (isLISTVALUE) 0) (+ 1 0))
((+ 0 1) (+ 0 0))
))
; Checks if next expression is type of an EXPB or not. Then it is decided that the flow of a program is going to which finite automata. This function is based on the given grammar.
(defun isEXPB ()
(cond
((and (equal (carcdrCheck *lexems*) "(") (equal (carcdrCheck2 *lexems*) "and")) (+ 1 0))
((and (equal (carcdrCheck *lexems*) "(") (equal (carcdrCheck2 *lexems*) "or")) (+ 1 0))
((and (equal (carcdrCheck *lexems*) "(") (equal (carcdrCheck2 *lexems*) "not")) (+ 1 0))
((and (equal (carcdrCheck *lexems*) "(") (equal (carcdrCheck2 *lexems*) "equal")) (+ 1 0))
((equal (carcar *lexems*) "binary") (+ 1 0))
((+ 0 1) (+ 0 0)) ; kisa yol
))
| 3,582 | Common Lisp | .cl | 51 | 67.392157 | 186 | 0.623827 | hizircanbayram/gLang | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:44:58 AM (Europe/Amsterdam) | 5846506299eaad04424a69698f7378788336a06ac2d0694c4ceec220710e6d01 | 38,532 | [
-1
] |
38,533 | error_processing.cl | hizircanbayram_gLang/parser/error_processing.cl |
;*********************************************************** ERROR PROCESSING ***********************************************************
; After an error message prints on the screen, rest of the lexems of the expression is consumed.
(defun finishLexems ()
(print "LEXEMS FINISHING. ABORTING...")
(setf *lexems* (cdr *lexems*))
(if (not (null *lexems*))
(finishLexems)))
; After an expression is finished except its left parentheses, this function removes them from the list.
(defun cleanParentheses (prt)
(if (> *parentheses* 0)
(if (equal (carcdrCheck *lexems*) prt)
(cleanParentInside)
()))) ; parenthesesError fonk vardi burada ancak burada olmamasi gerektigini dusunuyorum. Bir yerler abuk olursa buraya da bakip ilgili fonk.u tekrar cagirmayi dusunebiliriz.
; This function is an inside function of the function called cleanParentheses.
(defun cleanParentInside ()
(skipParentheses)
(cleanParentheses ")"))
; This function is a helper function. It reduces the parentheses by one.
(defun skipParentheses ()
(setf *parentheses* (- *parentheses* 1))
(carcdr *lexems*))
; It's a simple prompt function.
(defun parenthesesError ()
(print "UNMATCHED PARENTHESES ERROR!!"))
| 1,217 | Common Lisp | .cl | 24 | 48.083333 | 176 | 0.678239 | hizircanbayram/gLang | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:44:58 AM (Europe/Amsterdam) | f5ab0793576892f078df6d646cb980ff565e1dc630bddcabf846713b4221c0a6 | 38,533 | [
-1
] |
38,534 | parse_processing.cl | hizircanbayram_gLang/parser/parse_processing.cl |
;*********************************************************** PARSE PROCESSING ***********************************************************
(defun parser (lexems)
(setq *lexems* lexems)
(parserPrivate *lexems*)
(setf *AST* (reverse *AST*))
(push "INPUT" *AST*)
(push "START" *AST*)
(printAST *AST*)
)
; ;DIRECTIVE: parse tree
; Checks if next next expression is either EXPI or EXPLISTI. There is no any other expression type here since the only two of them are allowed to start a program. If any expression isn't matched with either of these, an error message prints on the screen.
(defun parserPrivate (lexems)
(cond
((> (isEXPI) 0) (push (expi *lexems*) *AST*))
((> (isEXPLISTI) 0) (push (explisti) *AST*))
; ((> (isLISTVALUE) 0) (push (listvalue) *AST*))
; ((> (isEXPB) 0) (push (expb) *AST*))
((and T T) (finishLexems)))
(cleanParentheses ")")
(if (not (null *lexems*))
(parserPrivate *lexems*)))
| 937 | Common Lisp | .cl | 21 | 42 | 256 | 0.582237 | hizircanbayram/gLang | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:44:58 AM (Europe/Amsterdam) | b066408d0ebe3df0b53c79151ba3330ef882d1180dc22b0287505bb249b70fcc | 38,534 | [
-1
] |
38,535 | automata.cl | hizircanbayram_gLang/parser/automata.cl |
;*********************************************************** FINITE AUTOMATAS ***********************************************************
; This is one of the finite automatas. When the flow of a program runs into an expression which is type of EXPI, specifies which EXPI it is. It then starts creating a branch of a tree recursively and stores it in the variable called *AST*. If it runs into an expression that is not defined in the given grammar, it prints it on the screen.
(defun expi (lexems)
(if (equal (carcdrCheck lexems) ")")
(cleanParentheses ")"))
(cond
((equal (carcar *lexems*) "identifier") (list "EXPI" (carcdr *lexems*)))
((equal (carcar *lexems*) "integer") (list "VALUES" (carcdr *lexems*)))
((and (equal (carcdrCheck *lexems*) "(") (equal (carcdrCheck2 *lexems*) "+")) (expiOperation "+"))
((and (equal (carcdrCheck *lexems*) "(") (equal (carcdrCheck2 *lexems*) "-")) (expiOperation "-"))
((and (equal (carcdrCheck *lexems*) "(") (equal (carcdrCheck2 *lexems*) "*")) (expiOperation "*"))
((and (equal (carcdrCheck *lexems*) "(") (equal (carcdrCheck2 *lexems*) "/")) (expiOperation "/"))
((and (equal (carcdrCheck *lexems*) "(") (equal (carcdrCheck2 *lexems*) "set")) (setOperation))
((and (equal (carcdrCheck *lexems*) "(") (equal (carcdrCheck2 *lexems*) "deffun")) (deffunOperation))
((and (equal (carcdrCheck *lexems*) "(") (equal (carcar2Check *lexems*) "identifier")) (expi_explisti_operation))
((and (equal (carcdrCheck *lexems*) "(") (equal (carcdrCheck2 *lexems*) "defvar")) (defvarOperation))
((and (equal (carcdrCheck *lexems*) "(") (equal (carcdrCheck2 *lexems*) "if")) (ifOperation))
((and (equal (carcdrCheck *lexems*) "(") (equal (carcdrCheck2 *lexems*) "while")) (whileOperation))
((and T T) (print "ERROR EXPI!!"))
))
; This is one of the EXPI operation. If the expression is either +, -, * or /, this function creates it recursively.
(defun expiOperation (opr)
(carcdr *lexems*)
(carcdr *lexems*)
(setf *parentheses* (+ *parentheses* 1))
(list "EXPI" opr (expi *lexems*) (expi *lexems*)))
; This is one of the EXPI operation. If the expression is if, this function creates it recursively.
(defun ifOperation ()
(carcdr *lexems*)
(carcdr *lexems*)
(setf *parentheses* (+ *parentheses* 1))
(list "EXPI" (expb) (explisti) (explisti)))
; This is one of the EXPI operation. If the expression is while, this function creates it recursively.
(defun whileOperation ()
(carcdr *lexems*)
(carcdr *lexems*)
(setf *parentheses* (+ *parentheses* 1))
(list "EXPI" (list "EXPI" "while") (expb) (explisti)))
; This is one of the EXPI operation. If the expression contains an expression which is type of EXPLISTI, this function creates it recursively.
(defun expi_explisti_operation ()
(carcdr *lexems*)
(setf first_id (carcdr *lexems*))
(setf *parentheses* (+ *parentheses* 1))
(list "EXPI" (list "EXPI" first_id) (explisti)))
; This is one of the EXPI operation. If the expression is defvar, this function creates it recursively.
(defun defvarOperation ()
(carcdr *lexems*)
(carcdr *lexems*)
(setf *parentheses* (+ *parentheses* 1))
(list "EXPI" (list "EXPI" (carcdr *lexems*)) (expi *lexems*)))
; This is one of the EXPI operation. If the expression is set, this function creates it recursively.
(defun setOperation ()
(carcdr *lexems*)
(carcdr *lexems*)
(setf *parentheses* (+ *parentheses* 1))
(list "EXPI" "set" (idOperation "ERROR | AFTER set KEYWORD, AN IDENTIFIER IS REQUIRED.") (expi *lexems*)))
; This is one of the EXPI operation. If the deffun is set, this function creates it recursively.
(defun deffunOperation ()
(carcdr *lexems*)
(carcdr *lexems*)
(list "EXPI" "deffun" (idOperation "ERROR | AFTER deffun KEYWORD, AN IDENTIFIER IS REQUIRED.") (idlist) (explisti))
)
; This is one of the EXPI operation. If the deffun is set, this function creates it recursively.
(defun idOperation (errMessage)
(if (equal (carcar *lexems*) "identifier")
(list "EXPI" (carcdr *lexems*))
(format t errMessage)))
; This is one of the LISTVALUE operation. It creates one of the LISTVALUE branch recursively.
(defun value ()
(if (equal (carcdrCheck *lexems*) ")")
(skipParentheses))
(if (equal (car (car *lexems*)) "integer")
(list (carcdr *lexems*) (value))))
; This is one of the finite automatas. When the flow of a program runs into an expression which is type of LISTVALUE, specifies which LISTVALUE it is. It then starts creating a branch of a tree recursively and stores it in the variable called *AST*. If it runs into an expression that is not defined in the given grammar, it prints it on the screen.
(defun listvalue ()
(if (equal (carcdrCheck *lexems*) ")")
(skipParentheses))
(cond
((equal (carcdrCheck *lexems*) "null") (list "EXPLISTI" (carcdr *lexems*))) ; VALUES TEKRAR EXPI'YA CEVRILEBILIR
((and (equal (carcdrCheck *lexems*) "'") (equal (carcdrCheck2 *lexems*) "(")) (listvalueOperation))
((equal (carcar *lexems*) "integer") (list "VALUES" (carcdr *lexems*)))
((and T T) (print "ERROR LISTVALUE!! "))))
; This is one of the finite automatas. When the flow of a program runs into an expression which is type of IDLIST, specifies which IDLIST it is. It then starts creating a branch of a tree recursively and stores it in the variable called *AST*. If it runs into an expression that is not defined in the given grammar, it prints it on the screen.
(defun idlist ()
(cond
((and (equal (carcdrCheck *lexems*) "(") (equal (carcar2Check *lexems*) "identifier")) (list "IDLIST" (idlistOperation)))))
; This is one of the IDLIST operation. It creates one of the IDLIST branch recursively.
(defun idlistOperation ()
(if (equal (carcdrCheck *lexems*) ")")
(skipParentheses))
(setf *parentheses* (+ *parentheses* 1))
(carcdr *lexems*)
(if (equal (carcar *lexems*) "identifier")
(list (carcdrCheck *lexems*) (idlistOperation))))
; This is one of the LISTVALUE operation. It creates one of the LISTVALUE branch recursively.
(defun listvalueOperation ()
(carcdr *lexems*)
(carcdr *lexems*)
(setf *parentheses* (+ *parentheses* 1))
(list "LISTVALUE" (value)))
; This is one of the finite automatas. When the flow of a program runs into an expression which is type of EXPLISTI, specifies which EXPLISTI it is. It then starts creating a branch of a tree recursively and stores it in the variable called *AST*. If it runs into an expression that is not defined in the given grammar, it prints it on the screen.
(defun explisti ()
(if (equal (carcdrCheck *lexems*) ")")
(skipParentheses))
(cond
((and (equal (carcdrCheck *lexems*) "(") (equal (carcdrCheck2 *lexems*) "concat")) (explistiOperation "concat"))
((and (equal (carcdrCheck *lexems*) "(") (equal (carcdrCheck2 *lexems*) "append")) (explistiOperation "append"))
((isEXPI) (expi *lexems*))
((isLISTVALUE) (list "EXPLISTI" (listvalue)))
((and T T) (print "ERROR EXPLISTI"))))
; This is one of the EXPLISTI operation. It creates one of the EXPLISTI branch recursively.
(defun explistiOperation (choice)
(carcdr *lexems*)
(carcdr *lexems*)
(setf *parentheses* (+ *parentheses* 1))
(cond
((equal choice "concat") (list "EXPLISTI" "concat" (explisti) (explisti)))
((equal choice "append") (list "EXPLISTI" "append" (expi *lexems*) (explisti)))))
; This is one of the finite automatas. When the flow of a program runs into an expression which is type of EXPB, specifies which EXPB it is. It then starts creating a branch of a tree recursively and stores it in the variable called *AST*. If it runs into an expression that is not defined in the given grammar, it prints it on the screen.
(defun expb ()
(if (equal (carcdrCheck *lexems*) ")")
(skipParentheses))
(cond
((and (equal (carcdrCheck *lexems*) "(") (equal (carcdrCheck2 *lexems*) "and")) (expbOperation "and"))
((and (equal (carcdrCheck *lexems*) "(") (equal (carcdrCheck2 *lexems*) "or")) (expbOperation "or"))
((and (equal (carcdrCheck *lexems*) "(") (equal (carcdrCheck2 *lexems*) "not")) (expbOperation "not"))
((and (equal (carcdrCheck *lexems*) "(") (equal (carcdrCheck2 *lexems*) "equal")) (expbOperation "equal"))
((equal (carcar *lexems*) "binary") (list "EXPB" (carcdr *lexems*)))
((and T T) (+ 0 0))))
; This is one of the EXPB operation. It creates one of the EXPB branch recursively.
(defun expbOperation (choice)
(carcdr *lexems*)
(carcdr *lexems*)
(setf *parentheses* (+ *parentheses* 1))
(cond
((equal choice "and") (list "EXPB" "and" (expb) (expb)))
((equal choice "or") (list "EXPB" "or" (expb) (expb)))
; ((equal choice "equal") (list "EXPB" "equal" (expb) (expb)))
((equal choice "equal") (list "EXPB" "equal" (expi *lexems*) (expi *lexems*)))
((equal choice "not") (list "EXPB" "not" (expb)))))
| 8,803 | Common Lisp | .cl | 140 | 60.05 | 349 | 0.686927 | hizircanbayram/gLang | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:44:58 AM (Europe/Amsterdam) | fedc085ac4fd4e016f554042609703c7886a8cbe5c9ba0bf819b04856de46d9b | 38,535 | [
-1
] |
38,536 | helper.cl | hizircanbayram_gLang/parser/helper.cl |
;*********************************************************** HELPER FUNCTIONS ***********************************************************
; Returns the first element of the first element of a given list.
(defun carcar (lexems)
(car (car lexems)))
; Returns the second element of the first element of a given list. It iterates the given program also.
(defun carcdr (lexems)
(setf *lexems* (cdr *lexems*))
(car (cdr (car lexems))))
; Returns the second element of the first element of a given list.
(defun carcdrCheck (lexems)
(car (cdr (car lexems))))
; Returns the first element of the first element of a given list.
(defun carcar2Check (var)
(car (car (cdr var))))
; Returns the second element of the first element of a given list.
(defun carcdrCheck2 (lexems)
(car (cdr (car (cdr lexems)))))
; Returns the second element of the second element of a given list.
(defun cdrcdr ()
(setf *lexems* (cdr (cdr *lexems*))))
; It is a simple function for reading from file to string.
(defun fileToString (file-path)
(with-open-file (file-stream file-path)
(let ((content (make-string (file-length file-stream))))
(read-sequence content file-stream)
content)))
| 1,196 | Common Lisp | .cl | 26 | 43.461538 | 145 | 0.65338 | hizircanbayram/gLang | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:44:58 AM (Europe/Amsterdam) | 04bd0925583aeceb0c48e1512af4d1e866ae64d4b1407d1826d21b385ff98d9c | 38,536 | [
-1
] |
38,537 | var_par.cl | hizircanbayram_gLang/parser/var_par.cl |
(defparameter *AST* ())
(defparameter *parentheses* 0)
(defparameter *lexems* '() )
| 86 | Common Lisp | .cl | 3 | 27.333333 | 30 | 0.695122 | hizircanbayram/gLang | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:44:58 AM (Europe/Amsterdam) | a72287d692280b87bd6a5f2d21f6184be0fd034b58f5ab0bb1f451b3991e4292 | 38,537 | [
-1
] |
38,538 | char_processing.cl | hizircanbayram_gLang/lexer/char_processing.cl |
; This function queries if the given character is a digit or not. It returns 1 if it is a digit, 0 otherwise.
(defun isDigit (num)
(if (or (char= num #\0) (char= num #\1) (char= num #\2) (char= num #\3) (char= num #\4) (char= num #\5) (char= num #\6) (char= num #\7) (char= num #\8) (char= num #\9) )
(- 2 1)
()))
; This function queries if the given character is a number or not(except 0). It returns 1 if it is a number, 0 otherwise.
(defun isNumber (num)
(if (or (char= num #\1) (char= num #\2) (char= num #\3) (char= num #\4) (char= num #\5) (char= num #\6) (char= num #\7) (char= num #\8) (char= num #\9) )
(- 2 1)
()))
; This function queries if the given character is a whitespace or not. It returns 1 if it is a whitespace character, 0 otherwise.
(defun isWhiteSpace (ch)
(if (or (char= ch #\Tab) (char= ch #\Newline) (char= ch #\Space))
(- 2 1)
()))
; This function queries if the given character is acceptible or not. It means that the given character is allowed to be used or not.
; It returns 1 if it is an acceptable character, 0 otherwise.
(defun isAcceptable (ch)
(if (or (isNumber ch) (alpha-char-p ch) (char= #\)) (char= #\() (char= #\+) (char= #\-) (char= #\*) (char= #\/))
(- 2 1)
()))
| 1,234 | Common Lisp | .cl | 21 | 56.380952 | 171 | 0.624378 | hizircanbayram/gLang | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:44:58 AM (Europe/Amsterdam) | 2668e51ee78d1f64a7f4c0f5eef816d5b4e78568dc3a7254353ab741cdd48057 | 38,538 | [
-1
] |
38,539 | var_lex.cl | hizircanbayram_gLang/lexer/var_lex.cl |
(defparameter *lexTable* ())
(defparameter *cursor* 0)
(defparameter *backward* 0)
(defparameter *lexem* "")
(defparameter *filename*
| 135 | Common Lisp | .cl | 5 | 25.8 | 28 | 0.751938 | hizircanbayram/gLang | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:44:58 AM (Europe/Amsterdam) | 7c41ad902e86377d9c8b5aa322205f3f8095b86323615f5f41d14314f4d088ac | 38,539 | [
-1
] |
38,540 | io_processing.cl | hizircanbayram_gLang/lexer/io_processing.cl |
; It is a simple function for reading from file to string.
(defun fileToString (file-path)
(with-open-file (file-stream file-path)
(let ((content (make-string (file-length file-stream))))
(read-sequence content file-stream)
content)))
; After every state is completed, the computation ends up with a result value that is based on the type of the state. The result value is passed into this
; function as a parameter. While this operation is still on process, one lexem is become ready. Based on the result value, the lexem and its token are paired
; so as to be added into the lexem table. After every lexem is delivered to the lexem table, string that holds the lexem is assigned to null.
(defun printTokens (retVal)
(cond
((eq retVal -1) (push (list "error" *lexem*) *lexTable*)) ; error
((eq retVal 1) (push (list "integer" *lexem*) *lexTable*)) ; int_value
((eq retVal 2) (push (list "identifier" *lexem*) *lexTable*)) ; identifier
((eq retVal 3) (push (list "binary" *lexem*) *lexTable*)) ; binary_t
((eq retVal 4) (push (list "binary" *lexem*) *lexTable*)) ; binary_f
((eq retVal 5) (push (list "keyword" *lexem*) *lexTable*)) ; kw_and
((eq retVal 6) (push (list "keyword" *lexem*) *lexTable*)) ; kw_or
((eq retVal 7) (push (list "keyword" *lexem*) *lexTable*)) ; kw_not
((eq retVal 8) (push (list "keyword" *lexem*) *lexTable*)) ; kw_equal
((eq retVal 9) (push (list "keyword" *lexem*) *lexTable*)) ; kw_append
((eq retVal 10) (push (list "keyword" *lexem*) *lexTable*)) ; kw_concat
((eq retVal 11) (push (list "keyword" *lexem*) *lexTable*)) ; kw_set
((eq retVal 12) (push (list "keyword" *lexem*) *lexTable*)) ; kw_deffun
((eq retVal 13) (push (list "keyword" *lexem*) *lexTable*)) ; kw_for
((eq retVal 14) (push (list "keyword" *lexem*) *lexTable*)) ; kw_while
((eq retVal 15) (push (list "keyword" *lexem*) *lexTable*)) ; kw_if
((eq retVal 16) (push (list "keyword" *lexem*) *lexTable*)) ; kw_exit
((eq retVal 17) (push (list "operator" *lexem*) *lexTable*)) ; op_plus
((eq retVal 18) (push (list "operator" *lexem*) *lexTable*)) ; op_minus
((eq retVal 19) (push (list "operator" *lexem*) *lexTable*)) ; op_div
((eq retVal 20) (push (list "operator" *lexem*) *lexTable*)) ; op_mul
((eq retVal 21) (push (list "operator" *lexem*) *lexTable*)) ; op_open_par
((eq retVal 22) (push (list "operator" *lexem*) *lexTable*)) ; op_fac
((eq retVal 23) (push (list "operator" *lexem*) *lexTable*))) ; op_close_par
(setf *lexem* "")
)
| 2,475 | Common Lisp | .cl | 37 | 64.783784 | 157 | 0.669815 | hizircanbayram/gLang | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:44:58 AM (Europe/Amsterdam) | 78803b7726a2ea5688d17e96756d2ed45d0fafcbcc0e57608db8101b2f954368 | 38,540 | [
-1
] |
38,541 | lex_processing.cl | hizircanbayram_gLang/lexer/lex_processing.cl |
; This function is responsible for controlling one of the states of deterministic finite automata. It checks whether given character that is on process
; is digit or not so as to decide current lexem is integer or not. As long as current element is a digit, the cursor moves forward to determine where the lexem
; stops. The function adds every digit element into the variable called lexem so that lexem can be determined. Any character but digit ends recursion.
(defun isIntValue (str ind)
(if (and (< ind (length str)) (isDigit (schar str ind))) ; identifier'dan sonra gelen karakter ) ise,cursor'i arttirmaki, lex fonk.u kendini cagirdiginda tekrar ) karakterinde baslayip ) karakterini hesaba katsin.
(setf *cursor* (+ 1 *cursor*)))
(if (and (< ind (length str)) (isDigit (schar str ind)) (not (char= #\) (schar str ind))))
(setf *lexem* (concatenate 'string *lexem* (string (schar str ind)))))
(cond
((= (length str) ind) (+ 1 0))
((isDigit (schar str ind)) (isIntValue str (+ 1 ind)))
(t (+ 1 0))))
; This is a sub-state for negative integers' control. What basically does is checking if there is any negative integers starting
; with 0. If it is, returns error. It is also used as a state for generating negative integers. Recursion operations used in this
; state ends with any unintented character for this state(etc. 'a', ' ')
(defun isSS (str ind)
(if (and (< ind (length str)) (isDigit (schar str ind)))
(setf *cursor* (+ 1 *cursor*)))
(if (and (< ind (length str)) (isDigit (schar str ind)))
(setf *lexem* (concatenate 'string *lexem* (string (schar str ind)))))
(cond
((= (length str) ind) (+ 17 1)) ; uzunluk kontrolunun cond'un basinda olmasi elzem.
((isNumber (schar str ind)) (isIntValue str (+ 1 ind)))
((isWhiteSpace (schar str ind)) (+ 17 1))
((not (isAcceptable (schar str ind))) (- 0 1))
(t (+ 17 1))))
; This function is responsible for controlling one of the states of deterministic finite automata. It checks whether given character
; that is on process is alaphabetic or not so as to decide current lexem is identifier or not. As long as current element is an
; alphabetic character, the cursor moves forward to determine where the lexem stops. The function adds every character element into
; the variable called lexem so that lexem can be determined. Any character but character ends recursion.
(defun isId (str ind)
(if (and (< ind (length str)) (alpha-char-p (schar str ind))) ; identifier'dan sonra gelen karakter ) ise,cursor'i arttirmaki, lex fonk.u kendini cagirdiginda tekrar ) karakterinde baslayip ) karakterini hesaba katsin.
(setf *cursor* (+ 1 *cursor*)))
(if (and (< ind (length str)) (alpha-char-p (schar str ind))) ; identifier'dan sonra gelen karakter ) ise,cursor'i arttirmaki, lex fonk.u kendini cagirdiginda tekrar ) karakterinde baslayip ) karakterini hesaba katsin.
(setf *lexem* (concatenate 'string *lexem* (string (schar str ind)))))
(cond
((= (length str) ind) (checkKeywords str ind))
((alpha-char-p (schar str ind)) (isId str (+ 1 ind)))
((not (isAcceptable (schar str ind))) (- 0 1))
(t (checkKeywords str ind))))
; This is another state for keywords and binary values. If any lexem can be classified as identifier, it goes to this state in order
; to determine the lexem can also be classified as either binary value or keyword before it is not classified as identifier. If it is
; it is classified as it has to be, identifier otherwise.
(defun checkKeywords (str endPoint)
(cond
((string= (subseq str *backward* endPoint) "true") (+ 1 2))
((string= (subseq str *backward* endPoint) "false") (+ 1 3))
((string= (subseq str *backward* endPoint) "and") (+ 1 4))
((string= (subseq str *backward* endPoint) "or") (+ 1 5))
((string= (subseq str *backward* endPoint) "not") (+ 1 6))
((string= (subseq str *backward* endPoint) "equal") (+ 1 7))
((string= (subseq str *backward* endPoint) "append") (+ 1 8))
((string= (subseq str *backward* endPoint) "concat") (+ 1 9))
((string= (subseq str *backward* endPoint) "set") (+ 1 10))
((string= (subseq str *backward* endPoint) "deffun") (+ 1 11))
((string= (subseq str *backward* endPoint) "for") (+ 1 12))
((string= (subseq str *backward* endPoint) "while") (+ 1 13))
((string= (subseq str *backward* endPoint) "if") (+ 1 14))
((string= (subseq str *backward* endPoint) "exit") (+ 1 15))
(t (+ 1 1)))) ; keyword'lerden biri degilse Id'dir. Id'nin return value'su da 2'dir
; This is a sub-state for factor operation. If consecutive two '*' characters follow each other, the operations is considered as
; factor operation. This function checks this condition. If there is only one '*' character, it is considered as multiplication.
(defun isMul (str ind)
(if (and (< ind (length str)) (char= #\* (schar str ind)))
(setf *cursor* (+ 1 *cursor*)))
(if (and (< ind (length str)) (char= #\* (schar str ind)))
(setf *lexem* (concatenate 'string *lexem* (string (schar str ind)))))
(cond
((not (char= (schar str ind) #\*)) (+ 19 1))
((char= (schar str ind) #\*) (+ 21 1))))
; This function is the main state of deterministic finite automata. It takes a character and goes to any state that is based on
; the character. This function also skips white-space characters.
(defun lexPrivate (str ind)
(if (and (< ind (length str)) (alpha-char-p (schar str ind)))
(setf *backward* ind))
(setf *cursor* (+ 1 *cursor*))
(if (and (< ind (length str)) (not (isWhiteSpace (schar str ind))))
(setf *lexem* (concatenate 'string *lexem* (string (schar str ind)))))
(cond
((>= ind (length str)) ()) ; index'in string boyutunun disina tasmamasi icin
((isWhiteSpace (schar str ind)) (lexPrivate str (+ 1 ind)))
((isDigit (schar str ind)) (isIntValue str (+ 1 ind)))
((char= (schar str ind) #\-) (isSS str (+ 1 ind)))
((char= (schar str ind) #\+) (+ 16 1))
((char= (schar str ind) #\-) (+ 17 1))
((char= (schar str ind) #\/) (+ 18 1))
((char= (schar str ind) #\*) (isMul str (+ 1 ind)))
((char= (schar str ind) #\() (+ 20 1))
((char= (schar str ind) #\)) (+ 22 1))
((alpha-char-p (schar str ind)) (isId str (+ 1 ind)))
(t (- 0 1))))
; This is a wrapper function for lexPrivate. It gets started the deterministic finite automata.
(defun lex (str)
(if (< *cursor* (length str))
(printTokens (lexPrivate str *cursor*)))
(if (< *cursor* (length str))
(lex str)))
; This is another wrapper function with just one parameter. It takes the input file and creates its lextable.
(defun lexer (str)
(lex (fileToString str))
(setf *lexTable* (reverse *lexTable*)))
| 6,570 | Common Lisp | .cl | 101 | 62.60396 | 220 | 0.686967 | hizircanbayram/gLang | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:44:58 AM (Europe/Amsterdam) | 7b294a619dc9be2ad920b5a105b17fdc9e7c29ba0cfa93854fb80b58204b7ddc | 38,541 | [
-1
] |
38,543 | glang | hizircanbayram_gLang/glang |
if [ -z "$1" ]
then
echo "File name is needed"
else
if [ ${1: -3} == ".gl" ]
then
echo "\"$1\")" >> ~/glang/lexer/var_lex.cl
cat ~/glang/lexer/var_lex.cl >> ~/glang/exe.cl
cat ~/glang/lexer/char_processing.cl >> ~/glang/exe.cl
cat ~/glang/lexer/io_processing.cl >> ~/glang/exe.cl
cat ~/glang/lexer/lex_processing.cl >> ~/glang/exe.cl
cat ~/glang/parser/var_par.cl >> ~/glang/exe.cl
cat ~/glang/parser/helper.cl >> ~/glang/exe.cl
cat ~/glang/parser/query.cl >> ~/glang/exe.cl
cat ~/glang/parser/automata.cl >> ~/glang/exe.cl
cat ~/glang/parser/parse_processing.cl >> ~/glang/exe.cl
cat ~/glang/parser/error_processing.cl >> ~/glang/exe.cl
cat ~/glang/parser/tree_patterns.cl >> ~/glang/exe.cl
cat ~/glang/main.cl >> ~/glang/exe.cl
clisp ~/glang/exe.cl
rm ~/glang/exe.cl
sed -i.bak -e '7d' ~/glang/lexer/var_lex.cl
rm ~/glang/lexer/var_lex.cl.bak
cat ~/glang/parse.tree
rm parse.tree
else
echo "File extension must be [.gl]"
fi
fi
| 980 | Common Lisp | .l | 29 | 31.034483 | 58 | 0.658201 | hizircanbayram/gLang | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:44:58 AM (Europe/Amsterdam) | 51634c22988861881381081d33fcd36fd1b2007806b41b78052f5101132f98d3 | 38,543 | [
-1
] |
38,569 | variables.lisp | MarcelKaemper_lisp/variables.lisp | (setq str "Hello World")
(setq x 12)
(setq y 25)
(setq z (+ x y))
(setq zz (* (+ z x) (- x y)))
(write-line str)
(write z)
(terpri)
(write zz)
(terpri)
| 154 | Common Lisp | .lisp | 10 | 14.2 | 29 | 0.598592 | MarcelKaemper/lisp | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:07 AM (Europe/Amsterdam) | c0c0b3507e6c85b0e46516c086360f40ac4e9f762e6b4fafe41f2507f0d9b1ad | 38,569 | [
-1
] |
38,570 | decisions.lisp | MarcelKaemper_lisp/decisions.lisp | (setq x 20)
(setq y 50)
(if (= x 20)
(write-line "x = 20"))
| 63 | Common Lisp | .lisp | 4 | 14 | 24 | 0.534483 | MarcelKaemper/lisp | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:07 AM (Europe/Amsterdam) | 9a838926f5b1b5ebcc33c592a89f5b054d4eba8fc47b9d416da782a3a8b998ad | 38,570 | [
-1
] |
38,606 | learning-lisp.asd | HOWZ1T_Learning-Lisp/learning-lisp.asd | (defsystem "learning-lisp"
:version "0.0.1"
:author "[email protected]"
:license "GNU GPLv3"
:depends-on ()
:components ((:module "src"
:components ((:module "utils"
:components ((:file "general")))
(:module "db"
:depends-on ("utils")
:components ((:file "db")))
(:file "main"))))
:description "A project playground for learning lisp"
:long-description
#.(read-file-string
(subpathname *load-pathname* "README.md"))
:in-order-to ((test-op (test-op "learning-lisp/tests"))))
(defsystem "learning-lisp/tests"
:author ""
:license ""
:depends-on ("learning-lisp"
"rove")
:components ((:module "tests"
:components
((:file "main"))))
:description "Test system for learning-lisp"
:perform (test-op (op c) (symbol-call :rove :run c)))
| 863 | Common Lisp | .lisp | 27 | 25.925926 | 59 | 0.597122 | HOWZ1T/Learning-Lisp | 0 | 1 | 0 | GPL-3.0 | 9/19/2024, 11:45:07 AM (Europe/Amsterdam) | 230fc9a418ebc9a7d4a191b55bbcfe84db00ef8526e89bb5b7b9f7da093493aa | 38,606 | [
-1
] |
38,607 | general.lisp | HOWZ1T_Learning-Lisp/src/utils/general.lisp | ;;;; This package has general utility functions for doing helpful things in lisp
(defpackage utils
(:use :cl)
(:export :print-globs :input))
(in-package :utils)
;;; PRIVATE FUNCTIONS BELOW
;;; get-globs returns 3 values that being a sorted list of symbols and the largest word size
;;; PARAMETERS:
;;; pkg - the package you're getting the globals for (e.g "SB-EXT")
;;; RETURN:
;;; (funcs: funcs vars: vars word-size: word-size)
(defun get-globs (pkg)
;; ensure pkg is uppercase if it is a string
(if (stringp pkg) (setf pkg (string-upcase pkg)))
(let ((funcs nil)
(vars nil)
(word-size 0))
(do-external-symbols (s (find-package pkg))
(let* ((sym-str (symbol-name s))
(sym-size (length sym-str)))
(if (> sym-size word-size)
(setf word-size sym-size))
(when (fboundp s)
(if s ; if s is not nil
(if (not (member sym-str funcs)) ; if s is not a member of the list, thus ensuring no duplicates
(push sym-str funcs))))
(when (boundp s)
(if s ; if s is not nil
(if (not (member sym-str vars)) ; if s is not a member of the list, thus ensuring no duplicates
(push sym-str vars))))))
(list :funcs (sort funcs #'string-lessp) :vars (sort vars #'string-lessp) :word-size word-size)))
;; print-header will print a nicely formatted section header
;; PARAMETERS:
;; title - the title of the section header
;; width - the total width of the section
;; RETURNS:
;; nil
(defun print-header (title width)
;; see: https://codereview.stackexchange.com/questions/48580/creating-a-repetitive-string-in-common-lisp
;; for explanation of format string
(format t "~%~v@{~A~:*~}" width "*")
(format t "~%~v{~A~:*~}" (- (/ width 2) (/ (length title) 2)) '(" "))
(princ title)
(format t "~%~v@{~A~:*~}" width "*"))
;;; PUBLIC FUNCTIONS BELOW
;;; print-globs will print out all externel symbols of the specified package
;;; PARAMETERS:
;;; pkg - the package you're getting the globals for (e.g "SB-EXT")
;;; RETURNS:
;;; nil
(defun print-globs (pkg)
;; ensure pkg is uppercase if it is a string
(if (stringp pkg) (setf pkg (string-upcase pkg)))
(let (raw-list
funcs
vars
word-size
(min-size 21))
(setf raw-list (get-globs pkg))
(setf funcs (getf raw-list :funcs))
(setf vars (getf raw-list :vars))
(setf word-size (getf raw-list :word-size))
(if (< word-size min-size)
(setf word-size min-size))
;; outputting to stdout
;; printing out global functions
(print-header "FUNCTIONS" word-size)
(if (> (length funcs) 0)
(loop for fn in funcs do
(format t "~%")
(princ fn)) ; princ prints the string in human-readable format without quotes
(progn
(format t "~%")
(princ "NO EXTERNAL FUNCTIONS")))
;; add newline separator to separator the previous section from the next one
(format t "~%")
;; printing out global variables
(print-header "VARIABLES" word-size)
(if (> (length vars) 0)
(loop for vr in vars do
(format t "~%")
(princ vr)) ; princ prints the string in human-readable format without quotes
(progn
(format t "~%")
(princ "NO EXTERNAL VARIABLES")))) nil)
;;; input - prompts the user for input
;;; PARAMETERS:
;;; prompt - the prompt displayed to the user
;;; RETURN:
;;; string - the input from the user as a string
(defun input (prompt)
(format *query-io* "~a: " prompt)
(force-output *query-io*) ;; ensuring that lisp doesn't wait for a newline before printing the prompt
(read-line *query-io*))
| 3,528 | Common Lisp | .lisp | 94 | 34.223404 | 106 | 0.66139 | HOWZ1T/Learning-Lisp | 0 | 1 | 0 | GPL-3.0 | 9/19/2024, 11:45:07 AM (Europe/Amsterdam) | 2b0905a4ba095370479e7fee24c6baf2b50063c977ef16b51fe92c6ef13c29ae | 38,607 | [
-1
] |
38,626 | Ejercicios Paquete #3.lisp | JRobertGit_AI-19/Lisp Practices/Ejercicios Paquete #3.lisp | ;; José Roberto Torres Mancilla
;; Paquete #3 de ejercicios (estructuras algorítmicas)
;; 1) [sin usar ELT ni POSITION] Defina una función ElemInPos que reciba tres argumentos: elem,
;; lista y pos. La función debe devolver T si elem está en la posición pos de lista, NIL si no
;; lo está.
;; Answer... assuming position starts in 1
(defun elemInPos (elem list pos)
(cond ((null list) NIL)
((eql 1 pos) (eql elem (first list)))
(T (elemInPos elem (rest list) (1- pos)))))
;; Test
(print (elemInPos 4 '() 2)) ;; => NIL
(print (elemInPos 1 '(1 4 3 2) 1)) ;; => T
(print (elemInPos 4 '(1 2 3 4) 2)) ;; => NIL
(print (elemInPos T '(1 T 3 2) 2)) ;; => T
(print (elemInPos '() '(1 T 3 NIL) 4)) ;; => T
(print "================================================")
;; 2) Escriba la función Inicio-en que recibe como argumentos una lista y un elemento cualquiera. La
;; función debe entregar como respuesta una copia de la lista original pero comenzando con la
;; primera ocurrencia del elemento dado en la lista original.
;; Answer:
(defun startsWith (list elem)
(cond ((null list) NIL)
((equal elem (first list)) list)
(T (startsWith (rest list) elem))))
;; Test:
(print (startsWith '(1 2 3 4 5) 4)) ;; => (4 5)
(print (startsWith '(a b c d r) 'd)) ;; => (D R)
(print (startsWith '(1 2 T 4 5) T)) ;; => (T 4 5)
(print (startsWith '((c) (a) (f) 4 5) '(f))) ;; => ((F) 4 5)
(print (startsWith '(1 2 3 4 NIL) NIL)) ;; => (NIL)
(print (startsWith '(1 2 3 "a" 5) "a")) ;; => ("a" 5)
(print "================================================")
;; 3) Modifique la función del ejercicio anterior para que se llame Termina-en y entregue como
;; respuesta una copia de la lista original pero que termina en la última ocurrencia del elemento
;; dado
;; Answer:
(defun endsWithAux (list elem)
(cond ((null list) NIL)
((equal elem (first list)) list)
(T (endsWithAux (rest list) elem))))
(defun endsWith (list elem)
(reverse (endsWithAux (reverse list) elem))
)
;; Test:
(print (endsWith '(1 2 4 3 4 5) 4)) ;; => (1 2 4 3 4)
(print (endsWith '(a d b c d r) 'd)) ;; => (A D B C D)
(print (endsWith '(1 T T 2 T 4 5) T)) ;; => (1 T T 2 T)
(print (endsWith '((f) (c) (a) 4 (f) 4 5) '(f)));; => ((F) (C) (A) 4 (F))
(print (endsWith '(() 1 2 3 4 ()) '(a))) ;; => NIL
(print (endsWith '("a" 1 2 3 "a" 5) "a")) ;; => ("a" 1 2 3 "a")
(print "================================================")
;; 4) Construya una función Primer-impar que reciba como argumento una lista y como respuesta
;; entregue otra lista conteniendo el primer elemento de la lista original que sea un número impar
;; y la posición (índice) donde se encuentra. Observe que los elementos de la lista pueden ser de
;; cualquier tipo de datos.
;;Answer:
(defun firstOddAux (list index)
(let ((current (first list)))
(cond ((null list) NIL)
((and (numberp current) (not (zerop (mod current 2)))) (list current index))
(T (firstOddAux (rest list) (1+ index))))))
(defun firstOdd (list)
(firstOddAux list 0))
;; Test
(print (firstOdd '(2 4 8 7 6))) ;; => (7 3)
(print (firstOdd '(2 4 8 10 6))) ;; => NIL
(print (firstOdd '(T 4 "a" NIL 3 6))) ;; => (3 4)
(print (firstOdd '(20 4 a 19 ()))) ;; => (19 3)
(print (firstOdd '((2 7) 5 b 6))) ;; => (5 1)
(print "================================================")
;; 5) Modifique la función del inciso anterior para que entregue en la lista de respuesta el último
;; elemento de la lista que sea un número real mayor o igual que cero y el número de veces que
;; dicho elemento se repite en toda la lista.
;; Answer:
(defun lastReal (list)
(cond ((null list) NIL)
(T (let ((current (first list))
(next (lastReal (rest list))))
(if (null next)
(if (and (realp current) (<= 0 current))
(list current 1)
NIL)
(if (eql current (first next))
(list current (1+ (second next)))
next))))))
;; Test:
(print (lastReal '(T T T 3 T T 6 T T T 6 T))) ;; => (6 2)
(print (lastReal '(T T T NIL T T NIL T T T NIL T))) ;; => NIL
(print (lastReal '(5.1 T 5 a () "a" 2/3 0.1 3.2 5.1 7 5.1)));; => (5.1 3)
(print (lastReal '(a s r T g h v s q 5 y u j))) ;; => (5 1)
(print "================================================")
;; 6) Escriba la función Conteo que recibe como argumento una lista cualquiera y, como respuesta,
;; entregue una celda de construcción cuya primera parte contiene el conteo de elementos
;; numéricos de la lista original y cuya segunda parte contiene el conteo de sublistas contenidas en
;; la lista original.
;; Answer:
(defun counting (list)
(cond ((null list) (cons 0 0))
(T (let ((current (first list))
(next (counting (rest list))))
(cond ((numberp current) (cons (1+ (first next)) (rest next)))
((listp current) (cons (first next) (1+ (rest next))))
(T next))))))
;; Test:
(print (counting '(1 2 3 4 (a) (b c)))) ;; => (4 . 2)
(print (counting '(T T a a T T))) ;; => (0 . 0)
(print (counting '(NIL NIL NIL))) ;; => (0 . 3)
(print (counting '(1 2 3 4 (a) (b) (c)))) ;; => (4 . 3)
(print (counting '(1 2 3 4))) ;; => (4 . 0)
(print "================================================")
;; 7) Defina una función Aplana que reciba como argumento una lista con elementos anidados a
;; cualquier nivel de profundidad y, como respuesta, entregue una lista conteniendo los mismos
;; elementos pero todos ellos al nivel principal de profundidad.
;; Answer:
(defun flatten (list)
(let ((current (first list))
(left (rest list)))
(cond ((null list) NIL)
((listp current) (append (flatten current) (flatten left)))
(T (append (list current) (flatten left))))))
;; Tests:
(print (flatten '(1 b c (a (b) c)))) ;; => (1 B C A B C)
(print (flatten '((4) () T (c) (a (b) c)))) ;; => (4 T C A B C)
(print (flatten '(0 (b) 1.2 (4 (T) 3/2)))) ;; => (0 B 1.2 4 T 3/2)
(print (flatten '(2 T NIL (((h)) (y) bc)))) ;; => (2 T H Y BC)
(print "================================================")
;; 8) Escriba la función Diagonal que recibe como argumento una lista conteniendo m sub-listas de
;; m elementos cada una de ellas y que representa una matriz de m x m elementos. Como
;; respuesta, esta función debe devolver una lista conteniendo los elementos en la diagonal principal
;; de dicha matriz. Observe que los elementos de la matriz pueden ser de cualquier tipo de datos, no
;; forzosamente numéricos.
;; Answer:
(defun diagonalAux (list index)
(let ((current (nth index (first list)))
(left (rest list)))
(cond ((null list) NIL)
((null left) (list current))
(T (cons current (diagonalAux left (1+ index)))))))
(defun diagonal (list)
(diagonalAux list 0))
;; Test:
(print (diagonal '((1 0) (0 1)))) ;; => (1 1)
(print (diagonal '((1 0 0) (0 1 0) (0 0 1)))) ;; => (1 1 1)
(print (diagonal '((4 0 6) (1 79 6) (7 8 0.1)))) ;; => (4 79 0.1)
(print (diagonal '((T NIL a) (9.7 "a" p) (3/4 T ())))) ;; => (T "a" NIL)
(print (diagonal '())) ;; => NIL
(print (diagonal '((T)))) ;; => (T)
(print "================================================")
;; 9) Construya una función que reciba como argumento una lista cualquiera y, como respuesta,
;; entregue una lista, con el mismo número de elementos de primer nivel, pero que contiene un
;; símbolo A si el elemento en la posición correspondiente es un átomo, un símbolo L si el
;; elemento correspondiente es una lista y un símbolo N si el elemento en la posición
;; correspondiente es una lista vacía.
;; Answer
(defun listTypes (list)
(let ((current (first list)))
(cond ((null list) NIL)
((null current) (cons 'N (listTypes (rest list))))
((atom current) (cons 'A (listTypes (rest list))))
((listp current) (cons 'L (listTypes (rest list)))))))
;; Test:
(print (listTypes '(1 T NIL '() "a" ()))) ;; => (A A N L A N)
(print (listTypes '(T T NIL NIL '() "a"))) ;; => (A A N N L A)
(print (listTypes '(z NIL b a "a" '()))) ;; => (A N A A A L)
(print (listTypes '((a) (n) NIL (a) "a" T)));; => (L L N L A A)
(print (listTypes '())) ;; => NIL
(print "================================================")
;; 10) Defina la función Suma-numérica que recibe como argumento una lista cualquiera (no
;; anidada), y como respuesta entrega la suma de exclusivamente aquellos elementos de la lista que
;; son numéricos.
;; Answer
(defun numberSum (list)
(let ((current (first list)))
(cond ((null list) 0)
((numberp current) (+ current (numberSum (rest list))))
(T (numberSum (rest list))))))
;; Test:
(print (numberSum '(1 2 3 4 5))); ;; => 15
(print (numberSum '(a b c d e))); ;; => 0
(print (numberSum '(1/2 2.3 3 T ()))); ;; => 5.8
(print (numberSum '(1 "a" 3.3 NIL '()))); ;; => 4.3
(print (numberSum '())) ;; => 0
(print "================================================")
;; 11) Escriba una función Filtra-vocales que reciba como argumento una lista (con elementos de
;; cualquier tipo y anidada a cualquier nivel de profundidad) y, como respuesta entregue una copia
;; de la lista argumento en la cual se han removido las letras vocales (tanto mayúsculas como
;; minúsculas).
;; Answer: A simbol is not a vowel
(defun vocal? (current)
(or (equal current #\a)
(equal current #\e)
(equal current #\i)
(equal current #\o)
(equal current #\u)
(equal current #\A)
(equal current #\E)
(equal current #\I)
(equal current #\O)
(equal current #\U)
(equal current "a")
(equal current "e")
(equal current "i")
(equal current "o")
(equal current "u")
(equal current "A")
(equal current "E")
(equal current "I")
(equal current "O")
(equal current "U")))
(defun vowelsFilter (list)
(let ((current (first list))
(left (rest list)))
(cond ((null list) NIL)
((listp current) (append (vowelsFilter current) (vowelsFilter left)))
((not (vocal? current)) (append (list current) (vowelsFilter left)))
(T (vowelsFilter left)))))
;; Tests:
(print (vowelsFilter '(1 "a" c (a (#\a) #\c)))) ;; => (1 C A #\c)
(print (vowelsFilter '((4) (#\c) T ("b") (a (b) c))));; => (4 #\c T "b" A B C)
(print (vowelsFilter '(0 #\a (b) 1.2 (4 ("u") 3/2))));; => (0 B 1.2 4 3/2)
(print (vowelsFilter '(2 T "e" ((("o")) ("i") bc)))) ;; => (2 T BC)
(print "================================================")
;; 12) Construya una función Filtra-múltiplos que reciba como argumentos una lista y un número
;; entero. Como respuesta debe entregar una copia de la lista argumento en la cual se han removido
;; todos los múltiplos del entero recibido.
;; Answer:
(defun multiplesFilter (list n)
(let ((current (first list)))
(cond ((null list) NIL)
((or (not (numberp current)) (not (zerop (mod current n))))
(cons current (multiplesFilter (rest list) n)))
(T (multiplesFilter (rest list) n)))))
;; Tests:
(print (multiplesFilter '(1 2 3 4 5 6 7 8) 2)) ;; => (1 3 5 7)
(print (multiplesFilter '(a v b 3 T 5 6 NIL 8) 3)) ;; => (A V B T 5 NIL 8)
(print (multiplesFilter '("a" 2 "b" 4 '() 6 7 8) 2));; => ("a" "b" NIL 7)
(print (multiplesFilter '() 2)) ;; => NIL
(print "================================================")
;; 13) Defina la función Celdas que recibe como argumento una lista (con elementos de cualquier tipo
;; y anidada a cualquier nivel de profundidad) y, como respuesta entrega el número de celdas de
;; construcción que contiene la representación interna de la lista argumento.
;; Answer;
;; Each element on the list counts as 1 construction cell
(defun cellNum (list)
(cond ((null list) 0)
((listp (first list)) (+ 1 (cellNum (first list)) (cellNum (rest list))))
(T (+ 1 (cellNum (rest list))))))
;; Tests:
(print (cellNum '(a b (a b) (a) d e (b)))) ;; => 11
(print (cellNum '(a b a b a d e b))) ;; => 8
(print (cellNum '(NIL T (a b) ("a") 4 5 (b (((NIL)))))));; => 15
(print (cellNum '(a b (a b) (a) ((())) T (b)))) ;; => 13
(print "================================================")
;; 14) Construya una función Implica con aridad indeterminada, que implemente el operador lógico de
;; la implicación.
;; Answer:
(defun impliesAux (val list)
(cond ((null list) NIL)
((null (rest list)) (or (not val) (first list)))
(T (impliesAux (or (not val) (first list)) (rest list)))))
(defun implies (&rest list)
(impliesAux T list))
;; Tests:
(print (implies T T NIL)) ;; NIL
(print (implies T NIL NIL)) ;; T
(print (implies T T T)) ;; T
(print (implies NIL T T)) ;; T
(print (implies NIL NIL NIL)) ;; NIL
(print (implies NIL)) ;; NIL
(print (implies T)) ;; T
(print (implies)) ;; NIL
(print "================================================")
;; 15) Escriba una función Mult que recibe como argumento dos listas, conteniendo sub-listas
;; numéricas, representando matrices. La función debe regresar la multiplicación de las dos
;; matrices si es que éstas son compatibles, en caso de no serlo debe regresar NIL.
;; Answer:
(defun transpose (matrix)
(apply #'mapcar #'list matrix))
(defun sum (list)
(cond ((null list) 0)
(T (+ (first list) (sum (rest list))))))
(defun multiply (matrix)
(sum (apply #'mapcar #'* matrix)))
(defun multiplyVectors (list1 list2)
(multiply (append list1 list2)))
(defun multiplyMatrixAux (matrix1 matrix2)
(cond ((and (= 1 (length matrix1)) (= 1 (length matrix2)))
(multiplyVectors matrix1 matrix2))
((and (= 1 (length matrix1)) (< 1 (length matrix2)))
(cons (multiplyMatrixAux matrix1 (list (first matrix2))) (multiplyMatrixAux matrix1 (rest matrix2))))
((< 1 (length matrix1))
(list (multiplyMatrixAux (list (first matrix1)) matrix2) (multiplyMatrixAux (rest matrix1) matrix2)))))
(defun multiplyMatrix (matrix1 matrix2)
(let ((matrix2t (transpose matrix2)))
(if (= (length matrix1) (length matrix2t)) (multiplyMatrixAux matrix1 matrix2t) NIL)))
(print (multiplyMatrix '((1 2)(3 4)) '((1 2)(3 4)))) ;; => ((7 10) (15 22))
(print (multiplyMatrix '((3 2)(1 6)) '((1 2)(3 4)))) ;; => ((9 14) (19 26))
(print (multiplyMatrix '((10 12)(9 7)) '((1 2)(3 4)))) ;; => ((46 68) (30 46))
(print (multiplyMatrix '((1 5 2)(3 5 4)(1 7 2)) '((3 5 4)(1 7 2)(3 7 4)))) ;; => ((14 54 22) (26 78 38) (16 68 26))
(print "================================================")
;; 16) Defina una función recursiva Find que reciba dos argumentos: elem y lista.
;; La función debe devolver NIL si elem no es un elemento de lista, de lo contrario,
;; deberá devolver la sublista que comienza con la primera instancia de elem.
;; Answer:
(defun myFind (list elem)
(cond ((null list) NIL)
((equal elem (first list)) list)
(T (myFind (rest list) elem))))
;; Test:
(print (myFind '(1 2 3 4 5) 4)) ;; => (4 5)
(print (myFind '(a b c d r) 'd)) ;; => (D R)
(print (myFind '(1 2 T 4 5) T)) ;; => (T 4 5)
(print (myFind '((c) (a) (f) 4 5) '(f))) ;; => ((F) 4 5)
(print (myFind '(1 2 3 4 NIL) NIL)) ;; => (NIL)
(print (myFind '(1 2 3 "a" 5) "a")) ;; => ("a" 5)
(print "================================================")
;; 17) Defina una función recursiva Cambia que reciba como argumento una lista y dos
;; elementos elem1, elem2. Como respuesta, la función debe entregar otra lista
;; parecida a la original, pero donde todas las ocurrecias de elem1 se sustituyeron por elem2.
;; Answer:
(defun change (list elem1 elem2)
(let ((current (first list)))
(cond ((null list ) NIL)
((equal current elem1) (cons elem2 (change (rest list) elem1 elem2)))
(T (cons current (change (rest list) elem1 elem2))))))
;; Tests:
(print (change '(1 1 1 1 1 1 1) 1 2)) ;; => (2 2 2 2 2 2 2)
(print (change '() 1 2)) ;; => NIL
(print (change '(1 1 1) 2 3)) ;; => (1 1 1)
(print (change '(1 2 2 2 4 4 4 2 2 2 1 1 1) 2 3)) ;; => (1 3 3 3 4 4 4 3 3 3 1 1 1)
;; 18) En el URL http://www.cliki.net/fibonacci se presentan diversas implementaciones
;; para los números de Fibonacci. Implemente TODAS las opciones que ahí se presentan
;; y compare su desempeño com time para el argumento 50.
;; 18.1)
;; Naive recursive computation of the nth element of the Fibonacci sequence
(defun fib (n)
(if (< n 2) n
(+ (fib (1- n)) (fib (- n 2)))))
(time (fib 50))
;; Real time: 5,08 sec.
;; Run time: 5.08 sec.
;; Space: 5 Mb
;; 18.2)
;; Tail-recursive computation of the nth element of the Fibonacci sequence
(defun fib (n)
(labels ((fib-aux (n f1 f2)
(if (zerop n) f1
(fib-aux (1- n) f2 (+ f1 f2)))))
(fib-aux n 0 1)))
(time (fib 50))
;; Real time: 3.03E-4 sec.
;; Run time: 0.001 sec.
;; Space: 600 Bytes
;; 18.3)
;; loop-based iterative computation of the nth element of the Fibonacci sequence
(defun fib (n)
(loop for f1 = 0 then f2
and f2 = 1 then (+ f1 f2)
repeat n finally (return f1)))
(time (fib 50))
;; Real time: 7.8E-5 sec.
;; Run time: 7.4E-5 sec.
;; Space: 0 Bytes
;; 18.4)
;; do-based iterative computation of the nth element of the Fibonacci sequence
(defun fib (n)
(do ((i n (1- i))
(f1 0 f2)
(f2 1 (+ f1 f2)))
((= i 0) f1)))
(time (fib 50))
;; Real time: 7.6E-5 sec.
;; Run time: 0.0 sec.
;; Space: 0 Bytes
;; 18.5)
;; CPS computation of the nth element of the Fibonacci sequence
(defun fib (n)
(labels ((fib-aux (n k)
(if (zerop n)
(funcall k 0 1)
(fib-aux (1- n) (lambda (x y)
(funcall k y (+ x y)))))))
(fib-aux n #'(lambda (a b) a))))
(time (fib 50))
;; Real time: 2.31E-4 sec.
;; Run time: 0.0 sec.
;; Space: 27008 Bytes
;; 18.6)
(defun fib (n)
(labels ((fib2 (n)
(cond ((= n 0)
(values 1 0))
(T (multiple-value-bind (val prev-val)
(fib2 (- n 1))
(values (+ val prev-val)
val))))))
(nth-value 0 (fib2 n))))
(time (fib 50))
;; Real time: 1.02E-4 sec.
;; Run time: 0.0 sec.
;; Space: 488 Bytes
;; 18.7)
;; Successive squaring method from SICP
(defun fib (n)
(labels ((fib-aux (a b p q count)
(cond ((= count 0) b)
((evenp count)
(fib-aux a b (+ (* p p) (* q q)) (+ (* q q) (* 2 p q)) (/ count 2)))
(T (fib-aux (+ (* b q) (* a q) (* a p)) (+ (* b p) (* a q)) p q (- count 1))))))
(fib-aux 1 0 0 1 n)))
(time (fib 50))
;; Real time: 3.6E-5 sec.
;; Run time: 0.0 sec.
;; Space: 720 Bytes
;; 18.8)
(defun fib (n)
(if (< n 2) n
(if (oddp n)
(let ((k (/ (1+ n) 2)))
(+ (expt (fib k) 2) (expt (fib (1- k)) 2)))
(let* ((k (/ n 2)) (fk (fib k)))
(* (+ (* 2 (fib (1- k))) fk) fk)))))
(time (fib 10))
;; Real time: 4.3E-5 sec.
;; Run time: 4.0E-5 sec.
;; Space: 0 Bytes
;; 18.9)
; Taken from Winston's Lisp, 3rd edition, this is a tail-recursive version, w/o an auxiliary function
(defun fib (n &optional (i 1) (previous-month 0) (this-month 1))
(if (<= n i)
this-month
(fib n (+ 1 i) this-month (+ this-month previous-month))))
(time (fib 50))
;; Real time: 6.8E-5 sec.
;; Run time: 0.0 sec.
;; Space: 0 Bytes
;; 18.10)
;;;Original code by Arnold Schoenhage,
;;;translated to Scheme by Bradley J. Lucier (2004),
;;;and adapted to Common Lisp by Nicolas Neuss.
(defun fast-fib-pair (n)
"Returns f_n f_{n+1}."
(case n
((0) (values 0 1))
((1) (values 1 1))
(T (let ((m (floor n 2)))
(multiple-value-bind (f_m f_m+1)
(fast-fib-pair m)
(let ((f_m^2 (* f_m f_m))
(f_m+1^2 (* f_m+1 f_m+1)))
(if (evenp n)
(values (- (* 2 f_m+1^2) (* 3 f_m^2) (if (oddp m) -2 2)) (+ f_m^2 f_m+1^2))
(values (+ f_m^2 f_m+1^2) (- (* 3 f_m+1^2) (* 2 f_m^2) (if (oddp m) -2 2))))))))))
(times (fib 50))
;; Real time: 0.002773 sec.
;; Run time: 0.002774 sec.
;; Space: 61568 Bytes
;; 18.11)
;; Fibonacci - Binet's Formula
(defun fib (n)
(* (/ 1 (sqrt 5))
(- (expt (/ (+ 1 (sqrt 5)) 2) n)
(expt (/ (- 1 (sqrt 5)) 2) n))))
(times (fib 50))
;; Real time: 3.0E-5 sec.
;; Run time: 0.0 sec.
;; Space: 0 Bytes
;; 18.12)
(defun fib (n)
(/ (- (expt (/ (+ 1 (sqrt 5)) 2) n)
(expt (/ (- 1 (sqrt 5)) 2) n))
(sqrt 5)))
(times (fib 50))
;; Real time: 4.6E-5 sec.
;; Run time: 0.0 sec.
;; Space: 0 Bytes
;; 19) Defina una función recursive Mapea que opere exactamente igual que la función
;; mapcar de Common Lisp
;; Answer
(defun mapTo (function list)
(cond ((null list) NIL)
(T (cons (apply function (list (first list))) (mapTo function (rest list))))
)
)
;; Tests:
(print (mapTo #'1+ '(1 2 3) )) ;; => (2 3 4)
(print (mapTo #'list '(1 2 3) )) ;; => ((1) (2) (3))
(print (mapTo #'(lambda (x) (cons x (1- x))) '(1 2 3) ));; => ((1 . 0) (2 . 1) (3 . 2))
(print (mapTo #'(lambda (x) (* 2 x)) '(1 2 3) )) ;; => (2 4 6)
;; 20) Defina una función Aplana que reciba como argumento una lista con elementos anidados a
;; cualquier nivel de profundidad y, como respuesta, entregue una lista conteniendo los mismos
;; elementos pero todos ellos al nivel principal de profundidad.
;; Answer:
(defun flatten (list)
(let ((current (first list))
(left (rest list)))
(cond ((null list) NIL)
((listp current) (append (flatten current) (flatten left)))
(T (append (list current) (flatten left))))))
;; Tests:
(print (flatten '(1 b c (a (b) c)))) ;; => (1 B C A B C)
(print (flatten '((4) () T (c) (a (b) c)))) ;; => (4 T C A B C)
(print (flatten '(0 (b) 1.2 (4 (T) 3/2)))) ;; => (0 B 1.2 4 T 3/2)
(print (flatten '(2 T NIL (((h)) (y) bc)))) ;; => (2 T H Y BC)
(print "================================================")
;; 21) Defina una función recursiva Elimina que reciba como argumentos una lista y un
;; número real n. La función debe entregar como resultado una copia de la lista original,
;; en la cual se hayan eliminado todos los elementos que no sean numéricos, así como
;; todos aquellos elementos numéricos que sean menores o iguales que n.
;; Answer:
(defun myDelete (list n)
(let ((current (first list)))
(cond ((null list) NIL)
((and (numberp current) (< n current)) (cons current (myDelete (rest list) n)))
(T (myDelete (rest list) n))
)))
;; Tests:
(print (myDelete '(1 1 1 1 1) 2)) ;; => NIL
(print (myDelete '(a b T 1 10 60 3.2) 5)) ;; => (10 60)
(print (myDelete '(5.2 40 T () NIL T a "b") 4)) ;; => (5.2 40)
(print (myDelete '() 1)) ;; => NIL
;; 22) Defina una función recursiva PegaYCambia que reciba como argumento dos listas
;; lista1 lista2 y dos elementos elem1, elem2. Como respuesta, la función debe
;;entregar una lista donde concatene las dos listas originales, pero substituyendo todas
;; las ocurrencias (en ambas listas) de elem1 por elem2.
;; Answer:
(defun pasteAndChange (list1 list2 elem1 elem2)
(let ((current (first list1))
(left (rest list1)))
(cond ((and (null list1) (null list2)) NIL)
((null list1) (pasteAndChange list2 NIL elem1 elem2))
((equal current elem1) (cons elem2 (pasteAndChange left list2 elem1 elem2)))
(T (cons current (pasteAndChange left list2 elem1 elem2)))
)
)
)
;; Tests:
(print (pasteAndChange '() '() 1 2)) ;; => NIL
(print (pasteAndChange '(NIL) '(NIL 1) 1 2)) ;; => (NIL NIL 2)
(print (pasteAndChange '(1 2 3 4 1 1 1) '(2 3 4 1) 1 2)) ;; => (2 2 3 4 2 2 2 2 3 4 2)
(print (pasteAndChange '(NIL NIL () () T) '(T T T NIL) NIL 'true)) ;; => (TRUE TRUE TRUE TRUE T T T T TRUE)
;; 23) Defina una función QSort que reciba como argumento único una lista e
;; implemente con ellos el algoritmo de ordenamiento Quick Sort, ignorando por
;; completo aquellos elementos de la lista que no sean numéricos. La respuesta
;; de la función debe ser una lista con los elementos numéricos de la original ordenados
;; de forma ascendente.
;; Answer:
(defun filter (list)
(cond ((null list) NIL)
((numberp (first list)) (cons (first list) (filter (rest list))))
(T (filter (rest list)))
)
)
(defun QSortAux (list)
(if (<= (length list) 1)
list
(let ((pivot (first list)))
(append (QSortAux (remove-if-not #'(lambda (x) (< x pivot)) list))
(remove-if-not #'(lambda (x) (= x pivot)) list)
(QSortAux (remove-if-not #'(lambda (x) (> x pivot)) list))))
)
)
(defun QSort (list)
(QSortAux (filter list))
)
;; Test:
(print (QSort '())) ;; => NIL
(print (QSort '(3 4 1 a 5 T 6 "b"))) ;; => (1 3 4 5 6)
(print (QSort '(4 4 1 a 5 T 6.9 NIL 1 8))) ;; => (1 1 4 4 5 6.9 8)
(print (QSort '(9 4 1 a 5 T 6.7 "v" NIL 8)));; => (1 4 5 6.7 8 9)
(print (QSort '(9 10 1 a 5 T 0 () 1))) ;; => (0 1 1 5 9 10)
| 25,874 | Common Lisp | .lisp | 572 | 40.991259 | 116 | 0.552085 | JRobertGit/AI-19 | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:07 AM (Europe/Amsterdam) | 00677f3a1725e357cd16d65f643a5ba4f4ada7a07f4f033f89d2394de6db84ff | 38,626 | [
-1
] |
38,627 | Ejercicios Paquete #2.lisp | JRobertGit_AI-19/Lisp Practices/Ejercicios Paquete #2.lisp | ;; José Roberto Torres Mancilla
;; Paquete #2 de ejercicios (estructuras algorítmicas)
;; 1) [sin usar ELT ni POSITION] Defina una función ElemInPos que reciba tres argumentos: elem,
;; lista y pos. La función debe devolver T si elem está en la posición pos de lista, NIL si no
;; lo está.
;; Answer... assuming position starts in 1
(defun elemInPos (elem list pos)
(dotimes (i (1- pos) (eql elem (first list)))
(setq list (rest list))
)
)
;; Test
(print (elemInPos 4 '() 2)) ;; => NIL
(print (elemInPos 1 '(1 4 3 2) 1)) ;; => T
(print (elemInPos 4 '(1 2 3 4) 2)) ;; => NIL
(print (elemInPos T '(1 T 3 2) 2)) ;; => T
(print (elemInPos '() '(1 T 3 NIL) 4)) ;; => T
(print "================================================")
;; 2) Escriba la función Inicio-en que recibe como argumentos una lista y un elemento cualquiera. La
;; función debe entregar como respuesta una copia de la lista original pero comenzando con la
;; primera ocurrencia del elemento dado en la lista original.
;; Answer:
(defun startsWith (list elem)
(let ((found? NIL)
(result '()))
(dolist (e list result)
(when (equal e elem) (setq found? T))
(if found? (setq result (append result (list e))))
)
)
)
;; Test:
(print (startsWith '(1 2 3 4 5) 4)) ;; => (4 5)
(print (startsWith '(a b c d r) 'd)) ;; => (D R)
(print (startsWith '(1 2 T 4 5) T)) ;; => (T 4 5)
(print (startsWith '((c) (a) (f) 4 5) '(f))) ;; => ((F) 4 5)
(print (startsWith '(1 2 3 4 NIL) NIL)) ;; => (NIL)
(print (startsWith '(1 2 3 "a" 5) "a")) ;; => ("a" 5)
(print "================================================")
;; 3) Modifique la función del ejercicio anterior para que se llame Termina-en y entregue como
;; respuesta una copia de la lista original pero que termina en la última ocurrencia del elemento
;; dado
;; Answer:
(defun endsWith (list elem)
(let ((result '())
(last NIL))
(dolist (e (reverse list) (append (reverse result) (list last)))
(if (or (not (equal e elem)) (not (null last)))
(setq result (append result (list e)))
(setq last e)
)
)
)
)
;; Test:
(print (endsWith '(1 2 4 3 4 5) 4)) ;; => (1 2 4 3 5 4)
(print (endsWith '(a d b c d r) 'd)) ;; => (A D B C R D)
(print (endsWith '(1 T T 2 T 4 5) T)) ;; => (1 T T 2 4 5 T)
(print (endsWith '((f) (c) (a) 4 (f) 4 5) '(f)));; => ((F) (C) (A) 4 4 5 (F))
(print (endsWith '(() 1 2 3 4 ()) '(a))) ;; => (NIL 1 2 3 4 NIL NIL)
(print (endsWith '("a" 1 2 3 "a" 5) "a")) ;; => ((NIL 1 2 3 4 NIL NIL))
(print "================================================")
;; 4) Construya una función Primer-impar que reciba como argumento una lista y como respuesta
;; entregue otra lista conteniendo el primer elemento de la lista original que sea un número impar
;; y la posición (índice) donde se encuentra. Observe que los elementos de la lista pueden ser de
;; cualquier tipo de datos.
;;Answer:
(defun firstOdd (list)
(do ((copy list (rest copy))
(index 0 (1+ index)))
((or (and (integerp (first copy)) (not (zerop (mod (first copy) 2))))
(= index (length list)))
(if (not (= index (length list)))
(list (first copy) index)))
)
)
;; Test
(print (firstOdd '(2 4 8 7 6))) ;; => (7 3)
(print (firstOdd '(2 4 8 10 6))) ;; => NIL
(print (firstOdd '(T 4 "a" NIL 3 6))) ;; => (3 4)
(print (firstOdd '(20 4 a 19 ()))) ;; => (19 3)
(print (firstOdd '((2 7) 5 b 6))) ;; => (5 1)
(print "================================================")
;; 5) Modifique la función del inciso anterior para que entregue en la lista de respuesta el último
;; elemento de la lista que sea un número real mayor o igual que cero y el número de veces que
;; dicho elemento se repite en toda la lista.
;; Answer:
(defun lastReal (list)
(let ((real NIL) (count 0))
(dolist (i (reverse list) (if (not (null real)) (list real count)))
(if (and (null real) (realp i))
(setq real i)
)
(if (and (not (null real)) (eql i real))
(setq count (1+ count))
)
)
)
)
;; Test:
(print (lastReal '(T T T 3 T T 6 T T T 6 T))) ;; => (6 2)
(print (lastReal '(T T T NIL T T NIL T T T NIL T))) ;; => NIL
(print (lastReal '(5.1 T 5 a () "a" 2/3 0.1 3.2 5.1 7 5.1)));; => (5.1 3)
(print (lastReal '(a s r T g h v s q 5 y u j))) ;; => (5 1)
(print "================================================")
;; 6) Escriba la función Conteo que recibe como argumento una lista cualquiera y, como respuesta,
;; entregue una celda de construcción cuya primera parte contiene el conteo de elementos
;; numéricos de la lista original y cuya segunda parte contiene el conteo de sublistas contenidas en
;; la lista original.
;; Answer:
(defun counting (list)
(let ((numbers 0) (sublists 0))
(dolist (i list (cons numbers sublists))
(if (numberp i) (setq numbers (1+ numbers)))
(if (listp i) (setq sublists (1+ sublists)))
)
)
)
;; Test:
(print (counting '(1 2 3 4 (a) (b c)))) ;; => (4 . 2)
(print (counting '(T T a a T T))) ;; => (0 . 0)
(print (counting '(NIL NIL NIL))) ;; => (0 . 3)
(print (counting '(1 2 3 4 (a) (b) (c)))) ;; => (4 . 3)
(print (counting '(1 2 3 4))) ;; => (4 . 0)
(print "================================================")
;; 7) Defina una función Aplana que reciba como argumento una lista con elementos anidados a
;; cualquier nivel de profundidad y, como respuesta, entregue una lista conteniendo los mismos
;; elementos pero todos ellos al nivel principal de profundidad.
;; Answer:
(defun flatten (list)
(let ((result '()))
(do ((current (pop list) (pop list)))
((and (null current) (null list)) result)
(if (listp current)
(setq list (append current list))
(setq result (append result (list current)))))))
;; Tests:
(print (flatten '(1 b c (a (b) c)))) ;; => (1 B C A B C)
(print (flatten '((4) () T (c) (a (b) c)))) ;; => (4 T C A B C)
(print (flatten '(0 (b) 1.2 (4 (T) 3/2)))) ;; => (0 B 1.2 4 T 3/2)
(print (flatten '(2 T NIL (((h)) (y) bc)))) ;; => (2 T H Y BC)
(print "================================================")
;; 8) Escriba la función Diagonal que recibe como argumento una lista conteniendo m sub-listas de
;; m elementos cada una de ellas y que representa una matriz de m x m elementos. Como
;; respuesta, esta función debe devolver una lista conteniendo los elementos en la diagonal principal
;; de dicha matriz. Observe que los elementos de la matriz pueden ser de cualquier tipo de datos, no
;; forzosamente numéricos.
;; Answer:
(defun diagonal (list)
(loop for i from 0 to (1- (length list)) collect (nth i (nth i list)))
)
;; Test:
(print (diagonal '((1 0) (0 1)))) ;; => (1 1)
(print (diagonal '((1 0 0) (0 1 0) (0 0 1)))) ;; => (1 1 1)
(print (diagonal '((4 0 6) (1 79 6) (7 8 0.1)))) ;; => (4 79 0.1)
(print (diagonal '((T NIL a) (9.7 "a" p) (3/4 T ())))) ;; => (T "a" NIL)
(print (diagonal '())) ;; => NIL
(print (diagonal '((T)))) ;; => (T)
(print "================================================")
;; 9) Construya una función que reciba como argumento una lista cualquiera y, como respuesta,
;; entregue una lista, con el mismo número de elementos de primer nivel, pero que contiene un
;; símbolo A si el elemento en la posición correspondiente es un átomo, un símbolo L si el
;; elemento correspondiente es una lista y un símbolo N si el elemento en la posición
;; correspondiente es una lista vacía.
;; Answer
(defun listTypes (list)
(let ((result '()))
(dolist (i list result)
(cond ((null i) (setq result (append result (list 'N))))
((atom i) (setq result (append result (list 'A))))
((listp i) (setq result (append result (list 'L))))
)
)
)
)
;; Test:
(print (listTypes '(1 T NIL '() "a" ()))) ;; => (A A N L A N)
(print (listTypes '(T T NIL NIL '() "a"))) ;; => (A A N N L A)
(print (listTypes '(z NIL b a "a" '()))) ;; => (A N A A A L)
(print (listTypes '((a) (n) NIL (a) "a" T)));; => (L L N L A A)
(print "================================================")
;; 10) Defina la función Suma-numérica que recibe como argumento una lista cualquiera (no
;; anidada), y como respuesta entrega la suma de exclusivamente aquellos elementos de la lista que
;; son numéricos.
;; Answer
(defun numberSum (list)
(let ((sum 0))
(dolist (i list sum)
(when (numberp i) (setq sum (+ sum i)))
)
)
)
;; Test:
(print (numberSum '(1 2 3 4 5))); ;; => 15
(print (numberSum '(a b c d e))); ;; => 0
(print (numberSum '(1/2 2.3 3 T ()))); ;; => 5.8
(print (numberSum '(1 "a" 3.3 NIL '()))); ;; => 4.3
(print (numberSum '())) ;; => 0
(print "================================================")
;; 11) Escriba una función Filtra-vocales que reciba como argumento una lista (con elementos de
;; cualquier tipo y anidada a cualquier nivel de profundidad) y, como respuesta entregue una copia
;; de la lista argumento en la cual se han removido las letras vocales (tanto mayúsculas como
;; minúsculas).
;; Answer: A simbol is not a vowel
(defun vowelsFilter (list)
(let ((result '()))
(do ((current (pop list) (pop list)))
((and (null current) (null list)) result)
(if (listp current)
(setq list (append current list))
(when (not (or (equal current #\a)
(equal current #\e)
(equal current #\i)
(equal current #\o)
(equal current #\u)
(equal current #\A)
(equal current #\E)
(equal current #\I)
(equal current #\O)
(equal current #\U)
(equal current "a")
(equal current "e")
(equal current "i")
(equal current "o")
(equal current "u")
(equal current "A")
(equal current "E")
(equal current "I")
(equal current "O")
(equal current "U")))
(setq result (append result (list current))))))))
;; Tests:
(print (vowelsFilter '(1 "a" c (a (#\a) #\c)))) ;; => (1 C A #\c)
(print (vowelsFilter '((4) (#\c) T ("b") (a (b) c))));; => (4 #\c T "b" A B C)
(print (vowelsFilter '(0 #\a (b) 1.2 (4 ("u") 3/2))));; => (0 B 1.2 4 3/2)
(print (vowelsFilter '(2 T "e" ((("o")) ("i") bc)))) ;; => (2 T BC)
(print "================================================")
;; 12) Construya una función Filtra-múltiplos que reciba como argumentos una lista y un número
;; entero. Como respuesta debe entregar una copia de la lista argumento en la cual se han removido
;; todos los múltiplos del entero recibido.
;; Answer:
(defun multiplesFilter (list n)
(let ((result '()))
(dolist (i list result)
(when (or (not (numberp i)) (not (zerop (mod i n))))
(setq result (append result (list i)))
)
)
)
)
;; Tests:
(print (multiplesFilter '(1 2 3 4 5 6 7 8) 2)) ;; => (1 3 5 7)
(print (multiplesFilter '(a v b 3 T 5 6 NIL 8) 3)) ;; => (A V B T 5 NIL 8)
(print (multiplesFilter '("a" 2 "b" 4 '() 6 7 8) 2));; => ("a" "b" NIL 7)
(print (multiplesFilter '() 2)) ;; => NIL
(print "================================================")
;; 13) Defina la función Celdas que recibe como argumento una lista (con elementos de cualquier tipo
;; y anidada a cualquier nivel de profundidad) y, como respuesta entrega el número de celdas de
;; construcción que contiene la representación interna de la lista argumento.
;; Answer;
;; Each element on the list counts as 1 construction cell
(defun cellNum (list)
(let ((count 0))
(do ((current (pop list) (pop list)))
((and (null current) (null list)) count)
(when (listp current) (setq list (append current list)))
(setq count (1+ count))
)
)
)
;; Tests:
(print (cellNum '(a b (a b) (a) d e (b)))) ;; => 11
(print (cellNum '(a b a b a d e b))) ;; => 8
(print (cellNum '(NIL T (a b) ("a") 4 5 (b (((NIL)))))));; => 14
(print (cellNum '(a b (a b) (a) ((())) T (b)))) ;; => 13
(print "================================================")
;; 14) Construya una función Implica con aridad indeterminada, que implemente el operador lógico de
;; la implicación.
;; Answer:
(defun implies (&rest list)
(let ((implies? T))
(dolist (i list implies?)
(setq implies? (or (not implies?) i))
)
)
)
;; Tests:
(print (implies T T NIL)) ;; NIL
(print (implies T NIL NIL)) ;; T
(print (implies T T T)) ;; T
(print (implies NIL T T)) ;; T
(print (implies NIL NIL NIL)) ;; NIL
(print "================================================")
;; 15) Escriba una función Mult que recibe como argumento dos listas, conteniendo sub-listas
;; numéricas, representando matrices. La función debe regresar la multiplicación de las dos
;; matrices si es que éstas son compatibles, en caso de no serlo debe regresar NIL.
;; Answer:
(defun matrixMult (list1 list2)
(let ((m1 (length list1))
(n1 (length (first list1)))
(m2 (length list2))
(n2 (length (first list2))))
( if (= n1 m2)
(loop for row1 from 0 to (1- m1)
collect (loop for col2 from 0 to (1- n2)
collect (loop for col1 from 0 to (1- n1) with n1 = 0 with n2 = 0
do (setq n1 (nth col1 (nth row1 list1)))
do (setq n2 (nth col2 (nth col1 list2))) sum (* n1 n2)))
)
)
)
)
;; Tests:
(print (matrixMult '((1 2)(3 4)) '((1 2)(3 4)))) ;; => ((7 10) (15 22))
(print (matrixMult '((3 2)(1 6)) '((1 2)(3 4)))) ;; => ((9 14) (19 26))
(print (matrixMult '((10 12)(9 7)) '((1 2)(3 4)))) ;; => ((46 68) (30 46))
(print (matrixMult '((1 5 2)(3 5 4)(1 7 2)) '((3 5 4)(1 7 2)(3 7 4)))) ;; => ((14 54 22) (26 78 38) (16 68 26))
(print "================================================") | 14,471 | Common Lisp | .lisp | 318 | 40.786164 | 112 | 0.530682 | JRobertGit/AI-19 | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:07 AM (Europe/Amsterdam) | cdf9a7d935d37e45cb69da169e1b6a61842b9baf2f27895573a05e4eff5dcb22 | 38,627 | [
-1
] |
38,628 | Ejercicios Paquete #1.lisp | JRobertGit_AI-19/Lisp Practices/Ejercicios Paquete #1.lisp | ;; José Roberto Torres Mancilla
;; Paquete #1:
;; 1) Construya una sola expresión LISP para calcular lo que se indica en cada uno de los siguientes incisos:
(print "===============================================")
;; a) El quinto elemento de la lista (((1 2) 3) 4 (5 (6)) A (B C) D (E (F G))), sin usar la funci ón FIFTH.
;; Answer:
(nth 4 '(((1 2) 3) 4 (5 (6)) A (B C) D (E (F G))))
;; Test:
(print (nth 4 '(((1 2) 3) 4 (5 (6)) A (B C) D (E (F G))))) ;; Should be (B C)
(print "================================================")
;; b) El número de segundos que tiene el año bisiesto 2004.
;; Answer:
(* 366 24 60 60)
;; Test:
(print (* 366 24 60 60)) ;; Should be 31622400 seconds
(print "================================================")
;; c) Si el valor numérico asociado a la variable x es diferente de cero y además
;; menor o igual que el valor asociado a la variable y.
;; Answer: (and (not (= x 0)) (<= x y))
;; Test:
(defun ltnz(x y)
(and (not (= x 0)) (<= x y))
)
(print (ltnz 1 3)) ;; Should be T
(print (ltnz 3 3)) ;; Should be T
(print (ltnz 0 3)) ;; Should be NIL
(print (ltnz 4 3)) ;; Should be NIL
(print "================================================")
;; d) Una lista con las dos soluciones reales de la ecuación
;; Answer:
(list (/ (- -7 (sqrt (- (expt 7 2) (* 4 2 5)))) (* 2 2)) (/ (+ -7 (sqrt (- (expt 7 2) (* 4 2 5)))) (* 2 2)))
;; Test:
(print (list (/ (- -7 (sqrt (- (expt 7 2) (* 4 2 5)))) (* 2 2)) (/ (+ -7 (sqrt (- (expt 7 2) (* 4 2 5)))) (* 2 2)))) ;; Should be (-5/2 -1)
(print "================================================")
;; 2) Escriba, en notación prefija y evalúe las siguientes expresiones aritméticas:
;; a) 2(4)+(6-8) = 8-2 = 6
;; Answer:
(+ (* 2 4) (- 6 8))
;; Test:
(print (+ (* 2 4) (- 6 8))) ;; Should be 6
(print "================================================")
;; b) 5+(-3+4) / 6+2/5 = 6 / 32/5 = 30/32 = 15/16
;; Answer:
(/ (+ 5 (+ -3 4)) (+ 6 (/ 2 5)))
;; Test:
(print (/ (+ 5 (+ -3 4)) (+ 6 (/ 2 5)))) ;; Should be 15/16
(print "================================================")
;; c) ((-(-4 -3/8) + 1.4502) / (-1^(3-5)^(1/3)))^1/2
;; Answer:
(sqrt (/ (- 1.4502 (- -4 (/ 3 8))) (expt -1 (expt (- 3 5) (/ 1 3)))))
;; Test:
(print (sqrt (/ (- 1.4502 (- -4 (/ 3 8))) (expt -1 (expt (- 3 5) (/ 1 3)))))) ;; Shoudl be #C(7.3559437 -11.196841)
(print "================================================")
;; d) ((65.402/(-1)^1/2)^1/5 / (0.17))^1/7
;; Answer
(expt (/ (expt (/ 65.402 (sqrt -1)) (/ 1 5)) 0.17) (/ 1 7))
;; Test;
(print (expt (/ (expt (/ 65.402 (sqrt -1)) (/ 1 5)) 0.17) (/ 1 7))) ;; Should be #C(1.4500146 -0.065120235)
(print "================================================")
;; 3) Indique el resultado de evaluar cada una de las siguientes expresiones:
;; a) (cdar '((one two) three four)))
(print (cdar '((one two) three four))) ;; Returns: (TWO)
(print "================================================")
;; b) (append (cons '(eva lisa) '(karl sven)) '(eva lisa) '(karl sven))
(print (append (cons '(eva lisa) '(karl sven)) '(eva lisa) '(karl sven))) ;; Returns: ((EVA LISA) KARL SVEN EVA LISA KARL SVEN)
(print "================================================")
;; c) (subst 'gitan 'birgitta '(eva birgitta lisa birgitta karin))
(print (subst 'gitan 'birgitta '(eva birgitta lisa birgitta karin))) ;; Returns: (EVA GITAN LISA GITAN KARIN)
(print "================================================")
;; d) (remove 'sven '(eva sven lisa sven anna))
(print (remove 'sven '(eva sven lisa sven anna))) ;; Returns: (EVA LISA ANNA)
(print "================================================")
;; e) (butlast '(karl adam nilsson gregg alisson vilma) 3)
(print (butlast '(karl adam nilsson gregg alisson vilma) 3)) ;; Returns: (KARL ADAM NILSSON)
(print "================================================")
;; f) (nth 2 '(a b c d e))
(print (nth 2 '(a b c d e))) ;; Returns: C
(print "================================================")
;; g) (nthcdr 2 '(a b c d e))
(print (nthcdr 2 '(a b c d e))) ;; Returns: (C D E)
(print "================================================")
;; h) (intersection '(a b c) '(x b z c))
(print (intersection '(a b c) '(x b z c))) ;; Returns: (B C)
(print "================================================")
;; i) (cdadar '(((((1 2 3) z) y) (x 4)) 7 8 (a b c (5 (6 7 8)))))
(print (cdadar '(((((1 2 3) z) y) (x 4)) 7 8 (a b c (5 (6 7 8)))))) ;; Returns: (4)
(print "================================================")
;; 4) Defina una función Recombina que reciba como argumento una lista de la forma ((A . x)
;; (B . y) (C . z)), donde A, B y C son átomos simbólicos, mientras que x, y y z son
;; números. Como respuesta, la función debe entregar otra lista con la siguiente estructura:
;; (((x y) . A) ((y z) . C) ((z y x) . B))
;; Answer:
(defun recombine (list)
(list
(cons (list (rest (first list)) (rest (second list))) (first (first list)))
(cons (list (rest (second list)) (rest (third list))) (first (third list)))
(cons (list (rest (third list)) (rest (second list)) (rest (first list))) (first (second list)))
)
)
;; Test:
(print (recombine '((A . x) (B . y) (C . z)))) ;; Shuld resturn: (((X Y) . A) ((Y Z) . C) ((Z Y X) . B))
(print "================================================")
;; 5) Defina un predicado RealNoCero? que reciba un argumento N y responda si su
;; argumento es o no un número real diferente de cero.
;; Answer;
(defun non-zeroReal? (n)
(and (realp n) (not (zerop n)))
)
;; Test:
(print (non-zeroReal? 1)) ;; Should return T
(print (non-zeroReal? 0)) ;; Should return NIL
(print (non-zeroReal? 0.0)) ;; Should return NIL
(print (non-zeroReal? (sqrt 2)));; Should return T
(print (non-zeroReal? T)) ;; Should return NIL
(print (non-zeroReal? '(1))) ;; Should return NIL
(print "================================================")
;; 6) Construya una función Analiza, con argumento X, que responda una lista con los valores
;; de verdad correspondientes a las respuestas a las siguientes preguntas: ¿es X un átomo?,
;; ¿es X un número?, ¿es X una lista? , ¿es X una celda de construcción? y ¿es X una
;; lista vacía?
;; Answer:
(defun analize (x)
(list (atom x) (numberp x) (listp x) (consp x) (null x))
)
;; Test
(print (analize NIL)) ;; Should return: (T NIL T NIL T)
(print (analize 1)) ;; Should return: (T T NIL NIL NIL)
(print (analize '(a))) ;; Should return: (NIL NIL T T NIL)
(print (analize 'A)) ;; Should return: (T NIL NIL NIL NIL)
(print (analize '())) ;; Should return: (T NIL T NIL T)
(print (analize T)) ;; Should return: (T NIL NIL NIL NIL)
(print "================================================")
;; 7) Defina una función Intercala que reciba como argumentos dos listas cualesquiera y,
;; como resultado entregue otra lista en la que se encuentran intercalados los elementos de
;; las listas originales; siempre en el mismo orden: un elemento de la primera lista y otro de
;; la segunda lista. Si las listas no tienen la misma longitud, todos los elementos restantes
;; de la lista más grande se colocan seguidos en la respuesta.
;; Answer:
(defun intercalate (list1 list2)
(cond ((and (null list1) (null list2)) nil)
((null list1) list2)
(T (cons (first list1) (intercalate list2 (rest list1))))
)
)
;; Test:
(print (intercalate NIL NIL)) ;; Should return NIL
(print (intercalate '() '())) ;; Should return NIL
(print (intercalate '() '(a))) ;; Should return (A)
(print (intercalate '(a b) '())) ;; Should return (A B)
(print (intercalate '(a b) '(c d))) ;; Should return (A C B D)
(print (intercalate '(a b e f g) '(c d))) ;; Should return (A C B D E F G)
(print "================================================")
;; 8) Programe un predicado MismoTipo que reciba como argumento dos listas de la misma
;; longitud y como respuesta, devuelva T si ambas listas tienen elementos del mismo
;; tipo y en las mismas posiciones, NIL en caso contrario. Observe que los elementos no
;; requieren ser iguales, sólo del mismo tipo de datos.
;; Answer:
(defun sameType? (list1 list2)
(cond ((and (null list1) (null list2)) T)
(T (and T (typep (first list1) (type-of (first list2))) (sameType? (rest list1) (rest list2))))
)
)
;; Test:
(print (sameType? '(A 10 1/3 (T) NIL) '(b 6 2/11 (T) NIL))) ;; Should return T
(print (sameType? '(a "x" NIL) '(y "t" ()))) ;; Should return T
(print (sameType? '(a "x" NIL) '(y T ()))) ;; Should return NIL
(print (sameType? '(a 7 1.4 T NIL) '(b 6 2.1 T NIL))) ;; Should return T
(print (sameType? '(a "x" T) '(y "t" ()))) ;; Should return NIL
(print "================================================")
;; 9) Defina una función APalíndromo, sensible a mayúsculas y minúsculas, que reciba como
;; argumento una cadena y, como respuesta entrega otra cadena que es el palíndromo de la
;; original. Ejemplo: APalíndromo("Hola") = "HolaaloH".
;; Answer:
(defun toPalindrome (text)
(concatenate 'string text (reverse text))
)
;; Test:
(print (toPalindrome "Hola")) ;; Should return "HolaaloH"
(print (toPalindrome "Hello")) ;; Should return "HelloolleH"
(print (toPalindrome "a;slkdjf")) ;; Should return "a;slkdjffjdkls;a"
(print "================================================")
;; 10) Defina un predicado Bisiesto que reciba como entrada un número entero representando
;; un año y, como respuesta, indique si se trata de un año bisiesto o no.
;; Answer:
(defun leapYear? (year)
(cond ((zerop (mod year 400)) T)
((and (zerop (mod year 4)) (not (zerop (mod year 100)))) T)
(T NIL)
)
)
;; Test:
(print (leapYear? 2004)) ;; Should return T
(print (leapYear? 2000)) ;; Should return T
(print (leapYear? 1000)) ;; Should return NIL
(print (leapYear? 4)) ;; Should return T
(print "================================================")
| 10,360 | Common Lisp | .lisp | 196 | 48.913265 | 143 | 0.51185 | JRobertGit/AI-19 | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:07 AM (Europe/Amsterdam) | f04bb3b1bcbaaa884778b8cbe8153ed3adf864d23c51d8edea7261a02a8d7129 | 38,628 | [
-1
] |
38,629 | maze2D.lisp | JRobertGit_AI-19/Informed Searchs Practices/maze2D/maze2D.lisp | ;;==================================
;; 2D Maze
;; José Roberto Torres Mancilla
;; April 2019
;;==================================
(load "maze_lib.lisp")
(add-algorithm 'Best-First)
(add-algorithm 'A*)
;;===================================================================
;; STATE REPRESEMTATION
;; An array with the form #(y x a c)
;; (aref state 0) => Row
;; (aref state 1) => Column
;; (aref state 2) => Aptitude
;; (aref state 3) => Cost
;; #(y x) Represent the state's position on the maze
;;====================================================================
;;====================================================================
;; INITIAL STATE
;; *start* (from maze_lib.lisp)
;; GOAL STATE
;; *goal* (from maze_lib.lisp)
;;====================================================================
;;==================================
;;GENERAL SEARCH PARAMETERS
;;==================================
(defparameter *current-ancestor* NIL)
(defparameter *id* -1)
(defparameter *memory* '())
(defparameter *search-space* '())
;;==================================
;;BASIC OPERATIONS
;;==================================
(defun create-node (state operator)
(incf *id*)
(list *id* state *current-ancestor* (translate-operator (first operator))))
(defun pop-state ()
(pop *search-space*))
(defun insert-node (state operator method)
(let ((node (create-node state operator)))
(cond ((eql method :Best-First)
(when (and (not (remember-state? state *search-space*)))
(push node *search-space*)
(sort-search-space)) )
((eql method :A*)
(update-search-space node)
(sort-search-space)))))
;;==================================
;;MAZE PARAMETERS & OPERATORS
;;==================================
(defparameter *operators* '((:down-right (1 1))
(:down-left (1 -1))
(:up-right (-1 1))
(:up-left (-1 -1))
(:down (1 0))
(:right (0 1))
(:up (-1 0))
(:left (0 -1))))
(defparameter *solution* NIL)
;;==================================
;;MAZE HEURISTICS
;;==================================
(defun euclidean-distance (p q)
(let ((x0 (aref q 0))
(y0 (aref q 1))
(x1 (aref p 0))
(y1 (aref p 1)))
(expt (+ (expt (- x0 x1) 2) (expt (- y0 y1) 2)) 0.5)))
;;==================================
;;APTITUDE & COST
;;==================================
(defun cost (new-state old-state)
(+ (aref old-state 3) (euclidean-distance new-state old-state)))
(defun aptitude (state)
(euclidean-distance state *goal*))
(defun reset-all ()
(setq *current-ancestor* NIL)
(setq *id* 0)
(setq *memory* NIL)
(setq *search-space* NIL)
(setq *solution* NIL))
;;==================================
;;OPERATIONS
;;==================================
(defun valid-operator? (operator position)
(let ((new-row (+ (aref position 0) (first (second operator))))
(new-column (+ (aref position 1) (second (second operator))))
(current-walls NIL)
(new-walls NIL))
(if (and (>= new-row 0)
(< new-row (get-maze-rows))
(>= new-column 0)
(< new-column (get-maze-cols)))
(setq new-walls (to-binary (get-cell-walls new-row new-column)))
(return-from valid-operator? NIL))
(setq current-walls (to-binary (get-cell-walls (aref position 0) (aref position 1))))
(case (first operator)
(:up-right
(and (>= 1 (+ (nth 3 current-walls) (nth 2 current-walls)))
(>= 1 (+ (nth 3 current-walls) (nth 1 new-walls)))
(>= 1 (+ (nth 2 current-walls) (nth 0 new-walls)))
(>= 1 (+ (nth 0 new-walls) (nth 1 new-walls)))))
(:down-right
(and (>= 1 (+ (nth 1 current-walls) (nth 2 current-walls)))
(>= 1 (+ (nth 1 current-walls) (nth 3 new-walls)))
(>= 1 (+ (nth 2 current-walls) (nth 0 new-walls)))
(>= 1 (+ (nth 0 new-walls) (nth 3 new-walls)))))
(:down-left
(and (>= 1 (+ (nth 1 current-walls) (nth 0 current-walls)))
(>= 1 (+ (nth 1 current-walls) (nth 3 new-walls)))
(>= 1 (+ (nth 0 current-walls) (nth 2 new-walls)))
(>= 1 (+ (nth 2 new-walls) (nth 3 new-walls)))))
(:up-left
(and (>= 1 (+ (nth 3 current-walls) (nth 0 current-walls)))
(>= 1 (+ (nth 3 current-walls) (nth 1 new-walls)))
(>= 1 (+ (nth 0 current-walls) (nth 2 new-walls)))
(>= 1 (+ (nth 2 new-walls) (nth 1 new-walls)))))
(:left (and (= (nth 0 current-walls) 0) (= (nth 2 new-walls) 0)))
(:down (and (= (nth 1 current-walls) 0) (= (nth 3 new-walls) 0)))
(:right (and (= (nth 2 current-walls) 0) (= (nth 0 new-walls) 0)))
(:up (and (= (nth 3 current-walls) 0) (= (nth 1 new-walls) 0)))
(otherwise NIL))))
(defun apply-operator (operator state &optional (star NIL))
(let ((new-state (make-array 4)))
(setf (aref new-state 0) (+ (aref state 0) (first (second operator))))
(setf (aref new-state 1) (+ (aref state 1) (second (second operator))))
(setf (aref new-state 2) (aptitude new-state))
;; IF A*
(if star (setf (aref new-state 3) (cost new-state state)))
(if star (setf (aref new-state 2) (+ (aref new-state 2) (aref new-state 3))))
new-state))
(defun expand (state &optional (star NIL))
(let ((decendents NIL))
(dolist (operator *operators* decendents)
(when (valid-operator? operator state)
(setq decendents (cons (list (apply-operator operator state star) operator) decendents))))))
(defun to-binary (number)
(case number
(0 '(0 0 0 0))
(1 '(0 0 0 1))
(2 '(0 0 1 0))
(3 '(0 0 1 1))
(4 '(0 1 0 0))
(5 '(0 1 0 1))
(6 '(0 1 1 0))
(7 '(0 1 1 1))
(8 '(1 0 0 0))
(9 '(1 0 0 1))
(10 '(1 0 1 0))
(11 '(1 0 1 1))
(12 '(1 1 0 0))
(13 '(1 1 0 1))
(14 '(1 1 1 0))
(15 '(1 1 1 1))))
(defun translate-operator (operator)
(case operator
(:up-right 1)
(:down-right 3)
(:down-left 5)
(:up-left 7)
(:right 2)
(:down 4)
(:left 6)
(:up 0))
)
(defun sort-search-space ()
(setq *search-space* (stable-sort *search-space* #'< :key #'(lambda (x) (aref (second x) 2)))))
(defun update-search-space (node)
(let ((state NIL)
(state-cost NIL)
(memory-state NIL)
(memory-cost NIL)
(found? NIL))
(when (null *search-space*)
(push node *search-space*)
(return-from update-search-space NIL))
(setq state (second node))
(setq state-cost (aref state 3))
(loop for i from 0 to (1- (length *search-space*)) do
(setq memory-state (second (nth i *search-space*)))
(setq memory-cost (aref memory-state 3))
(cond ((and (equalp (aref state 0) (aref memory-state 0))
(equalp (aref state 1) (aref memory-state 1)))
(when (< state-cost memory-cost) (setf (nth i *search-space*) node))
(setq found? T))))
(if (not found?) (push node *search-space*))))
(defun remember-state? (state memory-space)
(let ((space-node (second (first memory-space))))
(cond ((null memory-space) NIL)
((and (equalp (aref state 0) (aref space-node 0)) (equalp (aref state 1) (aref space-node 1))) T)
(T (remember-state? state (rest memory-space))))))
(defun filter-memories (nodes)
(cond ((null nodes) NIL)
((remember-state? (first (first nodes)) *memory*)
(filter-memories (rest nodes)))
(T (cons (first nodes) (filter-memories (rest nodes))))))
(defun extract-solution (node)
(labels ((locate-node (id momery)
(cond ((null momery) NIL)
((eql id (first (first momery))) (first momery))
(T (locate-node id (rest momery))))))
(let ((current (locate-node (first node) *memory*)))
(loop while (and (not (null current)) (not (null (fourth current)))) do
(setq *solution* (cons (fourth current) *solution*))
(setq current (locate-node (third current) *memory*))))))
(defun Best-First ()
(reset-all)
(let ((node NIL)
(state NIL)
(aux (make-array 2))
(decendents NIL)
(goal-found? NIL)
(initial-state (make-array 4))
(method :Best-First))
(setf (aref initial-state 0) (aref *start* 0))
(setf (aref initial-state 1) (aref *start* 1))
(setf (aref initial-state 2) (aptitude initial-state))
(insert-node initial-state NIL method)
(loop until (or goal-found? (null *search-space*)) do
(setq node (pop-state))
(setq state (second node))
(setf (aref aux 0) (aref state 0))
(setf (aref aux 1) (aref state 1))
(push node *memory*)
(cond ((equalp *goal* aux)
(extract-solution node)
(format t "Solution found ~a~% " *solution*)
(setq goal-found? T))
(T (setq *current-ancestor* (first node))
(setq decendents (filter-memories (expand state)))
(loop for element in decendents do
(insert-node (first element) (second element) method)))))))
(defun A* ()
(reset-all)
(let ((node NIL)
(state NIL)
(aux (make-array 2))
(decendents NIL)
(goal-found? NIL)
(initial-state (make-array 4))
(method :A*))
(setf (aref initial-state 0) (aref *start* 0))
(setf (aref initial-state 1) (aref *start* 1))
(setf (aref initial-state 2) (aptitude initial-state))
(setf (aref initial-state 3) 0)
(insert-node initial-state NIL method)
(loop until (or goal-found? (null *search-space*)) do
(setq node (pop-state))
(setq state (second node))
(setf (aref aux 0) (aref state 0))
(setf (aref aux 1) (aref state 1))
(push node *memory*)
(cond ((equalp *goal* aux)
(extract-solution node)
(format t "Solution found ~a~% " *solution*)
(setq goal-found? T))
(T (setq *current-ancestor* (first node))
(setq decendents (filter-memories (expand state T)))
(loop for element in decendents do
(insert-node (first element) (second element) method)))))))
(start-maze)
| 10,815 | Common Lisp | .lisp | 261 | 33.130268 | 109 | 0.496341 | JRobertGit/AI-19 | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:07 AM (Europe/Amsterdam) | 7b3c46647465514201789fc8dd2a1ebbe78fcecba2918cb80268136d989d9b83 | 38,629 | [
-1
] |
38,630 | maze3D.lisp | JRobertGit_AI-19/Informed Searchs Practices/maze2D/maze3D.lisp | ;;==================================
;; 3D Maze
;; José Roberto Torres Mancilla
;; April 2019
;;==================================
(load "maze_lib.lisp")
(add-algorithm 'Best-First)
(add-algorithm 'A*)
;;===================================================================
;; STATE REPRESEMTATION
;; An array with the form #(y x a c)
;; (aref state 0) => Row
;; (aref state 1) => Column
;; (aref state 2) => Aptitude
;; (aref state 3) => Cost
;; (aref state 4) => Avobe or Below
;; #(y x) Represent the state's position on the maze
;;====================================================================
;;====================================================================
;; INITIAL STATE
;; *start* (from maze_lib.lisp)
;; GOAL STATE
;; *goal* (from maze_lib.lisp)
;;====================================================================
;;==================================
;;GENERAL SEARCH PARAMETERS
;;==================================
(defparameter *current-ancestor* NIL)
(defparameter *id* -1)
(defparameter *memory* '())
(defparameter *search-space* '())
;;==================================
;;BASIC OPERATIONS
;;==================================
(defun create-node (state operator)
(incf *id*)
(list *id* state *current-ancestor* (translate-operator (first operator))))
(defun pop-state ()
(pop *search-space*))
(defun insert-node (state operator method)
(let ((node (create-node state operator)))
(cond ((eql method :Best-First)
(when (and (not (remember-state? state *search-space*)))
(push node *search-space*)
(sort-search-space)) )
((eql method :A*)
(update-search-space node)
(sort-search-space)))))
;;==================================
;;MAZE PARAMETERS & OPERATORS
;;==================================
(defparameter *operators* '((:down (1 0))
(:right (0 1))
(:up (-1 0))
(:left (0 -1))))
(defparameter *solution* NIL)
;;==================================
;;MAZE HEURISTICS
;;==================================
(defun euclidean-distance (p q)
(let ((x0 (aref q 0))
(y0 (aref q 1))
(x1 (aref p 0))
(y1 (aref p 1)))
(expt (+ (expt (- x0 x1) 2) (expt (- y0 y1) 2)) 0.5)))
;;==================================
;;APTITUDE & COST
;;==================================
(defun cost (new-state old-state)
(+ (aref old-state 3) (euclidean-distance new-state old-state)))
(defun aptitude (state)
(euclidean-distance state *goal*))
(defun reset-all ()
(setq *current-ancestor* NIL)
(setq *id* 0)
(setq *memory* NIL)
(setq *search-space* NIL)
(setq *solution* NIL))
;;==================================
;;OPERATIONS
;;==================================
(defun valid-operator? (operator current-state)
(let ((op NIL)
(celltype -1)
(current-walls NIL)
(pos 0)
(new-row (+ (aref current-state 0) (first (second operator))))
(new-column (+ (aref current-state 1) (second (second operator))))
(new-celltype -1)
(new-walls NIL))
(if (and (>= new-row 0)
(< new-row (get-maze-rows))
(>= new-column 0)
(< new-column (get-maze-cols)))
(setq new-celltype (get-cell-walls new-row new-column))
(return-from valid-operator? NIL))
(setq celltype (get-cell-walls (aref current-state 0) (aref current-state 1)))
(when (and (<= celltype 15) (> new-celltype 15)) (return-from valid-operator? T))
(setq current-walls (to-binary celltype))
(setq new-walls (to-binary new-celltype))
(setq pos (aref current-state 4))
(setq op (first operator))
(if (> celltype 15)
(if (or (and (or (eql op :left) (eql op :right))
(or (and (zerop pos) (= 16 celltype))
(and (= 1 pos) (= 17 celltype))))
(and (or (eql op :down) (eql op :up))
(or (and (= 1 pos) (= 16 celltype))
(and (zerop pos) (= 17 celltype))))) NIL T)
(case op
(:left (and (= (nth 0 current-walls) 0) (= (nth 2 new-walls) 0)))
(:down (and (= (nth 1 current-walls) 0) (= (nth 3 new-walls) 0)))
(:right (and (= (nth 2 current-walls) 0) (= (nth 0 new-walls) 0)))
(:up (and (= (nth 3 current-walls) 0) (= (nth 1 new-walls) 0)))
(otherwise NIL)))))
(defun apply-operator (operator state &optional (star NIL))
(let* ((op (first operator))
(pos (aref state 4))
(current-row (aref state 0))
(current-column (aref state 1))
(celltype (get-cell-walls current-row current-column))
(new-celltype -1)
(new-state (make-array 5)))
(setf (aref new-state 0) (+ current-row (first (second operator))))
(setf (aref new-state 1) (+ current-column (second (second operator))))
(setf (aref new-state 2) (aptitude new-state))
(setq new-celltype (get-cell-walls (aref new-state 0) (aref new-state 1)))
(if (or (and (or (eql :left op) (eql :right op))
(or (and (<= celltype 15) (= new-celltype 16))
(and (= 16 celltype) (= 16 new-celltype) (= 1 pos))
(and (= 17 celltype) (= 16 new-celltype) (zerop pos))))
(and (or (eql :up op) (eql :down op))
(or (and (<= celltype 15) (= new-celltype 17))
(and (= 16 celltype) (= 17 new-celltype) (zerop pos))
(and (= 17 celltype) (= 17 new-celltype) (= 1 pos)))))
(setf (aref new-state 4) 1)
(setf (aref new-state 4) 0))
;; IF A*
(if star (setf (aref new-state 3) (cost new-state state)))
(if star (setf (aref new-state 2) (+ (aref new-state 2) (aref new-state 3))))
new-state))
(defun expand (state &optional (star NIL))
(let ((decendents NIL))
(dolist (operator *operators* decendents)
(when (valid-operator? operator state)
(setq decendents (cons (list (apply-operator operator state star) operator) decendents))))))
(defun to-binary (number)
(case number
(0 '(0 0 0 0))
(1 '(0 0 0 1))
(2 '(0 0 1 0))
(3 '(0 0 1 1))
(4 '(0 1 0 0))
(5 '(0 1 0 1))
(6 '(0 1 1 0))
(7 '(0 1 1 1))
(8 '(1 0 0 0))
(9 '(1 0 0 1))
(10 '(1 0 1 0))
(11 '(1 0 1 1))
(12 '(1 1 0 0))
(13 '(1 1 0 1))
(14 '(1 1 1 0))
(15 '(1 1 1 1))
(16 '(1 0 0 0 0))
(17 '(1 0 0 0 1))))
(defun translate-operator (operator)
(case operator
(:right 2)
(:down 4)
(:left 6)
(:up 0))
)
(defun sort-search-space ()
(setq *search-space* (stable-sort *search-space* #'< :key #'(lambda (x) (aref (second x) 2)))))
(defun update-search-space (node)
(let ((state NIL)
(state-cost NIL)
(memory-state NIL)
(memory-cost NIL)
(found? NIL))
(when (null *search-space*)
(push node *search-space*)
(return-from update-search-space NIL))
(setq state (second node))
(setq state-cost (aref state 3))
(loop for i from 0 to (1- (length *search-space*)) do
(setq memory-state (second (nth i *search-space*)))
(setq memory-cost (aref memory-state 3))
(cond ((and (equalp (aref state 0) (aref memory-state 0))
(equalp (aref state 1) (aref memory-state 1))
(equalp (aref state 4) (aref memory-state 4)))
(when (< state-cost memory-cost) (setf (nth i *search-space*) node))
(setq found? T))))
(if (not found?) (push node *search-space*))))
(defun remember-state? (state memory-space)
(let ((space-node (second (first memory-space))))
(cond ((null memory-space) NIL)
((and (equalp (aref state 0) (aref space-node 0))
(equalp (aref state 1) (aref space-node 1))
(equalp (aref state 4) (aref space-node 4))) T)
(T (remember-state? state (rest memory-space))))))
(defun filter-memories (nodes)
(cond ((null nodes) NIL)
((remember-state? (first (first nodes)) *memory*)
(filter-memories (rest nodes)))
(T (cons (first nodes) (filter-memories (rest nodes))))))
(defun extract-solution (node)
(labels ((locate-node (id momery)
(cond ((null momery) NIL)
((eql id (first (first momery))) (first momery))
(T (locate-node id (rest momery))))))
(let ((current (locate-node (first node) *memory*)))
(loop while (and (not (null current)) (not (null (fourth current)))) do
(setq *solution* (cons (fourth current) *solution*))
(setq current (locate-node (third current) *memory*))))))
(defun Best-First ()
(reset-all)
(let ((node NIL)
(state NIL)
(aux (make-array 2))
(decendents NIL)
(goal-found? NIL)
(initial-state (make-array 5))
(method :Best-First))
(setf (aref initial-state 0) (aref *start* 0))
(setf (aref initial-state 1) (aref *start* 1))
(setf (aref initial-state 2) (aptitude initial-state))
(setf (aref initial-state 4) 0)
(insert-node initial-state NIL method)
(loop until (or goal-found? (null *search-space*)) do
(setq node (pop-state))
(setq state (second node))
(setf (aref aux 0) (aref state 0))
(setf (aref aux 1) (aref state 1))
(push node *memory*)
(cond ((equalp *goal* aux)
(extract-solution node)
(format t "Solution found ~a~% " *solution*)
(setq goal-found? T))
(T (setq *current-ancestor* (first node))
(setq decendents (filter-memories (expand state)))
(loop for element in decendents do
(insert-node (first element) (second element) method)))))))
(defun A* ()
(reset-all)
(let ((node NIL)
(state NIL)
(aux (make-array 2))
(decendents NIL)
(goal-found? NIL)
(initial-state (make-array 5))
(method :A*))
(setf (aref initial-state 0) (aref *start* 0))
(setf (aref initial-state 1) (aref *start* 1))
(setf (aref initial-state 2) (aptitude initial-state))
(setf (aref initial-state 3) 0)
(setf (aref initial-state 4) 0)
(insert-node initial-state NIL method)
(loop until (or goal-found? (null *search-space*)) do
(setq node (pop-state))
(setq state (second node))
(setf (aref aux 0) (aref state 0))
(setf (aref aux 1) (aref state 1))
(push node *memory*)
(cond ((equalp *goal* aux)
(extract-solution node)
(format t "Solution found ~a~% " *solution*)
(setq goal-found? T))
(T (setq *current-ancestor* (first node))
(setq decendents (filter-memories (expand state T)))
(loop for element in decendents do
(insert-node (first element) (second element) method)))))))
(start-maze)
| 11,331 | Common Lisp | .lisp | 274 | 33.00365 | 108 | 0.50522 | JRobertGit/AI-19 | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:07 AM (Europe/Amsterdam) | 95dc6e1aa675807362b76dc535f1af483c3cb97a06ebf03cdbe135af0074777d | 38,630 | [
-1
] |
38,632 | GLOL.lisp | JRobertGit_AI-19/Search Algorithms Practices/GLOL.lisp | ;;;======================================================================================
;;; GLOL.lisp
;;; Solves the Farmer (F), Wolf (W), Goat (G), Cavege (C) problem.
;;; The boat is represented as (B)
;;; using BFS DFS.
;;;
;;; State representation:
;;; Initial State: Goal State:
;;; F W G C B F W G C B F W G C B F W G C B
;;; ((1 1 1 1 1) (0 0 0 0 0)) ((0 0 0 0 0) (1 1 1 1 1))
;;;
;;; José Roberto Torres Mancilla
;;; January, 2019
;;;======================================================================================
(defparameter *search-space* '())
(defparameter *memory* '())
(defparameter *operators* '((:Farmer (1 0 0 0))
(:Farmer-Wolf (1 1 0 0))
(:Farmer-Goat (1 0 1 0))
(:Farmer-Cavege (1 0 0 1))))
(defparameter *id* -1)
(defparameter *current-parent* NIL)
(defparameter *solution* NIL)
(defparameter *created-nodes* 0)
(defparameter *expanded-nodes* 0)
(defparameter *max-size* 0)
;;;=======================================================================================
;;;=======================================================================================
(defun create-node (state operator)
(incf *id*)
(incf *created-nodes*)
(list *id* state *current-parent* (first operator)))
;;;=======================================================================================
;;;=======================================================================================
(defun sp-size ()
(when (< *max-size* (length *search-space*))
(setq *max-size* (length *search-space*))))
;;;=======================================================================================
;;;=======================================================================================
(defun insert-to-open (state operator method)
(let ((node (create-node state operator)))
(cond ((eql method :depth-first)
(push node *search-space*))
((eql method :breath-first)
(setq *search-space* (append *search-space* (list node))))
(T NIL)))
(sp-size))
;;;=======================================================================================
;;;=======================================================================================
(defun get-from-open ()
(pop *search-space*))
;;;=======================================================================================
;;;=======================================================================================
(defun barge-shore (state)
(if (= 1 (fifth (first state))) 0 1))
;;;=======================================================================================
;;;=======================================================================================
(defun valid-operator? (operator state)
(let* ((shore (nth (barge-shore state) state))
(op (second operator))
(farmer (first shore))
(wolf (second shore))
(goat (third shore))
(cavege (fourth shore)))
(and (>= farmer (first op))
(>= wolf (second op))
(>= goat (third op))
(>= cavege (fourth op)))))
;;;=======================================================================================
;;;=======================================================================================
;;; Invalid States:
;;; ((0 1 1 0) (1 0 0 1)), ((1 0 0 1) (0 1 1 0))
;;; ((0 0 1 1) (1 1 0 0)), ((1 1 0 0) (0 0 1 1))
(defun valid-state? (state)
(let* ((f0 (first (first state)))
(w0 (second (first state)))
(g0 (third (first state)))
(c0 (fourth (first state))))
(not (or (and (zerop f0) (= 1 w0) (= 1 g0) (zerop c0))
(and (= 1 f0) (zerop w0) (zerop g0) (= 1 c0))
(and (zerop f0) (zerop w0) (= 1 g0) (= 1 c0))
(and (= 1 f0) (= 1 w0) (zerop g0) (zerop c0))))))
;;;=======================================================================================
;;;=======================================================================================
(defun flip (bit) (boole BOOLE-XOR bit 1))
;;;=======================================================================================
;;;=======================================================================================
(defun apply-operator (operator state)
(let* ((shore1 (first state))
(shore2 (second state))
(f0 (first shore1))
(f1 (first shore2))
(w0 (second shore1))
(w1 (second shore2))
(g0 (third shore1))
(g1 (third shore2))
(c0 (fourth shore1))
(c1 (fourth shore2))
(b0 (fifth shore1))
(b1 (fifth shore2))
(op (first operator)))
(case op
(:Farmer
(list (list (flip f0) w0 g0 c0 (flip b0)) (list (flip f1) w1 g1 c1 (flip b1))))
(:Farmer-Wolf
(list (list (flip f0) (flip w0) g0 c0 (flip b0)) (list (flip f1) (flip w1) g1 c1 (flip b1))))
(:Farmer-Goat
(list (list (flip f0) w0 (flip g0) c0 (flip b0)) (list (flip f1) w1 (flip g1) c1 (flip b1))))
(:Farmer-Cavege
(list (list (flip f0) w0 g0 (flip c0) (flip b0)) (list (flip f1) w1 g1 (flip c1) (flip b1))))
(T "Error"))))
;;;=======================================================================================
;;;=======================================================================================
(defun expand (state)
(let ((children NIL) (new-state NIL))
(incf *expanded-nodes*)
(dolist (operator *operators* children)
(setq new-state (apply-operator operator state))
(when (and (valid-operator? operator state) (valid-state? new-state))
(setq children (cons (list new-state operator) children))))))
;;;=======================================================================================
;;;=======================================================================================
(defun remember-state? (state memory)
(cond ((null memory) NIL)
((equal state (second (first memory))) T)
(T (remember-state? state (rest memory)))))
;;;=======================================================================================
;;;=======================================================================================
(defun filter-memories (states-ops)
(cond ((null states-ops) NIL)
((remember-state? (first (first states-ops)) *memory*)
(filter-memories (rest states-ops)))
(T (cons (first states-ops) (filter-memories (rest states-ops))))))
;;;=======================================================================================
;;;=======================================================================================
(defun extract-solution (node)
(labels ((locate-node (id lst)
(cond ((null lst) NIL)
((eql id (first (first lst))) (first lst))
(T (locate-node id (rest lst))))))
(let ((current (locate-node (first node) *memory*)))
(loop while (not (null current)) do
(push current *solution*)
(setq current (locate-node (third current) *memory*))))
*solution*))
;;;=======================================================================================
;;;=======================================================================================
(defun display-solution (nodes)
(format t "Solition with ~A steps:~%~%" (1- (length nodes)))
(let ((node NIL))
(dotimes (i (length nodes))
(setq node (nth i nodes))
(if (= i 0)
(format t "Starts at: ~A~%" (second node))
(format t "\(~2A\) Applying ~20A we get ~A~%" i (fourth node) (second node))))
(format t "Created nodes: ~A~%" *created-nodes*)
(format t "Expanded nodes: ~A~%" *expanded-nodes*)
(format t "Search space max size: ~A~%" *max-size*)))
;;;=======================================================================================
;;;=======================================================================================
(defun reset-all ()
(setq *search-space* NIL)
(setq *memory* NIL)
(setq *id* 0)
(setq *current-parent* NIL)
(setq *solution* NIL)
(setq *created-nodes* 0)
(setq *expanded-nodes* 0)
(setq *max-size* 0))
;;;=======================================================================================
;;;=======================================================================================
(defun blind-search (initial-state goal-state method)
(reset-all)
(let ((node NIL)
(state NIL)
(sucesores '())
(operator NIL)
(goal-found NIL))
(insert-to-open initial-state NIL method)
(loop until (or goal-found (null *search-space*)) do
(setq node (get-from-open)
state (second node)
operator (third node))
(push node *memory*)
(cond ((equal goal-state state)
(format t "Success. Goal found in ~A tries~%" (first node))
(display-solution (extract-solution node))
(setq goal-found T))
(T (setq *current-parent* (first node))
(setq sucesores (expand state))
(setq sucesores (filter-memories sucesores))
(loop for element in sucesores do
(insert-to-open (first element) (second element) method)))))))
;;;=======================================================================================
;;;=======================================================================================
(time (blind-search '((1 1 1 1 1) (0 0 0 0 0)) '((0 0 0 0 0) (1 1 1 1 1)) ':breath-first))
(time (blind-search '((1 1 1 1 1) (0 0 0 0 0)) '((0 0 0 0 0) (1 1 1 1 1)) ':depth-first))
| 10,176 | Common Lisp | .lisp | 197 | 44.446701 | 109 | 0.352859 | JRobertGit/AI-19 | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:07 AM (Europe/Amsterdam) | 387b51a37ef77fce648d0be6af5576a3dab53a08576dd84f0d72a15aa76f6fca | 38,632 | [
-1
] |
38,633 | Ranas.lisp | JRobertGit_AI-19/Search Algorithms Practices/Ranas.lisp | ;;;======================================================================================
;;; Ranas.lisp
;;; Solves the problem of the Jumping Frogs, using BFS or DFS
;;;
;;; State representation:
;;; An array containing the number of Green Frogs (G) on the left,
;;; and the number of Red Frogs (R) on the right. And in the middle
;;; of the list an free space (_).
;;; Initial State: Goal State:
;;; (3 (G G G _ R R R)) (3 (R R R _ G G G))
;;;
;;; José Roberto Torres Mancilla
;;; January, 2019
;;;======================================================================================
(defparameter *search-space* '())
(defparameter *memory* '())
(defparameter *operators* '((:2-Derecha 2)
(:1-Derecha 1)
(:1-Izquierda -1)
(:2-Izquierda -2)))
(defparameter *id* -1)
(defparameter *current-parent* nil)
(defparameter *solution* nil)
(defparameter *created-nodes* 0)
(defparameter *expanded-nodes* 0)
(defparameter *max-size* 0)
;;;=======================================================================================
;;;=======================================================================================
(defun create-node (state operator)
(incf *id*)
(incf *created-nodes*)
(list *id* state *current-parent* (first operator)))
;;;=======================================================================================
;;;=======================================================================================
(defun sp-size ()
(when (< *max-size* (length *search-space*))
(setq *max-size* (length *search-space*))))
;;;=======================================================================================
;;;=======================================================================================
(defun insert-to-open (state operator method)
(let ((node (create-node state operator)))
(cond ((eql method :depth-first)
(push node *search-space*))
((eql method :breath-first)
(setq *search-space* (append *search-space* (list node))))
(T NIL)))
(sp-size))
;;;=======================================================================================
;;;=======================================================================================
(defun get-from-open ()
(pop *search-space*))
;;;=======================================================================================
;;;=======================================================================================
(defun valid-operator? (operator state)
(let ((next-index (+ (second operator) (first state))))
(and (< -1 next-index) (< next-index (length (second state))))))
;;;=======================================================================================
;;;=======================================================================================
(defun apply-operator (operator state)
(let* ((index (first state))
(new-state (copy-list (second state)))
(next-index (+ (second operator) index)))
(rotatef (nth index new-state)
(nth next-index new-state))
(list next-index new-state)))
;;;=======================================================================================
;;;=======================================================================================
(defun expand (state)
(let ((children NIL))
(incf *expanded-nodes*)
(dolist (operator *operators* children)
(when (valid-operator? operator state)
(setq children (cons (list
(apply-operator operator state) operator) children))))))
;;;=======================================================================================
;;;=======================================================================================
(defun remember-state? (state memory)
(cond ((null memory) NIL)
((equal state (second (first memory))) T)
(T (remember-state? state (rest memory)))))
;;;=======================================================================================
;;;=======================================================================================
(defun filter-memories (states-ops)
(cond ((null states-ops) NIL)
((remember-state? (first (first states-ops)) *memory*)
(filter-memories (rest states-ops)))
(T (cons (first states-ops) (filter-memories (rest states-ops))))))
;;;=======================================================================================
;;;=======================================================================================
(defun extract-solution (node)
(labels ((locate-node (id lst)
(cond ((null lst) NIL)
((eql id (first (first lst))) (first lst))
(T (locate-node id (rest lst))))))
(let ((current (locate-node (first node) *memory*)))
(loop while (not (null current)) do
(push current *solution*)
(setq current (locate-node (third current) *memory*))))
*solution*))
;;;=======================================================================================
;;;=======================================================================================
(defun display-solution (nodes)
(format t "Solition with ~A steps:~%~%" (1- (length nodes)))
(let ((node NIL))
(dotimes (i (length nodes))
(setq node (nth i nodes))
(if (= i 0)
(format t "Starts at: ~A~%" (second node))
(format t "\(~2A\) Applying ~20A we get ~A~%" i (fourth node) (second node))))
(format t "Created nodes: ~A~%" *created-nodes*)
(format t "Expanded nodes: ~A~%" *expanded-nodes*)
(format t "Search space max size: ~A~%" *max-size*)))
;;;=======================================================================================
;;;=======================================================================================
(defun reset-all ()
(setq *search-space* NIL)
(setq *memory* NIL)
(setq *id* 0)
(setq *current-parent* NIL)
(setq *solution* NIL)
(setq *created-nodes* 0)
(setq *expanded-nodes* 0)
(setq *max-size* 0))
;;;=======================================================================================
;;;=======================================================================================
(defun blind-search (initial-state goal-state method)
(reset-all)
(let ((node NIL)
(state NIL)
(sucesores '())
(operator NIL)
(goal-found NIL))
(insert-to-open initial-state NIL method)
(loop until (or goal-found (null *search-space*)) do
(setq node (get-from-open)
state (second node)
operator (third node))
(push node *memory*)
(cond ((equal goal-state state)
(format t "Success. Goal found in ~A tries~%" (first node))
(display-solution (extract-solution node))
(setq goal-found T))
(T (setq *current-parent* (first node))
(setq sucesores (expand state))
(setq sucesores (filter-memories sucesores))
(loop for element in sucesores do
(insert-to-open (first element) (second element) method)))))))
;;;=======================================================================================
;;;=======================================================================================
(time (blind-search '(3 (G G G _ R R R)) '(3 (R R R _ G G G)) ':breath-first))
(time (blind-search '(3 (G G G _ R R R)) '(3 (R R R _ G G G)) ':depth-first)) | 7,796 | Common Lisp | .lisp | 151 | 45.231788 | 94 | 0.366243 | JRobertGit/AI-19 | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:07 AM (Europe/Amsterdam) | 900cf021cfb5cdd0e794a9b1cf4af2c6fbecb964bc43b8099857931e871f1896 | 38,633 | [
-1
] |
38,657 | circular-buffer.lisp | commander-trashdin_common-deque/circular-buffer.lisp | ;;;; circular-buffer.lisp
(in-package #:deque)
(defclass circular-buffer ()
((contents
:type (vector *)
:initform nil
:accessor home)
(front
:type integer
:accessor front
:initform 0)
(back
:type integer
:accessor back
:initform 0)
(actual-size
:type integer
:accessor actsize
:initform 0
:initarg :size)))
(defmethod initialize-instance :after ((cirb circular-buffer)&key)
(setf (home cirb) (make-array (max 2 (actsize cirb)) :initial-element nil) (actsize cirb) 0))
(defmethod cb-print ((cirb circular-buffer))
(cbshow cirb)
(info cirb))
(defmethod cbshow ((cirb circular-buffer))
(format t "#CB( ")
(iter (for elem in-vector (home cirb))
(format t "~s " elem))
(format t ")~%"))
(defmethod cb-coerce (seq)
(let* ((len (length seq))
(res (make-instance 'circular-buffer :size (1+ len))))
(setf (front res) (1- len) (back res) 0 (actsize res) len)
(iter (for i from 0 to (1- len))
(setf (aref (home res) i) (elt seq i)))
res))
(defgeneric info (obj)
(:documentation "Shows all the slots, except for contents themselves"))
(defmethod info ((cirb circular-buffer))
(format t "Front: ~s ~%Back: ~s ~%Actual-size ~s ~%" (front cirb) (back cirb) (actsize cirb)))
(defmethod cbref ((cirb circular-buffer) index)
(with-slots (contents front actual-size) cirb
(if (<= index (1- actual-size))
(aref contents (mod (+ front index) (length contents))))))
(defmethod update-circular-buffer-place ((cirb circular-buffer) index newelem)
(with-slots (contents front actual-size) cirb
(if (<= index (1- actual-size))
(setf (aref contents (mod (+ front index) (length contents))) newelem))))
(defsetf cbref update-circular-buffer-place)
(defmethod cbemptyp ((cirb circular-buffer))
(zerop (actsize cirb)))
(defmethod cblength ((cirb circular-buffer))
(actsize cirb))
(defgeneric ensure-capacity (cirb)
(:documentation "Does the reallocation"))
(defmethod push-front ((cirb circular-buffer) newelem)
(with-slots (contents front actual-size) cirb
(when (= (length contents) actual-size) (extend-buffer cirb))
(setf front (mod (1- front) (length contents))
(aref contents front) newelem)
(incf actual-size)))
(defmethod push-back ((cirb circular-buffer) newelem)
(with-slots (contents back actual-size) cirb
(when (= (length contents) actual-size) (extend-buffer cirb))
(setf back (mod (1+ back) (length contents))
(aref contents back) newelem)
(incf actual-size)))
(defmethod pop-front ((cirb circular-buffer))
(with-slots (contents actual-size front) cirb
(unless (zerop actual-size)
(when (> (length contents) (* 3 actual-size))
(shrink-buffer cirb))
(prog1 (aref contents front)
(setf front (mod (1+ front) (length contents)))
(decf actual-size)))))
(defmethod pop-back ((cirb circular-buffer))
(with-slots (contents actual-size back) cirb
(unless (zerop actual-size)
(when (> (length contents) (* 3 actual-size))
(shrink-buffer cirb))
(prog1 (aref contents back)
(setf back (mod (1- back) (length contents)))
(decf actual-size)))))
(defmethod peek-front ((cirb circular-buffer))
(with-slots (contents front) cirb
(aref contents front)))
(defmethod peek-back ((cirb circular-buffer))
(with-slots (contents back) cirb
(aref contents back)))
(defmacro circle-iterate (front back contents &rest body)
`(let* ((len (length ,contents))
(first ,front)
(last ,back))
(if (<= first last)
(iter (for i from first to last)
(for element = (aref ,contents i))
,@body)
(progn (iter (for i from first to (1- len))
(for element = (aref ,contents i))
,@body)
(iter (for i from 0 to last)
(for element = (aref ,contents i))
,@body)))))
(defmethod shape-buffer ((cirb circular-buffer) newsize default-element)
(with-slots (contents front back) cirb
(let ((newhome (make-array newsize :initial-element nil))
(j 0))
(circle-iterate front back contents (setf (aref newhome j) element) (incf j))
(setf front 0 back (1- j))
(unless (= (1+ back) newsize)
(circle-iterate (mod (1+ back) newsize) (mod (1- front) newsize) newhome
(setf (aref newhome i) (and default-element (funcall default-element)))))
(setf contents newhome))))
(defgeneric extend-buffer (cirb &optional fact with-default)
(:documentation "Reallocates buffer, making it bigger. Triggers when actual size is equal
to vector size, extends by factor given"))
(defmethod extend-buffer ((cirb circular-buffer) &optional (fact 2) (with-default nil))
(with-slots (actual-size) cirb
(shape-buffer cirb (ceiling (* fact actual-size)) with-default)))
(defgeneric shrink-buffer (cirb &optional with-default)
(:documentation "Reallocates buffer, making it smaller. Triggers when actual size is less
then 1/3, shrink to the exact size"))
(defmethod shrink-buffer ((cirb circular-buffer) &optional (with-default nil))
(with-slots (actual-size) cirb
(shape-buffer cirb (* 2 actual-size) with-default)))
| 5,194 | Common Lisp | .lisp | 126 | 36.420635 | 96 | 0.671698 | commander-trashdin/common-deque | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:07 AM (Europe/Amsterdam) | 309e84c42abf24cc948cf062e37dbb45fba121ba73e1ccdd9444290db0bdfcb2 | 38,657 | [
-1
] |
38,658 | deque.lisp | commander-trashdin_common-deque/deque.lisp | ;;;; deque.lisp
(in-package #:deque)
(defclass deque (circular-buffer)
((contents-size
:type integer
:accessor contsize
:initarg :size
:initform 0)))
(defclass dblock ()
((block-contents
:type (vector * 128)
:accessor bl-contents
:initform (make-array 128 :initial-element nil))
(block-front
:type integer
:accessor bl-front
:initform 0
:initarg :fr)
(block-back
:type integer
:accessor bl-back
:initform 127
:initarg :bck)
(block-index
:type fixnum
:accessor bl-index
:initarg :ind)))
(defgeneric dqlength (deq)
(:documentation "Returns length; static"))
(defgeneric dqemptyp (deq)
(:documentation "T if empty, nil otherwise; static"))
(defgeneric dq-coerce (vector-sequence)
(:documentation "Coerces vector into deque and returns that deque"))
(defgeneric peek-front (deq)
(:documentation "Returns first element; static"))
(defgeneric peek-back (deq)
(:documentation "Returns last element; static"))
(defgeneric dqref (deq index)
(:documentation "Returns element by index, counting from the start; static"))
(defgeneric print-readable-deque (deq &optional start end)
(:documentation "Prints deque fromt start to end in readable form, enclosed in []"))
(defgeneric push-front (deq newelem)
(:documentation "Pushes newelem to the front of deque; returns new length"))
(defgeneric push-back (deq newelem)
(:documentation "Pushes newelem to the back of deque; returns new length"))
(defgeneric pop-front (deq)
(:documentation "Pops first element of the deque and returns it;
does not delete it; works only if deque is not empty"))
(defgeneric pop-back (deq)
(:documentation "Pops last element of the deque and returns it;
does not delete it; works only if deque is not empty"))
;;;; ========================================= Implementation =========================================
(defmethod initialize-instance :after ((deq deque) &key)
(iter (for i from 0 to (1- (length (home deq))))
(setf (aref (home deq) i) (make-instance 'dblock :ind i))))
(defmethod dqshow ((deq deque))
"Prints contetns slot; not for users"
(format t "#DQ( ")
(iter (for dblck in-vector (home deq))
(iter (for elem in-vector (bl-contents dblck))
(format t "~s " elem))
(format t "|| "))
(format t ")~%"))
(defmethod info :after ((deq deque))
"Prints other slots; not for users"
(format t "Contents size ~s ~%" (contsize deq)))
(defmethod dq-print ((deq deque))
(dqshow deq)
(info deq))
(defmethod peek-front ((deq deque))
(with-slots (contents front) deq
(with-slots (block-contents block-front) (aref contents front)
(aref block-contents block-front))))
(defmethod peek-back ((deq deque))
(with-slots (contents back) deq
(with-slots (block-contents block-back) (aref contents back)
(aref block-contents block-back))))
(defmethod dqref ((deq deque) ind)
(with-slots (contents front) deq
(with-slots (block-front) (aref contents front)
(multiple-value-bind (column place) (floor (+ block-front ind) 128)
(with-slots (block-contents) (cbref deq column)
(aref block-contents place))))))
(defmethod update-deque-place ((deq deque) ind newelem)
"Updates element on given place by newvalue; for setf, not for users"
(if (<= ind (1- (contsize deq)))
(with-slots (contents front) deq
(with-slots (block-contents block-front) (aref contents front)
(multiple-value-bind (column place) (floor (+ block-front ind) 128)
(setf (aref (cbref deq column) place) newelem))))))
(defsetf dqref update-deque-place)
(defmethod dqemptyp ((deq deque))
(zerop (contsize deq)))
(defmethod dqlength ((deq deque))
(contsize deq))
(defmethod dq-coerce (seq)
(let* ((block-amount (1+ (floor (length seq) 128)))
(res (make-instance 'deque :size block-amount)))
(with-slots (contents front back actual-size contents-size) res
(iter (for i from 0 to (1- (length seq)))
(multiple-value-bind (m n) (floor i 128)
(setf (aref (bl-contents (aref contents m)) n) (aref seq i)
(bl-front (aref contents m)) 0
(bl-back (aref contents m)) (if (< m (floor (1- (length seq)) 128)) 127 n))))
(setf front 0 back (floor (1- (length seq)) 128)
actual-size (1+ (floor (1- (length seq)) 128))
contents-size (length seq)))
res))
(defmethod print-readable-deque ((deq deque) &optional (start 0) (end nil))
(with-slots (contents front contents-size) deq
(let ((step start) (last (or end contents-size)))
(format t "[")
(iter (for i from step to (1- last))
(format t "~s" (dqref deq i))
(unless (= (1- last) i) (format t " ")))
(format t "]"))))
(defmethod shape-buffer ((deq deque) newsize default-element)
(call-next-method)
(with-slots (contents front back) deq
(unless (= (mod (1+ back) (length contents)) front)
(circle-iterate (mod (1+ back) (length contents)) (mod (1- front) (length contents)) contents
(setf (bl-index (aref contents i)) i)))))
(defmethod push-front ((deq deque) newelem)
(with-slots (contents front actual-size contents-size) deq
(with-slots (block-contents block-front block-index) (aref contents front)
(if (zerop block-front)
(progn (when (= actual-size (length contents)) (extend-buffer deq 2 (lambda () (make-instance 'dblock))))
(setf front (mod (1- front) (length contents)))
(incf actual-size)
(with-slots (block-contents block-front) (aref contents front)
(setf (aref block-contents 127) newelem block-front 127)))
(progn (decf block-front)
(setf (aref block-contents block-front) newelem)))
(incf contents-size))))
(defmethod push-back ((deq deque) newelem)
(with-slots (contents back actual-size contents-size) deq
(with-slots (block-contents block-back block-index) (aref contents back)
(if (= 127 block-back)
(progn (when (= actual-size (length contents)) (extend-buffer deq 2 (lambda () (make-instance 'dblock))))
(setf back (mod (1+ back) (length contents)))
(incf actual-size)
(with-slots (block-contents block-back) (aref contents back)
(setf (aref block-contents 0) newelem block-back 0)))
(progn (incf block-back)
(setf (aref block-contents block-back) newelem)))
(incf contents-size))))
(defmethod pop-back ((deq deque))
(with-slots (contents back actual-size contents-size) deq
(unless (zerop contents-size)
(with-slots (block-contents block-back) (aref contents back)
(let ((return-value (aref block-contents block-back)))
(decf contents-size)
(if (zerop block-back)
(progn (incf block-back 127)
(setf back (mod (1- back) (length contents)))
(decf actual-size)
(when (> (length contents) (* 3 actual-size))
(shrink-buffer deq (lambda () (make-instance 'dblock)))))
(decf block-back))
return-value)))))
(defmethod pop-front ((deq deque))
(with-slots (contents front actual-size contents-size) deq
(unless (zerop contents-size)
(with-slots (block-contents block-front) (aref contents front)
(let ((return-value (aref block-contents block-front)))
(decf contents-size)
(if (= 127 block-front)
(progn (decf block-front 127)
(setf front (mod (1+ front) (length contents)))
(decf actual-size)
(when (> (length contents) (* 3 actual-size))
(shrink-buffer deq (lambda () (make-instance 'dblock)))))
(incf block-front))
return-value)))))
| 7,803 | Common Lisp | .lisp | 174 | 38.637931 | 115 | 0.643356 | commander-trashdin/common-deque | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:07 AM (Europe/Amsterdam) | afee3aaec850e3ddff4e0dce2892a23e19d87dae18574a0b7eddd0bd864b47b8 | 38,658 | [
-1
] |
38,659 | deque.asd | commander-trashdin_common-deque/deque.asd | ;;;; deque.asd
(asdf:defsystem #:deque
:description "C++ std::deque clone."
:author "Andrew [email protected]"
:license "Specify license here"
:version "0.5"
:serial t
:depends-on (#:iterate)
:components ((:file "package")
(:file "circular-buffer")
(:file "deque")))
| 317 | Common Lisp | .asd | 11 | 23.727273 | 40 | 0.609836 | commander-trashdin/common-deque | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:07 AM (Europe/Amsterdam) | 29b6c95a9d1f10b9b34aefe4901af5d04af986c6b37566411410d36a065e48ba | 38,659 | [
-1
] |
38,677 | mrsmith.lisp | tomhumbert_MRSmith-lisp/mrsmith.lisp |
;;; About this program
;;;
;;; This program should in the end be able to generate new sentences.
;;; The idea is that the program reads a full text and generates from this a table of which word could map to which, with a weight of how often those words follow each other.
;;; From this information it will then try to generate new sentences.
;;; I tried to work with a very rudimental scoring and generation system, as i would need a lot more time and research to make it more advanced.
;;; As the program is started it first generates a kind of a lexicon, the bigger and more versatile the text, the more it knows.
;;; It then uses the score to increase or decrease the weight of the follow up words, the higher (worse) the score, the more it randomizes the values.
;;; It uses a greedy search to generate a sentence, then prompts the user for an evaluation. There is no limit as to how good or bad the user judges the sentence.
;;; Just know that the higher the score, the wilder the randomizing function goes.
;;; A positive rating will make the program keep the randomized lexicon. A negative rating will make the program reuse the old version of the lexicon.
;;; I hoped that this way, it will slowly raise the weight of the good connections between words.
;;; To exit the program write 'exit' when prompted.
;;; There is a lot that can be improved on. First, the search could work with the weight of the word itself, not only of its 'follow up' words. It could also need some kind of loop prevention
;;; The chaos function could change more than only weights, it could add new words as leafs to lexicon entries or remove some.
;;; Also i wish, there was rather some merging between lexicon generations, rather than total replacement.
;;; There are many things more i could add, for example implement conversation, where the program tries to reuse knowledge optained from sentences the user wrote to him.
;;; For now i am somewhat happy with the code and glad i learned a bit of lisp on the way. It is an amazing language.
;; load gui library
(load "/home/mars/ltk/ltk")
(use-package :ltk)
(load "~/quicklisp/setup.lisp")
(ql:quickload "cl-utilities")
(use-package :cl-utilities)
;;; variable that later holds the full set of relations between words
;;; i call it lexicon
;;; layout: ( word count is-initial ((next-word weigth) (other-word weight)))
(defvar word-map '())
;;; variable that keeps track of an acceptable sentence length
(defvar avg-sentence-length 8)
;;; a score that should vary depending on the programs performance
(defvar score 5)
(defun find-in-map (word map occurence)
"finds place in list where item occurred, either returns -1 or the index of the item"
(let ((x (+ 1 occurence)))
(cond
((NULL map) -1)
((null word) -1)
((string-equal word (car (car map))) x)
(t (find-in-map word (cdr map) x))
)
)
)
(defun return-node (lexicon word)
"finds and returns the lexicon entry of a word, returns nil if not found"
(cond
((string-equal word (car(car lexicon))) (car lexicon))
((null (cdr lexicon)) nil)
(T (return-node (cdr lexicon) word))
)
)
(defun nodep (lexicon word)
(cond
((null (return-node lexicon word)) nil)
(T T)
)
)
(defun return-node-leafs (lexicon word)
"returns the children of a node, if not in lexicon, return nil"
(cond
((null (return-node lexicon word)) nil)
(T (nth 3 (return-node lexicon word)))
)
)
(defun print-node (lexicon node)
"prints a node prettily"
(print (mapcar #'car (nth 3 node)))
(print " |")
(print (car node))
(return-from print-node lexicon)
)
(defun print-lex (lexicon)
"prints the lexicon nicely"
(cond
((null lexicon) (print "----------------------------------"))
((null (return-node-leafs lexicon (car (car lexicon)))) (print (car (car lexicon))))
(T (print-lex (cdr (print-node (car lexicon) lexicon))))
)
)
(defun update-leafs (leafs word-after nu-leafs)
"updates the children of a lexicon entry"
(cond
((null leafs) nu-leafs)
((string-equal word-after (car (car leafs))) (update-leafs (cdr leafs) word-after (append nu-leafs (list (list word-after (+ 1 (nth 1 (car leafs)))))) ))
(T (update-leafs (cdr leafs) word-after (if (null (cdr leafs)) (append nu-leafs (list (car leafs)) (list (list word-after 1))) (append nu-leafs (list (car leafs))))))
)
)
(defun update-lex (word next-word lexicon new-lex initial count)
"updates entries of the lexicon"
(cond
((null lexicon) new-lex)
((string-equal word (car (car lexicon))) (update-lex word next-word (cdr lexicon) (append new-lex (list (list word (+ count (nth 1 (car lexicon))) (if (nth 2 (car lexicon)) t initial) (update-leafs (nth 3 (car lexicon)) next-word '() )))) initial count))
(T (update-lex word next-word (cdr lexicon) (append new-lex (list (car lexicon))) initial count))
)
)
(defun eval-sentence (sentence lexicon iter)
"takes one sentence in the form as a list and adds the words to lexicon"
(let ((occ (nodep lexicon (car sentence)))
(initial (if (= iter 0) t nil))
(word (car sentence))
(next-word (nth 1 sentence)))
(cond
((NULL sentence) lexicon)
((null occ) (eval-sentence (cdr sentence) (append (list (list word 1 initial (if (not (null next-word)) (list (list next-word 1)) '() ))) lexicon) (+ 1 iter)))
(T (eval-sentence (cdr sentence) (update-lex word next-word lexicon '() initial 1) (+ 1 iter)))
)
)
)
(defun random-pick (list)
"return random element from a list"
(nth (random (list-length list) (make-random-state t)) list)
)
(defun random-sentence (lex)
"creates a new sentence from lexicon"
(let ((sent '()) (current-word) (next-word))
(loop
(setq current-word (random-pick lex))
(when (nth 2 current-word) (return current-word))
)
(setq sent (list (car current-word)))
(loop
(if (not (null (nth 3 current-word))) (setq next-word (car (random-pick (nth 3 current-word)))) (setq next-word nil) )
(when (or (> (list-length sent) (- avg-sentence-length 1)) (null next-word))
(return sent)
)
(setq sent (append sent (list next-word)))
(if (not(null next-word)) (setq current-word (nth (find-in-map next-word lex -1) lex)))
)
(return-from random-sentence sent)
)
)
(defun pick-by-weight (lex entry order)
(cond
((null lex) entry)
((< 0 order) (if (< (nth 1 entry)(nth 1 (car lex))) (pick-by-weight (cdr lex) (car lex) order) (pick-by-weight (cdr lex) entry order)))
((> 0 order) (if (> (nth 1 entry)(nth 1 (car lex))) (pick-by-weight (cdr lex) (car lex) order) (pick-by-weight (cdr lex) entry order)))
)
)
(defun reduce-lex (lex parent leafs new-lex)
(cond
((null leafs) new-lex)
(T (reduce-lex lex parent (cdr leafs) (append new-lex (list (return-node lex (car (car leafs)))))))
)
)
(defun informed-sentence (oldlex lex inter-result last-entry iter)
(let ((cur-entry)(next-word))
(setq cur-entry (pick-by-weight lex (car lex) 1))
(if (not (null last-entry))(setq next-word (car (pick-by-weight (nth 3 last-entry) (car (nth 3 last-entry)) 1))))
(cond
((or (= avg-sentence-length (list-length inter-result))
(and (null (nth 3 cur-entry)) (< 0 iter)))
(append inter-result (list (car cur-entry))))
((and (null inter-result) (not (nth 2 cur-entry)))
(informed-sentence oldlex (update-lex (car cur-entry) (car (car (nth 3 cur-entry))) lex '() nil -1) inter-result cur-entry iter))
(T (informed-sentence oldlex (reduce-lex oldlex (car cur-entry) (nth 3 cur-entry) '()) (append inter-result (list (car cur-entry))) (return-node lex next-word) (+ 1 iter)))
)
)
)
(defun change-weights (list strength)
(cond
((null list) nil)
(t (append (list (list (car (car list)) (+ (- (random strength (make-random-state t)) (floor (/ strength 2))) (nth 1 (car list))))) (change-weights (cdr list) strength) ))
)
)
(defun chaos (lex scor)
"wreaks more havoc the worse the score"
(cond
((null lex) nil)
(t (append (list (list (nth 0 (car lex)) (nth 1 (car lex)) (nth 2 (car lex)) (change-weights (nth 3 (car lex)) scor ))) (chaos (cdr lex) scor)))
)
)
(defun subroutine(lexicon interlex)
(let ((input)(lex lexicon)(ilex interlex))
(loop
(print '(this is the subroutine))
(return)
(when (numberp input)
(if (> score -1) (- score input))
(cond
((< 0 input) (setq lex ilex))
(t nil)
)
)
)
)
)
(defun send-button (input lex)
)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; main program ;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(trace eval-sentence update-lex update-leafs)
(with-ltk ()
(let* ((result)(input "test")(inputs)(lex word-map)(interlex)(line-height 5)(scroll-height 400)
(f (make-instance 'frame))
(sc (make-instance 'scrolled-canvas))
(c (canvas sc))
(texto (create-text c 5 line-height "Be nice to baby bot Smithy"))
(e (make-instance 'entry
:master f))
(b (make-instance 'button
:master f
:text "Send"
:command (lambda ()
(when T
(setq input (text e))
(setq line-height (+ line-height 15))
(create-text c 5 line-height input)
(setq lex (eval-sentence (split-sequence #\space input) lex 0))
(setq result (informed-sentence lex lex '() nil 0))
(setq line-height (+ line-height 15))
(create-text c 5 line-height result)
(if (> (+ 30 line-height) scroll-height) (setq scroll-height (+ scroll-height 35)))
(scrollregion c 0 0 0 scroll-height)
)
)))
)
(pack f)
(pack e :side :left)
(pack b :side :left)
(pack sc :expand 1 :fill :both)
(configure c :background 'white)
(scrollregion c 0 0 0 scroll-height)
;(loop
;(setq input (read-line))
;(setq inputs (split-sequence #\space input))
;(cond
; ((string-equal input "") )
; ((string-equal input "print") (print-lex lex))
; ((string-equal input "exit") (return nil))
; ((string-equal input "op") (subroutine lex interlex))
; (T (when T
; (setq lex (eval-sentence inputs lex 0))
; (print (random-sentence lex))
; )
;)
;)
;)
)
)
| 10,519 | Common Lisp | .lisp | 240 | 39.441667 | 257 | 0.639765 | tomhumbert/MRSmith-lisp | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:15 AM (Europe/Amsterdam) | 27d0a516f25d95d1ba2d5621cf88d8331111ecc168c231a98492c7622f5773a8 | 38,677 | [
-1
] |
38,694 | email_spam.lisp | corehello_lisp-gists/email_spam/email_spam.lisp | (defpackage :com.coreworks.spam
(:use :common-lisp))
(in-package :com.coreworks.spam)
(defparameter *max-ham-score* .4)
(defparameter *min-spam-score* .6)
(defun classification (score)
(values
(cond
((<= score *max-ham-score*) 'ham)
((>= score *min-spam-score*) 'spam)
(t 'unsure))
score))
(defun classify (text)
(classification (score (extract-features text))))
(defclass word-feature ()
((word
:initarg :word
:accessor word
:initform (error "Must supply :word")
:documentation "The word this feature represents.")
(spam-count
:initarg :spam-count
:accessor spam-count
:initform 0
:documentation "Number of spams we have seen this feature in.")
(ham-count
:initarg :ham-count
:accessor ham-count
:initform 0
:documentation "Number of hams we have seen this feature in.")))
(defvar *feature-databases* (make-hash-table :test #'equal))
(defun clear-database ()
(setf *feature-databases* (make-hash-table :test #'equal)
*total-spams* 0
*total-hams* 0))
(defun intern-feature (word)
(or (gethash word *feature-databases*)
(setf (gethash word *feature-databases*)
(make-instance 'word-feature :word word))))
(defun extract-words (text)
(delete-duplicates
(cl-ppcre:all-matches-as-strings "[a-zA-Z]{3,}" text)
:test #'string=))
(defun extract-features (text)
(mapcar #'intern-feature (extract-words text)))
(defmethod print-object ((object word-feature) stream)
(print-unreadable-object (object stream :type t)
(with-slots (word ham-count spam-count) object
(format stream "~s :hams ~d :spams ~d" word ham-count spam-count))))
(defun train (text type)
(dolist (feature (extract-features text))
(increment-count feature type))
(increment-total-count type))
(defun increment-count (feature type)
(ecase type
(ham (incf (ham-count feature)))
(spam (incf (spam-count feature)))))
(defvar *total-spams* 0)
(defvar *total-hams* 0)
(defun increment-total-count (type)
(ecase type
(ham (incf *total-hams*))
(spam (incf *total-spams*))))
(defun spam-probability (feature)
(with-slots (spam-count ham-count) feature
(let ((spam-frequency (/ spam-count (max 1 *total-spams*)))
(ham-frequency (/ ham-count (max 1 *total-hams*))))
(/ spam-frequency (+ spam-frequency ham-frequency)))))
(defun bayesian-spam-probability (feature &optional
(assumed-probability 1/2)
(weight 1))
(let ((basic-probability (spam-probability feature))
(data-points (+ (spam-count feature) (ham-count feature))))
(/ (+ (* weight assumed-probability)
(* data-points basic-probability))
(+ weight data-points))))
(defun score (features)
(let ((spam-probs ()) (ham-probs ()) (number-of-probs 0))
(dolist (feature features)
(unless (untrained-p feature)
(let ((spam-prob (float (bayesian-spam-probability feature) 0.0d0)))
(push spam-prob spam-probs)
(push (- 1.0d0 spam-prob) ham-probs)
(incf number-of-probs))))
(let ((h (- 1 (fisher spam-probs number-of-probs)))
(s (- 1 (fisher ham-probs number-of-probs))))
(/ (+ (- 1 h) s) 2.0d0))))
(defun untrained-p (feature)
(with-slots (spam-count ham-count) feature
(and (zerop spam-count) (zerop ham-count))))
(defun fisher (probs number-of-probs)
"The Fisher computation described by Robinson."
(inverse-chi-square
(* -2 (reduce #'+ probs :key #'log))
(* 2 number-of-probs)))
(defun inverse-chi-square (value degrees-of-freedom)
(assert (evenp degrees-of-freedom))
(min
(loop with m = (/ value 2)
for i below (/ degrees-of-freedom 2)
for prob = (exp (- m)) then (* prob (/ m i))
summing prob)
1.0))
(defun add-file-to-corpus (filename type corpus)
(vector-push-extend (list filename type) corpus))
(defparameter *corpus* (make-array 1000 :adjustable t :fill-pointer 0))
(defun add-directory-to-corpus (dir type corpus)
(dolist (filename (list-directory dir))
(add-file-to-corpus filename type corpus)))
(defun list-directory (dirname)
(when (wild-pathname-p dirname)
(error "Can only list concrete directory names."))
(directory (directory-wildcard dirname)))
(defun directory-wildcard (dirname)
(make-pathname
:name :wild
:type #-clisp :wild #+clisp nil
:defaults (pathname-as-directory dirname)))
(defun pathname-as-directory (name)
(let ((pathname (pathname name)))
(when (wild-pathname-p pathname)
(error "Can't reliably convert wild pathnames."))
(if (not (directory-pathname-p name))
(make-pathname
:directory (append (or (pathname-directory pathname) (list :relative))
(list (file-namestring pathname)))
:name nil
:type nil
:defaults pathname)
pathname)))
(defun directory-pathname-p (p)
(and
(not (component-present-p (pathname-name p)))
(not (component-present-p (pathname-type p)))
p))
(defun component-present-p (value)
(and value (not (eql value :unspecific))))
(defun test-classifier (corpus testing-fraction)
(clear-database)
(let* ((shuffled (shuffle-vector corpus))
(size (length corpus))
(train-on (floor (* size (- 1 testing-fraction)))))
(train-from-corpus shuffled :start 0 :end train-on)
(test-from-corpus shuffled :start train-on)))
(defparameter *max-chars* (* 10 1024))
(defun train-from-corpus (corpus &key (start 0) end)
(loop for idx from start below (or end (length corpus)) do
(destructuring-bind (file type) (aref corpus idx)
(train (start-of-file file *max-chars*) type))))
(defun test-from-corpus (corpus &key (start 0) end)
(loop for idx from start below (or end (length corpus)) collect
(destructuring-bind (file type) (aref corpus idx)
(multiple-value-bind (classification score)
(classify (start-of-file file *max-chars*))
(list
:file file
:type type
:classification classification
:score score)))))
(defun nshuffle-vector (vector)
(loop for idx downfrom (1- (length vector)) to 1
for other = (random (1+ idx))
do (unless (= idx other)
(rotatef (aref vector idx) (aref vector other))))
vector)
(defun shuffle-vector (vector)
(nshuffle-vector (copy-seq vector)))
(defun start-of-file (file max-chars)
(with-open-file (in file :external-format :iso-8859-1)
(let* ((length (min (file-length in) max-chars))
(text (make-string length))
(read (read-sequence text in)))
(if (< read length)
(subseq text 0 read)
text))))
(defun result-type (result)
(destructuring-bind (&key type classification &allow-other-keys) result
(ecase type
(ham
(ecase classification
(ham 'correct)
(spam 'false-positive)
(unsure 'missed-ham)))
(spam
(ecase classification
(ham 'false-negative)
(spam 'correct)
(unsure 'missed-spam))))))
(defun false-positive-p (result)
(eql (result-type result) 'false-positive))
(defun false-neganive-p (result)
(eql (result-type result) 'false-negagive))
(defun missed-ham-p (result)
(eql (result-type result) 'missed-ham))
(defun missed-spam-p (result)
(eql (result-type result) 'missed-spam))
(defun correct-p (result)
(eql (result-type result) 'correct))
(defun analyze-results (results)
(let* ((keys '(total correct false-positive
false-negative missed-ham missed-spam))
(counts (loop for x in keys collect (cons x 0))))
(dolist (item results)
(incf (cdr (assoc 'total counts)))
(incf (cdr (assoc (result-type item) counts))))
(loop with total = (cdr (assoc 'total counts))
for (label . count) in counts
do (format t "~&~@(~a~):~20t~5d~,5t: ~6,2f%~%"
label count (* 100 (/ count total))))))
(defun explain-classification (file)
(let* ((text (start-of-file file *max-chars*))
(features (extract-features text))
(score (score features))
(classification (classification score)))
(show-summary file text classification score)
(dolist (feature (sorted-interesting features))
(show-feature feature))))
(defun show-summary (file text classification score)
(format t "~&~a" file)
(format t "~2%~a~2%" text)
(format t "Classified as ~a with scroe of ~,5f~%" classification score))
(defun show-feature (feature)
(with-slots (word ham-count spam-count) feature
(format
t "~&~2t~a~30thams: ~5d; spams: ~5d;~,10tprob: ~,f~%"
word ham-count spam-count (bayesian-spam-probability feature))))
(defun sorted-interesting (features)
(sort (remove-if #'untrained-p features) #'< :key #'bayesian-spam-probability))
| 8,501 | Common Lisp | .lisp | 228 | 33.390351 | 81 | 0.683577 | corehello/lisp-gists | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:15 AM (Europe/Amsterdam) | 560569a8f3e3c0f3694bba425360414484a1f09142ac497bd5e4ed1cc0ca3dd1 | 38,694 | [
-1
] |
38,711 | utils.lisp | innaky_utils/tests/utils.lisp | (defpackage utils-test
(:use :cl
:utils
:prove))
(in-package :utils-test)
;; NOTE: To run this test file, execute `(asdf:test-system :utils)' in your Lisp.
(plan nil)
;; blah blah blah.
(finalize)
| 219 | Common Lisp | .lisp | 9 | 20.888889 | 81 | 0.660194 | innaky/utils | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:15 AM (Europe/Amsterdam) | 47b3b622ac6503959dde71469821b9ad55e41a24c5bbd056c69d1e9ebcf574bf | 38,711 | [
-1
] |
38,712 | utils.asd | innaky_utils/utils.asd | #|
This file is a part of utils project.
Copyright (c) 2019 Innaky ([email protected])
|#
#|
Author: Innaky ([email protected])
|#
(defsystem "utils"
:version "0.1.0"
:author "Innaky"
:license "GPLv3"
:depends-on ("cl-fad")
:components ((:module "src"
:components
((:file "utils"))))
:description "Utilities"
:long-description
#.(read-file-string
(subpathname *load-pathname* "README.markdown"))
:in-order-to ((test-op (test-op "utils-test"))))
| 516 | Common Lisp | .asd | 20 | 21.65 | 53 | 0.637652 | innaky/utils | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:15 AM (Europe/Amsterdam) | 18ee98051c4afaf23eaa1ba20d95758b323ea9f65b3722d6af26f694aff0a9de | 38,712 | [
-1
] |
38,713 | utils-test.asd | innaky_utils/utils-test.asd | #|
This file is a part of utils project.
Copyright (c) 2019 Innaky ([email protected])
|#
(defsystem "utils-test"
:defsystem-depends-on ("prove-asdf")
:author "Innaky"
:license "GPLv3"
:depends-on ("utils"
"prove")
:components ((:module "tests"
:components
((:test-file "utils"))))
:description "Test system for utils"
:perform (test-op (op c) (symbol-call :prove-asdf :run-test-system c)))
| 462 | Common Lisp | .asd | 15 | 25.333333 | 73 | 0.624719 | innaky/utils | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:15 AM (Europe/Amsterdam) | 97d861907086d74f418ed1fb79b45297a2fd63c8bc263586551b07cdb8bfce22 | 38,713 | [
-1
] |
38,732 | csv-list-based.lisp | manney_basic-csv/csv-list-based.lisp | ;;; basic-csv: csv-list-based.lisp
;;; By A. Sebold (manney)
;;;
;;; This program is free software: you can redistribute it and/or modify
;;; it under the terms of the GNU General Public License as published by
;;; the Free Software Foundation, either version 3 of the License, or
;;; (at your option) any later version.
;;;
;;; This program is distributed in the hope that it will be useful,
;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;; GNU General Public License for more details.
;;;
;;; You should have received a copy of the GNU General Public License
;;; along with this program. If not, see <http://www.gnu.org/licenses/>.
(defpackage :org.invigorated.csv
(:use :common-lisp)
(:export :parse-file
:save-file))
(in-package :org.invigorated.csv)
(defun get-text (filename)
"Opens and copies a text file in to a list then returns the list"
(let ((text nil)
(line nil))
(with-open-file (in filename :direction :input)
(loop while (setf line (read-line in nil nil)) do
(setf text (append text
(list (string-trim '(#\Space #\Newline) line))))))
text))
(defun parse-line (line col-end-char decimal-point)
"Returns a list of each element of the string LINE."
(let ((csv-line nil)
(char-at nil)
(in-string nil)
(in-quote nil)
(in-number nil))
(dotimes (x (length line))
(setf char-at (char line x))
;; Make sure we aren't already in a string or number
(if (and (null in-string)
(null in-number))
(cond
;; Blank cell
((char= char-at col-end-char)
(if (eol-p x line)
(setf csv-line (append csv-line (list nil))))
(setf csv-line (append csv-line (list nil))))
;; Number
((or (digit-char-p char-at)
(char= char-at #\-)
(char= char-at #\+)
(and (not (char= decimal-point col-end-char))
(char= char-at decimal-point)))
(setf in-number x))
;; String
(t
(if (and (null in-quote)
(char= char-at #\"))
(setf in-quote x))
(setf in-string x))))
;; Examine each character based on the cases below
(cond
;; If we are in a number and hit a string character
;; make the number in to a string
((and (not (null in-number))
(not (digit-char-p char-at))
(not (and (eql x in-number)
(or (char= char-at #\-)
(char= char-at #\+))))
(not (or (char= char-at col-end-char)
(eol-p x line)))
(not (and (not (char= decimal-point col-end-char))
(char= char-at decimal-point))))
(setf in-string in-number)
(setf in-number nil))
;; If we are in a string and hit a separator or EOL,
;; copy the new element to the list CSV-LINE
((and (not (null in-string))
(or (char= char-at col-end-char)
(eol-p x line))
(null in-quote))
(let ((string-to-copy nil))
;; Check for EOL
(if (eol-p x line)
(setf string-to-copy (subseq line in-string (length line)))
(setf string-to-copy (subseq line in-string x)))
(setf csv-line (append csv-line (list string-to-copy)))
(setf in-string nil)))
;; If we are in a quoted string and hit a separator
;; or EOL, check that we had an end quote before
;; copying the new element to the list CSV-LINE
((and (not (null in-string))
(not (null in-quote))
(or (char= char-at col-end-char)
(eol-p x line)))
;; Create the element to put in to CSV-LINE
(let ((string-to-copy nil))
;; Check for EOL
(if (eol-p x line)
(if (char= (char line x) #\")
(setf string-to-copy (subseq line
(1+ in-quote)
(1- (length line)))))
(if (char= (char line (1- x)) #\")
(setf string-to-copy (subseq line
(1+ in-quote)
(1- x)))))
;; Copy the element to CSV-LINE
(if string-to-copy
(progn
(setf csv-line (append csv-line (list string-to-copy)))
(setf in-quote nil)
(setf in-string nil)))))
;; If we are in a number and hit a separator or EOL,
;; copy the new element to the list CSV-LINE
((and (not (null in-number))
(or (char= char-at col-end-char)
(eol-p x line)))
;; Create the number to put in to the list
(let ((num-to-copy 0)
(string-to-num nil)
(comma-in-num nil))
;; Check for EOL
(if (eol-p x line)
(setf string-to-num (subseq line in-number (length line)))
(setf string-to-num (subseq line in-number x)))
;; Check for a #\, instead of a #\.
(setf comma-in-num (position decimal-point string-to-num))
(if comma-in-num
(setf (char string-to-num comma-in-num) #\.))
;; Convert the string to a number "safely"
(let ((*read-eval* nil))
(setf num-to-copy (apply 'read-from-string string-to-num nil)))
(setf csv-line (append csv-line (list num-to-copy))))
(setf in-number nil))))
csv-line))
(defun parse-file (filename &key (separator #\,) (decimal-point #\.))
"Returns a list of a list of each parsed line of a .csv."
(check-type filename string)
(check-type separator character)
(check-type decimal-point character)
(let ((csv-file (get-text filename))
(csv-list nil))
(dotimes (x (length csv-file))
(setf csv-list (append csv-list (list
(parse-line
(nth x csv-file)
separator
decimal-point)))))
csv-list))
(defun line-to-string (l separator decimal-point)
"Returns a string of a list whose elements are separated
by the character SEPARATOR. If there are numbers in
the list, it will convert the decimal point to the
character DECIMAL-POINT."
(let ((output nil))
(dotimes (x (length l))
(cond
;; NIL
((null (nth x l))
(setf output (concatenate 'string output (string separator))))
;; A number
((numberp (nth x l))
(let* ((num-to-string (princ-to-string (nth x l)))
;; If we have a decimal point, flag it's position
(period-in-string (position #\. num-to-string)))
;; Convert the decimal point if needed
(if period-in-string
(setf (char num-to-string period-in-string) decimal-point))
;; Dump it to our output string
;; Check if this is the first object
(if (null output)
(setf output num-to-string)
(if (null (nth (1- x) l))
;; Check to see if the previous object was NIL
(setf output (concatenate 'string output num-to-string))
(setf output (concatenate 'string output (string separator)
num-to-string))))))
(t
;; Default (always string?)
;; Check the string for a SEPARATOR in it;
;; if it has one, then quote it
(let ((separator-check (position separator (nth x l))))
(if separator-check
(let ((*print-escape* nil))
(setf (nth x l) (format nil "\"~A\"" (nth x l))))))
;; Check if this is the first object
(if (null output)
(setf output (princ-to-string (nth x l)))
(if (null (nth (1- x) l))
;; Check to see if the previous object was NIL
(setf output (concatenate 'string output
(princ-to-string (nth x l))))
(setf output (concatenate 'string output (string separator)
(princ-to-string (nth x l)))))))))
output))
(defun file-to-string (l separator decimal-point)
"Returns a string of a list of lists that contain
each element of a previously PARSEd-FILE."
(let ((output nil))
(dolist (x l)
(if output
(setf output
(concatenate 'string output
(string #\Newline)
(line-to-string x
separator
decimal-point)))
(setf output (line-to-string x separator decimal-point))))
output))
(defun save-file (l filename &key (separator #\,) (decimal-point #\.))
"Returns T if the list L has been converted back to
text and saved to the file FILENAME. Creates FILENAME
if it doesn't exist."
(check-type l list)
(check-type filename string)
(check-type separator character)
(check-type decimal-point character)
(let ((output nil))
;; Convert L to a string and place in OUTPUT
(if l
(setf output (file-to-string l separator decimal-point))
(setf output nil))
;; Save OUTPUT to a (new?) file named FILENAME
(if output
(progn
(with-open-file (out filename
:direction :output :if-exists :supersede)
(write-string output out))
t)
nil)))
(defun eol-p (x s)
"Returns T if integer X is at the EOL for string S."
(check-type x integer)
(check-type s string)
(if (= x (1- (length s)))
t
nil))
(in-package :cl-user)
| 10,259 | Common Lisp | .lisp | 239 | 30.598326 | 95 | 0.523633 | manney/basic-csv | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:15 AM (Europe/Amsterdam) | 6658d9fc3ba808ae4b94d41c54b49f5bd4b88eb3dbb34c019e7db176cf0fbdc3 | 38,732 | [
-1
] |
38,749 | package.lisp | daniel-bandstra_echorepl/package.lisp | (defpackage :echorepl
(:use :common-lisp :cffi :bordeaux-threads :trivial-garbage))
(in-package :echorepl)
(export
'(
start-recording
stop-recording
reset-score
loop-button
undo-button
undo
redo
play-score
update-score
time-rate
reverse-time
connect-input
monitor
pedal-open
save-project
load-project
))
;;; variables to edit for your setup
(defparameter *sample-rate* 44100) ;; this also gets set when Jack starts up
(defparameter *latency* 472)
;; *LATENCY* is a number of whole samples or frames. You can measure this
;; with the jack_delay utility and a patch cable.
(defparameter *jack-buffer-size* #.(expt 2 15))
(defparameter *pedal-port* "/dev/ttyUSB0")
;; Jack types for cffi
(defctype sample-t :float)
(defvar sample-t :float)
(defctype nframes-t :uint32)
(defvar nframes-t :uint32)
(defctype time-t :uint64)
(defvar time-t :uint64)
;;; foreign library definitions
;; library dependencies
(define-foreign-library sndfile
(t (:default "libsndfile")))
(use-foreign-library sndfile)
(define-foreign-library jack
(t (:default "libjack")))
(use-foreign-library jack)
;; homegrown packages
(define-foreign-library engine
(t (:default #.(namestring
(asdf:system-relative-pathname 'echorepl "engine/libengine")))))
(use-foreign-library engine)
(define-foreign-library pedal
(t (:default #.(namestring
(asdf:system-relative-pathname 'echorepl "pedal/libpedal")))))
(use-foreign-library pedal)
| 1,480 | Common Lisp | .lisp | 53 | 25.301887 | 76 | 0.748048 | daniel-bandstra/echorepl | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:23 AM (Europe/Amsterdam) | e3812857dc52a7952da38f8df25db4fafe421e3c8a2b35f2f7e8df5244997213 | 38,749 | [
-1
] |
38,750 | play.lisp | daniel-bandstra_echorepl/play.lisp | (in-package :echorepl)
;; clip naming stuff
(defun by-name (name)
(find name *clip-store*
:test (lambda (name clip)
(eq name (name clip)))))
(defun clip-names-in-score ()
(let ((output nil))
(labels ((trawl (score)
(cond
((by-name score)
(push score output))
((atom score))
(t
(trawl (car score))
(trawl (cdr score))))))
(trawl *score*)
(delete-duplicates output))))
(defun rename (new-name &optional (old-name (name (car *clip-store*))))
(labels
((rename-in-score (score)
(cond
((atom score)
(if (eq score old-name)
new-name
score))
(t
(cons (rename-in-score (car score))
(rename-in-score (cdr score)))))))
(let ((old-names (mapcar #'name *clip-store*)))
(unless (find new-name old-names)
(setf *score* (rename-in-score *score*))
(loop for clip in *clip-store* do
(if (eq (name clip) old-name)
(setf (name clip) new-name)))))))
(defun string-to-keyword (string)
(if (eq (elt string 0) ":")
(read-from-string string)
(read-from-string (concatenate 'string ":" string))))
(defun rename-for-slime (old-name new-name)
(rename (string-to-keyword new-name)
(string-to-keyword old-name)))
;; A link is one in a chain of structs that play various clips.
;; Start/end times include splices. All times are normalized, such that the start
;; of the clip is at (number-moment 0)
;; In what follows "link" is a link, "chain" is a link that may or may not have a
;; next-link
(defstruct (link (:conc-name nil)
(:constructor internal-make-link))
(clip (empty-clip)
:type clip)
(this-offset (number-moment 0)
:type moment)
(this-start (number-moment 0)
:type moment)
(this-end (number-moment 0)
:type moment)
(this-modulus 0
:type fixnum)
next-link
(next-start (number-moment 0)
:type moment)
(next-modulus 0
:type fixnum)
prev-link
(prev-end (number-moment 0)
:type moment)
(prev-modulus 0
:type fixnum)
(set-mute nil
:type boolean)
(set-gain 1.0
:type single-float))
(defun make-link (clip)
(internal-make-link :clip clip
:this-offset (offset clip)
:this-start (moment+ (offset clip)
(number-moment (- (fadein-start-pos clip)
(clip-start-pos clip))))
:this-end (moment+ (offset clip)
(number-moment (- (fadeout-end-pos clip)
(clip-start-pos clip))))
:this-modulus (modulus clip)))
;; Arranging links and chains
(defun chain-links (a b)
"Set link B to play after link A"
(setf (next-link a) b
(next-start a) (moment+ (this-start b)
(number-moment (this-modulus a)))
(next-modulus a) (this-modulus b)
(prev-link b) a
(prev-end b) (moment- (this-end a)
(number-moment (this-modulus a)))
(prev-modulus b) (this-modulus a))
a)
(defun last-link (chain)
"Return the last link in CHAIN"
(if (null (next-link chain))
chain
(last-link (next-link chain))))
(defun cycle (chain)
"Make CHAIN circular"
(chain-links (last-link chain) chain)
chain)
(defun series (&rest chains)
"Make a number of CHAINS into one CHAIN"
(if (cdr chains)
(chain-links (car chains)
(apply #'series (cdr chains)))
(car chains)))
(defun copy-chain (chain)
"Make a chain of copies of the links in CHAIN"
(if (next-link chain)
(chain-links (copy-link chain)
(copy-chain (next-link chain)))
(copy-link chain)))
(defun repeat (times chain)
"Make a chain of CHAIN a number of TIMES in a row"
(apply #'series
(loop for i below times
collect (copy-chain chain))))
;; Playing links and chains
(let ((elapsed (number-moment 0))
(gain-b 0.0))
(defun play-link (dst i link moment gain)
"Play LINK"
(declare (optimize (speed 3) (space 0) (safety 0)
(debug 1) (compilation-speed 0))
(single-float gain))
(unless (set-mute link)
(if (and (moment< (this-start link) moment)
(moment< moment (this-end link)))
(progn
(setf elapsed (moment- moment (this-offset link))
gain-b (* gain (fraction elapsed)))
(pos-play dst i (tape (clip link))
(frame elapsed) (* (set-gain link)
(- gain gain-b)))
(pos-play dst i (tape (clip link))
(the fixnum (1+ (frame elapsed)))
(* (set-gain link) gain-b)))))))
(defun play-chain (dst i chain moment gain)
"Play CHAIN"
(declare (optimize (speed 3) (space 0) (safety 0)
(debug 1) (compilation-speed 0)))
(play-link dst i chain moment gain)
(cond
((and (next-link chain)
(moment< (next-start chain) moment))
(decf (frame moment) (this-modulus chain))
(play-link dst i (next-link chain) moment gain))
((and (prev-link chain)
(moment< moment (prev-end chain)))
(incf (frame moment) (prev-modulus chain))
(play-link dst i (prev-link chain) moment gain))))
(defun play-fun (chain)
"Return a function to play CHAIN"
(let ((first-run t)
(this-start (number-moment 0))
(next-start (number-moment 0)))
(lambda (dst i time first-start gain)
(declare (optimize (speed 3) (space 0) (safety 0)
(debug 0) (compilation-speed 0)))
(if first-run
(setf this-start (copy-moment first-start)
next-start (moment+ first-start
(number-moment (this-modulus chain)))
first-run nil))
(play-chain dst i chain (moment- time this-start) gain)
(cond
((and (prev-link chain)
(moment< time this-start))
(decf (frame next-start) (this-modulus chain))
(decf (frame this-start) (prev-modulus chain))
(setf chain (prev-link chain)))
((and (next-link chain)
(moment< next-start time))
(incf (frame next-start) (next-modulus chain))
(incf (frame this-start) (this-modulus chain))
(setf chain (next-link chain)))))))
;; Volume Changing Functions
(defun db-gain (decibel)
"Change decibels to a simple multiplier (100db = 1.0)"
(coerce (expt 10
(/ (- decibel 100)
20))
'single-float))
(defun gain (db chain)
(setf (set-gain chain) (db-gain db))
(if (next-link chain)
(gain db (next-link chain)))
chain)
(defun mute (chain)
(setf (set-mute chain) t)
(if (next-link chain)
(mute (next-link chain)))
chain)
;; Compiling The Score
(defun score-modulus (score)
"Find how long SCORE should take to play."
(cond
((by-name score)
(modulus (by-name score)))
((atom score)
0)
(t
(case (car score)
(cycle
0)
(series
(apply #'+ (mapcar (lambda (score) (score-modulus score))
(cdr score))))
(repeat
(score-modulus (cons 'series (make-list (cadr score)
:initial-element (caddr score)))))
(otherwise
(apply #'max (mapcar (lambda (score) (score-modulus score))
score)))))))
(defun replace-names-with-links (score)
(cond
((by-name score)
(make-link (by-name score)))
((atom score)
score)
(t
(cons (replace-names-with-links (car score))
(replace-names-with-links (cdr score))))))
(defun compile-score ()
"Return a function that will CYCLE each element of SCORE altogether."
(let ((funs (mapcar (lambda (track) (play-fun (eval (list 'cycle track))))
(replace-names-with-links *score*))))
(lambda (dst i time start gain)
(declare (optimize (speed 3) (space 0) (safety 0)
(debug 0) (compilation-speed 0)))
(loop for fun in funs do
(funcall (the function fun) dst i time start gain)))))
(defun play-null (&rest args)
(declare (optimize (speed 3) (space 0) (safety 0)
(debug 0) (compilation-speed 0))
(ignore args)))
| 7,561 | Common Lisp | .lisp | 240 | 26.983333 | 81 | 0.640867 | daniel-bandstra/echorepl | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:23 AM (Europe/Amsterdam) | 3329615808a38a84e36214e47158b3fa3c42f02c155f8ad4d1a0516b2b289466 | 38,750 | [
-1
] |
38,751 | colors.lisp | daniel-bandstra_echorepl/colors.lisp | (in-package :echorepl)
;; For when my kids want to press the pedal buttons.
;; READ-PEDAL gets the time from Jack, so if you haven't connected Lisp to Jack at
;; least once, there will be an unhandled memory fault.
(setf *colors-running* nil)
(progn
(defparameter *colors-running* t)
(let ((a-state 0)
(a-colors '(0 0 0))
(b-state 2)
(b-colors '(0 0 0)))
(loop while *colors-running* do
(progn
(case (pedal-read)
(:a-down
(setf a-colors
(case a-state
(0 '(12 0 0))
(1 '(0 8 0))
(2 '(0 0 8))
(3 '(0 0 0)))
a-state (mod (1+ a-state) 4)))
(:b-down
(setf b-colors
(case b-state
(0 '(12 0 0))
(1 '(0 8 0))
(2 '(0 0 8))
(3 '(0 0 0)))
b-state (mod (1- b-state) 4))))
(pedal-color
(+ (car a-colors) (car b-colors))
(+ (cadr a-colors) (cadr b-colors))
(+ (caddr a-colors) (caddr b-colors)))))))
| 947 | Common Lisp | .lisp | 34 | 22.117647 | 82 | 0.53348 | daniel-bandstra/echorepl | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:23 AM (Europe/Amsterdam) | 2890e6decbb46ef3415c13cdfd24306d6ed8128772e118dc60b9dfa81b67b5fc | 38,751 | [
-1
] |
38,752 | pedal.lisp | daniel-bandstra_echorepl/pedal.lisp | (in-package :echorepl)
;;; C Functions
;; opening and closing the pedal
(defcfun ("open_pedal" internal-open-pedal) :int
(portname :string))
(defcfun ("close_pedal" internal-close-pedal) :void
(internal-pedal :int))
;; output and input
(defcfun ("pedal_color" internal-pedal-color) :int
(internal-pedal :int)
(red :int)
(green :int)
(blue :int))
(defcfun ("read_pedal" internal-read-pedal) :int
(internal-pedal :int)
(pedal-event :pointer))
;; pedal event struct
(defcstruct pedal-event
(event :char)
(time :uint64))
;;; Pedal Functions
(let ((internal-pedal 0)
(internal-red 0)
(internal-green 0)
(internal-blue 0)
(pedal-is-open nil)
(write-lock (make-lock "Pedal Write"))
(event (foreign-alloc '(:struct pedal-event))))
(declare (fixnum internal-pedal)
(type (integer 0 128) internal-red internal-green internal-blue)
(boolean pedal-is-open))
;; open and close
(defun pedal-close ()
(if pedal-is-open
(internal-close-pedal internal-pedal))
(setf pedal-is-open nil))
(defun pedal-open (portname)
(declare (string portname))
(pedal-close)
(setf internal-pedal (internal-open-pedal portname))
(if (>= internal-pedal 0)
(setf pedal-is-open t)))
;; color write
(defun pedal-set-color (red green blue)
(setf internal-red red
internal-green green
internal-blue blue))
(defun pedal-refresh-color ()
(if pedal-is-open
(with-lock-held (write-lock)
(internal-pedal-color internal-pedal
internal-red
internal-green
internal-blue))))
(defun pedal-color (red green blue)
(setf internal-red red
internal-green green
internal-blue blue)
(pedal-refresh-color))
(defun pedal-blink (red green blue)
(declare (type (integer 0 128) red green blue))
(if pedal-is-open
(progn
(with-lock-held (write-lock)
(internal-pedal-color internal-pedal red green blue))
(make-thread (lambda ()
(sleep 0.1)
(pedal-refresh-color))))))
;; Reading pedal events
;; (first, mung pedal_flags.h for keywords)
(let ((flags nil))
(with-open-file (str
(asdf:system-relative-pathname 'echorepl
"pedal/pedal/pedal_flags.h")
:direction :input)
(do ((l (read-line str nil :eof) (read-line str nil :eof)))
((or (eq l :eof)
(search "enum Pedal_Flags {" l))))
(do ((l (read-line str nil :eof) (read-line str nil :eof)))
((or (eq l :eof)
(search "};" l)))
(setf flags (append
flags
(list (let ((comma (position #\, l)))
(intern
(string-upcase
(substitute #\- #\_
(string-trim '(#\Space #\Tab)
(if comma
(subseq l 0 comma)
l))))
"KEYWORD")))))))
(defun pedal-read ()
(declare (optimize (speed 3) (space 0) (safety 0)
(debug 0) (compilation-speed 0)))
(if pedal-is-open
(progn
(internal-read-pedal internal-pedal event)
(values (nth (foreign-slot-value event
'(:struct pedal-event)
'event)
flags)
(usecs-moment (the fixnum
(foreign-slot-value event
'(:struct pedal-event)
'time)))))
(progn (sleep 1)
(values :nothing (number-moment 0)))))))
;; try to open the pedal
(pedal-open *pedal-port*)
| 3,309 | Common Lisp | .lisp | 110 | 24.818182 | 68 | 0.634555 | daniel-bandstra/echorepl | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:23 AM (Europe/Amsterdam) | e2341b17ad9257983915f717f0d35506a008f2fa8976252b25bed60d585840a4 | 38,752 | [
-1
] |
38,753 | jack.lisp | daniel-bandstra_echorepl/jack.lisp | (in-package :echorepl)
;; starting and stopping jack
(defconstant +jack-no-start-server+ #x01)
;; jack client
(defcfun "jack_client_open" :pointer
(client-name :string)
(options :int)
(status :pointer)) ;; pointer to an int
(defcfun "jack_client_close" :int
(client :pointer))
(defcfun "jack_set_process_callback" :int
(client :pointer)
(callback :pointer)
(arg :pointer))
(let ((so *standard-output*))
(defcallback *jack-shutdown-callback* :void
((arg :pointer))
(declare (ignore arg))
(format so "Jack shut down this client.~%")))
(defcfun "jack_on_shutdown" :void
(client :pointer)
(callback :pointer)
(arg :pointer))
;; non-callback api
(defcfun "jack_cycle_wait" nframes-t
(client :pointer))
(defcfun "jack_cycle_signal" :void
(client :pointer)
(status :int)) ;; should be zero
;; ports
(defconstant +jack-default-audio-type+
(if (boundp '+jack-default-audio-type+)
(symbol-value '+jack-default-audio-type+)
"32 bit float mono audio"))
(defconstant +jack-port-is-input+ #x1)
(defconstant +jack-port-is-output+ #x2)
(defconstant +jack-port-is-physical+ #x4)
(defcfun "jack_port_register" :pointer
(client :pointer)
(port-name :string)
(port-type :string)
(flags :unsigned-long)
(buffer-size :unsigned-long))
(defcfun "jack_activate" :int
(client :pointer))
(defcfun "jack_get_ports" :pointer
(client :pointer)
(port-name-pattern :string)
(type-name-pattern :string)
(flags :unsigned-long))
(defcfun "jack_free" :void
(ptr :pointer))
(defcfun "jack_port_connected" :int
(port :pointer))
(defcfun "jack_port_disconnect" :int
(client :pointer)
(port :pointer))
(defcfun "jack_connect" :int
(client :pointer)
(source-port :string)
(destination-port :string))
(defcfun "jack_port_name" :string
(port :pointer))
;; buffers
(defcfun "jack_port_get_buffer" :pointer
(port :pointer)
(count nframes-t))
;; timing
(defcfun "jack_get_sample_rate" nframes-t
(client :pointer))
(defcfun "jack_frame_time" nframes-t
(client :pointer))
(defcfun "jack_last_frame_time" nframes-t
(client :pointer))
(defcfun "jack_get_time" time-t
(client :pointer))
(defcfun "jack_time_to_frames" nframes-t
(client :pointer)
(time time-t))
(defcfun "jack_frames_to_time" time-t
(client :pointer)
(frames nframes-t))
;; Jack Functions for Lisp
;; The main function here is (start-jack "name" process-fun). PROCESS-FUN is a function
;; that takes the arguments (sample frame out-ptr), i.e. a single sample, that
;; sample's frame-time according to Jack, and a pointer to which a single output sample
;; could be written. Then there's (stop-jack), of course.
(let (
;; thread stuff
(jack-running nil)
(thread nil)
(so *standard-output*)
;; jack pointers
(callback-info (null-pointer))
(client (null-pointer))
(input (null-pointer))
(output (null-pointer)))
(defun jack-running ()
jack-running)
;; setup and tear-down
(defun connect-outputs ()
(if (jack-running)
(let ((ports (jack-get-ports client
(null-pointer)
(null-pointer)
(logior +jack-port-is-physical+
+jack-port-is-input+))))
(unless (null-pointer-p ports)
(if (> (jack-port-connected output) 0)
(jack-port-disconnect client output))
(jack-connect client
(jack-port-name output)
(mem-ref (mem-aptr ports :pointer 0) :pointer))
(jack-connect client
(jack-port-name output)
(mem-ref (mem-aptr ports :pointer 1) :pointer))
(jack-free ports)))))
(defun connect-input (port-number)
(if (jack-running)
(let ((ports (jack-get-ports client
(null-pointer)
(null-pointer)
(logior +jack-port-is-physical+
+jack-port-is-output+))))
(unless (null-pointer-p ports)
(if (> (jack-port-connected input) 0)
(jack-port-disconnect client input))
(jack-connect client
(mem-ref (mem-aptr ports :pointer port-number) :pointer)
(jack-port-name input))
(jack-free ports)))))
(defun start-jack (name process)
(if (jack-running)
(progn (format so "~&Jack is already running.~%")
t)
(progn
(setf
jack-running t
callback-info (new-callback-info *jack-buffer-size*)
client (with-foreign-object (status :int)
(jack-client-open name
+jack-no-start-server+
status))
input (jack-port-register client
"input"
+jack-default-audio-type+
+jack-port-is-input+
0)
output (jack-port-register client
"output"
+jack-default-audio-type+
+jack-port-is-output+
0)
(foreign-slot-value callback-info '(:struct callback-info) 'client)
client
(foreign-slot-value callback-info '(:struct callback-info) 'in-port)
input
(foreign-slot-value callback-info '(:struct callback-info) 'out-port)
output)
(if (null-pointer-p client)
(progn (format so "~&Could not open Jack.~%")
(setf jack-running nil))
(let ((dst (foreign-slot-value callback-info
'(:struct callback-info)
'out-buf))
(divisor (foreign-slot-value callback-info
'(:struct callback-info)
'buffer-size)))
(declare (fixnum divisor))
(setf
thread
(make-thread
(lambda ()
(declare (optimize (speed 3) (space 0) (safety 0)
(debug 0) (compilation-speed 0)))
(loop while jack-running do
(let* ((frame (get-sample-frame callback-info))
(sample (get-sample callback-info)))
(declare (fixnum frame))
(funcall (the function process)
sample
frame
dst
(mod frame divisor)))))))
(jack-on-shutdown client
(get-callback '*jack-shutdown-callback*)
(null-pointer))
(jack-set-process-callback client
(foreign-symbol-pointer
"echorepl_callback")
callback-info)
(jack-activate client)
(connect-outputs)
(connect-input 0)
(setf *sample-rate* (jack-get-sample-rate client))
t)))))
(defun stop-jack ()
(cond
(jack-running (setf jack-running nil)
(handler-case
(if thread (join-thread thread))
(t (c)
(format so "~&Caught error:~%~a~%" c)))
(setf thread nil)
(jack-client-close client)
(delete-callback-info callback-info))))
;; Time Functions
(defun usecs ()
(if (jack-running)
(jack-get-time client)
0))
(defun usecs-frame (usecs)
(if (jack-running)
(jack-time-to-frames client usecs)
0))
(defun frame-usecs (frame)
(if (jack-running)
(jack-frames-to-time client frame)
0))
;; software monitoring
(defun monitor ()
(if (jack-running)
(setf
(foreign-slot-value callback-info '(:struct callback-info) 'monitor)
(if
(zerop (foreign-slot-value callback-info '(:struct callback-info)
'monitor))
1
0)))))
| 6,877 | Common Lisp | .lisp | 229 | 25.235808 | 87 | 0.657919 | daniel-bandstra/echorepl | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:23 AM (Europe/Amsterdam) | 44277d3d7d5d72c59a25375b6a17776aab50aa2a4f6c860b2bed01e607f9a344 | 38,753 | [
-1
] |
38,754 | undo.lisp | daniel-bandstra_echorepl/undo.lisp | (in-package :echorepl)
(defvar *clip-store* nil)
(defvar *score* nil)
(defvar *undo-clip-store* nil)
(defvar *undo-score* nil)
(defvar *redo-clip-store* nil)
(defvar *redo-score* nil)
(let ((emacs-connection (if (find-package 'swank)
swank::*emacs-connection*)))
(defun signal-score-update ()
(if emacs-connection
(let ((event `(:ed-rpc-no-wait
,(swank::symbol-name-for-emacs 'echorepl-update-score)
nil)))
(etypecase emacs-connection
(swank::multithreaded-connection
(swank::send (swank::mconn.control-thread emacs-connection) event))
(swank::singlethreaded-connection
(swank::dispatch-event emacs-connection event))
(null))))))
(defun undo-push ()
(push *clip-store* *undo-clip-store*)
(push *score* *undo-score*))
(defun undo-pop ()
(setf *clip-store* (pop *undo-clip-store*)
*score* (pop *undo-score*))
(signal-score-update))
(defun redo-push ()
(push *clip-store* *redo-clip-store*)
(push *score* *redo-score*))
(defun redo-pop ()
(setf *clip-store* (pop *redo-clip-store*)
*score* (pop *redo-score*))
(signal-score-update))
(declaim (ftype (function ()) play-score))
(defun reset-score ()
(setf *score* nil)
(play-score)
(setf *clip-store* nil
*undo-clip-store* nil
*redo-clip-store* nil
*undo-score* nil
*redo-score* nil)
(reset-tick)
(format t "~&Reset~%")
(signal-score-update))
(defun undo ()
(if (and *undo-clip-store* *undo-score*)
(progn (redo-push)
(undo-pop)))
(play-score))
(defun redo ()
(if (and *redo-clip-store* *redo-score*)
(progn (undo-push)
(redo-pop)))
(play-score))
| 1,632 | Common Lisp | .lisp | 56 | 25.642857 | 73 | 0.659847 | daniel-bandstra/echorepl | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:23 AM (Europe/Amsterdam) | c595996f3fca918a5d531dfb2f5e472b2e8eb3833655280a499a2e3e05a28629 | 38,754 | [
-1
] |
38,755 | time.lisp | daniel-bandstra_echorepl/time.lisp | (in-package :echorepl)
;; Echorepl keeps track of its own time as a series of moments.
;; The MOMENT struct has a fixnum and a fractional part,
;; because really big FLOATs don't count accurately
(defstruct (moment (:constructor moment (frame fraction))
(:conc-name nil))
(frame 0 :type fixnum)
(fraction 0.0 :type (single-float 0.0 1.0)))
(declaim (ftype (function (moment moment) moment) moment+ moment-)
(ftype (function (moment moment) boolean) moment<)
(inline moment+ moment- moment<))
(defun moment+ (a b)
"Add two moments"
(declare (moment a b)
(optimize (speed 3) (space 0) (safety 0) (debug 1) (compilation-speed 0)))
(multiple-value-bind (add-frame new-fraction) (floor (+ (fraction a)
(fraction b)))
(declare (fixnum add-frame)
(type (single-float 0.0 1.0) new-fraction))
(moment (the fixnum (+ (frame a)
(frame b)
add-frame))
new-fraction)))
(defun moment- (a b)
"Subtract B from A"
(declare (moment a b)
(optimize (speed 3) (space 0) (safety 0) (debug 1) (compilation-speed 0)))
(multiple-value-bind (add-frame new-fraction) (floor (- (fraction a)
(fraction b)))
(declare (fixnum add-frame)
(type (single-float 0.0 1.0) new-fraction))
(moment (the fixnum (+ (- (frame a)
(frame b))
add-frame))
new-fraction)))
(defun moment< (a b)
"Tell if A is before B"
(declare (moment a b)
(optimize (speed 3) (space 0) (safety 0) (debug 1) (compilation-speed 0)))
(or (< (frame a) (frame b))
(and (= (frame a) (frame b))
(< (fraction a) (fraction b)))))
(defun number-moment (number)
"Make a moment out of any real number"
(declare (real number))
(if (integerp number)
(moment number 0.0)
(multiple-value-bind (frame fraction) (floor (coerce number 'single-float))
(moment frame fraction))))
;; in what follows, 'frame' refers to frame-time as tracked by Jack.
(let* ((latency (+ *latency* *jack-buffer-size*))
(now (number-moment -1))
;; rate
(rate (number-moment 1))
(reverse nil)
;; translating jack frame to time
(frame-moment-length (* latency 2))
(frame-moment-array (make-array frame-moment-length
:initial-element (number-moment 0)
:element-type 'moment)))
(declare (moment now rate)
(boolean reverse)
(type (integer 0 #.(1- (expt 2 32)))
frame-moment-length))
(defun reset-tick ()
(setf now (number-moment -1)
rate (number-moment 1)
reverse nil
latency (+ *latency* *jack-buffer-size*)
frame-moment-length (* latency 2)
frame-moment-array (make-array frame-moment-length
:initial-element (number-moment 0)
:element-type 'moment))
t)
(defun tick (frame)
"Update and return the time"
(declare (fixnum frame)
(optimize (speed 3) (space 0) (safety 0)
(debug 0) (compilation-speed 0)))
;; update and return the time
(let ((pos (mod frame frame-moment-length)))
(declare (fixnum pos))
(setf now (if reverse
(moment- now rate)
(moment+ now rate))
(aref frame-moment-array pos) now)))
(defun now ()
"Return the current time"
now)
(defun reverse-time ()
(setf reverse (not reverse)))
(defun frame-moment (frame)
(declare (fixnum frame))
"Translate FRAME to a moment."
(let* ((frame-ago (logand (- frame latency)
#.(1- (expt 2 32))))
(pos (mod frame-ago frame-moment-length)))
(declare (fixnum frame-ago pos))
(aref frame-moment-array pos)))
(defun time-rate (&optional new-rate)
(if new-rate
(setf rate (number-moment (abs new-rate)))
rate)))
;; getting rather accurate moments
(defun usecs-moment (usecs)
"Return the precise moment at USECS"
(if (jack-running)
(let* ((usecs-frame (usecs-frame usecs))
(frame-usecs (frame-usecs usecs-frame))
(pre-frame (if (< usecs frame-usecs)
(logand (1- usecs-frame)
#.(1- (expt 2 32)))
usecs-frame))
(post-frame (logand (1+ pre-frame)
#.(1- (expt 2 32))))
(pre-usecs (frame-usecs pre-frame))
(post-usecs (frame-usecs post-frame))
(fraction (/ (- usecs pre-usecs)
(- post-usecs pre-usecs)))
(pre-moment (frame-moment pre-frame))
(t-diff (moment- (frame-moment post-frame)
pre-moment))
(add-moment (number-moment (* fraction
(+ (frame t-diff)
(fraction t-diff))))))
(moment+ pre-moment add-moment))
(number-moment 0)))
(defun now-moment ()
(usecs-moment (usecs)))
| 4,578 | Common Lisp | .lisp | 129 | 30.031008 | 81 | 0.632486 | daniel-bandstra/echorepl | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:23 AM (Europe/Amsterdam) | 216dd9b83d843d598a7400d5cc0460084b24a16a4adc8b4f603d5eb295e0acde | 38,755 | [
-1
] |
38,756 | record.lisp | daniel-bandstra_echorepl/record.lisp | (in-package :echorepl)
;; thread-do, to put resource-intensive things on a back burner
(defmacro thread-do (&rest body)
(let ((result (gensym))
(thread (gensym)))
`(let* ((,result nil)
(,thread
(make-thread (lambda ()
(setf ,result
(progn ,@body))))))
(join-thread ,thread)
,result)))
;; main record/loop/play farrago
(let (
;; state variables
(running nil)
(state 0)
;; playback, timing, and clips
(play-fun #'play-null)
(master-gain 1.0)
(input-clip (empty-clip)) ;; place-holder
(output-start (number-moment 0))
(clip-start (number-moment 0))
(parent-modulus 0)
(process nil)
)
(declare (boolean running)
(fixnum state)
(single-float master-gain)
(clip input-clip)
(moment output-start clip-start))
;; recording samples, with interpolation
(let ((prev-sample 0.0)
(prev-moment (number-moment 0)))
(declare (single-float prev-sample)
(moment prev-moment))
(defun record-sample (sample moment)
(declare (single-float sample)
(moment moment)
(optimize (speed 3) (space 0) (safety 0)
(debug 1) (compilation-speed 0)))
(flet ((r-s (sample-a moment-a sample-b moment-b)
(declare (single-float sample-a sample-b)
(moment moment-a moment-b))
(let* ((moment-diff (moment- moment-b moment-a))
(t-diff (+ (frame moment-diff) (fraction moment-diff)))
(s-diff (- sample-b sample-a))
(tape-len (tape-len input-clip)))
(declare (type (integer 0 #.most-positive-fixnum) tape-len))
(loop
for i fixnum from (1+ (frame moment-a)) upto (frame moment-b)
for n single-float from (- 1.0 (fraction moment-a)) by 1.0 do
(setf (mem-ref (samples input-clip)
'sample-t
(the fixnum (* (mod i tape-len)
#.(foreign-type-size 'sample-t))))
(+ sample-a (* s-diff
(/ n t-diff))))))))
(declare (inline r-s))
(if (moment< prev-moment moment)
(r-s prev-sample prev-moment sample moment)
(r-s sample moment prev-sample prev-moment)))
(setf prev-sample sample
prev-moment moment)))
;; playing the score
(defun play-score ()
(setf play-fun (thread-do
(compile-score)))
(if *score*
(progn (pedal-color 0 8 0)
(setf parent-modulus (score-modulus *score*)))
(progn (pedal-color 0 0 0)
(setf parent-modulus 0)))
(signal-score-update))
(defun set-play-fun (&optional fun)
(if fun
(setf play-fun fun)
(play-score)
))
;; Looper Control Functions
(defun loop-button (&optional (time (now-moment)))
(case state
(0 (setf clip-start time)
(format t "~&Record~%")
(pedal-color 12 0 0))
(1 (let ((new-clip
(thread-do (create-clip input-clip
clip-start
time
parent-modulus))))
(if (zerop (modulus new-clip)) ;; probably an accidental button-tap
(decf state) ;; so keep recording
(progn
(if (zerop parent-modulus)
(setf output-start (if (moment< time clip-start)
time clip-start))
(setf (offset new-clip)
(let ((big-offset (moment- (if (moment< time clip-start)
time
clip-start)
output-start)))
(multiple-value-bind (discard frame)
(round (frame big-offset) (modulus new-clip))
(declare (ignore discard))
(moment frame
(fraction big-offset))))))
(undo-push)
(push new-clip *clip-store*)
(push (name new-clip)
*score*)
(play-score)
(format t "~&Play ~a~%" (name new-clip)))))))
(setf state (mod (1+ state) 2)))
(defun undo-button ()
(undo)
(setf state 0)
(format t "~&Undo~%")
(pedal-blink 12 8 0))
(defun master-reverse ()
(reverse-time)
(format t "~&Reverse~%"))
(setf process
(lambda (sample frame dst i)
(declare (optimize (speed 3) (space 0) (safety 0)
(debug 0) (compilation-speed 0)))
(let ((play-now (tick frame))
(rec-now (frame-moment frame)))
(record-sample sample rec-now)
(funcall (the function play-fun)
dst i play-now output-start master-gain))))
(defun start-recording (&optional (buffer-length 600))
(if running
(format t "~&Recorder is already running.~%")
(make-thread
(lambda ()
;; recording setup
(reset-tick)
(play-score)
(if (start-jack "echorepl" process)
(progn
(setf running t
input-clip
(let ((new-clip (make-clip :clip-len (* buffer-length
*sample-rate*))))
(clip-setup new-clip)
(setf (modulus new-clip) (tape-len new-clip)
(clip-start-pos new-clip) 0
(fadein-start-pos new-clip) 0
(fadein-end-pos new-clip) 0
(fadeout-start-pos new-clip) (tape-len new-clip)
(fadeout-end-pos new-clip) (tape-len new-clip))
new-clip))
(set-edge-space-defaults)
(sleep (/ (+ *default-half-splice* *default-fudge-factor*)
*sample-rate*))
(unless *score* (pedal-blink 0 8 0))
(format t "~&Ok, ready to record!~%")
;; pedal event loop
(handler-case
(loop while running do
(multiple-value-bind (event moment)
(pedal-read)
(case event
(:a-down (loop-button moment))
(:b-long-tap (undo-button))
(:b-double-tap (master-reverse)))))
(t (c)
(format t "~&Caught error:~%~a" c)))
;; cleanup
(stop-jack)
(pedal-color 0 0 0)
(pedal-blink 12 0 0)
(format t "~&All done!~%")
(sleep 0.1)
(setf state 0
master-gain 1.0
input-clip (empty-clip)
output-start (number-moment 0)
clip-start (number-moment 0))
(gc :full t)))))))
(defun stop-recording ()
(setf running nil)))
| 5,767 | Common Lisp | .lisp | 182 | 25.428571 | 71 | 0.60018 | daniel-bandstra/echorepl | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:23 AM (Europe/Amsterdam) | d6ee33e4b1836b63d266c4daf73f48146bc85a8a303de01ea1c9e8f34ec2e735 | 38,756 | [
-1
] |
38,757 | file.lisp | daniel-bandstra_echorepl/file.lisp | (in-package :echorepl)
(defctype sf-count-t :int64)
(defconstant +sf-read+ #x10)
(defconstant +sf-write+ #x20)
(defconstant +sf-format-wav+ #x010000)
(defconstant +sf-format-float+ #x0006)
(defconstant +sf-file-format+ (logior +sf-format-wav+
+sf-format-float+))
(defcstruct sf-info
(frames sf-count-t)
(sample-rate :int)
(channels :int)
(format :int)
(sections :int)
(seekable :int))
;; file open/close
(defcfun "sf_open" :pointer
(path :string)
(mode :int)
(info :pointer))
(defcfun "sf_write_sync" :void
(file :pointer))
(defcfun "sf_close" :int
(file :pointer))
;; read/write samples
(defcfun "sf_read_float" sf-count-t
(file :pointer)
(dst :pointer)
(count sf-count-t))
(defcfun "sf_write_float" sf-count-t
(file :pointer)
(src :pointer)
(count sf-count-t))
;; string data
(defconstant +sf-str-comment+ #x05)
(defcfun "sf_get_string" :string
(file :pointer)
(str-type :int))
(defcfun "sf_set_string" :int
(file :pointer)
(str-type :int)
(str :string))
;; save a clip
(defun clip-string (clip)
(prin1-to-string `(let ((new-clip
(make-clip
:name ,(name clip)
:sample-rate ,(sample-rate clip)
:clip-len ,(clip-len clip)
:half-splice ,(half-splice clip)
:fudge-factor ,(fudge-factor clip)
:tape (create-tape ,(tape-len clip))
:parent-modulus ,(parent-modulus clip)
:modulus ,(modulus clip)
:offset (moment ,(frame (offset clip))
,(fraction (offset clip))))))
(setf
(clip-start-pos new-clip) ,(clip-start-pos clip)
(fadein-start-pos new-clip) ,(fadein-start-pos clip)
(fadein-end-pos new-clip) ,(fadein-end-pos clip)
(fadeout-start-pos new-clip) ,(fadeout-start-pos clip)
(fadeout-end-pos new-clip) ,(fadeout-end-pos clip)
(splice new-clip) ,(splice clip))
new-clip)))
(defmethod save-clip ((clip clip) (path string))
(with-foreign-objects ((info '(:struct sf-info)))
(setf
(foreign-slot-value info '(:struct sf-info) 'sample-rate) (sample-rate clip)
(foreign-slot-value info '(:struct sf-info) 'channels) 1
(foreign-slot-value info '(:struct sf-info) 'format) +sf-file-format+)
(let ((file (sf-open path
+sf-write+
info)))
(sf-write-float file (samples clip) (tape-len clip))
(sf-set-string file
+sf-str-comment+
(clip-string clip))
(sf-write-sync file)
(sf-close file))))
(defmethod load-clip ((path string))
"Read a file created with SAVE-LOOP"
(with-foreign-object (info '(:struct sf-info))
(setf
(foreign-slot-value info '(:struct sf-info) 'sample-rate) *sample-rate*
(foreign-slot-value info '(:struct sf-info) 'channels) 1
(foreign-slot-value info '(:struct sf-info) 'format) 0)
(let ((file (sf-open path
+sf-read+
info))
(clip nil))
(if (= (foreign-slot-value info '(:struct sf-info) 'format)
+sf-file-format+)
(let ((string (sf-get-string file +sf-str-comment+)))
(setf clip (eval (read-from-string string)))
(sf-read-float file (samples clip) (tape-len clip)))
(format t "File ~a was in the wrong format.~%" path))
(sf-close file)
clip)))
;; pathname stuff
(defun pathname-to-directory (pathname)
"Make sure PATHNAME is a thing that ends with a directory"
(let ((hanging-name (pathname-name pathname)))
(if hanging-name
(merge-pathnames (make-pathname :directory `(:relative ,hanging-name))
(make-pathname :directory (pathname-directory pathname)))
(make-pathname :directory (pathname-directory pathname)))))
(defun save-project (directory)
(let ((directory (pathname-to-directory directory)))
(ensure-directories-exist directory)
(map nil
(lambda (name)
(save-clip (by-name name)
(concatenate 'string
(directory-namestring (truename directory))
(symbol-name name)
".WAV")))
(clip-names-in-score))
(let ((score-path (concatenate 'string
(directory-namestring (truename directory))
"score.lisp")))
(with-open-file (s (merge-pathnames score-path) :direction :output
:if-exists :overwrite
:if-does-not-exist :create)
(prin1 *score* s)))))
(defmacro load-project (directory
&optional (score '*score*) (clips '*clip-store*))
`(let ((directory (probe-file (pathname-to-directory ,directory))))
(if directory
(progn
(setf ,clips
(map 'list
(lambda (file) (load-clip (namestring file)))
(directory (merge-pathnames (make-pathname :name :wild :type "WAV")
directory)))
,score
(let ((score-path (concatenate 'string
(directory-namestring (truename directory))
"score.lisp")))
(if (probe-file score-path)
(with-open-file (s (merge-pathnames score-path)
:direction :input)
(read s))
(mapcar #'name ,clips))))))))
| 4,875 | Common Lisp | .lisp | 143 | 29.146853 | 81 | 0.649682 | daniel-bandstra/echorepl | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:23 AM (Europe/Amsterdam) | 624116e16728a5e2ef17884bbc0e0eaf89a4445d185e7a7cf22a472d522a07de | 38,757 | [
-1
] |
38,758 | clip.lisp | daniel-bandstra_echorepl/clip.lisp | (in-package :echorepl)
;; half-splice and fudge-factor,
;; i.e. extra recording time at beginning and end of clips
(defparameter *default-half-splice* (round (/ *sample-rate* 16)))
(defparameter *default-fudge-factor* *sample-rate*)
(defun set-edge-space-defaults ()
(defparameter *default-half-splice* (round (/ *sample-rate* 16)))
(defparameter *default-fudge-factor* *sample-rate*))
(set-edge-space-defaults)
;; "tape" is the medium of recording:
;; here, a C array of samples, plus information about where the important sound begins
(defcstruct tape
"the medium of audio recording"
;; the samples
(tape-len nframes-t)
(samples :pointer)
;; loop and splice positions
(clip-start-pos nframes-t)
(fadein-start-pos nframes-t)
(fadein-end-pos nframes-t)
(fadeout-start-pos nframes-t)
(fadeout-end-pos nframes-t)
(splice sample-t))
(defcfun "create_tape" :pointer
(tape-len nframes-t))
(defcfun "delete_tape" :void
(tape :pointer))
(defun pos-play (dst i tape pos gain)
(declare (fixnum pos i)
(single-float gain)
(optimize (speed 3) (space 0) (safety 0)
(debug 0) (compilation-speed 0)))
(foreign-funcall "pos_play"
:pointer dst nframes-t i
:pointer tape :long pos :float gain :void))
(defun raw-copy (dst i tape moment)
(declare (fixnum i)
(moment moment)
(optimize (speed 3) (space 0) (safety 0)
(debug 0) (compilation-speed 0)))
(foreign-funcall "raw_copy"
:pointer dst nframes-t i
:pointer tape
:long (frame moment) :float (fraction moment)))
;; a "clip" is tape plus some timing information
(defun new-name (prefix)
(intern (symbol-name (gensym prefix)) "KEYWORD"))
(defstruct (clip (:conc-name nil)
(:print-function (lambda (clip stream depth)
(declare (ignore depth))
(format stream "#<CLIP :~a>" (name clip)))))
(name (new-name "CLIP") :type symbol)
;; useful for file save
(sample-rate *sample-rate* :type fixnum)
;; timing
(clip-len 0 :type fixnum)
(half-splice *default-half-splice* :type fixnum)
(fudge-factor *default-fudge-factor* :type fixnum)
;; tape
tape
;; synchronization
(offset (number-moment 0) :type moment)
(modulus 0 :type fixnum)
(parent-modulus 0 :type fixnum))
;; accessing tape values
(defun tape-len (clip)
(foreign-slot-value (tape clip) '(:struct tape) 'tape-len))
(defun samples (clip)
(foreign-slot-value (tape clip) '(:struct tape) 'samples))
(defmacro getter-and-setter (name)
(let ((setter (intern (concatenate 'string "set-" (symbol-name name)))))
`(progn
(defun ,name (clip)
(foreign-slot-value (tape clip) '(:struct tape) ',name))
(defun ,setter (clip val)
(setf
(foreign-slot-value (tape clip) '(:struct tape) ',name)
val))
(defsetf ,name ,setter))))
(getter-and-setter clip-start-pos)
(getter-and-setter fadein-start-pos)
(getter-and-setter fadein-end-pos)
(getter-and-setter fadeout-start-pos)
(getter-and-setter fadeout-end-pos)
(getter-and-setter splice)
;; clip basic timing and position setup
(defun set-start-pos (clip &optional start-pos)
(setf
(clip-start-pos clip) (or start-pos
(+ (half-splice clip)
(fudge-factor clip)))
(fadein-start-pos clip) (- (clip-start-pos clip)
(half-splice clip))
(fadein-end-pos clip) (+ (clip-start-pos clip)
(half-splice clip))))
(defun set-modulus (clip)
(setf (modulus clip)
(if (zerop (parent-modulus clip))
(if (zerop (clip-len clip))
1
(clip-len clip))
(let* ((max-modulus (* (ceiling (clip-len clip) (parent-modulus clip))
(parent-modulus clip)))
(smaller-modulus (- max-modulus (parent-modulus clip))))
(if (< (abs (- smaller-modulus (clip-len clip)))
(fudge-factor clip))
smaller-modulus
max-modulus)))))
(defun set-end-pos (clip)
(let ((end-pos (+ (clip-start-pos clip)
(if (< (abs (- (modulus clip) (clip-len clip)))
(fudge-factor clip))
(modulus clip)
(clip-len clip)))))
(setf
(fadeout-start-pos clip) (- end-pos (half-splice clip))
(fadeout-end-pos clip) (+ end-pos (half-splice clip)))))
(defun clip-setup (clip)
"Infer the contents of various slots in CLIP"
(setf
(tape clip) (create-tape (+ (clip-len clip) (* 2 (+ (half-splice clip)
(fudge-factor clip))))))
(set-modulus clip)
(set-start-pos clip)
(set-end-pos clip)
(setf (splice clip) (coerce (* (half-splice clip) 2) 'single-float))
(let ((tape (tape clip)))
(finalize clip
(lambda () (delete-tape tape)))))
(defun empty-clip ()
(let ((clip (make-clip)))
(clip-setup clip)
clip))
;; create clip
(defun create-clip (input-clip
start
end
parent-modulus)
(declare (clip input-clip)
(moment start end)
(fixnum parent-modulus)
(optimize (speed 3) (space 0) (safety 0)
(debug 0) (compilation-speed 0)))
(let* ((edge-space (+ (the fixnum *default-half-splice*)
(the fixnum *default-fudge-factor*)))
(edge-time (number-moment edge-space)))
(declare (fixnum edge-space)
(moment edge-time))
(if (moment< start end)
;; clock is going forward
(let*
((clip-start (moment- start edge-time))
(clip-end (moment+ end edge-time))
(moment-length (moment- end start))
(clip-len (+ (frame moment-length)
(if (< (fraction moment-length) 0.5) 0 1)))
(first-chunk (+ clip-len edge-space))
(new-clip (make-clip :clip-len clip-len
:parent-modulus parent-modulus)))
(declare (fixnum clip-len first-chunk))
(clip-setup new-clip)
(let ((dst (samples new-clip))
(tape (tape input-clip)))
(loop for i fixnum below first-chunk do
(progn
(raw-copy dst i tape clip-start)
(incf (frame clip-start))))
(make-thread
(lambda ()
(loop while (moment< (now) clip-end) do
(sleep 0.1))
(loop for i fixnum from first-chunk below (tape-len new-clip) do
(progn
(raw-copy dst i tape clip-start)
(incf (frame clip-start)))))))
new-clip)
;; otherwise clock is going backwards
(let* ((end (copy-moment end))
(clip-start (moment- end edge-time))
(clip-end (moment+ start edge-time))
(moment-len (moment- start end))
(clip-len (+ (frame moment-len)
(if (< (fraction moment-len) 0.5) 0 1)))
(new-clip (make-clip :clip-len clip-len
:parent-modulus parent-modulus)))
(clip-setup new-clip)
(let ((dst (samples new-clip))
(tape (tape input-clip)))
(loop
for i fixnum from edge-space below (tape-len new-clip) do
(progn
(raw-copy dst i tape end)
(incf (frame end))))
(make-thread
(lambda ()
(loop while (moment< clip-end (now)) do
(sleep 0.1))
(loop for i fixnum below edge-space do
(progn
(raw-copy dst i tape clip-start)
(incf (frame clip-start)))))))
new-clip))))
| 6,898 | Common Lisp | .lisp | 202 | 29.49505 | 86 | 0.649745 | daniel-bandstra/echorepl | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:23 AM (Europe/Amsterdam) | ec14f85925ebbe6d725b9ea213bbc2e04568ff4a32fc4f1d1cd9e776af4775ca | 38,758 | [
-1
] |
38,759 | callback.lisp | daniel-bandstra_echorepl/callback.lisp | (in-package :echorepl)
(defcstruct callback-info
(monitor :int)
(client :pointer)
(in-port :pointer)
(out-port :pointer)
(buffer-size nframes-t)
(in-buf :pointer)
(frames-buf :pointer)
(out-buf :pointer))
(defcfun "new_callback_info" :pointer
(buffer-size :unsigned-int))
(defcfun "delete_callback_info" :void
(container :pointer))
(defun get-sample-frame (callback-info)
(declare (optimize (speed 3) (space 0) (safety 0)
(debug 0) (compilation-speed 0)))
(foreign-funcall "get_sample_frame"
:pointer callback-info
nframes-t))
(defun get-sample (callback-info)
(declare (optimize (speed 3) (space 0) (safety 0)
(debug 0) (compilation-speed 0)))
(foreign-funcall "get_sample"
:pointer callback-info
sample-t))
| 781 | Common Lisp | .lisp | 26 | 26.269231 | 51 | 0.695302 | daniel-bandstra/echorepl | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:23 AM (Europe/Amsterdam) | f210298522033222b3707100d6c08f13fd1b98f2333f56f9fe6c8542d6fbbd63 | 38,759 | [
-1
] |
38,760 | echorepl.asd | daniel-bandstra_echorepl/echorepl.asd | (defsystem "echorepl"
:name "echorepl"
:version "0.0.1"
:author "Daniel Bandstra"
:license "GPLv3"
:description "echorepl"
:long-description "A lisp DSL for recording and looping audio"
:depends-on ("cffi" "bordeaux-threads" "trivial-garbage")
:serial t
:components ((:file "package")
(:file "callback")
(:file "jack")
(:file "time")
(:file "pedal")
(:file "clip")
(:file "undo")
(:file "play")
(:file "record")
(:file "file")))
| 519 | Common Lisp | .asd | 19 | 21.578947 | 64 | 0.578 | daniel-bandstra/echorepl | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:23 AM (Europe/Amsterdam) | 2394af03a713f1d73689b0211d00ff3e8a976685685258e897048521815edd7a | 38,760 | [
-1
] |
38,765 | Makefile | daniel-bandstra_echorepl/Makefile | SUBDIRS = pedal engine
all: $(SUBDIRS)
$(SUBDIRS):
$(MAKE) -C $@
.PHONY: $(SUBDIRS)
| 88 | Common Lisp | .l | 5 | 15.8 | 22 | 0.65 | daniel-bandstra/echorepl | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:23 AM (Europe/Amsterdam) | bc1a291c067f999549282d3595ed28a28908cb9553f90dfb95a7a7b800d83d24 | 38,765 | [
-1
] |
38,774 | edit-score.el | daniel-bandstra_echorepl/edit-score.el | ;;;; Edit *score* interactively --- a slight modification of slime-edit-value
;;;
(setq score-buffer-name "*echorepl edit score*")
(defun echorepl-edit-score ()
"\\<echorepl-edit-score-mode-map>\
Edit the value of echorepl::*score*
The value is inserted into a temporary buffer for editing and then set
in Lisp when committed with \\[echorepl-edit-score-commit]."
(interactive)
(slime-eval-async `(swank:value-for-editing "*score*")
#'echorepl-edit-score-callback
"echorepl"))
(global-set-key (kbd "C-c e") 'echorepl-edit-score)
(global-set-key (kbd "C-c r") 'echorepl-rename-clip)
(global-set-key (kbd "C-c z") 'echorepl-undo)
(global-set-key (kbd "C-c M-z") 'echorepl-redo)
(defun echorepl-undo ()
(interactive)
(slime-eval-async `(echorepl:undo)))
(defun echorepl-redo ()
(interactive)
(slime-eval-async `(echorepl:redo)))
(define-minor-mode echorepl-edit-score-mode
"Mode for editing echorepl::*score*"
nil
"Edit-Value"
'(("\C-c\C-c" . echorepl-edit-score-commit)))
(defun echorepl-edit-score-callback (score)
(let ((buffer
(or (get-buffer score-buffer-name)
(slime-with-popup-buffer (score-buffer-name :package "echorepl"
:connection t
:select t
:mode 'lisp-mode)
(slime-popup-buffer-mode -1) ; don't want binding of 'q'
(slime-mode 1)
(echorepl-edit-score-mode 1)
(current-buffer)))))
(with-current-buffer buffer
(setq buffer-read-only nil)
(erase-buffer)
(insert score)
(message "Type C-c C-c to save and compile the score."))
(pop-to-buffer buffer)))
(defun echorepl-update-score-callback (score)
(let ((buffer (get-buffer score-buffer-name)))
(if buffer
(with-current-buffer buffer
(setq buffer-read-only nil)
(erase-buffer)
(insert score)))))
(defslimefun echorepl-update-score (_)
(slime-eval-async `(swank:value-for-editing "*score*")
#'echorepl-update-score-callback
"echorepl"))
(defun echorepl-edit-score-commit ()
"Commit the edited score to the Lisp image.
\\(See `echorepl-edit-score'.)"
(interactive)
(let ((value (buffer-substring-no-properties (point-min) (point-max))))
(lexical-let ((buffer (current-buffer)))
(slime-eval-async `(cl:progn
(echorepl::undo-push)
(swank:commit-edited-value "*score*"
,value))
(lambda (_)
(slime-eval-async `(echorepl::play-score)))))))
(defun echorepl-rename-clip ()
(interactive)
(let* ((name (or (slime-symbol-at-point)
(read-string "Clip to rename: ")))
(new-name (read-string (concat "Rename " name " to: "))))
(slime-eval-async
`(echorepl::rename-for-slime ,name ,new-name)
#'echorepl-update-score)))
| 2,689 | Common Lisp | .l | 75 | 31.8 | 77 | 0.676911 | daniel-bandstra/echorepl | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:23 AM (Europe/Amsterdam) | e4f13181c1b262bef8af54d25bb1388a49af0ba1e56556c4c68cec033296d9b8 | 38,774 | [
-1
] |
38,776 | callback.c | daniel-bandstra_echorepl/engine/callback.c | #include "callback.h"
#include <stdlib.h>
#include <string.h>
#include <sys/mman.h>
callback_info *new_callback_info(size_t buffer_size) {
callback_info *result = calloc(1, sizeof(callback_info));
mlock(result, sizeof(callback_info));
result->buffer_size = buffer_size;
result->in_buf = jack_ringbuffer_create(buffer_size * sizeof(sample_t));
jack_ringbuffer_mlock(result->in_buf);
result->frames_buf = jack_ringbuffer_create(buffer_size * sizeof(nframes_t));
jack_ringbuffer_mlock(result->frames_buf);
result->out_buf = calloc(buffer_size, sizeof(sample_t));
mlock(result->out_buf, buffer_size * sizeof(sample_t));
pthread_mutex_init(&result->lock, NULL);
pthread_cond_init(&result->cond, NULL);
return result;
}
void delete_callback_info(callback_info *container) {
pthread_mutex_destroy(&container->lock);
pthread_cond_destroy(&container->cond);
jack_ringbuffer_free(container->in_buf);
jack_ringbuffer_free(container->frames_buf);
munlock(container->out_buf, container->buffer_size * sizeof(sample_t));
free(container->out_buf);
munlock(container, sizeof(callback_info));
free(container);
}
int echorepl_callback(nframes_t count, void *info_ptr) {
sample_t *in, *out;
callback_info *info = (callback_info *)info_ptr;
nframes_t time = jack_last_frame_time(info->client);
in = jack_port_get_buffer(info->in_port, count);
out = jack_port_get_buffer(info->out_port, count);
if (info->monitor) {
memcpy(out, in, count * sizeof(sample_t));
} else {
memset(out, 0, count * sizeof(sample_t));
}
jack_ringbuffer_write(info->in_buf,
(char *)in,
count * sizeof(sample_t));
for (nframes_t i = 0; i < count; i++) {
jack_ringbuffer_write(info->frames_buf, (char *)&time, sizeof(nframes_t));
info->out_buf[time % info->buffer_size] = 0.0;
out[i] += info->out_buf[(time + 1) % info->buffer_size];
time++;
}
pthread_cond_broadcast(&info->cond);
return 0;
}
// functions for lisp to read/write
nframes_t get_sample_frame(callback_info *info) { // this is blocking, call it first
nframes_t time;
pthread_mutex_lock(&info->lock);
while(jack_ringbuffer_read(info->frames_buf,
(char *)&time,
sizeof(nframes_t)) == 0) {
pthread_cond_wait(&info->cond, &info->lock);
}
pthread_mutex_unlock(&info->lock);
return time;
}
sample_t get_sample(callback_info *info) {
sample_t sample;
jack_ringbuffer_read(info->in_buf, (char *)&sample, sizeof(sample_t));
return sample;
}
| 2,524 | Common Lisp | .l | 68 | 33.5 | 84 | 0.697347 | daniel-bandstra/echorepl | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:23 AM (Europe/Amsterdam) | 8b7ddefe969c83d1f7bbc895a70b61e36b70e25630aaa84365c731d4f9acf18d | 38,776 | [
-1
] |
38,777 | Makefile | daniel-bandstra_echorepl/engine/Makefile | all: libengine.so
callback.o: callback.c callback.h
gcc -O3 -Wall -Wextra -fpic -c callback.c
tape.o: tape.c tape.h
gcc -O3 -Wall -Wextra -fpic -c tape.c
libengine.so: callback.o tape.o
gcc -shared -o libengine.so callback.o tape.o
clean:
rm -f *.o *.so
| 268 | Common Lisp | .l | 9 | 27.444444 | 47 | 0.709804 | daniel-bandstra/echorepl | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:23 AM (Europe/Amsterdam) | 592fe2f145ebaea504232145971c76f24a285968814b46a798e82047da1f4238 | 38,777 | [
-1
] |
38,778 | callback.h | daniel-bandstra_echorepl/engine/callback.h | #ifndef CALLBACK_H
#define CALLBACK_H
#include <jack/jack.h>
#include <jack/ringbuffer.h>
#include <pthread.h>
#include <stdint.h>
typedef jack_default_audio_sample_t sample_t;
typedef jack_nframes_t nframes_t;
typedef struct callback_info_ {
int monitor; // whether Jack should do software monitoring
jack_client_t *client;
jack_port_t *in_port;
jack_port_t *out_port;
nframes_t buffer_size;
jack_ringbuffer_t *in_buf;
jack_ringbuffer_t *frames_buf;
sample_t *out_buf;
pthread_mutex_t lock;
pthread_cond_t cond;
} callback_info;
callback_info *new_callback_info(size_t);
void delete_callback_info(callback_info *);
int echorepl_callback(nframes_t, void *);
// functions for lisp to read/write
nframes_t get_sample_frame(callback_info *); // this is blocking, call it first
sample_t get_sample(callback_info *);
#endif
| 860 | Common Lisp | .l | 27 | 29.333333 | 79 | 0.759852 | daniel-bandstra/echorepl | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:23 AM (Europe/Amsterdam) | 02dad0a4311ad38e17adaf0b952cdf72dd5bfced36bf20063a17c8aa94688dc9 | 38,778 | [
-1
] |
38,779 | pedal.h | daniel-bandstra_echorepl/pedal/pedal.h | #ifndef PEDAL_H
#define PEDAL_H
#include <jack/jack.h>
struct pedal_event {
char event;
jack_time_t time;
};
int open_pedal(char *);
void close_pedal(int);
int pedal_color(int, int, int, int);
void read_pedal(int, struct pedal_event *);
#endif
| 254 | Common Lisp | .l | 12 | 19.333333 | 43 | 0.733051 | daniel-bandstra/echorepl | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:23 AM (Europe/Amsterdam) | ed09becfc37d977f80d4411750fe58ef40130b80f3c6d03abac46133d4b5c17f | 38,779 | [
-1
] |
38,780 | Makefile | daniel-bandstra_echorepl/pedal/Makefile | all: libpedal.so
pedal.o: pedal.c pedal.h
gcc -O3 -Wall -Wextra -fpic -c pedal.c
libpedal.so: pedal.o
gcc -shared -o libpedal.so pedal.o
clean:
rm -f *.o *.so
| 169 | Common Lisp | .l | 7 | 21.857143 | 40 | 0.691824 | daniel-bandstra/echorepl | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:23 AM (Europe/Amsterdam) | 97cc722dfa4c0b0d6fde0ba767b34b9e3f4b0d6223d932621ce3b1f134fcd22e | 38,780 | [
-1
] |
38,781 | pedal.c | daniel-bandstra_echorepl/pedal/pedal.c | #include "pedal.h"
#include "pedal/pedal_flags.h"
#include <fcntl.h>
#include <termios.h>
#include <unistd.h>
int open_pedal(char *portname) {
// open the terminal
int fd = open(portname, O_RDWR | O_NOCTTY);
if (fd < 0) {
return fd;
}
// get the options already set
struct termios options;
tcgetattr(fd, &options);
// set options for Arduino
// speed
cfsetispeed(&options, B9600);
cfsetospeed(&options, B9600);
options.c_cflag &= ~PARENB; // no parity bit
options.c_cflag &= ~CSTOPB; // no stop bit
options.c_cflag &= ~CSIZE; // 8 bit bytes
options.c_cflag |= CS8;
options.c_cflag &= ~CRTSCTS; // no hardware flow control
options.c_cflag |= CREAD | CLOCAL; // enable receiver, local line
options.c_iflag &= ~(IXON | IXOFF | IXANY); // enable software flow control
options.c_lflag &= ~(ICANON | ECHO | ECHOE | ISIG); // raw input
options.c_oflag &= ~OPOST; // no output processing
options.c_cc[VMIN] = 0; // don't block if there's no data
options.c_cc[VTIME] = 10; // but wait 1 second to see
// commit new options
tcsetattr(fd, TCSANOW, &options);
tcflush(fd, TCIFLUSH); // flush the buffer
return fd;
}
void close_pedal(int fd) {
pedal_color(fd, 0, 0, 0);
close(fd);
}
int pedal_color(int fd, int red, int green, int blue) {
char buf[2];
int error = 6;
buf[0] = led_red;
buf[1] = red;
error -= write(fd, buf, 2);
buf[0] = led_green;
buf[1] = green;
error -= write(fd, buf, 2);
buf[0] = led_blue;
buf[1] = blue;
error -= write(fd, buf, 2);
tcflush(fd, TCIFLUSH);
return error;
}
void read_pedal(int fd, struct pedal_event *event) {
char c;
event->event = read(fd, &c, 1) ? c : nothing;
event->time = jack_get_time();
}
| 1,735 | Common Lisp | .l | 58 | 26.965517 | 77 | 0.653382 | daniel-bandstra/echorepl | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:23 AM (Europe/Amsterdam) | 93e27bbdd64e02aa5d8fbfed95515ed7b6bc945bd03c660bc7f158af3c8cde66 | 38,781 | [
-1
] |
38,782 | pedal.ino | daniel-bandstra_echorepl/pedal/pedal/pedal.ino | #include "pedal_flags.h"
#define UP HIGH
#define DOWN LOW
// Button
const int a_button_pin = 2;
const int b_button_pin = 3;
const unsigned long debounce_delay = 10;
const unsigned long long_time = 1000; // timing a long tap
const unsigned long double_time = 500; // timing a double tap
int a_button_state = UP;
int a_reading;
int a_last_reading = UP;
unsigned long a_debounce_time = 0;
unsigned long a_down_time;
int b_button_state = UP;
int b_reading;
int b_last_reading = UP;
unsigned long b_debounce_time = 0;
unsigned long b_down_time;
// LED
const int red_pin = 11;
const int green_pin = 10;
const int blue_pin = 9;
void red(int value) {analogWrite(red_pin, 255 - value);}
void green(int value) {analogWrite(green_pin, 255 - value);}
void blue(int value) {analogWrite(blue_pin, 255 - value);}
void setup() {
pinMode(a_button_pin, INPUT_PULLUP);
pinMode(b_button_pin, INPUT_PULLUP);
pinMode(red_pin, OUTPUT);
pinMode(green_pin, OUTPUT);
pinMode(blue_pin, OUTPUT);
red(0);
green(0);
blue(0);
//start the serial interface
Serial.begin(9600);
}
void loop() {
unsigned long now = millis();
// Button A
a_reading = digitalRead(a_button_pin);
if (a_reading != a_last_reading) {
a_debounce_time = now;
a_last_reading = a_reading;
} else if (((now - a_debounce_time) > debounce_delay) && (a_reading != a_button_state)) {
a_button_state = a_reading;
if (a_button_state == DOWN) {
Serial.write(a_down);
if ((now - a_down_time) < double_time) {
Serial.write(a_double_tap);
}
a_down_time = now;
} else {
Serial.write(a_up);
}
}
if ((a_button_state == DOWN) && ((now - a_down_time) > long_time)) {
Serial.write(a_long_tap);
a_down_time = now;
}
// Button B
b_reading = digitalRead(b_button_pin);
if (b_reading != b_last_reading) {
b_debounce_time = now;
b_last_reading = b_reading;
} else if (((now - b_debounce_time) > debounce_delay) && (b_reading != b_button_state)) {
b_button_state = b_reading;
if (b_button_state == DOWN) {
Serial.write(b_down);
if ((now - b_down_time) < double_time) {
Serial.write(b_double_tap);
}
b_down_time = now;
} else {
Serial.write(b_up);
}
}
if ((b_button_state == DOWN) && ((now - b_down_time) > long_time)) {
Serial.write(b_long_tap);
b_down_time = now;
}
// Serial Read
if (Serial.available() > 0) {
char c = Serial.read();
switch (c) {
case led_red:
while (Serial.available() < 1) {}
red(Serial.read());
break;
case led_green:
while (Serial.available() < 1) {}
green(Serial.read());
break;
case led_blue:
while (Serial.available() < 1) {}
blue(Serial.read());
break;
default:
break;
}
}
}
| 2,818 | Common Lisp | .l | 103 | 23.436893 | 91 | 0.628539 | daniel-bandstra/echorepl | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:23 AM (Europe/Amsterdam) | 45d5eac09a3bfb27ca72658e6e86554847a455725c62ffe654490e0bb0b1f7f3 | 38,782 | [
-1
] |
38,783 | pedal_flags.h | daniel-bandstra_echorepl/pedal/pedal/pedal_flags.h | #ifndef PEDAL_FLAGS_H
#define PEDAL_FLAGS_H
enum Pedal_Flags {
nothing,
a_down,
a_up,
a_long_tap,
a_double_tap,
b_down,
b_up,
b_long_tap,
b_double_tap,
led_red,
led_green,
led_blue
};
#endif
| 217 | Common Lisp | .l | 17 | 10.235294 | 21 | 0.671717 | daniel-bandstra/echorepl | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:23 AM (Europe/Amsterdam) | 270ada4c99fa433b8e18334d2a6fa7861f3f8179db2c92143dae560ea6ff6cf6 | 38,783 | [
-1
] |
38,798 | project-code-mf2977.lisp | volb_album_topper/project-code-mf2977.lisp | (quicklisp:quickload :imago)
(quicklisp:quickload :drakma)
(quicklisp:quickload :opticl)
(defpackage :cover-topper (:use :cl :drakma :imago :opticl))
(in-package :cover-topper)
(defvar wth 250)
(defvar hgt 250)
(defvar cols 2)
(defvar rows 2)
(deftype binary () '(unsigned-byte 8))
(defun split-by-one-newline (string)
"Returns a list of substrings of string
divided by ONE newline each.
Note: Two consecutive spaces will be seen ash
if there were an empty string between them."
(loop for i = 0 then (1+ j)
as j = (position #\newline string :start i)
collect (subseq string i j)
while j))
(defun read-file-to-string (pathname)
(with-open-file (in pathname :direction :input
:external-format :utf-8)
(let ((seq (make-string (file-length in))))
(read-sequence seq in)
seq)))
(defvar raw_string (read-file-to-string "albums.txt"))
(defvar names (split-by-one-newline raw_string))
(defun create-chart ()
(declare (optimize (speed 3) (safety 0)))
(let ((height (* cols wth)) (width (* rows hgt)))
(let ((img (make-8-bit-rgb-image height width)))
(declare (type 8-bit-rgb-image img))
(fill-image img 0 0 0)
img)))
(defun save-chart ()
(let ((img (create-chart)))
(write-png-file "chart.png" img)))
(defvar canvas (save-chart))
(defun download-and-save-covers (lst)
(loop for i from 0 to (- (length lst) 2)
do
(with-open-file (my-stream (format nil "~D.jpg" i)
:direction :output
:element-type 'binary
:if-does-not-exist :create
:if-exists :supersede)
(let ((content (drakma:http-request (format nil "https://coverartarchive.org/release-group/~A/front-250.jpg" (nth i lst)))))
(loop for j across content do
(write-byte j my-stream))))
(write-png-file (format nil "~D.png" i) (read-jpeg-file (format nil "~D.jpg" i)))))
;; that thing in front of the front-250 is the MBID, distinguishes each album or "release group"
(download-and-save-covers names)
(defun apply-covers (base lst)
(let ((base-of-chart (read-png base)))
(loop for i from 0 to (- (length lst) 2)
do (let ((operator (imago::default-compose-operator base-of-chart))
(cover (read-png (format nil "~D.png" i))))
(write-png (compose nil base-of-chart cover (+ 0 (* i wth)) 0 operator) base)))))
(apply-covers "chart.png" names)
| 2,496 | Common Lisp | .lisp | 59 | 35.983051 | 135 | 0.631644 | volb/album_topper | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:23 AM (Europe/Amsterdam) | 05719f761a3186d3842328ecd13abf64c5520fd303af4f8104c9f7195b6d495f | 38,798 | [
-1
] |
38,815 | roberts_rules_of_order.lisp | codemac_lisp/roberts_rules_of_order.lisp | (in-package :net.codemac.ronr)
;; For RONR we define a statemchine to handle meetings.
;;
;; First, for each meeting we have an agenda
;; agenda:
| 148 | Common Lisp | .lisp | 5 | 28.2 | 55 | 0.739437 | codemac/lisp | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:31 AM (Europe/Amsterdam) | 969fbeed6332e123faaf7b671165e94f9deb65d7fd6b29f673dc547bab8b8d55 | 38,815 | [
-1
] |
38,832 | languages.lisp | along-emacs_cl-ygo/languages.lisp | ;;;; languages.lisp -*- coding: utf-8-unix; -*-
(in-package :cl-ygo)
(defvar *locale-string* nil)
(defvar *lang-seq* '(:zh-cn :zh-tw :en-us :ja-jp))
(defun init-locale-string (&rest categories)
(setq *locale-string* nil)
(loop for key in categories do
(setf (getf *locale-string* key) nil)))
(defun add-locale-string-item (category item lang-code string)
(pushnew (cons lang-code string)
(getf (getf *locale-string* category) item)
:test #'equal))
(defun get-locale-string-item (category item lang-code)
(cdr (assoc lang-code
(getf (getf *locale-string* category) item))))
(defmacro with-category (category action sub-category &rest args)
(cond ;TODO: add other action like remove...
((equal action 'add)
`(progn
,@(loop
for (lang string) on args by #'cddr
collect `(add-locale-string-item ,category ,sub-category
,lang ,string))))
(t ``t)))
(init-locale-string :card-category
:monster-category
:spell-category
:trap-category
:attribute :type
:race :zone :summon
:action :phase :other)
(with-category :card-category add :monster
:zh-cn "怪兽"
:zh-tw "怪獸"
:ja-jp "モンスタ")
(with-category :card-category add :spell
:zh-cn "魔法"
:zh-tw "魔法"
:ja-jp "魔法")
(with-category :card-category add :trap
:zh-cn "陷阱"
:zh-tw "陷阱"
:ja-jp "罠")
(with-category :monster-category add :normal
:zh-cn "通常"
:zh-tw "通常"
:ja-jp "通常")
(with-category :monster-category add :effect
:zh-cn "效果"
:zh-tw "效果"
:ja-jp "効果")
(with-category :monster-category add :fusion
:zh-cn "融合"
:zh-tw "融合"
:ja-jp "融合")
(with-category :monster-category add :ritual
:zh-cn "仪式"
:zh-tw "儀式"
:ja-jp "儀式")
(with-category :monster-category add :tuner
:zh-cn "调整"
:zh-tw "協調"
:ja-jp "チューナー")
(with-category :monster-category add :synchro
:zh-cn "同调"
:zh-tw "同步"
:ja-jp "シンクロ")
(with-category :monster-category add :xyz
:zh-cn "超量"
:zh-tw "超量"
:ja-jp "エクシーズ")
(with-category :monster-category add :pendulum
:zh-cn "灵摆"
:zh-tw "靈擺"
:ja-jp "ペンデュラム")
(with-category :monster-category add :trap
:zh-cn "陷阱怪兽"
:zh-tw "陷阱怪獸"
:ja-jp "罠モンスター")
(with-category :monster-category add :spirit
:zh-cn "灵魂"
:zh-tw "靈魂"
:ja-jp "スピリット")
(with-category :monster-category add :union
:zh-cn "同盟"
:zh-cn "聯合"
:ja-jp "ユニオン")
(with-category :monster-category add :gemini
:zh-cn "二重"
:zh-tw "二重"
:ja-jp "デュアル")
(with-category :monster-category add :flip
:zh-cn "反转"
:zh-tw "反轉"
:ja-jp "リバース")
(with-category :monster-category add :toon
:zh-cn "卡通"
:zh-tw "卡通"
:ja-jp "トゥーン")
(with-category :monster-category add :token
:zh-cn "衍生物"
:zh-tw "代幣"
:ja-jp "トークン")
(with-category :spell-category add :normal
:zh-cn "通常"
:zh-tw "通常"
:ja-jp "通常")
(with-category :spell-category add :quick-play
:zh-cn "速攻"
:zh-tw "速攻"
:ja-jp "速攻")
(with-category :spell-category add :continuous
:zh-cn "永续"
:zh-tw "永續"
:ja-jp "永続")
(with-category :spell-category add :equip
:zh-cn "装备"
:zh-tw "裝備"
:ja-jp "装備")
(with-category :spell-category add :field
:zh-cn "场地"
:zh-tw "場地"
:ja-jp "フィールド")
(with-category :spell-category add :ritual
:zh-cn "仪式"
:zh-tw "儀式"
:ja-jp "儀式")
(with-category :trap-category add :normal
:zh-cn "通常"
:zh-tw "通常"
:ja-jp "通常")
(with-category :trap-category add :continuous
:zh-cn "永续"
:zh-tw "永續"
:ja-jp "永続")
(with-category :trap-category add :counter
:zh-cn "反击"
:zh-tw "反擊"
:ja-jp "カウンター")
(with-category :attribute add :earth
:zh-cn "地"
:zh-tw "地"
:ja-jp "地")
(with-category :attribute add :water
:zh-cn "水")
(with-category :attribute add :fire
:zh-tw "炎"
:ja-jp "炎")
(with-category :attribute add :wind
:zh-tw "風"
:ja-jp "風")
(with-category :attribute add :light
:zh-tw "光"
:ja-jp "光")
(with-category :attribute add :dark
:zh-tw "闇"
:ja-jp "闇")
(with-category :attribute add :divine
:zh-tw "神"
:ja-jp "神")
(with-category :type add :warrior
:zh-tw "戰士"
:ja-jp "戦士族")
(with-category :type add :spellcaster
:zh-tw "魔法使"
:ja-jp "魔法使い族")
(with-category :type add :fairy
:zh-tw "天使"
:ja-jp "天使族")
(with-category :type add :fiend
:zh-tw "惡魔"
:ja-jp "悪魔族")
(with-category :type add :zombie
:zh-tw "不死"
:ja-jp "アンデット族")
(with-category :type add :machine
:zh-tw "機械"
:ja-jp "機械族")
(with-category :type add :aqua
:zh-tw "水"
:ja-jp "水族")
(with-category :type add :pyro
:zh-tw "炎"
:ja-jp "炎族")
(with-category :type add :rock
:zh-tw "岩石"
:ja-jp "岩石族")
(with-category :type add :winged
:zh-tw "鳥獸"
:ja-jp "鳥獣族")
(with-category :type add :plant
:zh-tw "植物"
:ja-jp "植物族")
(with-category :type add :insect
:zh-tw "昆蟲"
:ja-jp "昆虫族")
(with-category :type add :thunder
:zh-tw "雷"
:ja-jp "雷族")
(with-category :type add :dragon
:zh-tw "龍"
:ja-jp "ドラゴン族")
(with-category :type add :beast
:zh-tw "獸"
:ja-jp "獣族")
(with-category :type add :beast-warrior
:zh-tw "獸戰士"
:ja-jp "獣戦士族")
(with-category :type add :dinosaur
:zh-tw "恐龍"
:ja-jp "恐竜族")
(with-category :type add :fish
:zh-tw "魚"
:ja-jp "魚族")
(with-category :type add :sea-serpent
:zh-tw "海龍"
:ja-jp "海竜族")
(with-category :type add :reptile
:zh-tw "爬蟲類"
:ja-jp "爬虫類族")
(with-category :type add :psychic
:zh-tw "超能"
:ja-jp "サイキック族")
(with-category :type add :divine-beast
:zh-tw "幻神獸"
:ja-jp "幻神獣族")
(with-category :type add :creator-god
:zh-tw "創造神"
:ja-jp "創造神族")
(with-category :type add :wyrm
:zh-tw "幻龍"
:ja-jp "幻竜族")
(with-category :zone add :deck
:zh-tw "牌組"
:ja-jp "デッキ")
(with-category :zone add :hand
:zh-tw "手牌"
:ja-jp "手札")
(with-category :zone add :monster
:zh-tw "怪獸區"
:ja-jp "モンスターゾーン")
(with-category :zone add :spell&trap
:zh-tw "魔法陷阱區"
:ja-jp "魔法＆罠ゾーン")
(with-category :zone add :graveyard
:zh-tw "墓地"
:ja-jp "墓地")
(with-category :zone add :banished
:zh-tw "除外區"
:ja-jp "除外ゾーン")
(with-category :zone add :extra
:zh-tw "額外牌組"
:ja-jp "エクストラデッキ")
(with-category :zone add :overlay
:zh-tw "超量素材"
:ja-jp "Ｘ素材")
(with-category :zone add :field
:zh-tw "場地區"
:ja-jp "フィールドゾーン")
(with-category :zone add :pendulum
:zh-tw "靈擺區"
:ja-jp "ペンデュラムゾーン")
(with-category :summon add :normal
:zh-tw "通常召喚"
:ja-jp "通常召喚")
(with-category :summon add :special
:zh-tw "特殊召喚"
:ja-jp "特殊召喚")
(with-category :summon add :flip
:zh-tw "反轉召喚"
:ja-jp "反転召喚")
(with-category :summon add :advance
:zh-tw "升級召喚"
:ja-jp "アドバンス召喚")
(with-category :action add :release
:zh-tw "解放"
:ja-jp "リリース")
(with-category :action add :activate
:zh-tw "發動"
:ja-jp "発動")
(with-category :action add :remove-counter
:zh-tw "移除計數器"
:ja-jp "カウンターを取り除いて")
(with-category :action add :pay-lp
:zh-tw "支付生命值"
:ja-jp "LPを支払って")
(with-category :action add :remove-material
:zh-tw "移除(超量)的素材"
:ja-jp "素材を取り除いて")
(with-category :action add :reveal
:zh-tw "確認/公開"
:ja-jp "カードをめくる")
| 9,131 | Common Lisp | .lisp | 292 | 20.890411 | 65 | 0.554372 | along-emacs/cl-ygo | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:31 AM (Europe/Amsterdam) | e5ac5f37e1b0effc08db4b3e24d2c597856b0f3737bc6501b3f0ae81d805c94d | 38,832 | [
-1
] |
38,833 | cl-ygo.lisp | along-emacs_cl-ygo/cl-ygo.lisp | ;;;; cl-ygo.lisp -*- coding: utf-8-unix; -*-
(in-package #:cl-ygo)
(defclass player ()
((name :accessor player-name
:initarg :name)
(lp :accessor player-lp
:initarg :lp
:initform 8000)))
(defclass card ()
((id :accessor card-id
:initarg :id)
(category :accessor card-cate)
(name :accessor card-name
:initarg :name)
(attribute :accessor card-attr)
(rank :accessor card-rank)
(type :accessor card-type)
(description :accessor card-desc
:initarg :desc)
(functions :accessor card-func)
(flags :accessor card-flags)
(effects :accessor card-effects)))
(defclass deck ()
((name :accessor deck-name)
(cards :accessor deck-cards)))
(defparameter *deck-dir* "deck"
"directory of your deck.")
(defparameter *cards-db* "cards.cdb"
"sqlite3 database file")
(defparameter *cards-index* nil
"Index of all cards")
(defparameter *zone-list* '(:main :hand :extra
:monster :spell&trap
:graveyard :banished
:field :pendulum))
(defparameter *card-lists* (apply #'append
(loop for zone in *zone-list* collect
`(,zone nil))))
(defvar *deck-table* (let ((table (make-hash-table)))
(loop for deck-name in *zone-list* do
(setf (gethash deck-name table) (make-instance 'deck)))
table))
(defun empty-index ()
(setq *cards-index* nil))
(defun empty-deck ()
(loop for zone in *zone-list* do
(setf (getf *card-lists* zone) nil)))
(defun decks (&rest zones)
(let* ((zone-list (if (null zones)
'(:main) zones))
(card-list (loop for zone in zone-list collect
`(,zone ,(getf *card-lists* zone))))
(decks (apply #'append card-list)))
decks))
(defun cards (&rest zones)
(let* ((zone-list (if (null zones)
'(:main) zones))
(deck-list (apply #'decks zone-list))
(card-list (remove-if #'keywordp deck-list))
(cards (apply #'append card-list)))
cards))
(defun runsql (sql)
"For test"
(with-connection
(con :sqlite3
:database-name "D:/Programs/YGOPro/cards.cdb" )
(let* ((query (prepare con sql))
(result (execute query)))
(fetch-all result))))
(defmethod print-object ((cd card) stream)
(format stream "#<~A> "
;; (card-id cd)
(card-name cd)))
(defun get-dir-of (&rest paths)
(apply #'concatenate 'string
(namestring *default-pathname-defaults*)
paths))
(defun get-card-by-id (id)
(let* ((sql (concatenate 'string "select
texts.id, texts.name, texts.desc,
datas.atk, datas.def, datas.level
from texts
join datas on datas.id = texts.id
where texts.id = " (write-to-string id) ";"))
(card-info (car (runsql sql))))
(make-instance 'card
:id (getf card-info :|id|)
:name (getf card-info :|name|)
:desc (getf card-info :|desc|))))
(defun parse-deck (name)
(with-open-file (deck (get-dir-of *deck-dir* "/" name ".ydk"))
(let* ((raw-string (loop
for ctr from 1
for line = (read-line deck nil nil)
while line
collect (cond ((= ctr 1) "((")
((or (eq (char line 0) #\#)
(eq (char line 0) #\!))
(setf (char line 0) #\:)
(concatenate 'string ")" line "("))
(t line))))
(deck-string (regex-replace-all
"
" (apply #'concatenate 'string
(append raw-string '("))")))" "))
(deck-list (read-from-string deck-string nil t)))
(remove nil deck-list))))
(defun fill-deck (id &optional (zone :main))
(let ((card-obj (get-card-by-id id)))
(push card-obj *cards-index*)
(push card-obj (getf *card-lists* zone))))
(defun init-deck (name)
(empty-index)
(empty-deck)
(let ((deck-id-lists (parse-deck name)))
(loop for (zone id-list) on deck-id-lists by #'cddr do
(loop for id in id-list do
(fill-deck id zone)))))
(defun search-cards-by-name (name &rest zones)
(apply #'append
(loop for (zone cards) on (apply #'decks zones) by #'cddr collect
`(,zone ,(remove-if-not #'(lambda (card)
(scan-to-strings name
(card-name card)))
cards)))))
(defun search-cards-by-sequence (number &rest zones)
(apply #'append
(loop for (zone cards) on (apply #'decks zones) by #'cddr collect
`(,zone ,(loop
for card in cards
for ctr from 1 to number collect
card)))))
(defun Fisher-Yates-Shuffle (zone) ;(random n) => [0, n)
(let ((len (length (cards zone)))
(src (cards zone)))
(setf (getf *card-lists* zone)
(loop for i from len downto 1 collect
(let ((card (nth (random i) src)))
(setq src (remove card src))
card)))))
(defun move-cards (cards-lists-with-zone dest-zone)
(pprint cards-lists-with-zone)
(loop for (zone card-list) on cards-lists-with-zone by #'cddr do
(loop for card in card-list do
(push card (getf *card-lists* dest-zone))
(setf (getf *card-lists* zone)
(remove card (getf *card-lists* zone))))))
(defun draw (&optional (number 1))
(move-cards
(search-cards-by-sequence number :main) :hand))
| 5,001 | Common Lisp | .lisp | 149 | 29.174497 | 70 | 0.624119 | along-emacs/cl-ygo | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:31 AM (Europe/Amsterdam) | 734228926f269e87f52db690d74c689a49bc73084a79d911be4dd2cc0e995b5e | 38,833 | [
-1
] |
38,834 | cl-ygo.asd | along-emacs_cl-ygo/cl-ygo.asd | ;;;; cl-ygo.asd
(asdf:defsystem #:cl-ygo
:description "Common Lisp version of yu-gi-oh! engine"
:author "Xinlong Hu <[email protected]>"
:license "GNU General Public License v3.0"
:version "0.0.1"
:serial t
:components ((:file "package")
(:file "cl-ygo")
(:file "languages")))
| 318 | Common Lisp | .asd | 10 | 27.2 | 56 | 0.631922 | along-emacs/cl-ygo | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:31 AM (Europe/Amsterdam) | 4fe19f5fb567d2f6364530980b2e1a5624084370e47acbcba02ed112056f8354 | 38,834 | [
-1
] |
38,839 | Template.ydk | along-emacs_cl-ygo/deck/Template.ydk | #created by ...
#main
10000080
102380
55063751
55063751
14558127
14558127
23434538
23434538
23434538
97268402
97268402
97268402
12580477
18144507
83764718
10045474
10045474
94192409
94192409
#extra
!side
| 227 | Common Lisp | .l | 23 | 7.869565 | 16 | 0.843137 | along-emacs/cl-ygo | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:31 AM (Europe/Amsterdam) | f0c338e1d38c50ffecf121b5cbfcecf24d2f3e8d9dba882f0665c6a40a928b1d | 38,839 | [
-1
] |
38,854 | macrolayer.lisp | equwal_sl/macrolayer.lisp | ;;; This file is meant to provide a macro layer for Sly and Slime
;;; This contains a few things:
;;; - 5AM is used for testing, but only if it is a *features* member.
;;; The abstraction gets more specific as you go to the end of the file.
(in-package :sl)
(eval-when (:compile-toplevel :load-toplevel :execute)
(defun gen-case (base ex)
(if (symbolp ex)
(list 'eql base ex)
(append ex (list base))))
(defun select-preference (boundp qnames)
"Choose the function to use based on user preference."
(labels ((select-preference-aux (boundp qnames preflist)
(when preflist
(let* ((res (select (lambda (x)
(string-equal (car x) (car preflist)))
qnames))
(package (car res))
(symname (cadr res)))
(if (and res (find-package package))
(values symname package)
(select-preference-aux boundp qnames (cdr preflist)))))))
(select-preference-aux boundp qnames (mapcar #'car qnames)))))
#+5am (defmacro show-bound (unbind predicate thing &body body)
`(progn (,unbind ',thing)
,@body
(,predicate ',thing)))
#+5am (defmacro show-boundfn (fn &body body)
`(show-bound fmakunbound fboundp ,fn ,@body))
#+5am (defmacro show-boundvar (var &body body)
`(show-bound makunbound boundp ,var ,@body))
#+5am (select-preference 'fboundp '(("SLYNK" "OPERATOR-ARGLIST")))
(defmacro defweak-strings (namespace boundp sl-name &rest qualified-names)
"Make a weak definition, based on preferences. Probably should use wrapper
functions instead of this one, as it takes string arguments."
`(setf (,namespace (intern ,sl-name))
(multiple-value-bind (symname package)
(select-preference ',boundp ',(group qualified-names 2))
(,namespace (intern symname package)))))
#+5am (show-boundfn operator-arglist
(defweak-strings symbol-function fboundp "OPERATOR-ARGLIST"
"SWANK" "OPERATOR-ARGLIST"
"SLYNK" "OPERATOR-ARGLIST"))
(defmacro defweak (namespace boundp sl-name &rest qualified-names)
"Symbol wrapper for defweak-strings."
`(defweak-strings ,namespace ,boundp ,(symbol-name sl-name)
,@(loop for q in qualified-names
collect (symbol-name q))))
#+5am (show-boundfn operator-arglist
(defweak symbol-function fboundp operator-arglist
swank operator-arglist
slynk operator-arglist))
(defmacro defequivs (namespace boundp sl-name &rest packages)
"Define a name which is already the same in multiple packages."
`(defweak ,namespace ,boundp ,sl-name
,@(append (interpol sl-name packages) (list sl-name))))
#+5am (show-boundfn operator-arglist (defequivs symbol-function fboundp operator-arglist swank slynk))
(defmacro andcond (&rest pairs)
"Insert AND into a list in the condition position of a COND."
`(cond ,@(loop for p in pairs
collect (cons (list* 'and (car p))
(cdr p)))))
#+5am (andcond (((eql t nil) (eql t t)) 'x)
((t nil) 'y))
#+5am (and (gen-case :fn :fn)
(not (gen-case :fn '(listp))))
(defmacro bicase (a b &rest cases)
"Cover a CASE with two objects, and insert them into predicates."
;; FIXME: the predicate insertion is fragile: only flat lists allowed
;; FIXME: This should be generatlized for n cases (not just two).
`(cond ,@(loop for c in cases
collect (list* (and (gen-case a (car c))
(gen-case b (cadr c)))
(cddr c)))))
#+5am (bicase :a :b
((eql :a) (eql :b) t)
(:a :b 'h))
(defun neql (a b)
"Not eql."
;; KLUDGE: this thing only exists to keep `bicase' flat.
(not (eql a b)))
(defmacro defsl (sl-name fn-sym eq-ql &rest preflist)
"Magic macro to associate a name with functions in other packages, based on the preferences."
;; FIXME: This thing generates invalid--though inaccessible code. This makes
;; those compilation errors.
;; FIXME: This thing is way unhygienic. Once-only, and in-order would be nice.
`(bicase
,fn-sym ,eq-ql
(:fn :eq (defequivs symbol-function fboundp ,sl-name ,@preflist))
(:fn (neql :eq) (defweak symbol-function fboundp ,sl-name ,@(pack eq-ql)))
(:sym :eq (defequivs symbol-value boundp ,sl-name ,@preflist))
(:sym (neql :eq) (defweak symbol-value boundp ,sl-name ,@(pack eq-ql)))
((listp) :eq (defequivs ,@(pack fn-sym) ,sl-name ,@preflist))
((listp) (neql :eq) (defweak ,@(pack fn-sym) ,sl-name ,@(pack eq-ql)))))
#+5am (defsl operator-arglist (symbol-function fboundp) :eq slynk swank)
#+5am (defsl operator-arglist :fn :eq slynk swank)
| 4,925 | Common Lisp | .lisp | 96 | 42.59375 | 102 | 0.618642 | equwal/sl | 0 | 1 | 0 | GPL-3.0 | 9/19/2024, 11:45:31 AM (Europe/Amsterdam) | cc9998aaf7d55576ac4ded5bb40baa8c0cfed176d855e7ad407d34f5ccc0ba7d | 38,854 | [
-1
] |
38,855 | utils.lisp | equwal_sl/utils.lisp | (in-package :sl)
(eval-when (:compile-toplevel :load-toplevel :execute)
;; From Graham's OnLisp
(defun pack (obj)
"Ensure obj is a cons."
(if (consp obj) obj (list obj)))
(defun shuffle (x y)
"Interpolate lists x and y with the first item being from x."
(cond ((null x) y)
((null y) x)
(t (list* (car x) (car y)
(shuffle (cdr x) (cdr y))))))
(defun interpol (obj lst)
"Intersperse an object in a list."
(shuffle lst (loop for #1=#.(gensym) in (cdr lst)
collect obj)))
(defun group (source n)
(labels ((rec (source acc)
(let ((rest (nthcdr n source)))
(if (consp rest)
(rec rest (cons
(subseq source 0 n)
acc))
(nreverse
(cons source acc))))))
(if source (rec source nil) nil))))
(defun select (fn lst)
"Return the first element that matches the function."
(if (null lst)
nil
(let ((val (funcall fn (car lst))))
(if val
(values (car lst) val)
(select fn (cdr lst))))))
| 1,185 | Common Lisp | .lisp | 34 | 24.529412 | 65 | 0.499565 | equwal/sl | 0 | 1 | 0 | GPL-3.0 | 9/19/2024, 11:45:31 AM (Europe/Amsterdam) | c1bee8be8b9379b5d71a37cf6cc3b8e29dc83545412c095ca14dc52cb35460bc | 38,855 | [
-1
] |
38,856 | sl.lisp | equwal_sl/sl.lisp | ;;; Provide least common denominator shared functionality between Sly and Slime.
(in-package :sl)
(defequivsfn operator-arglist)
| 131 | Common Lisp | .lisp | 3 | 42 | 80 | 0.81746 | equwal/sl | 0 | 1 | 0 | GPL-3.0 | 9/19/2024, 11:45:31 AM (Europe/Amsterdam) | d83f82bf1e4ea03dd672c4c87c54679a644b18f630aea62d8596e6276ef9be7b | 38,856 | [
-1
] |
38,857 | sl.asd | equwal_sl/sl.asd | (defsystem :sl
:version "0.0.1"
:description "Wrapper for the lowest common denominator of Sly and Slime"
:author "Spenser Truex <[email protected]>"
:serial t
:license "GNU GPL v3"
:components ((:file "package")
(:file "utils")
(:file "macrolayer")
(:file "sl"))
:weakly-depends-on (:slynk :swank)
:depends-on (:alexandria))
| 413 | Common Lisp | .asd | 12 | 28.333333 | 76 | 0.581047 | equwal/sl | 0 | 1 | 0 | GPL-3.0 | 9/19/2024, 11:45:31 AM (Europe/Amsterdam) | 2ac16f1e1e1b5b9e93b394db7283cb518425465191423e91f79d98473481be81 | 38,857 | [
-1
] |
38,877 | rsss.lisp | JadedCtrl_rsss/rsss.lisp | ;; This program is free software: you can redistribute it and/or modify it
;; under the terms of the GNU General Public License as published by the
;; Free Software Foundation, either version 3 of the License, or (at your
;; option) any later version.
;; This program is distributed in the hope that it will be useful, but WITHOUT
;; ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
;; FITNESS FOR A PARTICULAR PURPOSE.
;; See the GNU General Public License for more details.
;; -----------------
(defpackage :rsss
(:use :cl)
(:export
:parse
:entries :name :uri :date :desc :author :text :media))
(in-package :rsss)
;; —————————————————————————————————————
;; CLASSES
;; —————————————————————————————————————
(defclass feed ()
((uri :initarg :uri :accessor uri :initform nil)
(name :initarg :name :accessor name :initform nil)
(date :initarg :date :accessor date :initform nil)
(desc :initarg :desc :accessor desc :initform nil)
(entries :initarg :entries :accessor entries :initform nil)))
(defclass entry ()
((uri :initarg :uri :accessor uri :initform nil)
(name :initarg :name :accessor name :initform nil)
(date :initarg :date :accessor date :initform nil)
(author :initarg :author :accessor author :initform nil)
(desc :initarg :desc :accessor desc :initform nil)
(media :initarg :media :accessor media :initform nil)
(text :initarg :text :accessor text :initform nil)))
;; —————————————————————————————————————
;; MISC
;; —————————————————————————————————————
(defmacro append-or-replace (list item)
"If a list is empty (nil), then replace it with a new list containing item.
Otherwise, append item to the pre-existing list.
Side-effectively, with nconc et. al."
`(if (nilp ,list)
(setf ,list (list ,item))
(nconc ,list (list ,item))))
(defmacro mapnil (function list)
"Map over a list with a function, but remove all NILs from the result list."
`(remove nil (mapcar ,function ,list)))
(defmacro mapfirst (function list)
"Map over a list with a function, and return the first non-NIL result."
`(car (mapnil ,function ,list)))
;; VARYING LIST → LIST
(defun str-assoc (item list)
"Run #'assoc, but with #'string-equal as the test function."
(assoc item list :test #'string-equal))
;; VARYING → BOOLEAN
(defun nilp (item)
"Return whether or note an item is eq to NIL."
(eq nil item))
;; LIST → VARYING
(defun ie-car (item)
"Try car'ing something… but don't sweat it if, y'know, it fucks."
(ignore-errors (car item)))
;; —————————————————————————————————————
;; PARSING
;; —————————————————————————————————————
;; STRING → RSSS:FEED
(defun parse (xml)
"Parse a given XML string (atom/rss[12]) into a FEED object."
(let* ((node (xmls:parse xml))
(type (feed-type node)))
(cond ((or (eq type :rss2) (eq type :rss1))
(parse-rss node))
((eq type :atom)
(parse-atom node)))))
;; -----------------
(defmacro common-let (node extra-let form &optional extra-form)
"A let-statement used by basically every parsing-function/macro."
`(let ((name (xmls:node-name ,node))
(chchild (xmls:node-children ,node))
(attrs (xmls:node-attrs ,node))
,@extra-let)
,form))
;; —————————————————
;; ATOM PARSING
;; —————————————————
(defmacro parse-atom-children (rsss parent-node child-node
&optional (cond-1 '(T nil))
(cond-2 '(T nil)))
"Code common to parsing both overarching Atom XML and individual entries."
`(mapcar
(lambda (,child-node)
(common-let ,child-node nil
(cond ((string-equal "link" name)
(setf (uri ,rsss) (cadr (str-assoc "href" attrs))))
((string-equal "title" name)
(setf (name ,rsss) (car chchild)))
((string-equal "updated" name)
(setf (date ,rsss) (car chchild)))
((string-equal "summary" name)
(setf (desc ,rsss) (car chchild)))
,cond-1 ,cond-2)))
;; nil))
(xmls:node-children ,parent-node)))
;; -----------------
;; XMLS:NODE → RSSS:FEED
(defun parse-atom (atom-node)
"Parse Atom XMLS node into an rsss FEED object."
(let ((feed (make-instance 'feed)))
(parse-atom-children
feed atom-node atom-child
((string-equal "entry" name)
(append-or-replace (entries feed) (parse-atom-entry atom-child))))
feed))
;; XMLS:NODE → RSSS:ENTRY
(defun parse-atom-entry (entry-node)
"Parse an Atom <entry>'s XMLS:NODE into an RSSS:ENTRY object."
(let ((entry (make-instance 'entry)))
(parse-atom-children
entry entry-node entry-child
((string-equal "content" name)
(setf (text entry) (car chchild)))
((string-equal "author" name)
(setf (author entry)
(parse-atom-author-name entry-child))))
entry))
;; -----------------
;; XMLS:NODE → STRING
(defun parse-atom-author-name (author-node)
"Return the proper name of an author, given an Atom <author> node."
(common-let author-node nil
(if (stringp chchild) chchild
(mapfirst
(lambda (chchchild)
(if (string-equal "name" (xmls:node-name chchchild))
(car (xmls:node-children chchchild))))
chchild))))
;; —————————————————
;; RSS1/RSS2 PARSING
;; —————————————————
(defmacro parse-rss-children (rsss parent-node child-node
&optional (cond-1 '(T nil))
(cond-2 '(T nil))
(cond-3 '(T nil))
(cond-4 '(T nil)))
"Some code common to parsing the children of rss nodes."
`(mapcar
(lambda (,child-node)
(common-let ,child-node nil
(cond ((string-equal "title" name)
(setf (name ,rsss) (ie-car chchild)))
((string-equal "pubDate" name)
(setf (date ,rsss) (ie-car chchild)))
((string-equal "date" name)
(setf (date ,rsss) (ie-car chchild)))
((string-equal "link" name)
(setf (uri ,rsss) (ie-car chchild)))
,cond-1 ,cond-2 ,cond-3 ,cond-4)))
(xmls:node-children ,parent-node)))
;; -----------------
;; XMLS:NODE → RSSS:FEED
(defun parse-rss (rss-node)
"Parse an RSS XMLS node into an rsss:FEED object."
(let ((feed (make-instance 'feed)))
(mapcar
(lambda (rss-child)
(let ((name (xmls:node-name rss-child)))
(cond ((string-equal "channel" name)
(parse-rss-channel feed rss-child))
((string-equal "item" name)
(append-or-replace
(entries feed) (parse-rss-item rss-child))))))
(xmls:node-children rss-node))
feed))
;; RSSS:FEED XMLS:NODE → NIL
(defun parse-rss-channel (feed channel-node)
"Parse a channel node of an RSS feed; modifies the FEED object."
(parse-rss-children
feed channel-node channel-child
((string-equal "description" name)
(setf (desc feed) (ie-car chchild)))
((string-equal "item" name)
(append-or-replace (entries feed) (parse-rss-item channel-child))))
feed)
;; XMLS:NODE → RSSS:ENTRY
(defun parse-rss-item (entry-node)
"Parse an item (XMLS:NODE) of an RSS feed."
(let ((entry (make-instance 'entry)))
(parse-rss-children
entry entry-node entry-child
((or (string-equal "content" name) (string-equal "encoded" name))
(setf (text entry) (ie-car chchild)))
;; about the following: people use <description> tags for both summaries
;; and for actual post-bodies. (wtf :/)
;; so, if the text is longer than 250 characters, it's *probably* not
;; a summary, but an actual post. then again, not all posts are *that*
;; long…
;; this is a hack that won't always be helpful or effective, it's the
;; best trade-off I could think of. sorry ♥
((string-equal "description" name)
(if (and (< 250 (length (ie-car chchild))) (not (text entry)))
(setf (text entry) (ie-car chchild))
(setf (desc entry) (ie-car chchild))))
((string-equal "enclosure" name)
(setf (media entry) (cadr (str-assoc "url" attrs))))
((or (string-equal "author" name) (string-equal "creator" name))
(setf (author entry) (ie-car chchild))))
entry))
;; —————————————————————————————————————
;; PRE-PARSING
;; —————————————————————————————————————
;; STRING → SYMBOL
(defun feed-type (node)
"Return the type of the feed-- :rss2 for RSS 2.0, :rss1 for RSS 1.0/other,
and :atom for (obviously!) Atom."
(let ((name (xmls:node-name node))
(attrs (xmls:node-attrs node)))
(cond ((and (string-equal "rss" name)
(equal "2.0" (cadr (assoc "version" attrs :test #'equal))))
:rss2)
((or (string-equal "rss" name) (string-equal "rdf" name))
:rss1)
((string-equal "feed" name)
:atom))))
| 9,360 | Common Lisp | .lisp | 221 | 34.950226 | 78 | 0.614527 | JadedCtrl/rsss | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:31 AM (Europe/Amsterdam) | 25bcebf4ef8bbd277f488267c807d53baec556024f4bae787b0ba81ad273cf74 | 38,877 | [
-1
] |
38,878 | rsss.lisp | JadedCtrl_rsss/t/rsss.lisp | (defpackage :rsss-testing
(:use :cl)
(:export :do-all))
(in-package :rsss-testing)
;; NIL → VARYING
(defun do-all ()
"Execute all tests."
(rt:do-tests))
;; -----------------
;; To run these tests, just load up :rsss-testing and run #'do-all.
;; Senproblem'!
;; -----------------
(defvar *atom-xml* (alexandria:read-file-into-string #p"t/atom.xml"))
(defvar *atom-node* (xmls:parse *atom-xml*))
(defvar *atom-entry* (eighth (xmls:node-children *atom-node*)))
(defvar *rss1-xml* (alexandria:read-file-into-string #p"t/rss1.xml"))
(defvar *rss1-node* (xmls:parse *rss1-xml*))
(defvar *rss1-entry* (second (xmls:node-children *rss1-node*)))
(defvar *rss2-xml* (alexandria:read-file-into-string #p"t/rss2.xml"))
(defvar *rss2-node* (xmls:parse *rss2-xml*))
(defvar *rss2-entry* (sixth (xmls:node-children
(car (xmls:node-children *rss2-node*)))))
;; —————————————————————————————————————
;; MISC
;; —————————————————————————————————————
(rt:deftest append-or-replace-i
(let ((test-list nil))
(rsss::append-or-replace test-list 1))
(1))
(rt:deftest append-or-replace-ii
(let ((test-list '("never again!" 2312 "well, maybe…")))
(rsss::append-or-replace test-list "again. MAYBE."))
("never again!" 2312 "well, maybe…" "again. MAYBE."))
(rt:deftest equ-assoc-i
(let ((test-assoc '(("mami" 2) ("madoka" 3) ("homura" 4))))
(rsss::equ-assoc "madoka" test-assoc))
("madoka" 3))
(rt:deftest equ-assoc-ii
(let ((test-assoc '(("homura" "madoka"))))
(rsss::equ-assoc "homura" test-assoc))
("homura" "madoka"))
(rt:deftest nilp-i
(rsss::nilp nil)
T)
(rt:deftest nilp-ii
(rsss::nilp 1)
nil)
(rt:deftest ie-car-i
(multiple-value-bind (result error)
(rsss::ie-car 1)
(list result (not (rsss::nilp error))))
(nil T))
(rt:deftest ie-car-ii
(multiple-value-bind (result error)
(rsss::ie-car '((1 2) 2 3))
(list result (not (rsss::nilp error))))
((1 2) nil))
;; —————————————————————————————————————
;; PARSING
;; —————————————————————————————————————
;; ATOM PARSING
;; —————————————————
(rt:deftest parse-atom-i
(rsss:name (rsss::parse-atom *atom-node*))
"Planet GNU")
(rt:deftest parse-atom-ii
(rsss:date (rsss::parse-atom *atom-node*))
"2019-07-09T17:55:32+00:00")
(rt:deftest parse-atom-iii
(rsss:uri (rsss::parse-atom *atom-node*))
"https://planet.gnu.org/")
(rt:deftest parse-atom-iv
(length (rsss:entries (rsss::parse-atom *atom-node*)))
60)
(rt:deftest parse-atom-v
(rsss:name (third (rsss:entries (rsss::parse-atom *atom-node*))))
"DW5821e firmware update integration in ModemManager and fwupd")
(rt:deftest parse-atom-entry-i
(length (rsss:text (rsss::parse-atom-entry *atom-entry*)))
7923)
(rt:deftest parse-atom-entry-ii
(rsss:author (rsss::parse-atom-entry *atom-entry*))
"Christopher Lemmer Webber")
(rt:deftest parse-atom-entry-iii
(rsss:date (rsss::parse-atom-entry *atom-entry*))
"2019-07-09T14:27:00+00:00")
(rt:deftest parse-atom-entry-iv
(rsss:uri (rsss::parse-atom-entry *atom-entry*))
"http://dustycloud.org/blog/racket-is-an-acceptable-python/")
;; —————————————————
;; RSS1 PARSING
;; —————————————————
(rt:deftest parse-rss1-i
(rsss:name (rsss::parse-rss *rss1-node*))
"Planet GNU")
(rt:deftest parse-rss1-ii
(rsss:date (rsss::parse-rss *rss1-node*))
nil)
(rt:deftest parse-rss1-iii
(rsss:uri (rsss::parse-rss *rss1-node*))
"https://planet.gnu.org/")
(rt:deftest parse-rss1-iv
(length (rsss:entries (rsss::parse-rss *rss1-node*)))
60)
(rt:deftest parse-rss1-v
(rsss:name (third (rsss:entries (rsss::parse-rss *rss1-node*))))
"FSF Blogs: Thank you for advancing free software: Read FSF spring news in the latest Bulletin")
(rt:deftest parse-rss1-entry-i
(length (rsss:text (rsss::parse-rss-item *rss1-entry*)))
14616)
(rt:deftest parse-rss1-entry-ii
(rsss:author (rsss::parse-rss-item *rss1-entry*))
"FSF Blogs")
(rt:deftest parse-rss1-entry-iii
(rsss:date (rsss::parse-rss-item *rss1-entry*))
"2019-07-09T15:39:21+00:00")
(rt:deftest parse-rss1-entry-iv
(rsss:uri (rsss::parse-rss-item *rss1-entry*))
"http://www.fsf.org/blogs/rms/photo-blog-2019-june-brno")
;; —————————————————
;; RSS2 PARSING
;; —————————————————
(rt:deftest parse-rss2-i
(rsss:name (rsss::parse-rss *rss2-node*))
"Esperanto-USA member blogs")
(rt:deftest parse-rss2-ii
(rsss:date (rsss::parse-rss *rss2-node*))
"2019-07-09T00:00:39-07:00")
(rt:deftest parse-rss2-iii
(rsss:uri (rsss::parse-rss *rss2-node*))
"http://esperanto-usa.org/eusa/blogs/member-blogs.rss")
(rt:deftest parse-rss2-iv
(length (rsss:entries (rsss::parse-rss *rss2-node*)))
21)
(rt:deftest parse-rss2-v
(rsss:name (third (rsss:entries (rsss::parse-rss *rss2-node*))))
"Maja bulteno")
(rt:deftest parse-rss2-entry-i
(length (rsss:text (rsss::parse-rss-item *rss2-entry*)))
0)
(rt:deftest parse-rss2-entry-ii
(rsss:author (rsss::parse-rss-item *rss2-entry*))
nil)
(rt:deftest parse-rss2-entry-iii
(rsss:date (rsss::parse-rss-item *rss2-entry*))
"2019-06-29T00:47:00+00:00")
(rt:deftest parse-rss2-entry-iv
(rsss:uri (rsss::parse-rss-item *rss2-entry*))
"http://eo1a.blogspot.com/2019/06/cirkau-la-mondon-post-okdek-tagoj-26.html")
;; —————————————————
;; GENERAL PARSING
;; —————————————————
(rt:deftest parse-i
(type-of (rsss:parse *atom-xml*))
rsss::feed)
(rt:deftest parse-ii
(type-of (rsss:parse *rss1-xml*))
rsss::feed)
(rt:deftest parse-iii
(type-of (rsss:parse *rss2-xml*))
rsss::feed)
| 6,251 | Common Lisp | .lisp | 161 | 31.559006 | 101 | 0.615871 | JadedCtrl/rsss | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:31 AM (Europe/Amsterdam) | 29c7b69c7a72eafd1ec0454169d76b9f023b96ea66bc8688b4b550d368dbc15d | 38,878 | [
-1
] |
38,879 | rsss.asd | JadedCtrl_rsss/rsss.asd | (defsystem "rsss"
:version "0.9"
:author "Jaidyn Ann <[email protected]>"
:license "GPLv3"
:depends-on ("xmls")
:components ((:file "rsss"))
:description
"Reading Syndicated Stuff Sagely is a feed format-neutral parser.
Both Atom and RSS-friendly.")
| 266 | Common Lisp | .asd | 9 | 27 | 66 | 0.715953 | JadedCtrl/rsss | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:31 AM (Europe/Amsterdam) | 69d082aa76ba701105bfafec4908c7695acf2479a29e86f682361843cf9692a5 | 38,879 | [
-1
] |
38,883 | rss1.xml | JadedCtrl_rsss/t/rss1.xml | <?xml version="1.0"?>
<rdf:RDF
xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
xmlns:dc="http://purl.org/dc/elements/1.1/"
xmlns:foaf="http://xmlns.com/foaf/0.1/"
xmlns:content="http://purl.org/rss/1.0/modules/content/"
xmlns="http://purl.org/rss/1.0/"
>
<channel rdf:about="https://planet.gnu.org/">
<title>Planet GNU</title>
<link>https://planet.gnu.org/</link>
<description>Planet GNU - https://planet.gnu.org/</description>
<items>
<rdf:Seq>
<rdf:li rdf:resource="http://www.fsf.org/blogs/rms/photo-blog-2019-june-brno"/>
<rdf:li rdf:resource="tag:dustycloud.org,2019-07-09:blog/racket-is-an-acceptable-python/"/>
<rdf:li rdf:resource="http://www.fsf.org/blogs/community/thank-you-for-advancing-free-software-read-fsf-spring-news-in-the-latest-bulletin"/>
<rdf:li rdf:resource="http://sigquit.wordpress.com/?p=1220"/>
<rdf:li rdf:resource="http://savannah.gnu.org/forum/forum.php?forum_id=9461"/>
<rdf:li rdf:resource="https://www.gnu.org/software/guile/news/gnu-guile-226-released.html"/>
<rdf:li rdf:resource="http://savannah.gnu.org/forum/forum.php?forum_id=9459"/>
<rdf:li rdf:resource="tag:dustycloud.org,2019-06-27:blog/how-do-spritelys-actor-and-storage-layers-tie-together/"/>
<rdf:li rdf:resource="http://www.fsf.org/blogs/community/gnu-spotlight-with-mike-gerwitz-17-new-gnu-releases-in-june"/>
<rdf:li rdf:resource="http://wingolog.org/2019/06/26/fibs-lies-and-benchmarks"/>
<rdf:li rdf:resource="http://www.fsf.org/blogs/gnu-press/emacs-t-shirts-available-now-at-the-gnu-press-shop"/>
<rdf:li rdf:resource="tag:dustycloud.org,2019-06-25:blog/lets-just-be-weird-together/"/>
<rdf:li rdf:resource="http://www.fsf.org/blogs/rms/drop-the-journalism-charges-against-julian-assange"/>
<rdf:li rdf:resource="http://savannah.gnu.org/forum/forum.php?forum_id=9457"/>
<rdf:li rdf:resource="http://savannah.gnu.org/forum/forum.php?forum_id=9456"/>
<rdf:li rdf:resource="http://savannah.gnu.org/forum/forum.php?forum_id=9453"/>
<rdf:li rdf:resource="http://savannah.gnu.org/forum/forum.php?forum_id=9451"/>
<rdf:li rdf:resource="http://savannah.gnu.org/forum/forum.php?forum_id=9450"/>
<rdf:li rdf:resource="https://www.gnu.org/software/guile/news/gnu-guile-225-released.html"/>
<rdf:li rdf:resource="http://www.fsf.org/events/event-20190904-madrid-gnuhackersmeeting"/>
<rdf:li rdf:resource="http://www.fsf.org/events/rms-20190715-frankfurt"/>
<rdf:li rdf:resource="https://gnu.org/software/guix/blog/2019/substitutes-are-now-available-as-lzip/"/>
<rdf:li rdf:resource="https://gnunet.org/#gnunet-0.11.5-release"/>
<rdf:li rdf:resource="http://savannah.gnu.org/forum/forum.php?forum_id=9442"/>
<rdf:li rdf:resource="http://wingolog.org/2019/06/03/pictie-my-c-to-webassembly-workbench"/>
<rdf:li rdf:resource="http://savannah.gnu.org/forum/forum.php?forum_id=9440"/>
<rdf:li rdf:resource="http://www.fsf.org/events/rms-20190622-mayhew"/>
<rdf:li rdf:resource="http://www.fsf.org/events/rms-20190607-vienna"/>
<rdf:li rdf:resource="https://www.gnu.org/software/guile/news/join-guile-guix-days-strasbourg-2019.html"/>
<rdf:li rdf:resource="http://www.fsf.org/events/rms-20190606-brno-smartcity"/>
<rdf:li rdf:resource="http://wingolog.org/2019/05/24/lightening-run-time-code-generation"/>
<rdf:li rdf:resource="https://www.gnu.org/software/guile/news/gnu-guile-292-beta-released.html"/>
<rdf:li rdf:resource="http://wingolog.org/2019/05/23/bigint-shipping-in-firefox"/>
<rdf:li rdf:resource="http://savannah.gnu.org/forum/forum.php?forum_id=9434"/>
<rdf:li rdf:resource="https://gnu.org/software/guix/blog/2019/creating-and-using-a-custom-linux-kernel-on-guix-system/"/>
<rdf:li rdf:resource="https://gnu.org/software/guix/blog/2019/gnu-guix-1.0.1-released/"/>
<rdf:li rdf:resource="http://savannah.gnu.org/forum/forum.php?forum_id=9433"/>
<rdf:li rdf:resource="http://www.fsf.org/news/six-more-devices-from-thinkpenguin-inc-now-fsf-certified-to-respect-your-freedom"/>
<rdf:li rdf:resource="https://gnunet.org/#gnunet-0.11.4-release"/>
<rdf:li rdf:resource="http://savannah.gnu.org/forum/forum.php?forum_id=9432"/>
<rdf:li rdf:resource="http://savannah.gnu.org/forum/forum.php?forum_id=9431"/>
<rdf:li rdf:resource="http://savannah.gnu.org/forum/forum.php?forum_id=9430"/>
<rdf:li rdf:resource="http://savannah.gnu.org/forum/forum.php?forum_id=9429"/>
<rdf:li rdf:resource="https://gnu.org/software/guix/blog/2019/gnu-guix-1.0.0-released/"/>
<rdf:li rdf:resource="http://savannah.gnu.org/forum/forum.php?forum_id=9426"/>
<rdf:li rdf:resource="http://savannah.gnu.org/forum/forum.php?forum_id=9425"/>
<rdf:li rdf:resource="http://savannah.gnu.org/forum/forum.php?forum_id=9424"/>
<rdf:li rdf:resource="http://savannah.gnu.org/forum/forum.php?forum_id=9423"/>
<rdf:li rdf:resource="http://savannah.gnu.org/forum/forum.php?forum_id=9422"/>
<rdf:li rdf:resource="http://savannah.gnu.org/forum/forum.php?forum_id=9419"/>
<rdf:li rdf:resource="http://savannah.gnu.org/forum/forum.php?forum_id=9417"/>
<rdf:li rdf:resource="http://savannah.gnu.org/forum/forum.php?forum_id=9415"/>
<rdf:li rdf:resource="https://gnunet.org/#gnunet-0.11.2-release"/>
<rdf:li rdf:resource="https://gnunet.org/#gnunet-0.11.1-release"/>
<rdf:li rdf:resource="https://gnu.org/software/guix/blog/2019/connecting-reproducible-deployment-to-a-long-term-source-code-archive/"/>
<rdf:li rdf:resource="http://savannah.gnu.org/forum/forum.php?forum_id=9405"/>
<rdf:li rdf:resource="http://savannah.gnu.org/forum/forum.php?forum_id=9404"/>
<rdf:li rdf:resource="http://www.fsf.org/news/fsf-job-opportunity-campaigns-manager-1"/>
<rdf:li rdf:resource="http://www.fsf.org/news/openstreetmap-and-deborah-nicholson-win-2018-fsf-awards"/>
<rdf:li rdf:resource="http://www.fsf.org/news/openstreetmap-and-deborah-nicholson-win-2019-fsf-awards"/>
</rdf:Seq>
</items>
</channel>
<item rdf:about="http://www.fsf.org/blogs/rms/photo-blog-2019-june-brno">
<title>FSF Blogs: June 2019: Photos from Brno</title>
<link>http://www.fsf.org/blogs/rms/photo-blog-2019-june-brno</link>
<content:encoded><div style="border-style: solid; border-width: 2px; text-align: left; margin: 4px 50px 4px 50px; padding-top: 4px; padding-left: 5px; padding-right: 5px;">
<p>Free Software Foundation president Richard Stallman (RMS) was in
<strong>Brno, Czech Republic</strong> on June 6, 2019, to give two speeches.</p>
<p>In the morning, he took part in the <a href="https://www.smartcityfair.cz/en/">URBIS Smart City Fair</a>, at the Brno Fair Grounds, giving his speech
"Computing, freedom, and privacy."<sup style="font-size: 8px;"><a href="https://static.fsf.org/fsforg/rss/blogs.xml#fn1" id="ref1">1</a></sup></p>
<p style="text-align: center;">
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-fair-grounds/20190606-brno-c-2019-veletrhy-brno-a-s-cc-by-4-0-1-thumb.jpg" style="margin-top: 4px;" width="265" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-fair-grounds/20190606-brno-c-2019-veletrhy-brno-a-s-cc-by-4-0-2-thumb.jpg" style="margin-top: 4px;" width="265" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-fair-grounds/20190606-brno-c-2019-veletrhy-brno-a-s-cc-by-4-0-3-thumb.jpg" style="margin-top: 4px;" width="530" />
</p>
<p style="padding: 0px 20px 0px 20px; margin-top: 1px; text-align: center;">
<em>(Copyright © 2019 Veletrhy Brno, a. s. Photos licensed under <a href="http://creativecommons.org/licenses/by/4.0/">CC BY 4.0</a>.)</em>
<br style="margin-bottom: 15px;" />
</p><p>In the afternoon, at the University Cinema Scala, he gave his
speech "The free software movement and the GNU/Linux operating
system," to about three hundred people.
</p><p style="text-align: center;">
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-jan-prokopius-cc-by-4-0-1-thumb.jpg" style="margin-top: 4px;" width="530" />
</p><p style="padding: 0px 20px 0px 20px; margin-top: 1px; text-align: center;">
<em>(Copyright © 2019 Pavel Loutocký. Photos licensed under <a href="http://creativecommons.org/licenses/by/4.0/">CC BY 4.0</a>.)</em>
<br style="margin-bottom: 15px;" />
</p><p style="text-align: center;">
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-047-thumb.jpg" style="margin-top: 4px;" width="176" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-050-thumb.jpg" style="margin-top: 4px;" width="176" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-051-thumb.jpg" style="margin-top: 4px;" width="176" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-052-thumb.jpg" style="margin-top: 4px;" width="265" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-053-thumb.jpg" style="margin-top: 4px;" width="265" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-054-thumb.jpg" style="margin-top: 4px;" width="176" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-055-thumb.jpg" style="margin-top: 4px;" width="176" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-056-thumb.jpg" style="margin-top: 4px;" width="176" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-057-thumb.jpg" style="margin-top: 4px;" width="176" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-058-thumb.jpg" style="margin-top: 4px;" width="176" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-064-thumb.jpg" style="margin-top: 4px;" width="176" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-063-thumb.jpg" style="margin-top: 4px;" width="530" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-066-thumb.jpg" style="margin-top: 4px;" width="176" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-069-thumb.jpg" style="margin-top: 4px;" width="176" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-070-thumb.jpg" style="margin-top: 4px;" width="176" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-071-thumb.jpg" style="margin-top: 4px;" width="176" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-073-thumb.jpg" style="margin-top: 4px;" width="176" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-074-thumb.jpg" style="margin-top: 4px;" width="176" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-068-thumb.jpg" style="margin-top: 4px;" width="265" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-072-thumb.jpg" style="margin-top: 4px;" width="265" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-075-thumb.jpg" style="margin-top: 4px;" width="530" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-076-thumb.jpg" style="margin-top: 4px;" width="530" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-078-thumb.jpg" style="margin-top: 4px;" width="530" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-079-thumb.jpg" style="margin-top: 4px;" width="132" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-080-thumb.jpg" style="margin-top: 4px;" width="133" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-081-thumb.jpg" style="margin-top: 4px;" width="133" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-082-thumb.jpg" style="margin-top: 4px;" width="132" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-083-thumb.jpg" style="margin-top: 4px;" width="132" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-084-thumb.jpg" style="margin-top: 4px;" width="133" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-085-thumb.jpg" style="margin-top: 4px;" width="133" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-086-thumb.jpg" style="margin-top: 4px;" width="132" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-087-thumb.jpg" style="margin-top: 4px;" width="132" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-088-thumb.jpg" style="margin-top: 4px;" width="133" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-090-thumb.jpg" style="margin-top: 4px;" width="133" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-091-thumb.jpg" style="margin-top: 4px;" width="132" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-092-thumb.jpg" style="margin-top: 4px;" width="132" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-093-thumb.jpg" style="margin-top: 4px;" width="133" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-094-thumb.jpg" style="margin-top: 4px;" width="133" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-095-thumb.jpg" style="margin-top: 4px;" width="132" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-114-thumb.jpg" style="margin-top: 4px;" width="176" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-115-thumb.jpg" style="margin-top: 4px;" width="176" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-116-thumb.jpg" style="margin-top: 4px;" width="176" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-117-thumb.jpg" style="margin-top: 4px;" width="265" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-120-thumb.jpg" style="margin-top: 4px;" width="265" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-121-thumb.jpg" style="margin-top: 4px;" width="530" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-124-thumb.jpg" style="margin-top: 4px;" width="176" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-126-thumb.jpg" style="margin-top: 4px;" width="176" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-128-thumb.jpg" style="margin-top: 4px;" width="176" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-132-thumb.jpg" style="margin-top: 4px;" width="530" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-131-thumb.jpg" style="margin-top: 4px;" width="176" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-133-thumb.jpg" style="margin-top: 4px;" width="176" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-134-thumb.jpg" style="margin-top: 4px;" width="176" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-135-thumb.jpg" style="margin-top: 4px;" width="176" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-136-thumb.jpg" style="margin-top: 4px;" width="176" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-140-thumb.jpg" style="margin-top: 4px;" width="176" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-137-thumb.jpg" style="margin-top: 4px;" width="530" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-141-thumb.jpg" style="margin-top: 4px;" width="530" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-143-thumb.jpg" style="margin-top: 4px;" width="176" /><img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-145-thumb.jpg" style="margin-top: 4px;" width="176" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-146-thumb.jpg" style="margin-top: 4px;" width="176" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-144-thumb.jpg" style="margin-top: 4px;" width="530" />
</p>
<p style="padding: 0px 20px 0px 20px; margin-top: 1px; text-align: center;">
<em>(Copyright © 2019 Pavel Loutocký. Photos licensed under <a href="http://creativecommons.org/licenses/by/4.0/">CC BY 4.0</a>.)</em>
<br style="margin-bottom: 15px;" />
</p><p style="text-align: center;"><strong>Thank you to everyone who made this visit possible!</strong></p>
<p style="text-align: center;">If you're in the area, please fill out our contact form, so
that we can inform you about future events in and around <a href="https://my.fsf.org/civicrm/profile/create?gid=578&amp;reset=1">Brno</a>.
</p>
<p style="text-align: center;">Please see <a href="http://www.fsf.org/events">www.fsf.org/events</a> for a full
list of all of RMS's confirmed engagements, <br /> and contact <a href="mailto:[email protected]">[email protected]</a> if you'd like
him to come speak.</p>
<hr />
<sup id="fn1">1. The recording will soon be posted on <a href="http://audio-video.gnu.org">our audio-video archive</a>.<a href="https://static.fsf.org/fsforg/rss/blogs.xml#ref1" title="Jump back to footnote 1 in the text.">↩</a></sup><br /></div></content:encoded>
<dc:date>2019-07-09T15:39:21+00:00</dc:date>
<dc:creator>FSF Blogs</dc:creator>
</item>
<item rdf:about="tag:dustycloud.org,2019-07-09:blog/racket-is-an-acceptable-python/">
<title>Christopher Allan Webber: Racket is an acceptable Python</title>
<link>http://dustycloud.org/blog/racket-is-an-acceptable-python/</link>
<content:encoded><p>A little over a decade ago, there were some popular blogposts about whether
<a class="reference external" href="http://www.randomhacks.net/2005/12/03/why-ruby-is-an-acceptable-lisp/">Ruby was an acceptable Lisp</a>
or whether even
<a class="reference external" href="https://steve-yegge.blogspot.com/2006/04/lisp-is-not-acceptable-lisp.html">Lisp was an acceptable Lisp</a>.
Peter Norvig was also writing at the time
<a class="reference external" href="https://norvig.com/python-lisp.html">introducing Python to Lisp programmers</a>.
Lisp, those in the know knew, was the right thing to strive for, and yet
seemed unattainable for anything aimed for production since the AI Winter
shattered Lisp's popularity in the 80s/early 90s.
If you can't get Lisp, what's closest thing you can get?</p>
<p>This was around the time I was starting to program; I had spent some
time configuring my editor with Emacs Lisp and loved every moment I
got to do it; I read some Lisp books and longed for more.
And yet when I tried to "get things done" in the language, I just
couldn't make as much headway as I could with my preferred language
for practical projects at the time: Python.</p>
<p>Python was great... mostly.
It was easy to read, it was easy to write, it was easy-ish to teach
to newcomers.
(Python's intro material is better than most, but <a class="reference external" href="https://mlemmer.org/">my spouse</a> has talked before about some major pitfalls
that the Python documentation has which make getting started
unnecessarily hard.
You can
<a class="reference external" href="https://www.youtube.com/watch?v=pv0lLciMI24&amp;t=4220s">hear her talk about that</a>
at this talk we co-presented on at last year's RacketCon.)
I ran a large free software project on a Python codebase, and it was
easy to get new contributors; the barrier to entry to becoming a
programmer with Python was low.
I consider that to be a feature, and it certainly helped me bootstrap
my career.</p>
<p>Most importantly of all though, Python was easy to pick up and run with
because no matter what you wanted to do, either the tools came built
in or the Python ecosystem had enough of the pieces nearby that building
what you wanted was usually fairly trivial.</p>
<p>But Python has its limitations, and I always longed for a lisp.
For a brief time, I thought I could get there by contributing to the
<a class="reference external" href="https://hy.readthedocs.io/en/stable/">Hy project</a>, which was a lisp
that transformed itself into the Python AST.
"Why write Python in a syntax that's easy to read when you could add
a bunch of parentheses to it instead?" I would joke when I talked about
it.
Believe it or not though, I do consider lisps easier to read, once you
are comfortable to understand their syntax.
I certainly find them easier to write and modify.
And I longed for the metaprogramming aspects of Lisp.</p>
<p>Alas, Hy didn't really reach my dream.
That macro expansion made debugging a nightmare as Hy would lose track
of where the line numbers are; it wasn't until that when I really realized
that without line numbers, you're just lost in terms of debugging in
Python-land.
That and Python didn't really have the right primitives; immutable
datastructures for whatever reason never became first class, meaning
that functional programming was hard, "cons" didn't really exist
(actually this doesn't matter as much as people might think), recursive
programming isn't really as possible without tail call elimination, etc
etc etc.</p>
<p>But I missed parentheses.
I longed for parentheses.
I <em>dreamed in</em> parentheses.
I'm not kidding, the only dreams I've ever had in code were in lisp,
and it's happened multiple times, programs unfolding before me.
The structure of lisp makes the flow of code so clear, and there's
simply nothing like the comfort of developing in front of a lisp REPL.</p>
<p>Yet to choose to use a lisp seemed to mean opening myself up to
eternal yak-shaving of developing packages that were already available
on the Python Package Index or limiting my development community an
elite group of Emacs users.
When I was in Python, I longed for the beauty of a Lisp; when I was in
a Lisp, I longed for the ease of Python.</p>
<p>All this changed when I discovered Racket:</p>
<ul class="simple">
<li>Racket comes with a full-featured editor named DrRacket built-in
that's damn nice to use.
It has all the features that make lisp hacking comfortable previously
mostly only to Emacs users: parenthesis balancing, comfortable REPL
integration, etc etc.
But if you want to use Emacs, you can use racket-mode.
Win-win.</li>
<li>Racket has intentionally been built as an educational language, not
unlike Python.
One of the core audiences of Racket is middle schoolers, and it even
comes with a built-in game engine for kids.</li>
<li>My spouse and I even taught classes about how to learn to program for
<a class="reference external" href="https://dustycloud.org/misc/digital-humanities/">humanities academics</a>
using Racket.
We found the age-old belief that "lisp syntax is just too hard" is
simply false; the main thing that most people lack is decent lisp-friendly
tooling with a low barrier to entry, and DrRacket provides that.
The only people who were afraid of the parentheses turned out to be people
who already knew how to program.
Those who didn't even praised the syntax for its clarity and the way
the editor could help show you when you made a syntax error
(DrRacket is very good at that).
"Lisp is too hard to learn" is a lie; if middle schoolers can learn it,
so can more seasoned programmers.</li>
<li>Racket might even be <em>more</em> batteries included than Python.
At least all the batteries that come included are generally nicer;
<a class="reference external" href="https://docs.racket-lang.org/gui/">Racket's GUI library</a> is the only
time I've ever had fun in my life writing GUI programs (and they're cross
platform too).
Constructing pictures with its <a class="reference external" href="https://docs.racket-lang.org/pict/index.html">pict</a>
library is a delight.
Plotting graphs with <a class="reference external" href="https://docs.racket-lang.org/plot/index.html">plot</a>
is an incredible experience.
Writing documentation with
<a class="reference external" href="https://docs.racket-lang.org/scribble/index.html">Scribble</a>
is the best non-org-mode experience I've ever had, but has the
advantage over org-mode in that your document is just inverted code.
I could go on.
And these are just some packages bundled with Racket; the
<a class="reference external" href="https://pkgs.racket-lang.org">Package repository</a> contains much more.</li>
<li>Racket's documentation is, in my experience, unparalleled.
The <a class="reference external" href="https://docs.racket-lang.org/guide/index.html">Racket Guide</a> walks
you through all the key concepts, and the
<a class="reference external" href="https://docs.racket-lang.org/reference/index.html">Racket Reference</a>
has everything else you need.</li>
<li>The tutorials are also wonderful; the
<a class="reference external" href="https://docs.racket-lang.org/quick/index.html">introductory tutorial</a>
gets your feet wet not through composing numbers or strings but by
building up pictures.
Want to learn more?
The next two tutorials show you how to
<a class="reference external" href="https://docs.racket-lang.org/continue/index.html">build web applications</a>
and then
<a class="reference external" href="https://docs.racket-lang.org/more/index.html">build your own web server</a>.</li>
<li>Like Python, even though Racket has its roots in education, it is more than
ready for serious practical use.
These days, when I want to build something and get it done quickly
and efficiently, I reach for Racket first.</li>
</ul>
<p>Racket is a great Lisp, but it's also an acceptable Python.
Sometimes you really can have it all.</p></content:encoded>
<dc:date>2019-07-09T14:27:00+00:00</dc:date>
<dc:creator>Christopher Lemmer Webber</dc:creator>
</item>
<item rdf:about="http://www.fsf.org/blogs/community/thank-you-for-advancing-free-software-read-fsf-spring-news-in-the-latest-bulletin">
<title>FSF Blogs: Thank you for advancing free software: Read FSF spring news in the latest Bulletin</title>
<link>http://www.fsf.org/blogs/community/thank-you-for-advancing-free-software-read-fsf-spring-news-in-the-latest-bulletin</link>
<content:encoded><p><a href="https://www.fsf.org/appeal"><img alt="ThankGNU Star Supporter" src="https://static.fsf.org/nosvn/images/badges/Spring19-lock-in.png" style="margin-top: 4px;" width="650" /></a></p><a href="https://www.fsf.org/appeal">
</a><p><a href="https://www.fsf.org/appeal"></a><a href="https://www.fsf.org/bulletin/2019/spring/issue-34-spring-2019">Our <em>Bulletin</em></a> highlights some important activities and issues in free software
over the last six months, including:</p>
<p>It highlights some important activities and issues in free software
over the last six months, including:</p>
<ul>
<li>
<p>an educational program we launched, together with free software
activist <a href="https://www.fsf.org/bulletin/2019/spring/fsf-teaches-free-software-to-public-school-youth">Devin Ulibarri</a>, where we used the program Music Blocks
to teach Boston area public school youth about coding and free
software, and then proceeded to donate ten fully freed laptops to the
schools we visited;</p>
</li>
<li>
<p>some ideas on how the free software community can do better to bring
visibility to our movement, according to LibrePlanet 2019 conference
speaker and free software activist <a href="https://www.fsf.org/bulletin/2019/spring/sparking-change-what-free-software-can-learn-from-social-justice-movements">Mary Kate Fain</a>, pulled from
her superb LibrePlanet talk <a href="https://media.libreplanet.org/u/libreplanet/m/sparking-change-what-free-software-can-learn-from-successful-social-movements/">“Sparking change: What free software
can learn from social justice movements”</a>; and</p>
</li>
<li>
<p>our licensing and compliance manager, <a href="https://www.fsf.org/bulletin/2019/spring/what-respects-your-freedom-is-for-and-what-it-isnt">Donald Robertson, III,
reports</a> on the progress of our Respects Your Freedom program,
with further explanation on the parameters needed for the
certification of hardware devices that meet FSF's criteria for
protecting the rights of users.</p>
</li>
</ul>
<p>Thirty-five volunteers joined FSF staff over the course of three
days to get all the <em>Bulletins</em> stuffed in envelopes and mailed out. This was a
great opportunity to catch up on free software issues with some of our
most dedicated free software enthusiasts here in Boston. We are
grateful to have such a strong core of supporters that keep the
movement growing, and thanks to your generous contribution, we
will be even stronger.</p>
<p>Please be vocal about your support for free software. <a href="https://www.fsf.org/bulletin/2019/spring/issue-34-spring-2019">Read and share
the <em>Bulletin</em> articles</a> online using the #ISupportFreeSoftware
hashtag, use our <a href="https://www.fsf.org/resources/badges">fundraiser support images</a>, and talk to your
community about why you support the FSF. It makes a difference.</p>
<p>Throughout our spring fundraiser, we have been enjoying both the
public posts from supporters using the hashtag on <a href="https://www.fsf.org/share">social media</a>,
as well as answers to the "What inspired you to join today?" question
we ask new members. Here are some of our favorites.</p>
<ul>
<li>We see many excited calls for user freedom and user control: <br />
<ul>
<li><em>"For freedom!"</em> <br />
</li>
<li><em>"Does the software you use grant you the freedom to
redistribute copies so you can help others? #FreeSoftware
does. Learn more by listening to Richard M. Stallman, on the
<a href="https://www.makingbetterpod.com/2019/06/17/making-better-episode-4-richard-stallman/">Making Better podcast</a>. #ISupportFreeSoftware"</em> from
@makingbetterpod</li>
<li>@mmaug shared: <em>"There are alternatives to Facebook, Microsoft,
Google, and Twitter. Take control of your privacy, and your
computer! #ISupportFreeSoftware #FSF"</em></li>
<li>@globalspectator posted: <em>"Software you don't control seizes
control over you. Help @fsf break the chains of proprietary
software for a freer future #ISupportFreeSoftware"</em> <br />
</li>
</ul>
</li>
<li>
<p>We receive humbling thank you's from people appreciating our
work, naming the <a href="https://media.libreplanet.org/">LibrePlanet conference</a>, our <a href="https://www.fsf.org/licensing/">licensing work</a>, and the
<a href="https://www.gnu.org/">GNU Project</a>:<br />
</p>
<ul>
<li><em>"Wanted to for a long time. Also, LibrePlanet!"</em> <br />
</li>
<li><em>"Gratitude. And a long lasting debt feeling. Thanks so much!"</em></li>
<li><em>"As a software developer and GNU/Linux user I want to set a
statement and do my part in keeping free software popular"</em> <br />
</li>
<li><em>"I use GNU tools, and have since the beginning"</em> <br />
</li>
</ul>
</li>
<li>
<p>And most importantly, we hear from people who have come across our
activities and campaign images online, or who were informed about
FSF through their on- and offline community and decided to take
action -- convincing us that people inspiring each other to join the
<a href="https://www.fsf.org/free-software-supporter/"><em>Free Software Supporter</em> mailing list</a>, or to <a href="https://my.fsf.org/join?pk_campaign=fr_sp2019&amp;pk_source=email2">become an associate
member</a> is by far the most powerful way to expand our reach and
strengthen our message: <br />
</p>
<ul>
<li><em>"I watched an interview with Richard Stallman"</em> <br />
</li>
<li><em>"A friend"</em> <br />
</li>
<li><em>"A post in the <a href="https://victorhckinthefreeworld.com/2019/06/27/la-free-software-foundation-quiere-redoblar-la-comunidad-del-software-libre-isupportfreesoftware/">'Victorhck in the free world'</a> blog"</em> <br />
</li>
<li>@opc_5 called for digital liberation through free software: <em>"Software Libre para la
liberación digital. #ISupportFreeSoftware"</em></li>
<li>@AugustinPMichel tagged his connections with: <em>"#ISupportFreeSoftware, do you?"</em></li>
</ul>
</li>
</ul>
<p>Today, we have one week left in our <a href="https://www.fsf.org/appeal?pk_campaign=fr_sp2019&amp;pk_source=email2">spring fundraiser</a>, and we are
confident we will achieve our membership goal of 200 members in 28
days if we keep at it. With your help, we may engage enough
people to also reach 400 <a href="https://my.fsf.org/donate?pk_campaign=fr_sp2019&amp;pk_source=email2">donations</a> before the 15th of July. Your
support helped get us where we are, in position to succeed. Your
generosity and outspokenness fuel our message, increase our reach, and
will allow us to continue to advocate on your behalf.</p>
<p>Thank you for your contribution to free software.</p></content:encoded>
<dc:date>2019-07-09T04:55:00+00:00</dc:date>
<dc:creator>FSF Blogs</dc:creator>
</item>
<item rdf:about="http://sigquit.wordpress.com/?p=1220">
<title>Aleksander Morgado: DW5821e firmware update integration in ModemManager and fwupd</title>
<link>https://sigquit.wordpress.com/2019/07/03/dw5821e-firmware-update-integration-in-modemmanager-and-fwupd/</link>
<content:encoded><p><img alt="" class="aligncenter size-full wp-image-1222" height="522" src="https://sigquit.files.wordpress.com/2019/07/dw5821e-image.png?w=604&amp;h=522" width="604" /></p>
<p>The <strong>Dell Wireless 5821e</strong> module is a <a href="https://www.qualcomm.com/products/snapdragon-modems-4g-lte-x20" rel="noopener" target="_blank">Qualcomm SDX20</a> based LTE Cat16 device. This modem can work in either MBIM mode or QMI mode, and provides different USB layouts for each of the modes. In Linux kernel based and Windows based systems, the MBIM mode is the default one, because it provides easy integration with the OS (e.g. no additional drivers or connection managers required in Windows) and also provides all the features that QMI provides through QMI over MBIM operations.</p>
<p>The firmware update process of this DW5821e module is integrated in your GNU/Linux distribution, since <a href="https://lists.freedesktop.org/archives/modemmanager-devel/2019-January/006983.html" rel="noopener" target="_blank">ModemManager 1.10.0</a> and <a href="https://groups.google.com/forum/#!msg/fwupd/HXavD9QqW4Q/WAsKVunxBQAJ" rel="noopener" target="_blank">fwupd 1.2.6</a>. There is no official firmware released in the LVFS (yet) but the setup is completely ready to be used, just waiting for Dell to publish an initial official firmware release.</p>
<p>The firmware update integration between ModemManager and fwupd involves different steps, which I’ll try to describe here so that it’s clear how to add support for more devices in the future.</p>
<h2>1) ModemManager reports expected update methods, firmware version and device IDs</h2>
<p>The Firmware interface in the modem object exposed in DBus contains, since MM 1.10, a new <a href="https://www.freedesktop.org/software/ModemManager/api/latest/gdbus-org.freedesktop.ModemManager1.Modem.Firmware.html#gdbus-property-org-freedesktop-ModemManager1-Modem-Firmware.UpdateSettings" rel="noopener" target="_blank">UpdateSettings</a> property that provides a bitmask specifying which is the expected firmware update method (or methods) required for a given module, plus a dictionary of key-value entries specifying settings applicable to each of the update methods.</p>
<p>In the case of the DW5821e, two update methods are reported in the bitmask: “<strong>fastboot</strong>” and “<strong>qmi-pdc</strong>“, because both are required to have a complete firmware upgrade procedure. “fastboot” would be used to perform the system upgrade by using an OTA update file, and “qmi-pdc” would be used to install the per-carrier configuration files after the system upgrade has been done.</p>
<p>The list of settings provided in the dictionary contain the two mandatory fields required for all devices that support at least one firmware update method: “device-ids” and “version”. These two fields are designed so that fwupd can fully rely on them during its operation:</p>
<ul>
<li>The “<strong>device-ids</strong>” field will include a list of strings providing the device IDs associated to the device, sorted from the most specific to the least specific. These device IDs are the ones that fwupd will use to build the GUIDs required to match a given device to a given firmware package. The DW5821e will expose four different device IDs:
<ul>
<li>“USB\<strong>VID_413C</strong>“: specifying this is a Dell-branded device.</li>
<li>“USB\VID_413C&amp;<strong>PID_81D7</strong>“: specifying this is a DW5821e module.</li>
<li>“USB\VID_413C&amp;PID_81D7&amp;<strong>REV_0318</strong>“: specifying this is hardware revision 0x318 of the DW5821e module.</li>
<li>“USB\VID_413C&amp;PID_81D7&amp;REV_0318&amp;<strong>CARRIER_VODAFONE</strong>“: specifying this is hardware revision 0x318 of the DW5821e module running with a Vodafone-specific carrier configuration.</li>
</ul>
</li>
<li>The “<strong>version</strong>” field will include the firmware version string of the module, using the same format as used in the firmware package files used by fwupd. This requirement is obviously very important, because if the format used is different, the simple version string comparison used by fwupd (literally ASCII string comparison) would not work correctly. It is also worth noting that if the carrier configuration is also versioned, the version string should contain not only the version of the system, but also the version of the carrier configuration. The DW5821e will expose a firmware version including both, e.g. “T77W968.F1.1.1.1.1.VF.001” (system version being F1.1.1.1.1 and carrier config version being “VF.001”)</li>
<li>In addition to the mandatory fields, the dictionary exposed by the DW5821e will also contain a “<strong>fastboot-at</strong>” field specifying which AT command can be used to switch the module into fastboot download mode.</li>
</ul>
<h2>2) fwupd matches GUIDs and checks available firmware versions</h2>
<p>Once fwupd detects a modem in ModemManager that is able to expose the correct UpdateSettings property in the Firmware interface, it will add the device as a known device that may be updated in its own records. The device exposed by fwupd will contain the <a href="https://en.wikipedia.org/wiki/Universally_unique_identifier" rel="noopener" target="_blank"><strong>GUIDs</strong></a> built from the “device-ids” list of strings exposed by ModemManager. E.g. for the “USB\VID_413C&amp;PID_81D7&amp;REV_0318&amp;CARRIER_VODAFONE” device ID, fwupd will use GUID “b595e24b-bebb-531b-abeb-620fa2b44045”.</p>
<p>fwupd will then be able to look for firmware packages (CAB files) available in the <a href="https://fwupd.org/" rel="noopener" target="_blank">LVFS</a> that are associated to any of the GUIDs exposed for the DW5821e.</p>
<p>The CAB files packaged for the LVFS will contain one single firmware OTA file plus one carrier MCFG file for each supported carrier in the give firmware version. The CAB files will also contain one “metainfo.xml” file for each of the supported carriers in the released package, so that per-carrier firmware upgrade paths are available: only firmware updates for the currently used carrier should be considered. E.g. we don’t want users running with the Vodafone carrier config to get notified of upgrades to newer firmware versions that aren’t certified for the Vodafone carrier.</p>
<p>Each of the CAB files with multiple “metainfo.xml” files will therefore be associated to multiple GUID/version pairs. E.g. the same CAB file will be valid for the following GUIDs (using Device ID instead of GUID for a clearer explanation, but really the match is per GUID not per Device ID):</p>
<ul>
<li>Device ID “USB\VID_413C&amp;PID_81D7&amp;REV_0318&amp;CARRIER_VODAFONE” providing version “T77W968.F1.2.2.2.2.VF.002”</li>
<li>Device ID “USB\VID_413C&amp;PID_81D7&amp;REV_0318&amp;CARRIER_TELEFONICA” providing version “T77W968.F1.2.2.2.2.TF.003”</li>
<li>Device ID “USB\VID_413C&amp;PID_81D7&amp;REV_0318&amp;CARRIER_VERIZON” providing version “T77W968.F1.2.2.2.2.VZ.004”</li>
<li>… and so on.</li>
</ul>
<p>Following our example, fwupd will detect our device exposing device ID “USB\VID_413C&amp;PID_81D7&amp;REV_0318&amp;CARRIER_VODAFONE” and version “T77W968.F1.1.1.1.1.VF.001” in ModemManager and will be able to find a CAB file for the same device ID providing a newer version “T77W968.F1.2.2.2.2.VF.002” in the LVFS. The firmware update is possible!</p>
<h2>3) fwupd requests device inhibition from ModemManager</h2>
<p>In order to perform the firmware upgrade, fwupd requires full control of the modem. Therefore, when the firmware upgrade process starts, fwupd will use the new <a href="https://www.freedesktop.org/software/ModemManager/api/latest/gdbus-org.freedesktop.ModemManager1.html#gdbus-method-org-freedesktop-ModemManager1.InhibitDevice" rel="noopener" target="_blank">InhibitDevice</a>(TRUE) method in the Manager DBus interface of ModemManager to request that a specific modem with a specific uid should be inhibited. Once the device is inhibited in ModemManager, it will be disabled and removed from the list of modems in DBus, and no longer used until the inhibition is removed.</p>
<p>The inhibition may be removed by calling InhibitDevice(FALSE) explicitly once the firmware upgrade is finished, and will also be automatically removed if the program that requested the inhibition disappears from the bus.</p>
<h2>4) fwupd downloads CAB file from LVFS and performs firmware update</h2>
<p>Once the modem is inhibited in ModemManager, fwupd can right away start the firmware update process. In the case of the DW5821e, the firmware update requires two different methods and two different upgrade cycles.</p>
<p>The first step would be to reboot the module into <strong>fastboot</strong> download mode using the AT command specified by ModemManager in the “at-fastboot” entry of the “UpdateSettings” property dictionary. After running the AT command, the module will reset itself and reboot with a completely different USB layout (and different vid:pid) that fwupd can detect as being the same device as before but in a different working mode. Once the device is in fastboot mode, fwupd will download and install the OTA file using the fastboot protocol, as defined in the “flashfile.xml” file provided in the CAB file:</p>
<pre>&lt;parts interface="AP"&gt;
&lt;part operation="flash" partition="ota" filename="T77W968.F1.2.2.2.2.AP.123_ota.bin" MD5="f1adb38b5b0f489c327d71bfb9fdcd12"/&gt;
&lt;/parts&gt;</pre>
<p>Once the OTA file is completely downloaded and installed, fwupd will trigger a reset of the module also using the fastboot protocol, and the device will boot from scratch on the newly installed firmware version. During this initial boot, the module will report itself running in a “default” configuration not associated to any carrier, because the OTA file update process involves fully removing all installed carrier-specific MCFG files.</p>
<p>The second upgrade cycle performed by fwupd once the modem is detected again involves downloading all carrier-specific MCFG files one by one into the module using the <strong>QMI PDC</strong> protocol. Once all are downloaded, fwupd will activate the specific carrier configuration that was previously active before the download was started. E.g. if the module was running with the Vodafone-specific carrier configuration before the upgrade, fwupd will select the Vodafone-specific carrier configuration after the upgrade. The module would be reseted one last time using the QMI DMS protocol as a last step of the upgrade procedure.</p>
<h2>5) fwupd removes device inhibition from ModemManager</h2>
<p>The upgrade logic will finish by removing the device inhibition from ModemManager using InhibitDevice(FALSE) explicitly. At that point, ModemManager would re-detect and re-probe the modem from scratch, which should already be running in the newly installed firmware and with the newly selected carrier configuration.</p></content:encoded>
<dc:date>2019-07-03T13:27:10+00:00</dc:date>
<dc:creator>aleksander</dc:creator>
</item>
<item rdf:about="http://savannah.gnu.org/forum/forum.php?forum_id=9461">
<title>rush @ Savannah: Version 2.0</title>
<link>http://savannah.gnu.org/forum/forum.php?forum_id=9461</link>
<content:encoded><p>Version 2.0 is available for download from <a href="https://ftp.gnu.org/gnu/rush/rush-2.0.tar.xz">GNU</a> and <a href="http://download.gnu.org.ua/release/rush/rush-2.0.tar.xz">Puszcza</a> archives.
<br />
</p>
<p>This release features a complete rewrite of the configuration support. It introduces a new configuration file syntax that offers a large set of control structures and transformation instructions for handling arbitrary requests. Please see the documentation for details.
<br />
</p>
<p>Backward compatibility with prior releases is retained and old configuration syntax is still supported. This ensures that existing installations will remain operational without any changes. Nevertheless, system administrators are encouraged to switch to the new syntax as soon as possible.<br />
</p></content:encoded>
<dc:date>2019-07-01T08:15:26+00:00</dc:date>
<dc:creator>Sergey Poznyakoff</dc:creator>
</item>
<item rdf:about="https://www.gnu.org/software/guile/news/gnu-guile-226-released.html">
<title>GNU Guile: GNU Guile 2.2.6 released</title>
<link>https://www.gnu.org/software/guile/news/gnu-guile-226-released.html</link>
<content:encoded><p>We are pleased to announce GNU Guile 2.2.6, the sixth bug-fix
release in the new 2.2 stable release series. This release represents
11 commits by 4 people since version 2.2.5. First and foremost, it
fixes a <a href="https://issues.guix.gnu.org/issue/36350">regression</a> introduced
in 2.2.5 that would break Guile’s built-in HTTP server.</p><p>See the <a href="https://lists.gnu.org/archive/html/guile-devel/2019-06/msg00059.html">release
announcement</a>
for details.</p></content:encoded>
<dc:date>2019-06-30T21:55:00+00:00</dc:date>
<dc:creator>Ludovic Courtès</dc:creator>
</item>
<item rdf:about="http://savannah.gnu.org/forum/forum.php?forum_id=9459">
<title>trans-coord @ Savannah: Malayalam team re-established</title>
<link>http://savannah.gnu.org/forum/forum.php?forum_id=9459</link>
<content:encoded><p>After more than 8 years of being orphaned, Malayalam team is active again. The new team leader, Aiswarya Kaitheri Kandoth, made a new translation of the <a href="https://www.gnu.org/philosophy/free-sw.html">Free Software Definition</a>, so now we have 41 translations of that page!
<br />
</p>
<p>Currently, Malayalam the only active translation team of official languages of India. It is a Dravidian language spoken by about 40 million people worldwide, with the most speakers living in the Indian state of Kerala. Like many Indian languages, it uses a syllabic script derived from Brahmi.
<br />
</p>
<p><a href="https://www.gnu.org/software/gnun/reports/report-ml.html#complete">Links to up-to-date translations</a> are shown on the automatically generated <a href="https://www.gnu.org/software/gnun/reports/report-ml.html">report page</a>.<br />
</p></content:encoded>
<dc:date>2019-06-29T06:54:45+00:00</dc:date>
<dc:creator>Ineiev</dc:creator>
</item>
<item rdf:about="tag:dustycloud.org,2019-06-27:blog/how-do-spritelys-actor-and-storage-layers-tie-together/">
<title>Christopher Allan Webber: How do Spritely's actor and storage layers tie together?</title>
<link>http://dustycloud.org/blog/how-do-spritelys-actor-and-storage-layers-tie-together/</link>
<content:encoded><p>I've been hacking away at <a class="reference external" href="https://gitlab.com/spritely">Spritely</a>
(see <a class="reference external" href="https://dustycloud.org/blog/tag/spritely/">previously</a>).
Recently I've been making progress on both the actor model
(<a class="reference external" href="https://gitlab.com/spritely/goblins">goblins</a> and its rewrite
<a class="reference external" href="https://gitlab.com/spritely/goblinoid">goblinoid</a>) as well as
the storage layers (currently called
<a class="reference external" href="https://gitlab.com/dustyweb/magenc/blob/master/magenc/scribblings/intro.org">Magenc</a>
and <a class="reference external" href="https://gitlab.com/spritely/crystal/blob/master/crystal/scribblings/intro.org">Crystal</a>,
but we are talking about probably renaming the both of them into a
suite called "datashards"... yeah, everything is moving and changing
fast right now.)</p>
<p>In the <a class="reference external" href="https://webchat.freenode.net/?channels=spritely">#spritely channel on freenode</a>
a friend asked, what is the big picture idea here?
Both the actor model layer and the storage layer describe themselves
as using "capabilities" (or more precisely "object capabilities" or
"ocaps") but they seem to be implemented differently.
How does it all tie together?</p>
<p>A great question!
I think the first point of confusion is that while both follow the
ocap paradigm (which is to say, reference/possession-based authority...
possessing the capability gives you access, and it does not matter what
your identity is for the most part for access control), they are
implemented very differently because they are solving different problems.
The storage system is based on encrypted, persistent data, with its ideas
drawn from <a class="reference external" href="https://tahoe-lafs.org/trac/tahoe-lafs">Tahoe-LAFS</a> and
<a class="reference external" href="https://freenetproject.org/">Freenet</a>, and the way that capabilities
work is based on possession of cryptographic keys (which are themselves
embedded/referenced in the URIs).
The actor model, on the other hand, is based on holding onto a
reference to a unique, unguessable URL (well, that's a bit of an
intentional oversimplification for the sake of this explaination but
we'll run with it) where the actor at that URL is "live" and communicated
with via message passing.
(Most of the ideas from this come from <a class="reference external" href="http://erights.org/">E</a> and
<a class="reference external" href="http://waterken.sourceforge.net/">Waterken</a>.)
Actors are connected to each other over secure channels to prevent
eavesdropping or leakage of the capabilities.</p>
<p>So yeah, how do these two seemingly very different layers tie together?
As usual, I find that I most easily explain things via narrative, so
let's imagine the following game scenario: Alice is in a room with a goblin.
First Alice sees the goblin, then Alice attacks the goblin, then the
goblin and Alice realize that they are not so different and become
best friends.</p>
<p>The goblin and Alice both manifest in this universe as live actors.
When Alice walks into the room (itself an actor), the room gives Alice
a reference to the goblin actor.
To "see" the goblin, Alice sends a message to it asking for its
description.
It replies with its datashards storage URI with its 3d model and associated
textures.
Alice can now query the storage system to reconstruct these models and
textures from the datashards storage systems she uses.
(The datashards storage systems themselves can't actually see the
contents if they don't have the capability itself; this is much safer
for peers to help the network share data because they can help route
things through the network without personally knowing or being
responsible for what the contents of those messages are.
It could also be possible for the goblin to provide Alice with a direct
channel to a storage system to retrieve its assets from.)
Horray, Alice got the 3d model and images!
Now she can see the goblin.</p>
<p>Assuming that the goblin is an enemy, Alice attacks!
Attacking is common in this game universe, and there is no reason
necessarily to keep around attack messages, so sending a message to
the goblin is just a one-off transient message... there's no need
to persist it in the storage system.</p>
<p>The attack misses!
The goblin shouts, "Wait!" and makes its case, that both of them are
just adventurers in this room, and shouldn't they both be friends?
Alice is touched and halts her attack.
These messages are also sent transiently; while either party could
log them, they are closer to an instant messenger or IRC conversation
rather than something intended to be persisted long-term.</p>
<p>They exchange their mailbox addresses and begin sending each other
letters.
These, however, are intended to be persisted; when Alice receives a
message from the goblin in her mailbox (or vice versa), the message
received contains the datashards URI to the letter, which Alice can
then retrieve from the appropriate store.
She can then always refer to this message, and she can choose whether
or not to persist it locally or elsewhere.
Since the letter has its own storage URI, when Alice constructs a
reply, she can clearly mark that it was in reference to the previous
letter.
Even if Alice or the goblin's servers go down, either can continue
to refer to these letters.
Alice and the goblin have the freedom to choose what storage systems
they wish, whether targeted/direct/local or via a public peer to peer
routing system, with reasonable assumptions (given the continued
strength of the underlying cryptographic algorithms used) that the
particular entities storing or forwarding their data cannot read its
content.</p>
<p>And so it is: live references of actors are able to send live,
transient messages, but can only be sent to other actors whose
(unguessable/unforgeable) address you have.
This allows for highly dynamic and expressive interactions while
retaining security.
Datashards URIs allow for the storage and retrieval of content which
can continue to be persisted by interested parties, even if the
originating host goes down.</p>
<p>There are some things I glossed over in this writeup.
The particular ways that the actors' addresses and references work is
one thing (unguessable http based capability URLs on their own
have <a class="reference external" href="https://www.w3.org/TR/capability-urls/">leakage problems</a>
due to the way various web technologies are implemented, and
not even every actor reference needs to be a long-lived URI;
see <a class="reference external" href="http://erights.org/elib/distrib/captp/index.html">CapTP for more details</a>),
how to establish connections between actor processes/servers
(we can reuse TLS, or even better, something like tor's onion services),
so are how interactions such as fighting can be scoped to a
room (<a class="reference external" href="https://www.uni-weimar.de/fileadmin/user/fak/medien/professuren/Virtual_Reality/documents/publications/capsec_vr2008_preprint.pdf">this paper</a>
explains how), as well as how we can map human meaningful names
onto unguessable identifiers (the answer there is
<a class="reference external" href="https://github.com/cwebber/rebooting-the-web-of-trust-spring2018/blob/petnames/draft-documents/making-dids-invisible-with-petnames.md">petnames</a>).
But I have plans for this and increasing confidence that it will come
together... I think we're already on track.</p>
<p>Hopefully this writeup brings some clarity on how some of the
components will work together, though!</p></content:encoded>
<dc:date>2019-06-27T18:15:00+00:00</dc:date>
<dc:creator>Christopher Lemmer Webber</dc:creator>
</item>
<item rdf:about="http://www.fsf.org/blogs/community/gnu-spotlight-with-mike-gerwitz-17-new-gnu-releases-in-june">
<title>FSF Blogs: GNU Spotlight with Mike Gerwitz: 17 new GNU releases in June!</title>
<link>http://www.fsf.org/blogs/community/gnu-spotlight-with-mike-gerwitz-17-new-gnu-releases-in-june</link>
<content:encoded><ul>
<li><a href="https://www.gnu.org/software/apl/">apl-1.8</a></li>
<li><a href="https://www.gnu.org/software/artanis/">artanis-0.3.2</a></li>
<li><a href="https://www.gnu.org/software/dr-geo/">dr-geo-19.06a</a></li>
<li><a href="https://www.gnu.org/software/gawk/">gawk-5.0.1</a></li>
<li><a href="https://www.gnu.org/software/gengetopt/">gengetopt-2.23</a></li>
<li><a href="https://www.gnu.org/software/gnunet/">gnunet-0.11.5</a></li>
<li><a href="https://www.gnu.org/software/guile/">guile-2.2.5</a></li>
<li><a href="https://www.gnu.org/software/gnuzilla/">icecat-60.7.0-gnu1</a></li>
<li><a href="https://www.gnu.org/software/libmicrohttpd/">libmicrohttpd-0.9.64</a></li>
<li><a href="https://www.gnu.org/software/libredwg/">libredwg-0.8</a></li>
<li><a href="https://www.gnu.org/software/mailutils/">mailutils-3.7</a></li>
<li><a href="https://www.gnu.org/software/mit-scheme/">mit-scheme-10.1.9</a></li>
<li><a href="https://www.gnu.org/software/nano/">nano-4.3</a></li>
<li><a href="https://www.gnu.org/software/nettle/">nettle-3.5</a></li>
<li><a href="https://www.gnu.org/software/parallel/">parallel-20190622</a></li>
<li><a href="https://www.gnu.org/software/unifont/">unifont-12.1.02</a></li>
<li><a href="https://www.gnu.org/software/units/">units-2.19</a></li>
</ul>
<p>For announcements of most new GNU releases, subscribe to the info-gnu
mailing list: <a href="https://lists.gnu.org/mailman/listinfo/info-gnu">https://lists.gnu.org/mailman/listinfo/info-gnu</a>.</p>
<p>To download: nearly all GNU software is available from
<a href="https://ftp.gnu.org/gnu/">https://ftp.gnu.org/gnu/</a>, or preferably one of its mirrors from
<a href="https://www.gnu.org/prep/ftp.html">https://www.gnu.org/prep/ftp.html</a>. You can use the URL
<a href="https://ftpmirror.gnu.org/">https://ftpmirror.gnu.org/</a> to be automatically redirected to a
(hopefully) nearby and up-to-date mirror.</p>
<p>A number of GNU packages, as well as the GNU operating system as a
whole, are looking for maintainers and other assistance: please see
<a href="https://www.gnu.org/server/takeaction.html#unmaint">https://www.gnu.org/server/takeaction.html#unmaint</a> if you'd like to
help. The general page on how to help GNU is at
<a href="https://www.gnu.org/help/help.html">https://www.gnu.org/help/help.html</a>.</p>
<p>If you have a working or partly working program that you'd like
to offer to the GNU project as a GNU package, see
<a href="https://www.gnu.org/help/evaluation.html">https://www.gnu.org/help/evaluation.html</a>.</p>
<p>As always, please feel free to write to us at <a href="mailto:[email protected]">[email protected]</a>
with any GNUish questions or suggestions for future installments.</p></content:encoded>
<dc:date>2019-06-27T16:08:17+00:00</dc:date>
<dc:creator>FSF Blogs</dc:creator>
</item>
<item rdf:about="http://wingolog.org/2019/06/26/fibs-lies-and-benchmarks">
<title>Andy Wingo: fibs, lies, and benchmarks</title>
<link>http://wingolog.org/archives/2019/06/26/fibs-lies-and-benchmarks</link>
<content:encoded><div><p>Friends, consider the recursive Fibonacci function, expressed most lovelily in Haskell:</p><pre>fib 0 = 0
fib 1 = 1
fib n = fib (n-1) + fib (n-2)
</pre><p>Computing elements of the Fibonacci sequence ("Fibonacci numbers") is a common microbenchmark. Microbenchmarks are like a <a href="https://en.wikipedia.org/wiki/Suzuki_method">Suzuki exercises for learning violin</a>: not written to be good tunes (good programs), but rather to help you improve a skill.</p><p>The <tt>fib</tt> microbenchmark teaches language implementors to improve recursive function call performance.</p><p>I'm writing this article because after adding native code generation to Guile, I wanted to check how Guile was doing relative to other language implementations. The results are mixed. We can start with the most favorable of the comparisons: Guile present versus Guile of the past.</p><p></p><center><img src="http://wingolog.org/pub/guile-versions.png" /><br /></center><p>I collected these numbers on my i7-7500U CPU @ 2.70GHz 2-core laptop, with no particular performance tuning, running each benchmark 10 times, waiting 2 seconds between measurements. The bar value indicates the median elapsed time, and above each bar is an overlayed histogram of all results for that scenario. Note that the y axis is on a log scale. The 2.9.3* version corresponds to unreleased Guile from git.</p><p>Good news: Guile has been getting significantly faster over time! Over decades, true, but I'm pleased.</p><p><b>where are we? static edition</b></p><p>How good are Guile's numbers on an absolute level? It's hard to say because there's no absolute performance oracle out there. However there are relative performance oracles, so we can try out perhaps some other language implementations.</p><p>First up would be the industrial C compilers, GCC and LLVM. We can throw in a few more "static" language implementations as well: compilers that completely translate to machine code ahead-of-time, with no type feedback, and a minimal run-time.</p><p></p><center><img src="http://wingolog.org/pub/static-languages.png" /><br /></center><p>Here we see that GCC is doing best on this benchmark, completing in an impressive 0.304 seconds. It's interesting that the result differs so much from clang. I had a look at the disassembly for GCC and I see:</p><pre>fib:
push %r12
mov %rdi,%rax
push %rbp
mov %rdi,%rbp
push %rbx
cmp $0x1,%rdi
jle finish
mov %rdi,%rbx
xor %r12d,%r12d
again:
lea -0x1(%rbx),%rdi
sub $0x2,%rbx
callq fib
add %rax,%r12
cmp $0x1,%rbx
jg again
and $0x1,%ebp
lea 0x0(%rbp,%r12,1),%rax
finish:
pop %rbx
pop %rbp
pop %r12
retq
</pre><p>It's not quite straightforward; what's the loop there for? It turns out that <a href="https://stackoverflow.com/a/10058823">GCC inlines one of the recursive calls to <tt>fib</tt></a>. The microbenchmark is no longer measuring call performance, because GCC managed to reduce the number of calls. If I had to guess, I would say this optimization doesn't have a wide applicability and is just to game benchmarks. In that case, well played, GCC, well played.</p><p>LLVM's compiler (clang) looks more like what we'd expect:</p><pre>fib:
push %r14
push %rbx
push %rax
mov %rdi,%rbx
cmp $0x2,%rdi
jge recurse
mov %rbx,%rax
add $0x8,%rsp
pop %rbx
pop %r14
retq
recurse:
lea -0x1(%rbx),%rdi
<b>callq fib</b>
mov %rax,%r14
add $0xfffffffffffffffe,%rbx
mov %rbx,%rdi
<b>callq fib</b>
add %r14,%rax
add $0x8,%rsp
pop %rbx
pop %r14
retq
</pre><p>I bolded the two recursive calls.</p><p>Incidentally, the <tt>fib</tt> as implemented by GCC and LLVM isn't quite the same program as Guile's version. If the result gets too big, GCC and LLVM will overflow, whereas in Guile we overflow into a <a href="https://wingolog.org/archives/2019/05/23/bigint-shipping-in-firefox">bignum</a>. Also in C, it's possible to "smash the stack" if you recurse too much; compilers and run-times attempt to mitigate this danger but it's not completely gone. In Guile <a href="https://wingolog.org/archives/2014/03/17/stack-overflow">you can recurse however much you want</a>. Finally in Guile you can interrupt the process if you like; the compiled code is instrumented with safe-points that can be used to run profiling hooks, debugging, and so on. Needless to say, this is not part of C's mission.</p><p>Some of these additional features can be implemented with no significant performance cost (e.g., via guard pages). But it's fair to expect that they have some amount of overhead. More on that later.</p><p>The other compilers are OCaml's <tt>ocamlopt</tt>, coming in with a very respectable result; Go, also doing well; and V8 WebAssembly via Node. As you know, you can compile C to WebAssembly, and then V8 will compile that to machine code. In practice it's just as static as any other compiler, but the generated assembly is a bit more involved:</p><pre>
fib_tramp:
jmp fib
fib:
push %rbp
mov %rsp,%rbp
pushq $0xa
push %rsi
sub $0x10,%rsp
mov %rsi,%rbx
mov 0x2f(%rbx),%rdx
mov %rax,-0x18(%rbp)
cmp %rsp,(%rdx)
jae stack_check
post_stack_check:
cmp $0x2,%eax
jl return_n
lea -0x2(%rax),%edx
mov %rbx,%rsi
mov %rax,%r10
mov %rdx,%rax
mov %r10,%rdx
callq fib_tramp
mov -0x18(%rbp),%rbx
sub $0x1,%ebx
mov %rax,-0x20(%rbp)
mov -0x10(%rbp),%rsi
mov %rax,%r10
mov %rbx,%rax
mov %r10,%rbx
callq fib_tramp
return:
mov -0x20(%rbp),%rbx
add %ebx,%eax
mov %rbp,%rsp
pop %rbp
retq
return_n:
jmp return
stack_check:
callq WasmStackGuard
mov -0x10(%rbp),%rbx
mov -0x18(%rbp),%rax
jmp post_stack_check
</pre><p>Apparently <tt>fib</tt> compiles to a function of two arguments, the first passed in <tt>rsi</tt>, and the second in <tt>rax</tt>. (V8 uses a custom calling convention for its compiled WebAssembly.) The first synthesized argument is a handle onto run-time data structures for the current thread or isolate, and in the function prelude there's a check to see that the function has enough stack. V8 uses these stack checks also to handle interrupts, for when a web page is stuck in JavaScript.</p><p>Otherwise, it's a more or less normal function, with a bit more register/stack traffic than would be strictly needed, but pretty good.</p><p><b>do optimizations matter?</b></p><p>You've heard of Moore's Law -- though it doesn't apply any more, it roughly translated into hardware doubling in speed every 18 months. (Yes, I know it wasn't precisely that.) There is a corresponding rule of thumb for compiler land, <a href="http://proebsting.cs.arizona.edu/law.html">Proebsting's Law</a>: compiler optimizations make software twice as fast every 18 <i>years</i>. Zow!</p><p>The previous results with GCC and LLVM were with optimizations enabled (-O3). One way to measure Proebsting's Law would be to compare the results with -O0. Obviously in this case the program is small and we aren't expecting much work out of the optimizer, but it's interesting to see anyway:</p><p></p><center><img src="http://wingolog.org/pub/optimization-levels.png" /><br /></center><p>Answer: optimizations don't matter much for this benchark. This investigation does give a good baseline for compilers from high-level languages, like Guile: in the absence of clever trickery like the recursive inlining thing GCC does and in the absence of industrial-strength instruction selection, what's a good baseline target for a compiler? Here we see for this benchmark that it's somewhere between 420 and 620 milliseconds or so. Go gets there, and OCaml does even better.</p><p><b>how is time being spent, anyway?</b></p><p>Might we expect V8/WebAssembly to get there soon enough, or is the stack check that costly? How much time does one stack check take anyway? For that we'd have to determine the number of recursive calls for a given invocation.</p><p>Friends, it's not entirely clear to me why this is, but I instrumented a copy of <tt>fib</tt>, and I found that the number of calls in <tt>fib(<i>n</i>)</tt> was a more or less constant factor of the result of calling <tt>fib</tt>. That ratio converges to twice the golden ratio, which means that since <tt>fib(n+1) ~= φ * fib(n)</tt>, then the number of calls in <tt>fib(n)</tt> is approximately <tt>2 * fib(n+1)</tt>. I scratched my head for a bit as to why this is and I gave up; the Lord works in mysterious ways.</p><p>Anyway for <tt>fib(40)</tt>, that means that there are around 3.31e8 calls, absent GCC shenanigans. So that would indicate that each call for clang takes around 1.27 ns, which at turbo-boost speeds on this machine is 4.44 cycles. At maximum throughput (4 IPC), that would indicate 17.8 instructions per call, and indeed on the <tt>n &gt; 2</tt> path I count 17 instructions.</p><p>For WebAssembly I calculate 2.25 nanoseconds per call, or 7.9 cycles, or 31.5 (fused) instructions at max IPC. And indeed counting the extra jumps in the trampoline, I get 33 cycles on the recursive path. I count 4 instructions for the stack check itself, one to save the current isolate, and two to shuffle the current isolate into place for the recursive calls. But, compared to clang, V8 puts 6 words on the stack per call, as opposed to only 4 for LLVM. I think with better interprocedural register allocation for the isolate (i.e.: reserve a register for it), V8 could get a nice boost for call-heavy workloads.</p><p><b>where are we? dynamic edition</b></p><p>Guile doesn't aim to replace C; it's different. It has garbage collection, an integrated debugger, and a compiler that's available at run-time, it is dynamically typed. It's perhaps more fair to compare to languages that have some of these characteristics, so I ran these tests on versions of recursive <tt>fib</tt> written in a number of languages. Note that all of the numbers in this post include start-up time.</p><p></p><center><img src="http://wingolog.org/pub/dynamic-languages.png" /><br /></center><p>Here, the ocamlc line is the same as before, but using the bytecode compiler instead of the native compiler. It's a bit of an odd thing to include but it performs so well I just had to include it.</p><p>I think the real takeaway here is that Chez Scheme has fantastic performance. I have not been able to see the disassembly -- does it do the trick like GCC does? -- but the numbers are great, and I can see why Racket decided to rebase its implementation on top of it.</p><p>Interestingly, as far as I understand, Chez implements stack checks in the straightfoward way (an inline test-and-branch), not with a guard page, and instead of using the stack check as a generic ability to interrupt a computation in a timely manner as V8 does, Chez emits a <a href="https://www.scheme.com/csug8/system.html#./system:s89">separate interrupt check</a>. I would like to be able to see Chez's disassembly but haven't gotten around to figuring out how yet.</p><p>Since I originally published this article, I added a LuaJIT entry as well. As you can see, LuaJIT performs as well as Chez in this benchmark.</p><p>Haskell's call performance is surprisingly bad here, beaten even by OCaml's bytecode compiler; is this the cost of laziness, or just a lacuna of the implementation? I do not know. I do know I have this mental image that Haskell is a good compiler but apparently if that's the standard, so is Guile :)</p><p>Finally, in this comparison section, I was not surprised by cpython's relatively poor performance; we know cpython is not fast. I think though that it just goes to show how little these microbenchmarks are worth when it comes to user experience; like many of you I use plenty of Python programs in my daily work and don't find them slow at all. Think of micro-benchmarks like x-ray diffraction; they can reveal the hidden substructure of DNA but they say nothing at all about the organism.</p><p><b>where to now?</b></p><p>Perhaps you noted that in the last graph, the Guile and Chez lines were labelled "(lexical)". That's because instead of running this program:</p><pre>(define (fib n)
(if (&lt; n 2)
n
(+ (fib (- n 1)) (fib (- n 2)))))
</pre><p>They were running this, instead:</p><pre>(define (fib n)
(define (fib* n)
(if (&lt; n 2)
n
(+ (fib* (- n 1)) (fib* (- n 2)))))
(fib* n))
</pre><p>The thing is, historically, Scheme programs have treated top-level definitions as being mutable. This is because you don't know the extent of the top-level scope -- there could always be someone else who comes and adds a new definition of <tt>fib</tt>, effectively mutating the existing definition in place.</p><p>This practice has its uses. It's useful to be able to go in to a long-running system and change a definition to fix a bug or add a feature. It's also a useful way of developing programs, to incrementally build the program bit by bit.</p><p></p><center><img src="http://wingolog.org/pub/top-level-vs-lexical.png" /><br /></center><p>But, I would say that as someone who as written and maintained a lot of Scheme code, it's not a normal occurence to mutate a top-level binding on purpose, and it has a significant performance impact. If the compiler knows the target to a call, that unlocks a number of important optimizations: type check elision on the callee, more optimal closure representation, smaller stack frames, possible contification (turning calls into jumps), argument and return value count elision, representation specialization, and so on.</p><p>This overhead is especially egregious for calls inside modules. Scheme-the-language only gained modules relatively recently -- relative to the history of scheme -- and one of the aspects of modules is precisely to allow reasoning about top-level module-level bindings. This is why running Chez Scheme with the <tt>--program</tt> option is generally faster than <tt>--script</tt> (which I used for all of these tests): it opts in to the "newer" specification of what a top-level binding is.</p><p>In Guile we would probably like to move towards a more static way of treating top-level bindings, at least those within a single compilation unit. But we haven't done so yet. It's probably the most important single optimization we can make over the near term, though.</p><p>As an aside, it seems that LuaJIT also shows a similar performance differential for <tt>local function fib(n)</tt> versus just plain <tt>function fib(n)</tt>.</p><p>It's true though that even absent lexical optimizations, top-level calls can be made more efficient in Guile. I am not sure if we can reach Chez with the current setup of having a <a href="https://www.gnu.org/software/guile/docs/master/guile.html/Just_002dIn_002dTime-Native-Code.html#Just_002dIn_002dTime-Native-Code">template JIT</a>, because we need two return addresses: one virtual (for bytecode) and one "native" (for JIT code). Register allocation is also something to improve but it turns out to not be so important for <tt>fib</tt>, as there are few live values and they need to spill for the recursive call. But, we can avoid some of the indirection on the call, probably using an inline cache associated with the callee; Chez has had this optimization since 1984!</p><p><b>what guile learned from <tt>fib</tt></b></p><p>This exercise has been useful to speed up Guile's procedure calls, as you can see for the difference between the latest Guile 2.9.2 release and what hasn't been released yet (2.9.3).</p><p>To decide what improvements to make, I extracted the assembly that Guile generated for <tt>fib</tt> to a standalone file, and tweaked it in a number of ways to determine what the potential impact of different scenarios was. Some of the detritus from this investigation is <a href="https://gitlab.com/wingo/fib-asm-tinkering">here</a>.</p><p>There were three big performance improvements. One was to avoid eagerly initializing the slots in a function's stack frame; this took a surprising amount of run-time. Fortunately the rest of the toolchain like the local variable inspector was already ready for this change.</p><p>Another thing that became clear from this investigation was that our stack frames were too large; there was too much memory traffic. I was able to improve this in the lexical-call by adding an optimization to elide useless closure bindings. Usually in Guile when you call a procedure, you pass the callee as the 0th parameter, then the arguments. This is so the procedure has access to its closure. For some "well-known" procedures -- procedures whose callers can be enumerated -- we optimize to pass a specialized representation of the closure instead ("closure optimization"). But for well-known procedures with no free variables, there's no closure, so we were just passing a throwaway value (<tt>#f</tt>). An unhappy combination of Guile's current calling convention being stack-based and a strange outcome from the slot allocator meant that frames were a couple words too big. Changing to allow a custom calling convention in this case sped up <tt>fib</tt> considerably.</p><p>Finally, and also significantly, Guile's JIT code generation used to manually handle calls and returns via manual stack management and indirect jumps, instead of using the platform calling convention and the C stack. This is to allow <a href="https://wingolog.org/archives/2014/03/17/stack-overflow">unlimited stack growth</a>. However, it turns out that the indirect jumps at return sites were stalling the pipeline. Instead we switched to use call/return but keep our manual stack management; this allows the CPU to use its return address stack to predict return targets, speeding up code.</p><p><b>et voilà</b></p><p>Well, long article! Thanks for reading. There's more to do but I need to hit the publish button and pop this off my stack. Until next time, happy hacking!</p></div></content:encoded>
<dc:date>2019-06-26T10:34:11+00:00</dc:date>
<dc:creator>Andy Wingo</dc:creator>
</item>
<item rdf:about="http://www.fsf.org/blogs/gnu-press/emacs-t-shirts-available-now-at-the-gnu-press-shop">
<title>FSF Blogs: GNU Emacs T-shirts available now at the GNU Press Shop</title>
<link>http://www.fsf.org/blogs/gnu-press/emacs-t-shirts-available-now-at-the-gnu-press-shop</link>
<content:encoded><p><img alt="zoe modeling emacs tee" src="https://shop.fsf.org/sites/default/files/styles/product_zoom/public/Emacs%20shirt%20three%20quarter.jpg" style="margin-top: 4px;" width="300" /> </p>
<p>Have you been waiting with bated breath for the opportunity to show your love for GNU Emacs, the text editor that also does everything else, with a nifty T-shirt? Wait no longer. The GNU Press Shop now has GNU Emacs logo T-shirts in unisex sizes S through XXXL. Order one at <a href="https://shop.fsf.org/tshirts-hoodies/gnu-emacs-logo-t-shirt">https://shop.fsf.org/tshirts-hoodies/gnu-emacs-logo-t-shirt</a>, and we'll ship it to you sooner than you can say "extensible, customizable, self-documenting, real-time display editor."</p>
<p>All GNU Press Shop purchases support the Free Software Foundation's efforts to free all software, and <a href="https://my.fsf.org/join">FSF associate members</a> get a 20% discount off of all purchases.</p></content:encoded>
<dc:date>2019-06-25T19:20:00+00:00</dc:date>
<dc:creator>FSF Blogs</dc:creator>
</item>
<item rdf:about="tag:dustycloud.org,2019-06-25:blog/lets-just-be-weird-together/">
<title>Christopher Allan Webber: Let's Just Be Weird Together</title>
<link>http://dustycloud.org/blog/lets-just-be-weird-together/</link>
<content:encoded><div class="figure">
<img alt="ascii art of weird tea mugs with steam" src="http://dustycloud.org/etc/images/blog/ljbwt.gif" />
</div>
<p>Approximately a month ago was <a class="reference external" href="https://mlemmer.org/">Morgan</a> and I's
10 year wedding anniversary.
To commemorate that, and as a surprise gift, I made the above ascii
art and animation.</p>
<p>Actually, it's not just an animation, it's a program, and one
<a class="reference external" href="https://gitlab.com/dustyweb/dos-hurd/blob/master/dos-hurd/examples/ljbwt.rkt">you can run</a>.
As a side note, I originally thought I'd write up how I made it,
but I kept procrastinating on that and it lead me to putting off
writing this post for about a month.
Oh well, all I'll say for now is that it lead to a
<a class="reference external" href="https://gitlab.com/spritely/goblinoid">major rewrite</a> of one of
the <a class="reference external" href="https://gitlab.com/spritely/goblins">main components of Spritely</a>.
But that's something to speak of for another time, I suppose.</p>
<p>Back to the imagery!
Morgan was surprised to see the animation, and yet the image itself
wasn't a surprise.
That's because the design is actually built off of one we collaborated
on together:</p>
<div class="figure">
<img alt="embroidery of weird tea mugs with steam" src="http://dustycloud.org/etc/images/blog/ljbwt-embroidery-scaled.jpg" />
</div>
<p>I did the sketch for it and Morgan embroidered it.
The plan is to put this above the tea station we set up in the reading
area of our house.</p>
<p>The imagery and phrasing captures the philosophy of Morgan and I's
relationship.
We're both weird and deeply imperfect people, maybe even in some ways
broken.
But that's okay.
We don't expect each other to change or become something else... we
just try to become the best weird pairing we can together.
I think that strategy has worked out for us.</p>
<p>Thanks for all the happy times so far, Morgan.
I look forward to many weird years ahead.</p></content:encoded>
<dc:date>2019-06-25T18:10:00+00:00</dc:date>
<dc:creator>Christopher Lemmer Webber</dc:creator>
</item>
<item rdf:about="http://www.fsf.org/blogs/rms/drop-the-journalism-charges-against-julian-assange">
<title>FSF Blogs: Drop the journalism charges against Julian Assange</title>
<link>http://www.fsf.org/blogs/rms/drop-the-journalism-charges-against-julian-assange</link>
<content:encoded><p>The US government has persecuted Julian Assange for a decade for
Wikileaks' journalism, and now <a href="https://theintercept.com/2019/05/24/the-indictment-of-julian-assange-under-the-espionage-act-is-a-threat-to-the-press-and-the-american-people/">seeks to use his case to label the
publishing of leaked secret information as spying.</a></p>
<p>The Free Software Foundation stands for freedom of publication and due
process, because they are necessary to exercise and uphold the
software freedom we campaign for. The attack on journalism threatens
freedom of publication; the twisting of laws to achieve an unstated
aim threatens due process of law. The FSF therefore calls on the
United States to drop all present and future charges against Julian
Assange relating to Wikileaks activities.</p>
<p>Accusations against Assange that are unrelated to journalism should be
pursued or not pursued based on their merits, giving him neither
better nor worse treatment on account of his journalism.</p></content:encoded>
<dc:date>2019-06-25T17:50:06+00:00</dc:date>
<dc:creator>FSF Blogs</dc:creator>
</item>
<item rdf:about="http://savannah.gnu.org/forum/forum.php?forum_id=9457">
<title>libredwg @ Savannah: libredwg-0.8 released</title>
<link>http://savannah.gnu.org/forum/forum.php?forum_id=9457</link>
<content:encoded><p>This is a major release, adding the new dynamic API, read and write
<br />
all header and object fields by name. Many of the old dwg_api.h field
<br />
accessors are deprecated.
<br />
More here: <a href="https://www.gnu.org/software/libredwg/">https://www.gnu.org/software/libredwg/</a> and <a href="http://git.savannah.gnu.org/cgit/libredwg.git/tree/NEWS">http://git.savannah.gnu.org/cgit/libredwg.git/tree/NEWS</a>
<br />
</p>
<p>Here are the compressed sources:
<br />
<a href="http://ftp.gnu.org/gnu/libredwg/libredwg-0.8.tar.gz">http://ftp.gnu.org/gnu/libredwg/libredwg-0.8.tar.gz</a> (9.8MB)
<br />
<a href="http://ftp.gnu.org/gnu/libredwg/libredwg-0.8.tar.xz">http://ftp.gnu.org/gnu/libredwg/libredwg-0.8.tar.xz</a> (3.7MB)
<br />
</p>
<p>Here are the GPG detached signatures[*]:
<br />
<a href="http://ftp.gnu.org/gnu/libredwg/libredwg-0.8.tar.gz.sig">http://ftp.gnu.org/gnu/libredwg/libredwg-0.8.tar.gz.sig</a>
<br />
<a href="http://ftp.gnu.org/gnu/libredwg/libredwg-0.8.tar.xz.sig">http://ftp.gnu.org/gnu/libredwg/libredwg-0.8.tar.xz.sig</a>
<br />
</p>
<p>Use a mirror for higher download bandwidth:
<br />
<a href="https://www.gnu.org/order/ftp.html">https://www.gnu.org/order/ftp.html</a>
<br />
</p>
<p>Here are more binaries:
<br />
<a href="https://github.com/LibreDWG/libredwg/releases/tag/0.8">https://github.com/LibreDWG/libredwg/releases/tag/0.8</a>
<br />
</p>
<p>Here are the SHA256 checksums:
<br />
</p>
<p>087f0806220a0a33a9aab2c2763266a69e12427a5bd7179cff206289e60fe2fd libredwg-0.8.tar.gz
<br />
0487c84e962a4dbcfcf3cbe961294b74c1bebd89a128b4929a1353bc7f58af26 libredwg-0.8.tar.xz
<br />
</p>
<p>[*] Use a .sig file to verify that the corresponding file (without the
<br />
.sig suffix) is intact. First, be sure to download both the .sig file
<br />
and the corresponding tarball. Then, run a command like this:
<br />
</p>
<p> gpg --verify libredwg-0.8.tar.gz.sig
<br />
</p>
<p>If that command fails because you don't have the required public key,
<br />
then run this command to import it:
<br />
</p>
<p> gpg --keyserver keys.gnupg.net --recv-keys B4F63339E65D6414
<br />
</p>
<p>and rerun the 'gpg --verify' command.<br />
</p></content:encoded>
<dc:date>2019-06-25T09:55:44+00:00</dc:date>
<dc:creator>Reini Urban</dc:creator>
</item>
<item rdf:about="http://savannah.gnu.org/forum/forum.php?forum_id=9456">
<title>apl @ Savannah: GNU APL 1.8 Released</title>
<link>http://savannah.gnu.org/forum/forum.php?forum_id=9456</link>
<content:encoded><p>I am happy to announce that GNU APL 1.8 has been released.
<br />
</p>
<p>GNU APL is a free implementation of the ISO standard 13751 aka.
<br />
"Programming Language APL, Extended",
<br />
</p>
<p>This release contains:
<br />
</p>
<ul>
<li>bug fixes,
</li>
</ul>
<ul>
<li>⎕DLX (Donald Knuth's Dancing Links Algorithm),
</li>
</ul>
<ul>
<li>⎕FFT (fast fourier transforms; real, complex, and windows),
</li>
</ul>
<ul>
<li>⎕GTK (create GUI windows from APL),
</li>
</ul>
<ul>
<li>⎕RE (regular expressions), and
</li>
</ul>
<ul>
<li>user-defined APL commands.
</li>
</ul>
<p>Also, you can now call GNU APL from Python.<br />
</p></content:encoded>
<dc:date>2019-06-23T13:03:32+00:00</dc:date>
<dc:creator>Jürgen Sauermann</dc:creator>
</item>
<item rdf:about="http://savannah.gnu.org/forum/forum.php?forum_id=9453">
<title>denemo @ Savannah: Release 2.3 is imminent - please test.</title>
<link>http://savannah.gnu.org/forum/forum.php?forum_id=9453</link>
<content:encoded><p>New Features
<br />
Seek Locations in Scores
<br />
Specify type of object sought
<br />
Or valid note range
<br />
Or any custom condition
<br />
Creates a clickable list of locations
<br />
Each location is removed from list once visited
<br />
Syntax highlighting in LilyPond view
<br />
Playback Start/End markers draggable
<br />
Source window navigation by page number
<br />
Page number always visible
<br />
Rapid marking of passages
<br />
Two-chord Tremolos
<br />
Allowing breaks at half-measure for whole movement
<br />
Also breaks at every beat
<br />
Passages
<br />
Mark Passages of music
<br />
Perform tasks on the marked passages
<br />
Swapping musical material with staff below implemented
<br />
Search for lost scores
<br />
Interval-based
<br />
Searches whole directory hierarchy
<br />
Works for transposed scores
<br />
Compare Scores
<br />
Index Collection of Scores
<br />
All scores below a start directory indexed
<br />
Index includes typeset incipit for music
<br />
Title, Composer, Instrumentation, Score Comment fields
<br />
Sort by composer surname
<br />
Filter by any Scheme condition
<br />
Open files by clicking on them in Index
<br />
Intelligent File Opening
<br />
Re-interprets file paths for moved file systems
<br />
Improved Score etc editor appearance
<br />
Print History
<br />
History records what part of the score was printed
<br />
Date and printer included
<br />
Improvements to Scheme Editor
<br />
Title bar shows open file
<br />
Save dialog gives help
<br />
Colors now differentiate palettes, titles etc. in main display
<br />
Swapping Display and Source positions
<br />
for switching between entering music and editing
<br />
a single keypress or MIDI command
<br />
Activate object from keyboard
<br />
Fn2 key equivalent to mouse-right click
<br />
Shift and Control right-click via Shift-Fn2 and Control-Fn2
<br />
Help via Email
<br />
Auto-translation to Spanish
<br />
</p>
<p>Bug Fixes
<br />
</p>
<p> Adding buttons to palettes no longer brings hidden buttons back
<br />
</p>
<p> MIDI playback of empty measures containing non-notes
<br />
</p>
<p> Instrument name with Ambitus clash in staff properties menu fixed
<br />
</p>
<p> Visibility of emmentaler glyphs fixed
<br />
</p>
<p> Update of layout on staff to voice change
<br />
</p>
<p> Open Recent anomalies fixed
<br />
</p>
<p> Failures to translate menu titles and palettes fixed<br />
</p></content:encoded>
<dc:date>2019-06-22T09:29:29+00:00</dc:date>
<dc:creator>Richard Shann</dc:creator>
</item>
<item rdf:about="http://savannah.gnu.org/forum/forum.php?forum_id=9451">
<title>parallel @ Savannah: GNU Parallel 20190622 ('HongKong') released</title>
<link>http://savannah.gnu.org/forum/forum.php?forum_id=9451</link>
<content:encoded><p>GNU Parallel 20190622 ('HongKong') has been released. It is available for download at: <a href="http://ftpmirror.gnu.org/parallel/">http://ftpmirror.gnu.org/parallel/</a>
<br />
</p>
<p>GNU Parallel is 10 years old in a year on 2020-04-22. You are here by invited to a reception on Friday 2020-04-17.
<br />
</p>
<p>See <a href="https://www.gnu.org/software/parallel/10-years-anniversary.html">https://www.gnu.org/software/parallel/10-years-anniversary.html</a>
<br />
</p>
<p>Quote of the month:
<br />
</p>
<p> I want to make a shout-out for @GnuParallel, it's a work of beauty and power
<br />
-- Cristian Consonni @CristianCantoro
<br />
</p>
<p>New in this release:
<br />
</p>
<ul>
<li>--shard can now take a column name and optionally a perl expression. Similar to --group-by and replacement strings.
</li>
</ul>
<ul>
<li>Using AWK and R to parse 25tb <a href="https://livefreeordichotomize.com/2019/06/04/using_awk_and_r_to_parse_25tb/">https://livefreeordichotomize.com/2019/06/04/using_awk_and_r_to_parse_25tb/</a>
</li>
</ul>
<ul>
<li>Parallel and Visual testing with Behat <a href="http://parallelandvisualtestingwithbehat.blogspot.com/p/blog-page.html">http://parallelandvisualtestingwithbehat.blogspot.com/p/blog-page.html</a>
</li>
</ul>
<ul>
<li>维基百科，自由的百科全书<a href="https://zh.wikipedia.org/wiki/GNU_parallel">https://zh.wikipedia.org/wiki/GNU_parallel</a>
</li>
</ul>
<ul>
<li>Bug fixes and man page updates.
</li>
</ul>
<p>Get the book: GNU Parallel 2018 <a href="http://www.lulu.com/shop/ole-tange/gnu-parallel-2018/paperback/product-23558902.html">http://www.lulu.com/shop/ole-tange/gnu-parallel-2018/paperback/product-23558902.html</a>
<br />
</p>
<p>GNU Parallel - For people who live life in the parallel lane.
<br />
</p>
<h2>About GNU Parallel</h2>
<p>GNU Parallel is a shell tool for executing jobs in parallel using one or more computers. A job can be a single command or a small script that has to be run for each of the lines in the input. The typical input is a list of files, a list of hosts, a list of users, a list of URLs, or a list of tables. A job can also be a command that reads from a pipe. GNU Parallel can then split the input and pipe it into commands in parallel.
<br />
</p>
<p>If you use xargs and tee today you will find GNU Parallel very easy to use as GNU Parallel is written to have the same options as xargs. If you write loops in shell, you will find GNU Parallel may be able to replace most of the loops and make them run faster by running several jobs in parallel. GNU Parallel can even replace nested loops.
<br />
</p>
<p>GNU Parallel makes sure output from the commands is the same output as you would get had you run the commands sequentially. This makes it possible to use output from GNU Parallel as input for other programs.
<br />
</p>
<p>You can find more about GNU Parallel at: <a href="http://www.gnu.org/s/parallel/">http://www.gnu.org/s/parallel/</a>
<br />
</p>
<p>You can install GNU Parallel in just 10 seconds with:
<br />
(wget -O - pi.dk/3 || curl pi.dk/3/ || fetch -o - <a href="http://pi.dk/3">http://pi.dk/3</a>) | bash
<br />
</p>
<p>Watch the intro video on <a href="http://www.youtube.com/playlist?list=PL284C9FF2488BC6D1">http://www.youtube.com/playlist?list=PL284C9FF2488BC6D1</a>
<br />
</p>
<p>Walk through the tutorial (man parallel_tutorial). Your command line will love you for it.
<br />
</p>
<p>When using programs that use GNU Parallel to process data for publication please cite:
<br />
</p>
<p>O. Tange (2018): GNU Parallel 2018, March 2018, <a href="https://doi.org/10.5281/zenodo.1146014">https://doi.org/10.5281/zenodo.1146014</a>.
<br />
</p>
<p>If you like GNU Parallel:
<br />
</p>
<ul>
<li>Give a demo at your local user group/team/colleagues
</li>
<li>Post the intro videos on Reddit/Diaspora*/forums/blogs/ Identi.ca/Google+/Twitter/Facebook/Linkedin/mailing lists
</li>
<li>Get the merchandise <a href="https://gnuparallel.threadless.com/designs/gnu-parallel">https://gnuparallel.threadless.com/designs/gnu-parallel</a>
</li>
<li>Request or write a review for your favourite blog or magazine
</li>
<li>Request or build a package for your favourite distribution (if it is not already there)
</li>
<li>Invite me for your next conference
</li>
</ul>
<p>If you use programs that use GNU Parallel for research:
<br />
</p>
<ul>
<li>Please cite GNU Parallel in you publications (use --citation)
</li>
</ul>
<p>If GNU Parallel saves you money:
<br />
</p>
<ul>
<li>(Have your company) donate to FSF <a href="https://my.fsf.org/donate/">https://my.fsf.org/donate/</a>
</li>
</ul>
<h2>About GNU SQL</h2>
<p>GNU sql aims to give a simple, unified interface for accessing databases through all the different databases' command line clients. So far the focus has been on giving a common way to specify login information (protocol, username, password, hostname, and port number), size (database and table size), and running queries.
<br />
</p>
<p>The database is addressed using a DBURL. If commands are left out you will get that database's interactive shell.
<br />
</p>
<p>When using GNU SQL for a publication please cite:
<br />
</p>
<p>O. Tange (2011): GNU SQL - A Command Line Tool for Accessing Different Databases Using DBURLs, ;login: The USENIX Magazine, April 2011:29-32.
<br />
</p>
<h2>About GNU Niceload</h2>
<p>GNU niceload slows down a program when the computer load average (or other system activity) is above a certain limit. When the limit is reached the program will be suspended for some time. If the limit is a soft limit the program will be allowed to run for short amounts of time before being suspended again. If the limit is a hard limit the program will only be allowed to run when the system is below the limit.<br />
</p></content:encoded>
<dc:date>2019-06-21T13:36:51+00:00</dc:date>
<dc:creator>Ole Tange</dc:creator>
</item>
<item rdf:about="http://savannah.gnu.org/forum/forum.php?forum_id=9450">
<title>mailutils @ Savannah: Version 3.7</title>
<link>http://savannah.gnu.org/forum/forum.php?forum_id=9450</link>
<content:encoded><p>Version 3.7 of GNU mailutils is <a href="https://ftp.gnu.org/gnu/mailutils/mailutils-3.7.tar.gz">available for download</a>.
<br />
</p>
<p>This version introduces a new format for mailboxes: <strong>dotmail</strong>. Dotmail is a replacement for traditional mbox format, proposed by
<br />
Kurt Hackenberg. A dotmail mailbox is a single disk file, where messages are stored sequentially. Each message ends with a single
<br />
dot (similar to the format used in the SMTP DATA command). A dot appearing at the start of the line is doubled, to prevent it from being interpreted as end of message marker.
<br />
</p>
<p>For a complete list of changes, please see the <a href="http://git.savannah.gnu.org/cgit/mailutils.git/plain/NEWS?id=8a92bd208e5cf9f2a9f6b347051bf824b8c0995c">NEWS file</a>.<br />
</p></content:encoded>
<dc:date>2019-06-21T13:15:09+00:00</dc:date>
<dc:creator>Sergey Poznyakoff</dc:creator>
</item>
<item rdf:about="https://www.gnu.org/software/guile/news/gnu-guile-225-released.html">
<title>GNU Guile: GNU Guile 2.2.5 released</title>
<link>https://www.gnu.org/software/guile/news/gnu-guile-225-released.html</link>
<content:encoded><p>We are pleased to announce GNU Guile 2.2.5, the fifth bug-fix
release in the new 2.2 stable release series. This release represents
100 commits by 11 people since version 2.2.4. It fixes bugs that
had accumulated over the last few months, notably in the SRFI-19 date
and time library and in the <code>(web uri)</code> module. This release also
greatly improves performance of bidirectional pipes, and introduces the
new <code>get-bytevector-some!</code> binary input primitive that made it possible.</p><p>Guile 2.2.5 can be downloaded from <a href="https://www.gnu.org/software/guile/download">the usual
places</a>.</p><p>See the <a href="https://lists.gnu.org/archive/html/guile-devel/2019-06/msg00045.html">release
announcement</a>
for details.</p><p>Besides, we remind you that Guile 3.0 is in the works, and that you can
try out <a href="https://www.gnu.org/software/guile/news/gnu-guile-292-beta-released.html">version 2.9.2, which is the latest beta release of what will
become
3.0</a>.</p><p>Enjoy!</p></content:encoded>
<dc:date>2019-06-20T11:20:00+00:00</dc:date>
<dc:creator>Ludovic Courtès</dc:creator>
</item>
<item rdf:about="http://www.fsf.org/events/event-20190904-madrid-gnuhackersmeeting">
<title>FSF Events: Event - GNU Hackers Meeting (Madrid, Spain)</title>
<link>http://www.fsf.org/events/event-20190904-madrid-gnuhackersmeeting</link>
<content:encoded><p>Twelve years after it's first edition in Orense, the GNU Hackers
Meeting (2019-09-04–06) will help in Spain again. This is an
opportunity to meet, hack, and learn with other free software
enthusiasts.</p>
<p>See <a href="https://www.gnu.org/ghm/2019/">event page</a> for registration, call-for-talks, accommodations,
transportation, and other information.</p>
<p><strong>Location:</strong> <em><a href="http://www.etsisi.upm.es/">ETSISI</a> (Escuela Técnica Superior de Ingeniería de Sistemas Informáticos), Universidad Politécnica de Madrid, Calle Alan Turing s/n (Carretera de Valencia Km 7), 28031 Madrid, España</em></p>
<p>Please fill out our contact form, so that <a href="https://my.fsf.org/civicrm/profile/create?gid=69&amp;reset=1">we
can contact you about future events in and around Madrid.</a></p></content:encoded>
<dc:date>2019-06-19T16:35:12+00:00</dc:date>
<dc:creator>FSF Events</dc:creator>
</item>
<item rdf:about="http://www.fsf.org/events/rms-20190715-frankfurt">
<title>FSF Events: Richard Stallman - "Are we facing surveillance like in China?" (Frankurt, Germany)</title>
<link>http://www.fsf.org/events/rms-20190715-frankfurt</link>
<content:encoded><blockquote><p>Digital technology has enabled governments to impose surveillance
that Stalin could only dream of, making it next to impossible to
talk with a reporter (or do most things) unmonitored. This puts
democracy and human rights danger, as illustrated by the
totalitarian regime of China today.</p>
<p>Stallman will present the absolute upper limit on surveillance
of the public compatible with democracy, and present ways to
design systems that don't collect dossiers on people, except those
designated by courts based on valid specific suspicion of crime.</p></blockquote>
<p>This speech by Richard Stallman will be nontechnical, admission is
gratis, and the public is encouraged to attend.</p>
<p><strong>Location:</strong> <em>Festsaal, Casino (<a href="http://www.uni-frankfurt.de/73177180/GU_Lageplan_Campus_Westend_0318_Mensa_Bib_ENGL.pdf?">#7</a>),
Campus Westend, Johann Wolfgang Goethe-Universität Frankfurt am Main,
GrĂźneburgplatz 1, 60323 Frankfurt</em></p>
<p>Please fill out our contact form, so that <a href="https://my.fsf.org/civicrm/profile/create?gid=393&amp;reset=1">we
can contact you about future events in and around Frankfurt.</a></p></content:encoded>
<dc:date>2019-06-18T08:15:00+00:00</dc:date>
<dc:creator>FSF Events</dc:creator>
</item>
<item rdf:about="https://gnu.org/software/guix/blog/2019/substitutes-are-now-available-as-lzip/">
<title>GNU Guix: Substitutes are now available as lzip</title>
<link>https://gnu.org/software/guix/blog/2019/substitutes-are-now-available-as-lzip/</link>
<content:encoded><p>For a long time, our build farm at ci.guix.gnu.org has been delivering
<a href="https://www.gnu.org/software/guix/manual/en/html_node/Substitutes.html">substitutes</a>
(pre-built binaries) compressed with gzip. Gzip was never the best
choice in terms of compression ratio, but it was a reasonable and
convenient choice: it’s rock-solid, and zlib made it easy for us to have
<a href="https://git.savannah.gnu.org/cgit/guix.git/tree/guix/zlib.scm">Guile
bindings</a>
to perform in-process compression in our multi-threaded <a href="https://www.gnu.org/software/guix/manual/en/html_node/Invoking-guix-publish.html"><code>guix publish</code></a>
server.</p><p>With the exception of building software from source, downloads take the
most time of Guix package upgrades. If users can download less,
upgrades become faster, and happiness ensues. Time has come to improve
on this, and starting from early June, Guix can publish and fetch
<a href="https://nongnu.org/lzip/">lzip</a>-compressed substitutes, in addition to
gzip.</p><h1>Lzip</h1><p><a href="https://nongnu.org/lzip/">Lzip</a> is a relatively little-known
compression format, initially developed by Antonio Diaz Diaz ca. 2013.
It has several C and C++ implementations with surprisingly few lines of
code, which is always reassuring. One of its distinguishing features is
a very good compression ratio with reasonable CPU and memory
requirements, <a href="https://nongnu.org/lzip/lzip_benchmark.html">according to benchmarks published by the
authors</a>.</p><p><a href="https://nongnu.org/lzip/lzlib.html">Lzlib</a> provides a well-documented C
interface and Pierre Neidhardt set out to write bindings for that
library, which eventually landed as the <a href="https://git.savannah.gnu.org/cgit/guix.git/tree/guix/lzlib.scm"><code>(guix lzlib)</code>
module</a>.</p><p>With this in place we were ready to start migrating our tools, and then
our build farm, to lzip compression, so we can all enjoy smaller
downloads. Well, easier said than done!</p><h1>Migrating</h1><p>The compression format used for substitutes is not a core component like
it can be in “traditional” binary package formats <a href="https://lwn.net/Articles/789449/">such as
<code>.deb</code></a> since Guix is conceptually a
“source-based” distro. However, deployed Guix installations did not
support lzip, so we couldn’t just switch our build farm to lzip
overnight; we needed to devise a transition strategy.</p><p>Guix asks for the availability of substitutes over HTTP. For example, a
question such as:</p><blockquote><p>“Dear server, do you happen to have a binary of
<code>/gnu/store/6yc4ngrsig781bpayax2cg6pncyhkjpq-emacs-26.2</code> that I could download?”</p></blockquote><p>translates into prose to an HTTP GET of
<a href="https://ci.guix.gnu.org/6yc4ngrsig781bpayax2cg6pncyhkjpq.narinfo">https://ci.guix.gnu.org/6yc4ngrsig781bpayax2cg6pncyhkjpq.narinfo</a>,
which returns something like:</p><pre><code>StorePath: /gnu/store/6yc4ngrsig781bpayax2cg6pncyhkjpq-emacs-26.2
URL: nar/gzip/6yc4ngrsig781bpayax2cg6pncyhkjpq-emacs-26.2
Compression: gzip
NarHash: sha256:0h2ibqpqyi3z0h16pf7ii6l4v7i2wmvbrxj4ilig0v9m469f6pm9
NarSize: 134407424
References: 2dk55i5wdhcbh2z8hhn3r55x4873iyp1-libxext-1.3.3 …
FileSize: 48501141
System: x86_64-linux
Deriver: 6xqibvc4v8cfppa28pgxh0acw9j8xzhz-emacs-26.2.drv
Signature: 1;berlin.guixsd.org;KHNpZ25hdHV…</code></pre><p>(This narinfo format is inherited from <a href="https://nixos.org/nix/">Nix</a> and
implemented
<a href="https://git.savannah.gnu.org/cgit/guix.git/tree/guix/scripts/substitute.scm?id=121d9d1a7a2406a9b1cbe22c34343775f5955b34#n283">here</a>
and
<a href="https://git.savannah.gnu.org/cgit/guix.git/tree/guix/scripts/publish.scm?id=121d9d1a7a2406a9b1cbe22c34343775f5955b34#n265">here</a>.)
This tells us we can download the actual binary from
<code>/nar/gzip/…-emacs-26.2</code>, and that it will be about 46 MiB (the
<code>FileSize</code> field.) This is what <code>guix publish</code> serves.</p><p>The trick we came up with was to allow <code>guix publish</code> to advertise
several URLs, one per compression format. Thus, for recently-built
substitutes, we get something <a href="https://ci.guix.gnu.org/mvhaar2iflscidl0a66x5009r44fss15.narinfo">like
this</a>:</p><pre><code>StorePath: /gnu/store/mvhaar2iflscidl0a66x5009r44fss15-gimp-2.10.12
URL: nar/gzip/mvhaar2iflscidl0a66x5009r44fss15-gimp-2.10.12
Compression: gzip
FileSize: 30872887
URL: nar/lzip/mvhaar2iflscidl0a66x5009r44fss15-gimp-2.10.12
Compression: lzip
FileSize: 18829088
NarHash: sha256:10n3nv3clxr00c9cnpv6x7y2c66034y45c788syjl8m6ga0hbkwy
NarSize: 94372664
References: 05zlxc7ckwflz56i6hmlngr86pmccam2-pcre-8.42 …
System: x86_64-linux
Deriver: vi2jkpm9fd043hm0839ibbb42qrv5xyr-gimp-2.10.12.drv
Signature: 1;berlin.guixsd.org;KHNpZ25hdHV…</code></pre><p>Notice that there are two occurrences of the <code>URL</code>, <code>Compression</code>, and
<code>FileSize</code> fields: one for gzip, and one for lzip. Old Guix instances
will just pick the first one, gzip; newer Guix will pick whichever
supported method provides the smallest <code>FileSize</code>, usually lzip. This
will make migration trivial in the future, should we add support for
other compression methods.</p><p>Users need to upgrade their Guix daemon to benefit from lzip. On a
“foreign distro”, simply run <code>guix pull</code> as root. On standalone Guix
systems, run <code>guix pull &amp;&amp; sudo guix system reconfigure /etc/config.scm</code>. In both cases, the daemon has to be restarted, be it
with <code>systemctl restart guix-daemon.service</code> or with <code>herd restart guix-daemon</code>.</p><h1>First impressions</h1><p>This new gzip+lzip scheme has been deployed on ci.guix.gnu.org for a
week. Specifically, we run <code>guix publish -C gzip:9 -C lzip:9</code>, meaning
that we use the highest compression ratio for both compression methods.</p><p>Currently, only a small subset of the package substitutes are available
as both lzip and gzip; those that were already available as gzip have
not been recompressed. The following Guile program that taps into the
API of <a href="https://www.gnu.org/software/guix/manual/en/html_node/Invoking-guix-weather.html"><code>guix weather</code></a>
allows us to get some insight:</p><pre><code class="language-scheme">(use-modules (gnu) (guix)
(guix monads)
(guix scripts substitute)
(srfi srfi-1)
(ice-9 match))
(define all-packages
(@@ (guix scripts weather) all-packages))
(define package-outputs
(@@ (guix scripts weather) package-outputs))
(define (fetch-lzip-narinfos)
(mlet %store-monad ((items (package-outputs (all-packages))))
(return
(filter (lambda (narinfo)
(member "lzip" (narinfo-compressions narinfo)))
(lookup-narinfos "https://ci.guix.gnu.org" items)))))
(define (lzip/gzip-ratio narinfo)
(match (narinfo-file-sizes narinfo)
((gzip lzip)
(/ lzip gzip))))
(define (average lst)
(/ (reduce + 0 lst)
(length lst) 1.))</code></pre><p>Let’s explore this at the
<a href="https://en.wikipedia.org/wiki/Read%E2%80%93eval%E2%80%93print_loop">REPL</a>:</p><pre><code class="language-scheme">scheme@(guile-user)&gt; (define lst
(with-store s
(run-with-store s (fetch-lzip-narinfos))))
computing 9,897 package derivations for x86_64-linux...
updating substitutes from 'https://ci.guix.gnu.org'... 100.0%
scheme@(guile-user)&gt; (length lst)
$4 = 2275
scheme@(guile-user)&gt; (average (map lzip/gzip-ratio lst))
$5 = 0.7398994395478715</code></pre><p>As of this writing, around 20% of the package substitutes are
available as lzip, so take the following stats with a grain of salt.
Among those, the lzip-compressed substitute is on average 26% smaller
than the gzip-compressed one. What if we consider only packages bigger
than 5 MiB uncompressed?</p><pre><code class="language-scheme">scheme@(guile-user)&gt; (define biggest
(filter (lambda (narinfo)
(&gt; (narinfo-size narinfo)
(* 5 (expt 2 20))))
lst))
scheme@(guile-user)&gt; (average (map lzip/gzip-ratio biggest))
$6 = 0.5974238562384483
scheme@(guile-user)&gt; (length biggest)
$7 = 440</code></pre><p>For those packages, lzip yields substitutes that are 40% smaller on
average. Pretty nice! Lzip decompression is slightly more
CPU-intensive than gzip decompression, but downloads are
bandwidth-bound, so the benefits clearly outweigh the costs.</p><h1>Going forward</h1><p>The switch from gzip to lzip has the potential to make upgrades “feel”
faster, and that is great in itself.</p><p>Fundamentally though, we’ve always been looking in this project at
peer-to-peer solutions with envy. Of course, the main motivation is to
have a community-supported and resilient infrastructure, rather than a
centralized one, and that vision goes <a href="https://www.gnu.org/software/guix/blog/2017/reproducible-builds-a-status-update/">hand-in-hand with reproducible
builds</a>.</p><p>We started working on <a href="https://issues.guix.gnu.org/issue/33899">an extension to publish and fetch
substitutes</a> over
<a href="https://ipfs.io/">IPFS</a>. Thanks to its content-addressed nature, IPFS
has the potential to further reduce the amount of data that needs to be
downloaded on an upgrade.</p><p>The good news is that IPFS developers are also <a href="https://github.com/ipfs/package-managers">interested in working
with package manager
developers</a>, and I bet
there’ll be interesting discussions at <a href="https://camp.ipfs.io/">IPFS
Camp</a> in just a few days. We’re eager to pursue
our IPFS integration work, and if you’d like to join us and hack the
good hack, <a href="https://www.gnu.org/software/guix/contact/">let’s get in
touch!</a></p><h4>About GNU Guix</h4><p><a href="https://www.gnu.org/software/guix">GNU Guix</a> is a transactional package
manager and an advanced distribution of the GNU system that <a href="https://www.gnu.org/distros/free-system-distribution-guidelines.html">respects
user
freedom</a>.
Guix can be used on top of any system running the kernel Linux, or it
can be used as a standalone operating system distribution for i686,
x86_64, ARMv7, and AArch64 machines.</p><p>In addition to standard package management features, Guix supports
transactional upgrades and roll-backs, unprivileged package management,
per-user profiles, and garbage collection. When used as a standalone
GNU/Linux distribution, Guix offers a declarative, stateless approach to
operating system configuration management. Guix is highly customizable
and hackable through <a href="https://www.gnu.org/software/guile">Guile</a>
programming interfaces and extensions to the
<a href="http://schemers.org">Scheme</a> language.</p></content:encoded>
<dc:date>2019-06-17T12:30:00+00:00</dc:date>
<dc:creator>Ludovic Courtès</dc:creator>
</item>
<item rdf:about="https://gnunet.org/#gnunet-0.11.5-release">
<title>GNUnet News: 2019-06-05: GNUnet 0.11.5 released</title>
<link>https://gnunet.org/#gnunet-0.11.5-release</link>
<content:encoded><h3>
<a name="gnunet-0.11.5-release">2019-06-05: GNUnet 0.11.5 released</a>
</h3>
<p>
We are pleased to announce the release of GNUnet 0.11.5.
</p>
<p>
This is a bugfix release for 0.11.4, mostly fixing a few
minor bugs and improving performance, in particular for
identity management with a large number of egos.
In the wake of this release, we also launched the
<a href="https://rest.gnunet.org">REST API documentation</a>.
In
terms of usability, users should be aware that there are still a large
number of known open issues in particular with respect to ease of use,
but also some critical privacy issues especially for mobile users.
Also, the nascent network is tiny (about 200 peers) and thus unlikely to
provide good anonymity or extensive amounts of interesting
information. As a result, the 0.11.5 release is still only suitable
for early adopters with some reasonable pain tolerance.
</p>
<h4>Download links</h4>
<ul>
<li><a href="http://ftpmirror.gnu.org/gnunet/gnunet-0.11.5.tar.gz">http://ftpmirror.gnu.org/gnunet/gnunet-0.11.5.tar.gz</a></li>
<li><a href="http://ftpmirror.gnu.org/gnunet/gnunet-0.11.5.tar.gz.sig">http://ftpmirror.gnu.org/gnunet/gnunet-0.11.5.tar.gz.sig</a></li>
<li><a href="http://ftpmirror.gnu.org/gnunet/gnunet-gtk-0.11.5.tar.gz">http://ftpmirror.gnu.org/gnunet/gnunet-gtk-0.11.5.tar.gz</a></li>
<li><a href="http://ftpmirror.gnu.org/gnunet/gnunet-gtk-0.11.5.tar.gz.sig">http://ftpmirror.gnu.org/gnunet/gnunet-gtk-0.11.5.tar.gz.sig</a></li>
<li><a href="http://ftpmirror.gnu.org/gnunet/gnunet-fuse-0.11.0.tar.gz">http://ftpmirror.gnu.org/gnunet/gnunet-fuse-0.11.0.tar.gz</a></li>
<li><a href="http://ftpmirror.gnu.org/gnunet/gnunet-fuse-0.11.0.tar.gz.sig">http://ftpmirror.gnu.org/gnunet/gnunet-fuse-0.11.0.tar.gz.sig</a></li>
</ul>
<p>
gnunet-gtk saw some minor changes to adopt it to API changes in the main code
related to the identity improvements.
gnunet-fuse was not released again, as there were no
changes and the 0.11.0 version is expected to continue to work fine
with gnunet-0.11.5.
</p>
<p>
Note that due to mirror synchronization, not all links might be functional
early after the release. For direct access try <a href="http://ftp.gnu.org/gnu/gnunet/">http://ftp.gnu.org/gnu/gnunet/</a>
</p>
<h4>Noteworthy changes in 0.11.5 (since 0.11.4)</h4>
<ul>
<li>
<tt>gnunet-identity</tt> is much faster when creating or deleting
egos given a large number of existing egos.
</li>
<li>
GNS now supports CAA records.
</li>
<li>
Documentation, comments and code quality was improved.
</li>
</ul>
<h4>Known Issues</h4>
<ul>
<li>
There are known major design issues in the TRANSPORT, ATS and CORE subsystems
which will need to be addressed in the future to achieve acceptable usability,
performance and security.
</li>
<li>
There are known moderate implementation limitations in CADET that
negatively impact performance. Also CADET may unexpectedly deliver messages out-of-order.
</li>
<li>
There are known moderate design issues in FS that also impact
usability and performance.
</li>
<li>
There are minor implementation limitations in SET that create
unnecessary attack surface for availability.
</li>
<li>
The RPS subsystem remains experimental.
</li>
<li>
Some high-level tests in the test-suite fail non-deterministically due to
the low-level TRANSPORT issues.
</li>
</ul>
<p>
In addition to this list, you may also want to consult our bug tracker
at <a href="https://bugs.gnunet.org/">bugs.gnunet.org</a> which lists
about 190 more specific issues.
</p>
<h4>Thanks</h4>
<p>
This release was the work of many people. The following people
contributed code and were thus easily identified:
Christian Grothoff, Florian Dold, Marcello Stanisci, ng0, Martin Schanzenbach and Bernd Fix.
</p></content:encoded>
<dc:date>2019-06-05T00:00:00+00:00</dc:date>
<dc:creator>GNUnet News</dc:creator>
</item>
<item rdf:about="http://savannah.gnu.org/forum/forum.php?forum_id=9442">
<title>gengetopt @ Savannah: 2.23 released</title>
<link>http://savannah.gnu.org/forum/forum.php?forum_id=9442</link>
<content:encoded><p>New version (2.23) was released. Main changes were in build system, so please report any issues you notice.<br />
</p></content:encoded>
<dc:date>2019-06-04T08:41:09+00:00</dc:date>
<dc:creator>Gray Wolf</dc:creator>
</item>
<item rdf:about="http://wingolog.org/2019/06/03/pictie-my-c-to-webassembly-workbench">
<title>Andy Wingo: pictie, my c++-to-webassembly workbench</title>
<link>http://wingolog.org/archives/2019/06/03/pictie-my-c-to-webassembly-workbench</link>
<content:encoded><div><p>Hello, interwebs! Today I'd like to share a little skunkworks project with y'all: <a href="https://github.com/wingo/pictie">Pictie</a>, a workbench for WebAssembly C++ integration on the web.</p><p><b id="pictie-status">loading pictie...</b></p><div id="pictie-log"></div><form hidden="1" id="pictie-form">
<label for="entry" id="pictie-prompt">&gt; </label>
<input id="pictie-entry" name="entry" size="40" type="text" />
</form><p>&lt;noscript&gt;
JavaScript disabled, no pictie demo. See <a href="https://github.com/wingo/pictie/">the pictie web page</a> for more information.
&lt;/noscript&gt;&gt;&amp;&amp;&lt;&amp;&gt;&gt;&gt;&amp;&amp;&gt;&lt;&lt;&gt;&gt;&amp;&amp;&lt;&gt;&lt;&gt;&gt;</p><p><b>wtf just happened????!?</b></p><p>So! If everything went well, above you have some colors and a prompt that accepts Javascript expressions to evaluate. If the result of evaluating a JS expression is a painter, we paint it onto a canvas.</p><p>But allow me to back up a bit. These days everyone is talking about WebAssembly, and I think with good reason: just as many of the world's programs run on JavaScript today, tomorrow much of it will also be in languages compiled to WebAssembly. JavaScript isn't going anywhere, of course; it's around for the long term. It's the "also" aspect of WebAssembly that's interesting, that it appears to be a computing substrate that is compatible with JS and which can extend the range of the kinds of programs that can be written for the web.</p><p>And yet, it's early days. What are programs of the future going to look like? What elements of the web platform will be needed when we have systems composed of WebAssembly components combined with JavaScript components, combined with the browser? Is it all going to work? Are there missing pieces? What's the status of the toolchain? What's the developer experience? What's the user experience?</p><p>When you look at the current set of applications targetting WebAssembly in the browser, mostly it's games. While compelling, games don't provide a whole lot of insight into the shape of the future web platform, inasmuch as there doesn't have to be much JavaScript interaction when you have an already-working C++ game compiled to WebAssembly. (Indeed, much of the incidental interactions with JS that are currently necessary -- bouncing through JS in order to call WebGL -- people are actively working on removing all of that overhead, so that WebAssembly can call platform facilities (WebGL, etc) directly. But I digress!)</p><p>For WebAssembly to really succeed in the browser, there should also be incremental stories -- what does it look like when you start to add WebAssembly modules to a system that is currently written mostly in JavaScript?</p><p>To find out the answers to these questions and to evaluate potential platform modifications, I needed a small, standalone test case. So... I wrote one? It seemed like a good idea at the time.</p><p><b>pictie is a test bed</b></p><p>Pictie is a simple, standalone C++ graphics package implementing an algebra of painters. It was created not to be a great graphics package but rather to be a test-bed for compiling C++ libraries to WebAssembly. You can read more about it on <a href="https://github.com/wingo/pictie">its github page</a>.</p><p>Structurally, pictie is a modern C++ library with a functional-style interface, smart pointers, reference types, lambdas, and all the rest. We use emscripten to compile it to WebAssembly; you can see more information on how that's done in the repository, or check the <a href="https://github.com/wingo/pictie/blob/master/README.md#webassembly">README</a>.</p><p>Pictie is inspired by Peter Henderson's "Functional Geometry" (<a href="http://pmh-systems.co.uk/phAcademic/papers/funcgeo.pdf">1982</a>, <a href="https://eprints.soton.ac.uk/257577/1/funcgeo2.pdf">2002</a>). "Functional Geometry" inspired the <a href="https://sarabander.github.io/sicp/html/2_002e2.xhtml#g_t2_002e2_002e4">Picture language</a> from the well-known <i>Structure and Interpretation of Computer Programs</i> computer science textbook.</p><p><b>prototype in action</b></p><p>So far it's been surprising how much stuff just works. There's still lots to do, but just getting a C++ library on the web is pretty easy! I advise you to take a look to see the details.</p><p>If you are thinking of dipping your toe into the WebAssembly water, maybe take a look also at Pictie when you're doing your back-of-the-envelope calculations. You can use it or a prototype like it to determine the effects of different compilation options on compile time, load time, throughput, and network trafic. You can check if the different binding strategies are appropriate for your C++ idioms; Pictie currently uses <a href="https://emscripten.org/docs/porting/connecting_cpp_and_javascript/embind.html">embind</a> <a href="https://github.com/wingo/pictie/blob/master/pictie.bindings.cc">(source)</a>, but <a href="https://emscripten.org/docs/porting/connecting_cpp_and_javascript/embind.html">I would like to compare to WebIDL as well</a>. You might also use it if you're considering what shape your C++ library should have to have a minimal overhead in a WebAssembly context.</p><p>I use Pictie as a test-bed when working on the web platform; the <a href="https://github.com/tc39/proposal-weakrefs">weakref proposal</a> which adds finalization, <a href="https://github.com/emscripten-core/emscripten/pull/8687">leak detection</a>, and working on the binding layers around Emscripten. Eventually I'll be able to use it in other contexts as well, with the <a href="https://github.com/WebAssembly/webidl-bindings/blob/master/proposals/webidl-bindings/Explainer.md">WebIDL bindings</a> proposal, typed objects, and <a href="https://github.com/WebAssembly/webidl-bindings/blob/master/proposals/webidl-bindings/Explainer.md">GC</a>.</p><p><b>prototype the web forward</b></p><p>As the browser and adjacent environments have come to dominate programming in practice, we lost a bit of the delightful variety from computing. JS is a great language, but it shouldn't be the only medium for programs. WebAssembly is part of this future world, waiting in potentia, where applications for the web can be written in any of a number of languages. But, this future world will only arrive if it "works" -- if all of the various pieces, from standards to browsers to toolchains to virtual machines, only if all of these pieces fit together in some kind of sensible way. Now is the early phase of annealing, when the platform as a whole is actively searching for its new low-entropy state. We're going to need a lot of prototypes to get from here to there. In that spirit, may your prototypes be numerous and soon replaced. Happy annealing!</p></div></content:encoded>
<dc:date>2019-06-03T10:10:38+00:00</dc:date>
<dc:creator>Andy Wingo</dc:creator>
</item>
<item rdf:about="http://savannah.gnu.org/forum/forum.php?forum_id=9440">
<title>unifont @ Savannah: GNU Unifont 12.1.02 Released</title>
<link>http://savannah.gnu.org/forum/forum.php?forum_id=9440</link>
<content:encoded><p><strong>1 June 2019</strong> Unifont 12.1.02 is now available. This version introduces a <strong>Japanese TrueType version</strong>, unifont_jp, replacing over 10,000 ideographs from the default Unifont build with kanji from the public domain Jiskan16 font. This version also contains redrawn Devanagari and Bengali glyphs. Full details are in the ChangeLog file.
<br />
</p>
<p>Download this release at:
<br />
</p>
<p><a href="https://ftpmirror.gnu.org/unifont/unifont-12.1.02/">https://ftpmirror.gnu.org/unifont/unifont-12.1.02/</a>
<br />
</p>
<p>or if that fails,
<br />
</p>
<p><a href="https://ftp.gnu.org/gnu/unifont/unifont-12.1.02/">https://ftp.gnu.org/gnu/unifont/unifont-12.1.02/</a>
<br />
</p>
<p>or, as a last resort,
<br />
</p>
<p><a href="ftp://ftp.gnu.org/gnu/unifont/unifont-12.1.02/">ftp://ftp.gnu.org/gnu/unifont/unifont-12.1.02/</a><br />
</p></content:encoded>
<dc:date>2019-06-01T22:43:49+00:00</dc:date>
<dc:creator>Paul Hardy</dc:creator>
</item>
<item rdf:about="http://www.fsf.org/events/rms-20190622-mayhew">
<title>FSF Events: CANCELLED - Richard Stallman - "The Free Software Movement" (Mayhew, MS)</title>
<link>http://www.fsf.org/events/rms-20190622-mayhew</link>
<content:encoded><strike><blockquote>The Free Software Movement campaigns for computer users'
freedom to cooperate and control their own computing. The Free
Software Movement developed the GNU operating system, typically used
together with the kernel Linux, specifically to make these freedoms
possible.</blockquote></strike>
<strike></strike><p><strike>This speech by Richard Stallman will be nontechnical, admission is
gratis, and the public is encouraged to attend.</strike>
<strike></strike></p><p><strike><strong>Location:</strong> <em>Lyceum, 8731 South Frontage Rd., Mayhew, MS 39753</em></strike>
<strike></strike></p><p><strike>Please fill out our contact form, so that <a href="https://my.fsf.org/civicrm/profile/create?gid=581&amp;reset=1">we
can contact you about future events in and around Mayhew.</a></strike>
</p><p>The event this speech was going to be part of has been cancelled.</p></content:encoded>
<dc:date>2019-05-30T17:10:00+00:00</dc:date>
<dc:creator>FSF Events</dc:creator>
</item>
<item rdf:about="http://www.fsf.org/events/rms-20190607-vienna">
<title>FSF Events: Richard Stallman - "Free software and your freedom" (Vienna, Austria)</title>
<link>http://www.fsf.org/events/rms-20190607-vienna</link>
<content:encoded><p>
</p><blockquote>
Most computers now contain at least some free software. This success makes it more important than ever to know about the ideas behind free software. Users should be aware of the freedoms it gives us and how to make use of it.
</blockquote>
<blockquote>
As opposed to secrecy and profit orientation, free access to and sharing of knowledge and ideas have the potential to change the world. Knowledge should be treated as a common good. This revolutionary idea was the base on which GNU/Linux and the free and collaborative encyclopedia Wikipedia were built.
</blockquote>
<p></p>
<p>This speech by Richard Stallman will be nontechnical, admission is
gratis, and the public is encouraged to attend.</p>
<p><strong>Location:</strong> <em>Hall: FS0.01, Fachhochschule FH Technikum Wien, Höchstädtplatz 6, KG Brigittenau, 1200 Wien, Österreich</em></p>
<p>Please fill out our contact form, so that <a href="https://my.fsf.org/civicrm/profile/create?gid=300&amp;reset=1">we
can contact you about future events in and around Vienna.</a></p></content:encoded>
<dc:date>2019-05-30T16:55:00+00:00</dc:date>
<dc:creator>FSF Events</dc:creator>
</item>
<item rdf:about="https://www.gnu.org/software/guile/news/join-guile-guix-days-strasbourg-2019.html">
<title>GNU Guile: Join the Guile and Guix Days in Strasbourg, June 21–22!</title>
<link>https://www.gnu.org/software/guile/news/join-guile-guix-days-strasbourg-2019.html</link>
<content:encoded><p>We’re organizing Guile Days at the University of Strasbourg, France,
<a href="https://journeesperl.fr/jp2019/">co-located with the Perl Workshop</a>,
on June 21st and 22nd.</p><p><img alt="Guile Days 2019" src="https://www.gnu.org/software/guile/static/base/img/guile-days-2019.png" /></p><p><em><em>Update</em>: The program is now complete, <a href="https://journeesperl.fr/jp2019/schedule?day=2019-06-21">view the schedule
on-line</a>.</em></p><p>The schedule is not complete yet, but we can already announce a couple
of events:</p><ul><li><em>Getting Started with GNU Guix</em> will be an introductory hands-on
session to <a href="https://www.gnu.org/software/guix/">Guix</a>, targeting an
audience of people who have some experience with GNU/Linux but are
new to Guix.</li><li>During a “<em>code buddy</em>” session, experienced Guile programmers will
be here to get you started programming in Guile, and to answer
questions and provide guidance while you hack at your pace on the
project of your choice.</li></ul><p>If you’re already a Guile or Guix user or developer, consider submitting
by June 8th, <a href="https://journeesperl.fr/jp2019/newtalk">on the web site</a>,
talks on topics such as:</p><ul><li><p>The neat Guile- or Guix-related project you’ve been working on.</p></li><li><p>Cool Guile hacking topics—Web development, databases, system
development, graphical user interfaces, shells, you name it!</p></li><li><p>Fancy Guile technology—concurrent programming with Fibers, crazy
macrology, compiler front-ends, JIT compilation and Guile 3,
development environments, etc.</p></li><li><p>Guixy things: on Guix subsystems, services, the Shepherd, Guile
development with Guix, all things OS-level in Guile, Cuirass,
reproducible builds, bootstrapping, Mes and Gash, all this!</p></li></ul><p>You can also propose hands-on workshops, which could last anything from
an hour to a day. We expect newcomers at this event, people who don’t
know Guile and Guix and want to learn about it. Consider submitting
introductory workshops on Guile and Guix!</p><p>We encourage submissions from people in communities usually
underrepresented in free software, including women, people in sexual
minorities, or people with disabilities.</p><p>We want to make this event a pleasant experience for everyone, and
participation is subject to a <a href="https://journeesperl.fr/jp2019/conduct.html">code of
conduct</a>.</p><p>Many thanks to the organizers of the <a href="https://journeesperl.fr/jp2019/">Perl
Workshop</a> and to the sponsors of the
event: RENATER, Université de Strasbourg, X/Stra, and Worteks.</p></content:encoded>
<dc:date>2019-05-28T09:11:00+00:00</dc:date>
<dc:creator>Ludovic Courtès</dc:creator>
</item>
<item rdf:about="http://www.fsf.org/events/rms-20190606-brno-smartcity">
<title>FSF Events: Richard Stallman - "Computing, freedom, and privacy" (Brno, Czech Republic)</title>
<link>http://www.fsf.org/events/rms-20190606-brno-smartcity</link>
<content:encoded><blockquote>The way digital technology is developing, it threatens our
freedom, within our computers and in the internet. What are the
threats? What must we change?</blockquote>
<p>This speech by Richard Stallman will be nontechnical, admission to just the speech is gratis—<a href="https://my.fsf.org/civicrm/profile/create?gid=580&amp;reset=1">provided you register via the FSF link</a>—and the public is encouraged to attend.</p>
<p><strong>Location:</strong> <em>Pavilion G1, Digital City Stage, Brno Fair Grounds (BVV), URBIS Smart City Fair, Výstaviště 405/1, 603 00 </em></p>
<p><a href="https://my.fsf.org/civicrm/profile/create?gid=580&amp;reset=1">Please register, so that we can accommodate all the people who wish to
attend</a>.</p>
<p>Please fill out our contact form, so that <a href="https://my.fsf.org/civicrm/profile/create?gid=578&amp;reset=1">we
can contact you about future events in and around Brno.</a></p></content:encoded>
<dc:date>2019-05-24T13:35:00+00:00</dc:date>
<dc:creator>FSF Events</dc:creator>
</item>
<item rdf:about="http://wingolog.org/2019/05/24/lightening-run-time-code-generation">
<title>Andy Wingo: lightening run-time code generation</title>
<link>http://wingolog.org/archives/2019/05/24/lightening-run-time-code-generation</link>
<content:encoded><div><p>The upcoming Guile 3 release will have just-in-time native code generation. Finally, amirite? There's lots that I'd like to share about that and I need to start somewhere, so this article is about one piece of it: <a href="https://gitlab.com/wingo/lightening">Lightening, a library to generate machine code</a>.</p><p><b>on lightning</b></p><p>Lightening is a fork of <a href="https://www.gnu.org/software/lightning/">GNU Lightning</a>, adapted to suit the needs of Guile. In fact at first we chose to use GNU Lightning directly, "vendored" into the Guile source respository via the <a href="https://git-scm.com/book/en/v1/Git-Tools-Subtree-Merging">git subtree mechanism</a>. (I see that in the meantime, <tt>git</tt> gained a kind of a <a href="https://github.com/git/git/blob/master/contrib/subtree/git-subtree.txt"><tt>subtree</tt> command</a>; one day I will have to figure out what it's for.)</p><p><a href="https://www.gnu.org/software/lightning/">GNU Lightning</a> has lots of things going for it. It has support for many architectures, even things like Itanium that I don't really care about but which a couple Guile users use. It abstracts the differences between e.g. x86 and ARMv7 behind a common API, so that in Guile I don't need to duplicate the JIT for each back-end. Such an abstraction can have a slight performance penalty, because maybe it missed the opportunity to generate optimal code, but this is acceptable to me: I was more concerned about the maintenance burden, and GNU Lightning seemed to solve that nicely.</p><p>GNU Lightning also has <a href="https://www.gnu.org/software/lightning/manual/">fantastic documentation</a>. It's written in C and not C++, which is the right thing for Guile at this time, and it's also released under the LGPL, which is Guile's license. As it's a GNU project there's a good chance that GNU Guile's needs might be taken into account if any changes need be made.</p><p>I mentally associated Paolo Bonzini with the project, who I knew was a good no-nonsense hacker, as he used Lightning for a <a href="http://smalltalk.gnu.org/">smalltalk implementation</a>; and I knew also that Matthew Flatt used Lightning in <a href="https://racket-lang.org/">Racket</a>. Then I looked in the source code to see architecture support and was pleasantly surprised to see MIPS, POWER, and so on, so I went with GNU Lightning for Guile in our <a href="https://www.gnu.org/software/guile/news/gnu-guile-291-beta-released.html">2.9.1 release last October</a>.</p><p><b>on lightening the lightning</b></p><p>When I chose GNU Lightning, I had in mind that it was a very simple library to cheaply write machine code into buffers. (Incidentally, if you have never worked with this stuff, I remember a time when I was pleasantly surprised to realize that an assembler could be a library and not just a program that processes text. A CPU interprets machine code. Machine code is just bytes, and you can just write C (or Scheme, or whatever) functions that write bytes into buffers, and pass those buffers off to the CPU. Now you know!)</p><p>Anyway indeed GNU Lightning 1.4 or so was that very simple library that I had in my head. I needed simple because I would need to debug any problems that came up, and I didn't want to add more complexity to the C side of Guile -- eventually I should be migrating this code over to Scheme anyway. And, of course, simple can mean fast, and I needed fast code generation.</p><p>However, GNU Lightning has a new release series, the 2.x series. This series is a rewrite in a way of the old version. On the plus side, this new series adds all of the weird architectures that I was pleasantly surprised to see. The old 1.4 didn't even have much x86-64 support, much less AArch64.</p><p>This new GNU Lightning 2.x series fundamentally changes the way the library works: instead of having a <a href="https://www.gnu.org/software/lightning/manual/html_node/The-instruction-set.html#The-instruction-set"><tt>jit_ldr_f</tt></a> function that directly emits code to load a <tt>float</tt> from memory into a floating-point register, the <tt>jit_ldr_f</tt> function now creates a node in a graph. Before code is emitted, that graph is optimized, some register allocation happens around call sites and for temporary values, dead code is elided, and so on, then the graph is traversed and code emitted.</p><p>Unfortunately this wasn't really what I was looking for. The optimizations were a bit opaque to me and I just wanted something simple. Building the graph took more time than just emitting bytes into a buffer, and it takes more memory as well. When I found bugs, I couldn't tell whether they were related to my usage or in the library itself.</p><p>In the end, the node structure wasn't paying its way for me. But I couldn't just go back to the 1.4 series that I remembered -- it didn't have the architecture support that I needed. Faced with the choice between changing GNU Lightning 2.x in ways that went counter to its upstream direction, switching libraries, or refactoring GNU Lightning to be something that I needed, I chose the latter.</p><p><b>in which our protagonist cannot help himself</b></p><p>Friends, I regret to admit: I named the new thing "Lightening". True, it is a lightened Lightning, yes, but I am aware that it's horribly confusing. Pronounced like almost the same, visually almost identical -- I am a bad person. Oh well!!</p><p>I ported some of the existing GNU Lightning backends over to Lightening: ia32, x86-64, ARMv7, and AArch64. I deleted the backends for Itanium, HPPA, Alpha, and SPARC; they have no Debian ports and there is no situation in which I can afford to do QA on them. I would gladly accept contributions for PPC64, MIPS, RISC-V, and maybe S/390. At this point I reckon it takes around 20 hours to port an additional backend from GNU Lightning to Lightening.</p><p>Incidentally, if you need a code generation library, consider your choices wisely. It is likely that Lightening is not right for you. If you can afford platform-specific code and you need C, Lua's <a href="https://luajit.org/dynasm.html">DynASM</a> is probably the right thing for you. If you are in C++, copy the <a href="https://searchfox.org/mozilla-central/source/js/src/jit/arm/MacroAssembler-arm.cpp">assemblers</a> from a <a href="https://trac.webkit.org/browser/webkit/trunk/Source/JavaScriptCore/assembler">JavaScript</a> <a href="https://chromium.googlesource.com/v8/v8.git/+/refs/heads/master/src/x64/assembler-x64.h">engine</a> -- C++ offers much more type safety, capabilities for optimization, and ergonomics.</p><p>But if you can only afford one emitter of JIT code for all architectures, you need simple C, you don't need register allocation, you want a simple library to just include in your source code, and you are good with the LGPL, then Lightening could be a thing for you. Check the <a href="https://gitlab.com/wingo/lightening">gitlab page</a> for info on how to test Lightening and how to include it into your project.</p><p><b>giving it a spin</b></p><p>Yesterday's <a href="https://lists.gnu.org/archive/html/guile-devel/2019-05/msg00030.html">Guile 2.9.2 release</a> includes Lightening, so you can give it a spin. The switch to Lightening allowed us to lower our JIT optimization threshold by a factor of 50, letting us generate fast code sooner. If you try it out, let <tt>#guile</tt> on freenode know how it went. In any case, happy hacking!</p></div></content:encoded>
<dc:date>2019-05-24T08:44:56+00:00</dc:date>
<dc:creator>Andy Wingo</dc:creator>
</item>
<item rdf:about="https://www.gnu.org/software/guile/news/gnu-guile-292-beta-released.html">
<title>GNU Guile: GNU Guile 2.9.2 (beta) released</title>
<link>https://www.gnu.org/software/guile/news/gnu-guile-292-beta-released.html</link>
<content:encoded><p>We are delighted to announce GNU Guile 2.9.2, the second beta release in
preparation for the upcoming 3.0 stable series. See the <a href="https://lists.gnu.org/archive/html/guile-devel/2019-05/msg00030.html">release
announcement</a>
for full details and a download link.</p><p>This release extends just-in-time (JIT) native code generation support
to the ia32, ARMv7, and AArch64 architectures. Under the hood, we
swapped out GNU Lightning for a related fork called
<a href="https://gitlab.com/wingo/lightening/">Lightening</a>, which was better
adapted to Guile's needs.</p><p>GNU Guile 2.9.2 is a beta release, and as such offers no API or ABI
stability guarantees. Users needing a stable Guile are advised to stay
on the stable 2.2 series.</p><p>Users on the architectures that just gained JIT support are especially
encouraged to report experiences (good or bad) to <code>[email protected]</code>.
If you know you found a bug, please do send a note to
<code>[email protected]</code>. Happy hacking!</p></content:encoded>
<dc:date>2019-05-23T21:00:00+00:00</dc:date>
<dc:creator>Andy Wingo</dc:creator>
</item>
<item rdf:about="http://wingolog.org/2019/05/23/bigint-shipping-in-firefox">
<title>Andy Wingo: bigint shipping in firefox!</title>
<link>http://wingolog.org/archives/2019/05/23/bigint-shipping-in-firefox</link>
<content:encoded><div><p>I am delighted to share with folks the results of a project I have been helping out on for the last few months: implementation of "BigInt" in Firefox, which is finally shipping in Firefox 68 (beta).</p><p><b>what's a bigint?</b></p><p>BigInts are a new kind of JavaScript primitive value, like numbers or strings. A BigInt is a true integer: it can take on the value of any finite integer (subject to some arbitrarily large implementation-defined limits, such as the amount of memory in your machine). This contrasts with JavaScript number values, which have the well-known property of <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/MAX_SAFE_INTEGER">only being able to precisely represent integers between -2<sup>53</sup> and 2<sup>53</sup></a>.</p><p>BigInts are written like "normal" integers, but with an <tt>n</tt> suffix:</p><pre>var a = 1n;
var b = a + 42n;
b &lt;&lt; 64n
// result: 793209995169510719488n
</pre><p>With the bigint proposal, the usual mathematical operations (<tt>+</tt>, <tt>-</tt>, <tt>*</tt>, <tt>/</tt>, <tt>%</tt>, <tt>&lt;&lt;</tt>, <tt>&gt;&gt;</tt>, <tt>**</tt>, and the comparison operators) are extended to operate on bigint values. As a new kind of primitive value, bigint values have their own <tt>typeof</tt>:</p><pre>typeof 1n
// result: 'bigint'
</pre><p>Besides allowing for more kinds of math to be easily and efficiently expressed, BigInt also allows for better interoperability with systems that use 64-bit numbers, such as <a href="https://github.com/nodejs/node/pull/20220">"inodes" in file systems</a>, <a href="https://sauleau.com/notes/wasm-bigint.html">WebAssembly i64 values</a>, <a href="https://nodejs.org/api/process.html#process_process_hrtime_bigint">high-precision timers</a>, and so on.</p><p>You can <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt">read more about the BigInt feature over on MDN</a>, as usual. You might also like this <a href="https://developers.google.com/web/updates/2018/05/bigint">short article on BigInt basics</a> that V8 engineer Mathias Bynens wrote when Chrome shipped support for BigInt last year. There is an accompanying <a href="https://v8.dev/blog/bigint">language implementation</a> article as well, for those of y'all that enjoy the nitties and the gritties. </p><p><b>can i ship it?</b></p><p>To try out BigInt in Firefox, simply download a copy of <a href="https://www.mozilla.org/en-US/firefox/channel/desktop/">Firefox Beta</a>. This version of Firefox will be fully released to the public in a few weeks, on July 9th. If you're reading this in the future, I'm talking about Firefox 68.</p><p>BigInt is also shipping already in V8 and Chrome, and my colleague Caio Lima has an project in progress to implement it in JavaScriptCore / WebKit / Safari. Depending on your target audience, BigInt might be deployable already!</p><p><b>thanks</b></p><p>I must mention that my role in the BigInt work was relatively small; my Igalia colleague Robin Templeton did the bulk of the BigInt implementation work in Firefox, so large ups to them. Hearty thanks also to Mozilla's Jan de Mooij and Jeff Walden for their patient and detailed code reviews.</p><p>Thanks as well to the V8 engineers for their open source implementation of BigInt fundamental algorithms, as we used many of them in Firefox.</p><p>Finally, I need to make one big thank-you, and I hope that you will join me in expressing it. The road to ship anything in a web browser is long; besides the "simple matter of programming" that it is to implement a feature, you need a <a href="https://github.com/tc39/proposal-bigint/blob/master/README.md">specification with buy-in from implementors and web standards people</a>, you need a good working relationship with a browser vendor, you need willing technical reviewers, you need to follow up on the inevitable security bugs that any browser change causes, and all of this takes time. It's all predicated on having the backing of an organization that's foresighted enough to invest in this kind of long-term, high-reward platform engineering.</p><p>In that regard I think all people that work on the web platform should send a big shout-out to <a href="https://techatbloomberg.com">Tech at Bloomberg</a> for making BigInt possible by underwriting all of <a href="https://igalia.com/">Igalia</a>'s work in this area. Thank you, Bloomberg, and happy hacking!</p></div></content:encoded>
<dc:date>2019-05-23T12:13:59+00:00</dc:date>
<dc:creator>Andy Wingo</dc:creator>
</item>
<item rdf:about="http://savannah.gnu.org/forum/forum.php?forum_id=9434">
<title>parallel @ Savannah: GNU Parallel 20190522 ('Akihito') released</title>
<link>http://savannah.gnu.org/forum/forum.php?forum_id=9434</link>
<content:encoded><p>GNU Parallel 20190522 ('Akihito') has been released. It is available for download at: <a href="http://ftpmirror.gnu.org/parallel/">http://ftpmirror.gnu.org/parallel/</a>
<br />
</p>
<p>GNU Parallel is 10 years old in a year on 2020-04-22. You are here by invited to a reception on Friday 2020-04-17.
<br />
</p>
<p>See <a href="https://www.gnu.org/software/parallel/10-years-anniversary.html">https://www.gnu.org/software/parallel/10-years-anniversary.html</a>
<br />
</p>
<p>Quote of the month:
<br />
</p>
<p> Amazingly useful script!
<br />
-- <a href="mailto:[email protected]">[email protected]</a>
<br />
</p>
<p>New in this release:
<br />
</p>
<ul>
<li>--group-by groups lines depending on value of a column. The value can be computed.
</li>
</ul>
<ul>
<li>How to compress (bzip/gzip) a very large text quickly? <a href="https://medium.com/">https://medium.com/</a>@gchandra/how-to-compress-bzip-gzip-a-very-large-text-quickly-27c11f4c6681
</li>
</ul>
<ul>
<li>Simple tutorial to install &amp; use GNU Parallel <a href="https://medium.com/">https://medium.com/</a>@gchandra/simple-tutorial-to-install-use-gnu-parallel-79251120d618
</li>
</ul>
<ul>
<li>Introducing Parallel into Shell <a href="https://petelawson.com/post/parallel-in-shell/">https://petelawson.com/post/parallel-in-shell/</a>
</li>
</ul>
<ul>
<li>Bug fixes and man page updates.
</li>
</ul>
<p>Get the book: GNU Parallel 2018 <a href="http://www.lulu.com/shop/ole-tange/gnu-parallel-2018/paperback/product-23558902.html">http://www.lulu.com/shop/ole-tange/gnu-parallel-2018/paperback/product-23558902.html</a>
<br />
</p>
<p>GNU Parallel - For people who live life in the parallel lane.
<br />
</p>
<h2>About GNU Parallel</h2>
<p>GNU Parallel is a shell tool for executing jobs in parallel using one or more computers. A job can be a single command or a small script that has to be run for each of the lines in the input. The typical input is a list of files, a list of hosts, a list of users, a list of URLs, or a list of tables. A job can also be a command that reads from a pipe. GNU Parallel can then split the input and pipe it into commands in parallel.
<br />
</p>
<p>If you use xargs and tee today you will find GNU Parallel very easy to use as GNU Parallel is written to have the same options as xargs. If you write loops in shell, you will find GNU Parallel may be able to replace most of the loops and make them run faster by running several jobs in parallel. GNU Parallel can even replace nested loops.
<br />
</p>
<p>GNU Parallel makes sure output from the commands is the same output as you would get had you run the commands sequentially. This makes it possible to use output from GNU Parallel as input for other programs.
<br />
</p>
<p>You can find more about GNU Parallel at: <a href="http://www.gnu.org/s/parallel/">http://www.gnu.org/s/parallel/</a>
<br />
</p>
<p>You can install GNU Parallel in just 10 seconds with:
<br />
(wget -O - pi.dk/3 || curl pi.dk/3/ || fetch -o - <a href="http://pi.dk/3">http://pi.dk/3</a>) | bash
<br />
</p>
<p>Watch the intro video on <a href="http://www.youtube.com/playlist?list=PL284C9FF2488BC6D1">http://www.youtube.com/playlist?list=PL284C9FF2488BC6D1</a>
<br />
</p>
<p>Walk through the tutorial (man parallel_tutorial). Your command line will love you for it.
<br />
</p>
<p>When using programs that use GNU Parallel to process data for publication please cite:
<br />
</p>
<p>O. Tange (2018): GNU Parallel 2018, March 2018, <a href="https://doi.org/10.5281/zenodo.1146014">https://doi.org/10.5281/zenodo.1146014</a>.
<br />
</p>
<p>If you like GNU Parallel:
<br />
</p>
<ul>
<li>Give a demo at your local user group/team/colleagues
</li>
<li>Post the intro videos on Reddit/Diaspora*/forums/blogs/ Identi.ca/Google+/Twitter/Facebook/Linkedin/mailing lists
</li>
<li>Get the merchandise <a href="https://gnuparallel.threadless.com/designs/gnu-parallel">https://gnuparallel.threadless.com/designs/gnu-parallel</a>
</li>
<li>Request or write a review for your favourite blog or magazine
</li>
<li>Request or build a package for your favourite distribution (if it is not already there)
</li>
<li>Invite me for your next conference
</li>
</ul>
<p>If you use programs that use GNU Parallel for research:
<br />
</p>
<ul>
<li>Please cite GNU Parallel in you publications (use --citation)
</li>
</ul>
<p>If GNU Parallel saves you money:
<br />
</p>
<ul>
<li>(Have your company) donate to FSF <a href="https://my.fsf.org/donate/">https://my.fsf.org/donate/</a>
</li>
</ul>
<h2>About GNU SQL</h2>
<p>GNU sql aims to give a simple, unified interface for accessing databases through all the different databases' command line clients. So far the focus has been on giving a common way to specify login information (protocol, username, password, hostname, and port number), size (database and table size), and running queries.
<br />
</p>
<p>The database is addressed using a DBURL. If commands are left out you will get that database's interactive shell.
<br />
</p>
<p>When using GNU SQL for a publication please cite:
<br />
</p>
<p>O. Tange (2011): GNU SQL - A Command Line Tool for Accessing Different Databases Using DBURLs, ;login: The USENIX Magazine, April 2011:29-32.
<br />
</p>
<h2>About GNU Niceload</h2>
<p>GNU niceload slows down a program when the computer load average (or other system activity) is above a certain limit. When the limit is reached the program will be suspended for some time. If the limit is a soft limit the program will be allowed to run for short amounts of time before being suspended again. If the limit is a hard limit the program will only be allowed to run when the system is below the limit.<br />
</p></content:encoded>
<dc:date>2019-05-22T20:29:50+00:00</dc:date>
<dc:creator>Ole Tange</dc:creator>
</item>
<item rdf:about="https://gnu.org/software/guix/blog/2019/creating-and-using-a-custom-linux-kernel-on-guix-system/">
<title>GNU Guix: Creating and using a custom Linux kernel on Guix System</title>
<link>https://gnu.org/software/guix/blog/2019/creating-and-using-a-custom-linux-kernel-on-guix-system/</link>
<content:encoded><p>Guix is, at its core, a source based distribution with
<a href="https://www.gnu.org/software/guix/manual/en/html_node/Substitutes.html">substitutes</a>,
and as such building packages from their source code is an expected part
of regular package installations and upgrades. Given this starting
point, it makes sense that efforts are made to reduce the amount of time
spent compiling packages, and recent changes and upgrades to the
building and distribution of substitutes continues to be a topic of
discussion within Guix.</p><p>One of the packages which I prefer to not build myself is the
Linux-Libre kernel. The kernel, while not requiring an overabundance of
RAM to build, does take a very long time on my build machine (which my
children argue is actually their Kodi computer), and I will often delay
reconfiguring my laptop while I want for a substitute to be prepared by
the official build farm. The official kernel configuration, as is the
case with many GNU/Linux distributions, errs on the side of
inclusiveness, and this is really what causes the build to take such a
long time when I build the package for myself.</p><p>The Linux kernel, however, can also just be described as a package
installed on my machine, and as such can be customized just like any
other package. The procedure is a little bit different, although this
is primarily due to the nature of how the package definition is written.</p><p>The
<a href="https://git.savannah.gnu.org/cgit/guix.git/tree/gnu/packages/linux.scm#n294"><code>linux-libre</code></a>
kernel package definition is actually a procedure
which creates a package.</p><pre><code class="language-scheme">(define* (make-linux-libre version hash supported-systems
#:key
;; A function that takes an arch and a variant.
;; See kernel-config for an example.
(extra-version #f)
(configuration-file #f)
(defconfig "defconfig")
(extra-options %default-extra-linux-options)
(patches (list %boot-logo-patch)))
...)</code></pre><p>The current <code>linux-libre</code> package is for the 5.1.x series, and is
declared like this:</p><pre><code class="language-scheme">(define-public linux-libre
(make-linux-libre %linux-libre-version
%linux-libre-hash
'("x86_64-linux" "i686-linux" "armhf-linux" "aarch64-linux")
#:patches %linux-libre-5.1-patches
#:configuration-file kernel-config))</code></pre><p>Any keys which are not assigned values inherit their default value from
the <code>make-linux-libre</code> definition. When comparing the two snippets above,
you may notice that the code comment in the first doesn't actually refer
to the <code>#:extra-version</code> keyword; it is actually for <code>#:configuration-file</code>.
Because of this, it is not actually easy to include a custom kernel
configuration from the definition, but don't worry, there are other ways
to work with what we do have.</p><p>There are two ways to create a kernel with a custom kernel configuration.
The first is to provide a standard <code>.config</code> file during the build
process by including an actual <code>.config</code> file as a native input to our
custom kernel. The
<a href="https://git.savannah.gnu.org/cgit/guix.git/tree/gnu/packages/linux.scm#n379">following</a>
is a snippet from the custom 'configure phase of the <code>make-linux-libre</code>
package definition:</p><pre><code class="language-scheme">(let ((build (assoc-ref %standard-phases 'build))
(config (assoc-ref (or native-inputs inputs) "kconfig")))
;; Use a custom kernel configuration file or a default
;; configuration file.
(if config
(begin
(copy-file config ".config")
(chmod ".config" #o666))
(invoke "make" ,defconfig))</code></pre><p>Below is a sample kernel package for one of my computers. Linux-Libre
is just like other regular packages and can be inherited and overridden
like any other:</p><pre><code class="language-scheme">(define-public linux-libre/E2140
(package
(inherit linux-libre)
(native-inputs
`(("kconfig" ,(local-file "E2140.config"))
,@(alist-delete "kconfig"
(package-native-inputs linux-libre))))))</code></pre><p>In the same directory as the file defining <code>linux-libre-E2140</code> is a file
named <code>E2140.config</code>, which is an actual kernel configuration file. I
left the defconfig keyword of <code>make-linux-libre</code> blank, so the only
kernel configuration in the package is the one which I included as a
native-input.</p><p>The second way to create a custom kernel is to pass a new value to the
extra-options keyword of the <code>make-linux-libre</code> procedure. The
extra-options keyword works with another function defined right below it:</p><pre><code class="language-scheme">(define %default-extra-linux-options
`(;; https://lists.gnu.org/archive/html/guix-devel/2014-04/msg00039.html
("CONFIG_DEVPTS_MULTIPLE_INSTANCES" . #t)
;; Modules required for initrd:
("CONFIG_NET_9P" . m)
("CONFIG_NET_9P_VIRTIO" . m)
("CONFIG_VIRTIO_BLK" . m)
("CONFIG_VIRTIO_NET" . m)
("CONFIG_VIRTIO_PCI" . m)
("CONFIG_VIRTIO_BALLOON" . m)
("CONFIG_VIRTIO_MMIO" . m)
("CONFIG_FUSE_FS" . m)
("CONFIG_CIFS" . m)
("CONFIG_9P_FS" . m)))
(define (config-&gt;string options)
(string-join (map (match-lambda
((option . 'm)
(string-append option "=m"))
((option . #t)
(string-append option "=y"))
((option . #f)
(string-append option "=n")))
options)
"\n"))</code></pre><p>And in the custom configure script from the <code>make-linux-libre</code> package:</p><pre><code class="language-scheme">;; Appending works even when the option wasn't in the
;; file. The last one prevails if duplicated.
(let ((port (open-file ".config" "a"))
(extra-configuration ,(config-&gt;string extra-options)))
(display extra-configuration port)
(close-port port))
(invoke "make" "oldconfig"))))</code></pre><p>So by not providing a configuration-file the <code>.config</code> starts blank, and
then we write into it the collection of flags that we want. Here's
another custom kernel which I have:</p><pre><code class="language-scheme">(define %macbook41-full-config
(append %macbook41-config-options
%filesystems
%efi-support
%emulation
(@@ (gnu packages linux) %default-extra-linux-options)))
(define-public linux-libre-macbook41
;; XXX: Access the internal 'make-linux-libre' procedure, which is
;; private and unexported, and is liable to change in the future.
((@@ (gnu packages linux) make-linux-libre) (@@ (gnu packages linux) %linux-libre-version)
(@@ (gnu packages linux) %linux-libre-hash)
'("x86_64-linux")
#:extra-version "macbook41"
#:patches (@@ (gnu packages linux) %linux-libre-5.1-patches)
#:extra-options %macbook41-config-options))</code></pre><p>From the above example <code>%filesystems</code> is a collection of flags I
compiled enabling different filesystem support, <code>%efi-support</code> enables
EFI support and <code>%emulation</code> enables my x86_64-linux machine to act in
32-bit mode also. <code>%default-extra-linux-options</code> are the ones quoted
above, which had to be added in since I replaced them in the
extra-options keyword.</p><p>This all sounds like it should be doable, but how does one even know
which modules are required for their system? The two places I found
most helpful to try to answer this question were the <a href="https://wiki.gentoo.org/wiki/Handbook:AMD64/Installation/Kernel">Gentoo
Handbook</a>,
and the
<a href="https://www.kernel.org/doc/html/latest/admin-guide/README.html?highlight=localmodconfig">documentation</a>
from the kernel itself. From the kernel documentation, it seems that
<code>make localmodconfig</code> is the command we want.</p><p>In order to actually run <code>make localmodconfig</code> we first need to get and
unpack the kernel source code:</p><pre><code class="language-shell">tar xf $(guix build linux-libre --source)</code></pre><p>Once inside the directory containing the source code run <code>touch .config</code>
to create an initial, empty <code>.config</code> to start with. <code>make localmodconfig</code> works by seeing what you already have in <code>.config</code> and
letting you know what you're missing. If the file is blank then you're
missing everything. The next step is to run:</p><pre><code class="language-shell">guix environment linux-libre -- make localmodconfig</code></pre><p>and note the output. Do note that the <code>.config</code> file is still empty.
The output generally contains two types of warnings. The first start
with "WARNING" and can actually be ignored in our case. The second read:</p><pre><code class="language-shell">module pcspkr did not have configs CONFIG_INPUT_PCSPKR</code></pre><p>For each of these lines, copy the <code>CONFIG_XXXX_XXXX</code> portion into the
<code>.config</code> in the directory, and append <code>=m</code>, so in the end it looks
like this:</p><pre><code class="language-shell">CONFIG_INPUT_PCSPKR=m
CONFIG_VIRTIO=m</code></pre><p>After copying all the configuration options, run <code>make localmodconfig</code>
again to make sure that you don't have any output starting with
"module". After all of these machine specific modules there are a
couple more left that are also needed. <code>CONFIG_MODULES</code> is necessary so
that you can build and load modules separately and not have everything
built into the kernel. <code>CONFIG_BLK_DEV_SD</code> is required for reading from
hard drives. It is possible that there are other modules which you
will need.</p><p>This post does not aim to be a guide to configuring your own kernel
however, so if you do decide to build a custom kernel you'll have to
seek out other guides to create a kernel which is just right for your
needs.</p><p>The second way to setup the kernel configuration makes more use of
Guix's features and allows you to share configuration segments between
different kernels. For example, all machines using EFI to boot have a
number of EFI configuration flags that they need. It is likely that all
the kernels will share a list of filesystems to support. By using
variables it is easier to see at a glance what features are enabled and
to make sure you don't have features in one kernel but missing in another.</p><p>Left undiscussed however, is Guix's initrd and its customization. It is
likely that you'll need to modify the initrd on a machine using a custom
kernel, since certain modules which are expected to be built may not be
available for inclusion into the initrd.</p><p>Suggestions and contributions toward working toward a satisfactory
custom initrd and kernel are welcome!</p><h4>About GNU Guix</h4><p><a href="https://www.gnu.org/software/guix">GNU Guix</a> is a transactional package
manager and an advanced distribution of the GNU system that <a href="https://www.gnu.org/distros/free-system-distribution-guidelines.html">respects
user
freedom</a>.
Guix can be used on top of any system running the kernel Linux, or it
can be used as a standalone operating system distribution for i686,
x86_64, ARMv7, and AArch64 machines.</p><p>In addition to standard package management features, Guix supports
transactional upgrades and roll-backs, unprivileged package management,
per-user profiles, and garbage collection. When used as a standalone
GNU/Linux distribution, Guix offers a declarative, stateless approach to
operating system configuration management. Guix is highly customizable
and hackable through <a href="https://www.gnu.org/software/guile">Guile</a>
programming interfaces and extensions to the
<a href="http://schemers.org">Scheme</a> language.</p></content:encoded>
<dc:date>2019-05-21T10:00:00+00:00</dc:date>
<dc:creator>Efraim Flashner</dc:creator>
</item>
<item rdf:about="https://gnu.org/software/guix/blog/2019/gnu-guix-1.0.1-released/">
<title>GNU Guix: GNU Guix 1.0.1 released</title>
<link>https://gnu.org/software/guix/blog/2019/gnu-guix-1.0.1-released/</link>
<content:encoded><p>We are pleased to announce the release of GNU Guix version 1.0.1. This
new version fixes bugs in the <a href="https://www.gnu.org/software/guix/manual/en/html_node/Guided-Graphical-Installation.html">graphical
installer</a>
for the standalone Guix System.</p><p>The release comes with <a href="https://www.gnu.org/software/guix/manual/en/html_node/System-Installation.html">ISO-9660 installation
images</a>,
a <a href="https://www.gnu.org/software/guix/manual/en/html_node/Running-Guix-in-a-VM.html">virtual machine
image</a>,
and with tarballs to install the package manager on top of your
GNU/Linux distro, either <a href="https://www.gnu.org/software/guix/manual/en/html_node/Requirements.html">from
source</a>
or <a href="https://www.gnu.org/software/guix/manual/en/html_node/Binary-Installation.html">from
binaries</a>.
Guix users can update by running <code>guix pull</code>.</p><p>It’s been just over two weeks since we <a href="https://www.gnu.org/software/guix/blog/2019/gnu-guix-1.0.0-released/">announced
1.0.0</a>—two
weeks and 706 commits by 40 people already!</p><p>This is primarily a bug-fix release, specifically focusing on issues in
the graphical installer for the standalone system:</p><ul><li>The most <a href="https://issues.guix.gnu.org/issue/35541">embarrassing bug</a>
would lead the graphical installer to produce a configuration where
<a href="https://www.gnu.org/software/guix/manual/en/html_node/Using-the-Configuration-System.html#index-_0025base_002dpackages"><code>%base-packages</code></a>
was omitted from the <code>packages</code> field. Consequently, the freshly
installed system would not have the usual commands in <code>$PATH</code>—<code>ls</code>,
<code>ps</code>, etc.—and Xfce would fail to start for that reason. See below
for a “post-mortem” analysis.</li><li>The <code>wpa-supplicant</code> service would <a href="https://issues.guix.gnu.org/issue/35550">sometimes fail to
start</a> in the installation
image, thereby breaking network access; this is now fixed.</li><li>The installer <a href="https://issues.guix.gnu.org/issue/35540">now</a> allows
you to toggle the visibility of passwords and passphrases, and it <a href="https://issues.guix.gnu.org/issue/35716">no
longer</a> restricts their
length.</li><li>The installer <a href="https://issues.guix.gnu.org/issue/35657">can now
create</a> Btrfs file
systems.</li><li><code>network-manager-applet</code> is <a href="https://issues.guix.gnu.org/35554">now</a>
part of
<a href="https://www.gnu.org/software/guix/manual/en/html_node/Desktop-Services.html#index-_0025desktop_002dservices"><code>%desktop-services</code></a>,
and thus readily usable not just from GNOME but also from Xfce.</li><li>The
<a href="https://git.savannah.gnu.org/cgit/guix.git/tree/NEWS?h=version-1.0.1"><code>NEWS</code></a>
file has more details, but there were also minor bug fixes for
<a href="https://issues.guix.gnu.org/issue/35618"><code>guix environment</code></a>, <a href="https://issues.guix.gnu.org/issue/35588"><code>guix search</code></a>, and <a href="https://issues.guix.gnu.org/issue/35684"><code>guix refresh</code></a>.</li></ul><p>A couple of new features were reviewed in time to make it into 1.0.1:</p><ul><li><a href="https://www.gnu.org/software/guix/manual/en/html_node/Invoking-guix-system.html"><code>guix system docker-image</code></a>
now produces an OS image with an “entry point”, which makes it
easier to use than before.</li><li><a href="https://www.gnu.org/software/guix/manual/en/html_node/Invoking-guix-system.html"><code>guix system container</code></a>
has a new <code>--network</code> option, allowing the container to share
networking access with the host.</li><li>70 new packages were added and 483 packages were updated.</li><li>Translations were updated as usual and we are glad to announce a
20%-complete <a href="https://www.gnu.org/software/guix/manual/ru/html_node">Russian translation of the
manual</a>.</li></ul><h1>Recap of <a href="https://issues.guix.gnu.org/issue/35541">bug #35541</a></h1><p>The 1.0.1 release was primarily motivated by <a href="https://issues.guix.gnu.org/issue/35541">bug
#35541</a>, which was reported
shortly after the 1.0.0 release. If you installed Guix System with the
<a href="https://www.gnu.org/software/guix/manual/en/html_node/Guided-Graphical-Installation.html">graphical
installer</a>,
chances are that, because of this bug, you ended up with a system where
all the usual GNU/Linux commands—<code>ls</code>, <code>grep</code>, <code>ps</code>, etc.—were <em>not</em> in
<code>$PATH</code>. That in turn would also prevent Xfce from starting, if you
chose that desktop environment for your system.</p><p>We quickly published a note in the <a href="https://www.gnu.org/software/guix/manual/en/html_node/Guided-Graphical-Installation.html">system installation
instructions</a>
explaining how to work around the issue:</p><ul><li><p>First, install packages that provide those commands, along with the
text editor of your choice (for example, <code>emacs</code> or <code>vim</code>):</p><pre><code>guix install coreutils findutils grep procps sed emacs vim</code></pre></li><li><p>At this point, the essential commands you would expect are
available. Open your configuration file with your editor of choice,
for example <code>emacs</code>, running as root:</p><pre><code>sudo emacs /etc/config.scm</code></pre></li><li><p>Change the <code>packages</code> field to add the “base packages” to the list of
globally-installed packages, such that your configuration looks like
this:</p><pre><code class="language-scheme">(operating-system
;; … snip …
(packages (append (list (specification-&gt;package "nss-certs"))
%base-packages))
;; … snip …
)</code></pre></li><li><p>Reconfigure the system so that your new configuration is in effect:</p><pre><code>guix pull &amp;&amp; sudo guix system reconfigure /etc/config.scm</code></pre></li></ul><p>If you already installed 1.0.0, you can perform the steps above to get
all these core commands back.</p><p>Guix is <em>purely declarative</em>: if you give it <a href="https://www.gnu.org/software/guix/manual/en/html_node/Using-the-Configuration-System.html">an operating system
definition</a>
where the “base packages” are not <a href="https://www.gnu.org/software/guix/manual/en/html_node/Using-the-Configuration-System.html#Globally_002dVisible-Packages">available
system-wide</a>,
then it goes ahead and installs precisely that. That’s exactly what
happened with this bug: the installer generated such a configuration and
passed it to <code>guix system init</code> as part of the installation process.</p><h1>Lessons learned</h1><p>Technically, this is a “trivial” bug: it’s fixed by adding one line to
your operating system configuration and reconfiguring, and the fix for
the installer itself <a href="https://git.savannah.gnu.org/cgit/guix.git/commit/?id=ecb0df6817eb3767e6b4dcf1945f3c2dfbe3b44f">is also a
one-liner</a>.
Nevertheless, it’s obviously a serious bug for the impression it
gives—this is <em>not</em> the user experience we want to offer. So how did such
a serious bug go through unnoticed?</p><p>For several years now, Guix has had a number of automated <a href="https://www.gnu.org/software/guix/blog/2016/guixsd-system-tests/"><em>system
tests</em></a>
running in virtual machines (VMs). These tests primarily ensure that
<a href="https://www.gnu.org/software/guix/manual/en/html_node/Services.html">system
services</a>
work as expected, but some of them <a href="https://git.savannah.gnu.org/cgit/guix.git/tree/gnu/tests/install.scm">specifically test system
installation</a>:
installing to a RAID or encrypted device, with a separate <code>/home</code>, using
Btrfs, etc. These tests even run on our <a href="https://ci.guix.gnu.org/jobset/guix-master">continuous integration
service</a> (search for the
“tests.*” jobs there).</p><p>Unfortunately, those installation tests target the so-called <a href="https://www.gnu.org/software/guix/manual/en/html_node/Manual-Installation.html">“manual”
installation
process</a>,
which is scriptable. They do <em>not</em> test the installer’s graphical user
interface. Consequently, testing the user interface (UI) itself was a
manual process. Our attention was, presumably, focusing more on UI
aspects since—so we thought—the actual installation tests were already
taken care of by the system tests. That the generated system
configuration could be syntactically correct but definitely wrong from a
usability viewpoint perhaps didn’t occur to us. The end result is that
the issue went unnoticed.</p><p>The lesson here is that: manual testing should <em>also</em> look for issues in
“unexpected places”, and more importantly, we need automated tests for
the graphical UI. The Debian and Guix installer UIs are similar—both
using the <a href="https://pagure.io/newt">Newt</a> toolkit. Debian tests its
installer using
<a href="https://wiki.debian.org/DebianInstaller/Preseed">“pre-seeds”</a>
(<a href="https://salsa.debian.org/installer-team/preseed">code</a>), which are
essentially answers to all the questions and choices the UI would
present. We could adopt a similar approach, or we could test the UI
itself at a lower level—reading the screen, and simulating key strokes.
UI testing is notoriously tricky so we’ll have to figure out how to get
there.</p><h1>Conclusion</h1><p>Our 1.0 party was a bit spoiled by this bug, and we are sorry that
installation was disappointing to those of you who tried 1.0. We hope
1.0.1 will allow you to try and see what declarative and programmable
system configuration management is like, because that’s where the real
value of Guix System is—the graphical installer is icing on the cake.</p><p>Join us <a href="https://www.gnu.org/software/guix/contact/">on <code>#guix</code> and on the mailing
lists</a>!</p><h4>About GNU Guix</h4><p><a href="https://www.gnu.org/software/guix">GNU Guix</a> is a transactional package
manager and an advanced distribution of the GNU system that <a href="https://www.gnu.org/distros/free-system-distribution-guidelines.html">respects
user
freedom</a>.
Guix can be used on top of any system running the kernel Linux, or it
can be used as a standalone operating system distribution for i686,
x86_64, ARMv7, and AArch64 machines.</p><p>In addition to standard package management features, Guix supports
transactional upgrades and roll-backs, unprivileged package management,
per-user profiles, and garbage collection. When used as a standalone
GNU/Linux distribution, Guix offers a declarative, stateless approach to
operating system configuration management. Guix is highly customizable
and hackable through <a href="https://www.gnu.org/software/guile">Guile</a>
programming interfaces and extensions to the
<a href="http://schemers.org">Scheme</a> language.</p></content:encoded>
<dc:date>2019-05-19T21:30:00+00:00</dc:date>
<dc:creator>Ludovic Courtès</dc:creator>
</item>
<item rdf:about="http://savannah.gnu.org/forum/forum.php?forum_id=9433">
<title>bison @ Savannah: Bison 3.4 released [stable]</title>
<link>http://savannah.gnu.org/forum/forum.php?forum_id=9433</link>
<content:encoded><p>We are happy to announce the release of Bison 3.4.
<br />
</p>
<p>A particular focus was put on improving the diagnostics, which are now
<br />
colored by default, and accurate with multibyte input. Their format was
<br />
also changed, and is now similar to GCC 9's diagnostics.
<br />
</p>
<p>Users of the default backend (yacc.c) can use the new %define variable
<br />
api.header.include to avoid duplicating the content of the generated header
<br />
in the generated parser. There are two new examples installed, including a
<br />
reentrant calculator which supports recursive calls to the parser and
<br />
Flex-generated scanner.
<br />
</p>
<p>See below for more details.
<br />
</p>
<p>==================================================================
<br />
</p>
<p>Bison is a general-purpose parser generator that converts an annotated
<br />
context-free grammar into a deterministic LR or generalized LR (GLR) parser
<br />
employing LALR(1) parser tables. Bison can also generate IELR(1) or
<br />
canonical LR(1) parser tables. Once you are proficient with Bison, you can
<br />
use it to develop a wide range of language parsers, from those used in
<br />
simple desk calculators to complex programming languages.
<br />
</p>
<p>Bison is upward compatible with Yacc: all properly-written Yacc grammars
<br />
work with Bison with no change. Anyone familiar with Yacc should be able to
<br />
use Bison with little trouble. You need to be fluent in C, C++ or Java
<br />
programming in order to use Bison.
<br />
</p>
<p>Here is the GNU Bison home page:
<br />
<a href="https://gnu.org/software/bison/">https://gnu.org/software/bison/</a>
<br />
</p>
<p>==================================================================
<br />
</p>
<p>Here are the compressed sources:
<br />
<a href="https://ftp.gnu.org/gnu/bison/bison-3.4.tar.gz">https://ftp.gnu.org/gnu/bison/bison-3.4.tar.gz</a> (4.1MB)
<br />
<a href="https://ftp.gnu.org/gnu/bison/bison-3.4.tar.xz">https://ftp.gnu.org/gnu/bison/bison-3.4.tar.xz</a> (3.1MB)
<br />
</p>
<p>Here are the GPG detached signatures[*]:
<br />
<a href="https://ftp.gnu.org/gnu/bison/bison-3.4.tar.gz.sig">https://ftp.gnu.org/gnu/bison/bison-3.4.tar.gz.sig</a>
<br />
<a href="https://ftp.gnu.org/gnu/bison/bison-3.4.tar.xz.sig">https://ftp.gnu.org/gnu/bison/bison-3.4.tar.xz.sig</a>
<br />
</p>
<p>Use a mirror for higher download bandwidth:
<br />
<a href="https://www.gnu.org/order/ftp.html">https://www.gnu.org/order/ftp.html</a>
<br />
</p>
<p>[*] Use a .sig file to verify that the corresponding file (without the
<br />
.sig suffix) is intact. First, be sure to download both the .sig file
<br />
and the corresponding tarball. Then, run a command like this:
<br />
</p>
<p> gpg --verify bison-3.4.tar.gz.sig
<br />
</p>
<p>If that command fails because you don't have the required public key,
<br />
then run this command to import it:
<br />
</p>
<p> gpg --keyserver keys.gnupg.net --recv-keys 0DDCAA3278D5264E
<br />
</p>
<p>and rerun the 'gpg --verify' command.
<br />
</p>
<p>This release was bootstrapped with the following tools:
<br />
Autoconf 2.69
<br />
Automake 1.16.1
<br />
Flex 2.6.4
<br />
Gettext 0.19.8.1
<br />
Gnulib v0.1-2563-gd654989d8
<br />
</p>
<p>==================================================================
<br />
</p>
<p>NEWS
<br />
</p>
<textarea class="verbatim" cols="80" readonly="readonly" rows="20">* Noteworthy changes in release 3.4 (2019-05-19) [stable]
** Deprecated features
The %pure-parser directive is deprecated in favor of '%define api.pure'
since Bison 2.3b (2008-05-27), but no warning was issued; there is one
now. Note that since Bison 2.7 you are strongly encouraged to use
'%define api.pure full' instead of '%define api.pure'.
** New features
*** Colored diagnostics
As an experimental feature, diagnostics are now colored, controlled by the
new options --color and --style.
To use them, install the libtextstyle library before configuring Bison.
It is available from
https://alpha.gnu.org/gnu/gettext/
for instance
https://alpha.gnu.org/gnu/gettext/libtextstyle-0.8.tar.gz
The option --color supports the following arguments:
- always, yes: Enable colors.
- never, no: Disable colors.
- auto, tty (default): Enable colors if the output device is a tty.
To customize the styles, create a CSS file similar to
/* bison-bw.css */
.warning { }
.error { font-weight: 800; text-decoration: underline; }
.note { }
then invoke bison with --style=bison-bw.css, or set the BISON_STYLE
environment variable to "bison-bw.css".
*** Disabling output
When given -fsyntax-only, the diagnostics are reported, but no output is
generated.
The name of this option is somewhat misleading as bison does more than
just checking the syntax: every stage is run (including checking for
conflicts for instance), except the generation of the output files.
*** Include the generated header (yacc.c)
Before, when --defines is used, bison generated a header, and pasted an
exact copy of it into the generated parser implementation file. If the
header name is not "y.tab.h", it is now #included instead of being
duplicated.
To use an '#include' even if the header name is "y.tab.h" (which is what
happens with --yacc, or when using the Autotools' ylwrap), define
api.header.include to the exact argument to pass to #include. For
instance:
%define api.header.include {"parse.h"}
or
%define api.header.include {&lt;parser/parse.h&gt;}
*** api.location.type is now supported in C (yacc.c, glr.c)
The %define variable api.location.type defines the name of the type to use
for locations. When defined, Bison no longer defines YYLTYPE.
This can be used in programs with several parsers to factor their
definition of locations: let one of them generate them, and the others
just use them.
** Changes
*** Graphviz output
In conformance with the recommendations of the Graphviz team, if %require
"3.4" (or better) is specified, the option --graph generates a *.gv file
by default, instead of *.dot.
*** Diagnostics overhaul
Column numbers were wrong with multibyte characters, which would also
result in skewed diagnostics with carets. Beside, because we were
indenting the quoted source with a single space, lines with tab characters
were incorrectly underlined.
To address these issues, and to be clearer, Bison now issues diagnostics
as GCC9 does. For instance it used to display (there's a tab before the
opening brace):
foo.y:3.37-38: error: $2 of ‘expr’ has no declared type
expr: expr '+' "number" { $$ = $1 + $2; }
^~
It now reports
foo.y:3.37-38: error: $2 of ‘expr’ has no declared type
3 | expr: expr '+' "number" { $$ = $1 + $2; }
| ^~
Other constructs now also have better locations, resulting in more precise
diagnostics.
*** Fix-it hints for %empty
Running Bison with -Wempty-rules and --update will remove incorrect %empty
annotations, and add the missing ones.
*** Generated reports
The format of the reports (parse.output) was improved for readability.
*** Better support for --no-line.
When --no-line is used, the generated files are now cleaner: no lines are
generated instead of empty lines. Together with using api.header.include,
that should help people saving the generated files into version control
systems get smaller diffs.
** Documentation
A new example in C shows an simple infix calculator with a hand-written
scanner (examples/c/calc).
A new example in C shows a reentrant parser (capable of recursive calls)
built with Flex and Bison (examples/c/reccalc).
There is a new section about the history of Yaccs and Bison.
** Bug fixes
A few obscure bugs were fixed, including the second oldest (known) bug in
Bison: it was there when Bison was entered in the RCS version control
system, in December 1987. See the NEWS of Bison 3.3 for the previous
oldest bug.
</textarea></content:encoded>
<dc:date>2019-05-19T10:01:36+00:00</dc:date>
<dc:creator>Akim Demaille</dc:creator>
</item>
<item rdf:about="http://www.fsf.org/news/six-more-devices-from-thinkpenguin-inc-now-fsf-certified-to-respect-your-freedom">
<title>FSF News: Six more devices from ThinkPenguin, Inc. now FSF-certified to Respect Your Freedom</title>
<link>http://www.fsf.org/news/six-more-devices-from-thinkpenguin-inc-now-fsf-certified-to-respect-your-freedom</link>
<content:encoded><p>This is ThinkPenguin's second batch of devices to receive <a href="https://www.fsf.org/ryf">RYF
certification</a> this spring. The <a href="https://www.fsf.org/news/seven-new-devices-from-thinkpenguin-inc-now-fsf-certified-to-respect-your-freedom">FSF announced certification</a> of
seven other devices from ThinkPenguin on March 21st. This latest
collection of devices makes ThinkPenguin the retailer with the largest
catalog of RYF-certified devices.</p>
<p>"It's unfortunate that so many of even the simplest devices out there
have surprise proprietary software requirements. RYF is an antidote
for that. It connects ethical shoppers concerned about their freedom
with companies offering options respecting that freedom," said the
FSF's executive director, John Sullivan.</p>
<p>Today's certifications expands the availability of RYF-certified
peripheral devices. The <a href="https://www.thinkpenguin.com/gnu-linux/penguin-usb-20-external-stereo-sound-adapter-gnu-linux-tpe-usbsound">Penguin USB 2.0 External USB Stereo Sound
Adapter</a> and the <a href="https://www.thinkpenguin.com/gnu-linux/51-channels-24-bit-96khz-pci-express-audio-sound-card-w-full-low-profile-bracket-tpe-pcies">5.1 Channels 24-bit 96KHz PCI Express Audio Sound
Card</a> help users get the most of their computers in terms of sound
quality. For wireless connectivity, ThinkPenguin offers the <a href="https://www.thinkpenguin.com/gnu-linux/wireless-n-pci-express-dual-band-mini-half-height-card-w-full-height-bracket-option-tpe-nh">Wireless
N PCI Express Dual-Band Mini Half-Height Card</a> and <a href="https://www.thinkpenguin.com/gnu-linux/penguin-wireless-n-mini-pcie">Penguin
Wireless N Mini PCIe Card</a>. For users with an older printer, the
<a href="https://www.thinkpenguin.com/gnu-linux/usb-parallel-printer-cable-tpe-usbparal">USB to Parallel Printer Cable</a> can let them continue to use it
with their more current hardware. Finally, the <a href="https://www.thinkpenguin.com/gnu-linux/pcie-esata-sata-6gbps-controller-card-w-full-lowprofile-brackets-tpe-pciesata">PCIe eSATA / SATA
6Gbps Controller Card</a> help users to connect to external eSATA
devices as well as internal SATA.</p>
<p>"I've spent the last 14 years working on projects aimed at making free
software adoption easy for everyone, but the single greatest obstacle
over the past 20 years has not been software. It's been hardware. The
RYF program helps solve this problem by linking users to trustworthy
sources where they can get hardware guaranteed to work on GNU/Linux,
and be properly supported using free software," said Christopher Waid,
founder and CEO of ThinkPenguin.</p>
<p>While ThinkPenguin has consistently sought certification since the
inception of the RYF program -- gaining their <a href="https://www.fsf.org/news/ryf-certification-thinkpenguin-usb-with-atheros-chip">first</a> certification
in 2013, and adding several more over the years since -- the pace at
which they are gaining certifications now eclipses all past efforts.</p>
<p>"ThinkPenguin continues to impress with the rapid expansion of their
catalog of RYF-certified devices. Adding 14 new devices in a little
over a month shows their dedication to the RYF certification program
and the protection of users it represents," said the FSF's licensing
and compliance manager, Donald Robertson, III.</p>
<p>To learn more about the Respects Your Freedom certification program,
including details on the certification of these ThinkPenguin devices,
please visit <a href="https://fsf.org/ryf">https://fsf.org/ryf</a>.</p>
<p>Retailers interested in applying for certification can consult
<a href="https://www.fsf.org/resources/hw/endorsement/criteria">https://www.fsf.org/resources/hw/endorsement/criteria</a>.</p>
<h3>About the Free Software Foundation</h3>
<p>The <a href="https://fsf.org">Free Software Foundation</a>, founded in 1985, is dedicated to
promoting computer users' right to use, study, copy, modify, and
redistribute computer programs. The FSF promotes the development and
use of free (as in freedom) software -- particularly the GNU operating
system and its GNU/Linux variants -- and free documentation for free
software. The FSF also helps to spread awareness of the ethical and
political issues of freedom in the use of software, and its Web sites,
located at <a href="https://fsf.org">https://fsf.org</a> and <a href="https://gnu.org">https://gnu.org</a>, are an important
source of information about GNU/Linux. Donations to support the FSF's
work can be made at <a href="https://donate.fsf.org">https://donate.fsf.org</a>. Its headquarters are in
Boston, MA, USA.</p>
<p>More information about the FSF, as well as important information for
journalists and publishers, is at <a href="https://www.fsf.org/press">https://www.fsf.org/press</a>.</p>
<h3>About ThinkPenguin, Inc.</h3>
<p>Started by Christopher Waid, founder and CEO, ThinkPenguin, Inc., is a
consumer-driven company with a mission to bring free software to the
masses. At the core of the company is a catalog of computers and
accessories with broad support for GNU/Linux. The company provides
technical support for end-users and works with the community,
distributions, and upstream projects to make GNU/Linux all that it can
be.</p>
<h3>Media Contacts</h3>
<p>Donald Robertson, III <br />
Licensing and Compliance Manager <br />
Free Software Foundation<br />
+1 (617) 542 5942<br />
<a href="mailto:[email protected]">[email protected]</a><br />
</p>
<p>ThinkPenguin, Inc. <br />
+1 (888) 39 THINK (84465) x703 <br />
<a href="mailto:[email protected]">[email protected]</a> <br />
</p></content:encoded>
<dc:date>2019-05-16T17:44:36+00:00</dc:date>
<dc:creator>FSF News</dc:creator>
</item>
<item rdf:about="https://gnunet.org/#gnunet-0.11.4-release">
<title>GNUnet News: 2019-05-12: GNUnet 0.11.4 released</title>
<link>https://gnunet.org/#gnunet-0.11.4-release</link>
<content:encoded><h3>
<a name="gnunet-0.11.4-release">2019-05-12: GNUnet 0.11.4 released</a>
</h3>
<p>
We are pleased to announce the release of GNUnet 0.11.4.
</p>
<p>
This is a bugfix release for 0.11.3, mostly fixing minor bugs,
improving documentation and fixing various build issues. In
terms of usability, users should be aware that there are still a large
number of known open issues in particular with respect to ease of use,
but also some critical privacy issues especially for mobile users.
Also, the nascent network is tiny (about 200 peers) and thus unlikely to
provide good anonymity or extensive amounts of interesting
information. As a result, the 0.11.4 release is still only suitable
for early adopters with some reasonable pain tolerance.
</p>
<h4>Download links</h4>
<ul>
<li><a href="http://ftpmirror.gnu.org/gnunet/gnunet-0.11.4.tar.gz">http://ftpmirror.gnu.org/gnunet/gnunet-0.11.4.tar.gz</a></li>
<li><a href="http://ftpmirror.gnu.org/gnunet/gnunet-0.11.4.tar.gz.sig">http://ftpmirror.gnu.org/gnunet/gnunet-0.11.4.tar.gz.sig</a></li>
<li><a href="http://ftpmirror.gnu.org/gnunet/gnunet-gtk-0.11.0.tar.gz">http://ftpmirror.gnu.org/gnunet/gnunet-gtk-0.11.0.tar.gz</a></li>
<li><a href="http://ftpmirror.gnu.org/gnunet/gnunet-gtk-0.11.0.tar.gz.sig">http://ftpmirror.gnu.org/gnunet/gnunet-gtk-0.11.0.tar.gz.sig</a></li>
<li><a href="http://ftpmirror.gnu.org/gnunet/gnunet-fuse-0.11.0.tar.gz">http://ftpmirror.gnu.org/gnunet/gnunet-fuse-0.11.0.tar.gz</a></li>
<li><a href="http://ftpmirror.gnu.org/gnunet/gnunet-fuse-0.11.0.tar.gz.sig">http://ftpmirror.gnu.org/gnunet/gnunet-fuse-0.11.0.tar.gz.sig</a></li>
</ul>
<p>
(gnunet-gtk and gnunet-fuse were not released again, as there were no
changes and the 0.11.0 versions are expected to continue to work fine
with gnunet-0.11.4.)
</p>
<p>
Note that due to mirror synchronization, not all links might be functional
early after the release. For direct access try <a href="http://ftp.gnu.org/gnu/gnunet/">http://ftp.gnu.org/gnu/gnunet/</a>
</p>
<p>
Note that GNUnet is now started using <tt>gnunet-arm -s</tt>. GNUnet should be
stopped using <tt>gnunet-arm -e</tt>.
</p>
<h4>Noteworthy changes in 0.11.4</h4>
<ul>
<li>gnunet-arm -s no longer logs into the console by default and
instead into a logfile (in $GNUNET_HOME). </li>
<li>The reclaim subsystem is no longer experimental.
Further, the internal encryption scheme moved from ABE to GNS-style
encryption. </li>
<li>GNUnet now depends on a more recent version of libmicrohttpd. </li>
<li>The REST API now includes read-only access to the configuration. </li>
<li>All manpages are now in mdoc format. </li>
<li>gnunet-download-manager.scm removed. </li>
</ul>
<h4>Known Issues</h4>
<ul>
<li>There are known major design issues in the TRANSPORT, ATS and CORE subsystems
which will need to be addressed in the future to achieve acceptable usability,
performance and security.</li>
<li>There are known moderate implementation limitations in CADET that
negatively impact performance. Also CADET may unexpectedly deliver messages out-of-order.</li>
<li>There are known moderate design issues in FS that also impact
usability and performance.</li>
<li>There are minor implementation limitations in SET that create
unnecessary attack surface for availability.</li>
<li>The RPS subsystem remains experimental.</li>
<li>Some high-level tests in the test-suite fail non-deterministically due to
the low-level TRANSPORT issues.</li>
</ul>
<p>
In addition to this list, you may also want to consult our bug tracker
at <a href="https://bugs.gnunet.org/">bugs.gnunet.org</a> which lists
about 190 more specific issues.
</p>
<h4>Thanks</h4>
<p>
This release was the work of many people. The following people
contributed code and were thus easily identified:
ng0, Christian Grothoff, Hartmut Goebel, Martin Schanzenbach, Devan Carpenter, Naomi Phillips and Julius Bünger.
</p></content:encoded>
<dc:date>2019-05-12T17:40:00+00:00</dc:date>
<dc:creator>GNUnet News</dc:creator>
</item>
<item rdf:about="http://savannah.gnu.org/forum/forum.php?forum_id=9432">
<title>unifont @ Savannah: Unifont 12.1.01 Released</title>
<link>http://savannah.gnu.org/forum/forum.php?forum_id=9432</link>
<content:encoded><p><strong>11 May 2019</strong> Unifont 12.1.01 is now available. Significant changes in this version include the <strong>Reiwa Japanese era glyph</strong> (U+32FF), which was the only addition made in the Unicode 12.1.0 release of 7 May 2019; Rebecca Bettencourt has contributed many Under ConScript Uniocde Registry (UCSUR) scripts; and David Corbett and Johnnie Weaver modified glyphs in two Plane 1 scripts. Full details are in the ChangeLog file.
<br />
</p>
<p>Download this release at:
<br />
</p>
<p><a href="https://ftpmirror.gnu.org/unifont/unifont-12.1.01/">https://ftpmirror.gnu.org/unifont/unifont-12.1.01/</a>
<br />
</p>
<p>or if that fails,
<br />
</p>
<p><a href="https://ftp.gnu.org/gnu/unifont/unifont-12.1.01/">https://ftp.gnu.org/gnu/unifont/unifont-12.1.01/</a>
<br />
</p>
<p>or, as a last resort,
<br />
</p>
<p><a href="ftp://ftp.gnu.org/gnu/unifont/unifont-12.1.01/">ftp://ftp.gnu.org/gnu/unifont/unifont-12.1.01/</a><br />
</p></content:encoded>
<dc:date>2019-05-11T20:59:48+00:00</dc:date>
<dc:creator>Paul Hardy</dc:creator>
</item>
<item rdf:about="http://savannah.gnu.org/forum/forum.php?forum_id=9431">
<title>remotecontrol @ Savannah: Nest, the company, died at Google I/O 2019</title>
<link>http://savannah.gnu.org/forum/forum.php?forum_id=9431</link>
<content:encoded><p><a href="https://arstechnica.com/gadgets/2019/05/nest-the-company-died-at-google-io-2019/">https://arstechnica.com/gadgets/2019/05/nest-the-company-died-at-google-io-2019/</a><br />
</p></content:encoded>
<dc:date>2019-05-11T11:39:18+00:00</dc:date>
<dc:creator>Stephen H. Dawson DSL</dc:creator>
</item>
<item rdf:about="http://savannah.gnu.org/forum/forum.php?forum_id=9430">
<title>gettext @ Savannah: GNU gettext 0.20 released</title>
<link>http://savannah.gnu.org/forum/forum.php?forum_id=9430</link>
<content:encoded><p>Download from <a href="https://ftp.gnu.org/pub/gnu/gettext/gettext-0.20.tar.gz">https://ftp.gnu.org/pub/gnu/gettext/gettext-0.20.tar.gz</a>
<br />
</p>
<p>New in this release:
<br />
</p>
<ul>
<li>Support for reproducible builds:
</li>
</ul><p> - msgfmt now eliminates the POT-Creation-Date header field from .mo files.
<br />
</p>
<ul>
<li>Improvements for translators:
</li>
</ul><p> - update-po target in Makefile.in.in now uses msgmerge --previous.
<br />
</p>
<ul>
<li>Improvements for maintainers:
</li>
</ul><p> - msgmerge now has an option --for-msgfmt, that produces a PO file meant for use by msgfmt only. This option saves processing time, in particular by omitting fuzzy matching that is not useful in this situation.
<br />
- The .pot file in a 'po' directory is now erased by "make maintainer-clean".
<br />
- It is now possible to override xgettext options from the po/Makefile.in.in through options in XGETTEXT_OPTIONS (declared in po/Makevars).
<br />
- The --intl option of the gettextize program (deprecated since 2010) is no longer available. Instead of including the intl sources in your package, we suggest making the libintl library an optional prerequisite of your package. This will simplify the build system of your package.
<br />
- Accordingly, the Autoconf macro AM_GNU_GETTEXT_INTL_SUBDIR is gone as well.
<br />
</p>
<ul>
<li>Programming languages support:
</li>
</ul><p> - C, C++:
<br />
xgettext now supports strings in u8"..." syntax, as specified in C11 and C++11.
<br />
- C, C++:
<br />
xgettext now supports 'p'/'P' exponent markers in number tokens, as specified in C99 and C++17.
<br />
- C++:
<br />
xgettext now supports underscores in number tokens.
<br />
- C++:
<br />
xgettext now supports single-quotes in number tokens, as specified in C++14.
<br />
- Shell:
<br />
o The programs 'gettext', 'ngettext' now support a --context argument.
<br />
o gettext.sh contains new function eval_pgettext and eval_npgettext for producing translations of messages with context.
<br />
- Java:
<br />
o xgettext now supports UTF-8 encoded .properties files (a new feature of Java 9).
<br />
o The build system and tools now support Java 9, 10, and 11. On the other hand, support for old versions of Java (Java 5 and older, GCJ 4.2.x and older) has been dropped.
<br />
- Perl:
<br />
o Native support for context functions (pgettext, dpgettext, dcpgettext, npgettext, dnpgettext, dcnpgettext).
<br />
o better detection of question mark and slash as operators (as opposed to regular expression delimiters).
<br />
- Scheme:
<br />
xgettext now parses the syntax for specialized byte vectors (#u8(...), #vu8(...), etc.) correctly.
<br />
- Pascal:
<br />
xgettext can now extract strings from .rsj files, produced by the Free Pascal compiler version 3.0.0 or newer.
<br />
- Vala:
<br />
xgettext now parses escape sequences in strings more accurately.
<br />
- JavaScript:
<br />
xgettext now parses template literals correctly.
<br />
</p>
<ul>
<li>Runtime behaviour:
</li>
</ul><p> - The interpretation of the language preferences on macOS has been fixed.
<br />
- Per-thread locales are now also supported on Solaris 11.4.
<br />
- The replacements for the printf()/fprintf()/... functions that are provided through &lt;libintl.h&gt; on native Windows and NetBSD are now POSIX compliant. There is no conflict any more between these replacements and other possible replacements provided by gnulib or mingw.
<br />
</p>
<ul>
<li>Libtextstyle:
</li>
</ul><p> - This package installs a new library 'libtextstyle', together with a new header file &lt;textstyle.h&gt;. It is a library for styling text output sent to a console or terminal emulator. Packagers: please see the suggested packaging hints in the file PACKAGING.<br />
</p></content:encoded>
<dc:date>2019-05-09T02:15:21+00:00</dc:date>
<dc:creator>Bruno Haible</dc:creator>
</item>
<item rdf:about="http://savannah.gnu.org/forum/forum.php?forum_id=9429">
<title>cssc @ Savannah: CSSC-1.4.1 released</title>
<link>http://savannah.gnu.org/forum/forum.php?forum_id=9429</link>
<content:encoded><textarea class="verbatim" cols="80" readonly="readonly" rows="20">I'm pleased to announce the release of GNU CSSC, version
1.4.1. This is a stable release. The previous stable
release was 1.4.0.
Stable releases of CSSC are available from
https://ftp.gnu.org/gnu/cssc/. Development releases and
release candidates are available from
https://alpha.gnu.org/gnu/cssc/.
CSSC ("Compatibly Stupid Source Control") is the GNU
project's replacement for the traditional Unix SCCS suite.
It aims for full compatibility, including precise nuances
of behaviour, support for all command-line options, and in
most cases bug-for-bug compatibility. CSSC comes with an
extensive automated test suite.
If you are currently using SCCS to do version control of
software, you should be able to just drop in CSSC, even for
example if you have a large number of shell scripts which
are layered on top of SCCS and depend on it. This should
allow you to develop on and for the GNU/Linux platform if
your source code exists only in an SCCS repository. CSSC
also allows you to migrate to a more modern version control
system (such as git).
There is a mailing list for users of the CSSC suite. To
join it, please send email to &lt;[email protected]&gt;
or visit the URL
http://lists.gnu.org/mailman/listinfo/cssc-users.
There is also a mailing list for (usually automated) mails
about bugs and changes to CSSC. This is
http://lists.gnu.org/mailman/listinfo/bug-cssc.
For more information about CSSC, please see
http://www.gnu.org/software/cssc/.
These people have contributed to the development of CSSC :-
James Youngman, Ross Ridge, Eric Allman, Lars Hecking,
Larry McVoy, Dave Bodenstab, Malcolm Boff, Richard Polton,
Fila Kolodny, Peter Kjellerstedt, John Interrante, Marko
Rauhamaa, Achim Hoffann, Dick Streefland, Greg A. Woods,
Aron Griffis, Michael Sterrett, William W. Austin, Hyman
Rosen, Mark Reynolds, Sergey Ostashenko, Frank van
Maarseveen, Jeff Sheinberg, Thomas Duffy, Yann Dirson,
Martin Wilck
Many thanks to all the above people.
Changes since the previous release stable are:
New in CSSC-1.4.1, 2019-05-07
* This release - and future releases - of CSSC must be
compiled with a C++ compiler that supports the 2011
C++ standard.
* When the history file is updated (with admin or delta for
example) the history file is not made executable simply
because the 'x' flag is set. Instead, preserve the
executable-ness from the history file we are replacing.
* This release is based on updated versions of gnulib and of
the googletest unit test framework.
Checksums for the release file are:
$ for sum in sha1sum md5sum ; do $sum CSSC-1.4.1.tar.gz; done
bfb99cbd6255c7035e99455de7241d4753746fe1 CSSC-1.4.1.tar.gz
c9aaae7602e39b7a5d438b0cc48fcaa3 CSSC-1.4.1.tar.gz
Please report any bugs via this software to the CSSC bug
reporting page, http://savannah.gnu.org/bugs/?group=cssc
</textarea></content:encoded>
<dc:date>2019-05-07T20:27:17+00:00</dc:date>
<dc:creator>James Youngman</dc:creator>
</item>
<item rdf:about="https://gnu.org/software/guix/blog/2019/gnu-guix-1.0.0-released/">
<title>GNU Guix: GNU Guix 1.0.0 released</title>
<link>https://gnu.org/software/guix/blog/2019/gnu-guix-1.0.0-released/</link>
<content:encoded><p>We are excited to announce the release of GNU Guix version 1.0.0!</p><p>The release comes with <a href="https://www.gnu.org/software/guix/manual/en/html_node/System-Installation.html">ISO-9660 installation
images</a>,
a <a href="https://www.gnu.org/software/guix/manual/en/html_node/Running-Guix-in-a-VM.html">virtual machine
image</a>,
and with tarballs to install the package manager on top of your
GNU/Linux distro, either <a href="https://www.gnu.org/software/guix/manual/en/html_node/Requirements.html">from
source</a>
or <a href="https://www.gnu.org/software/guix/manual/en/html_node/Binary-Installation.html">from
binaries</a>.
Guix users can update by running <code>guix pull</code>.</p><p><img alt="Guix 1.0!" src="https://www.gnu.org/software/guix/static/blog/img/guix-1.0.png" /></p><p>One-point-oh always means a lot for free software releases. For Guix,
1.0 is the result of seven years of development, with code, packaging,
and documentation contributions made by 260 people, translation work
carried out by a dozen of people, and artwork and web site development
by a couple of individuals, to name some of the activities that have
been happening. During those years we published no less than <a href="https://www.gnu.org/software/guix/blog/tags/releases/">19 “0.x”
releases</a>.</p><h1>The journey to 1.0</h1><p>We took our time to get there, which is quite unusual in an era where
free software moves so fast. Why did we take this much time? First, it
takes time to build a community around a GNU/Linux distribution, and a
distribution wouldn’t really exist without it. Second, we feel like
we’re contributing an important piece to <a href="https://www.gnu.org/gnu/about-gnu.html">the GNU operating
system</a>, and that is surely
intimidating and humbling.</p><p>Last, we’ve been building something new. Of course we stand on the
shoulders of giants, and in particular <a href="https://nixos.org/nix/">Nix</a>,
which brought the functional software deployment paradigm that Guix
implements. But developing Guix has been—and still is!—a challenge in
many ways: it’s a <a href="https://arxiv.org/abs/1305.4584">programming</a>
<a href="https://www.gnu.org/software/guix/blog/2017/back-from-gpce/">language</a>
design challenge, an
<a href="https://www.gnu.org/software/guix/blog/2015/service-composition-in-guixsd/">operating</a>
<a href="https://www.gnu.org/software/guix/blog/2017/running-system-services-in-containers/">system</a>
design challenge, a challenge for
<a href="https://www.gnu.org/software/guix/blog/2016/timely-delivery-of-security-updates/">security</a>,
<a href="https://www.gnu.org/software/guix/blog/tags/reproducibility/">reproducibility</a>,
<a href="https://www.gnu.org/software/guix/blog/tags/bootstrapping/">bootstrapping</a>,
usability, and more. In other words, it’s been a long but insightful
journey! :-)</p><h1>What GNU Guix can do for you</h1><p>Presumably some of the readers are discovering Guix today, so let’s recap
what Guix can do for you as a user. Guix is a complete toolbox for
software deployment in general, which makes it different from most of
the tools you may be familiar with.</p><p><img alt="Guix manages packages, environments, containers, and systems." src="https://www.gnu.org/software/guix/static/blog/img/guix-scope.png" /></p><p>This may sound a little abstract so let’s look at concrete use cases:</p><ul><li><p><em>As a user</em>, Guix allows you to <a href="https://www.gnu.org/software/guix/manual/en/html_node/Invoking-guix-package.html">install applications and to keep
them
up-to-date</a>:
search for software with <code>guix search</code>, install it with <code>guix install</code>, and maintain it up-to-date by regularly running <code>guix pull</code> and <code>guix upgrade</code>. Guix follows a so-called “rolling
release” model, so you can run <code>guix pull</code> at any time to get the
latest and greatest bits of free software.</p><p>This certainly sounds familiar, but a distinguishing property here
is <em>dependability</em>: Guix is transactional, meaning that you can at
any time roll back to a previous “generation” of your package set
with <code>guix package --roll-back</code>, inspect differences with <code>guix package -l</code>, and so on.</p><p>Another useful property is <em>reproducibility</em>: Guix allows you to
deploy the <em>exact same software environment</em> on different machines
or at different points in time thanks to <a href="https://www.gnu.org/software/guix/manual/en/html_node/Invoking-guix-describe.html"><code>guix describe</code></a>
and <a href="https://www.gnu.org/software/guix/manual/en/html_node/Invoking-guix-pull.html"><code>guix pull</code></a>.</p><p>This, coupled with the fact that package management operations do
not require root access, is invaluable notably in the context of
high-performance computing (HPC) and reproducible science, which the
<a href="https://guix-hpc.bordeaux.inria.fr/">Guix-HPC effort</a> has been
focusing on.</p></li><li><p><em>As a developer</em>, we hope you’ll enjoy <a href="https://www.gnu.org/software/guix/manual/en/html_node/Invoking-guix-environment.html"><code>guix environment</code></a>,
which allows you to spawn one-off software environments. Suppose
you’re a GIMP developer: running <code>guix environment gimp</code> spawns a
shell with everything you need to hack on GIMP—much quicker than
manually installing its many dependencies.</p><p>Developers often struggle to push their work to users so they get
quick feedback. The <a href="https://www.gnu.org/software/guix/blog/2017/creating-bundles-with-guix-pack/"><code>guix pack</code></a>
provides an easy way to create <em>container images</em> for use by Docker
&amp; co., or even <a href="https://www.gnu.org/software/guix/blog/2018/tarballs-the-ultimate-container-image-format/">standalone relocatable
tarballs</a>
that anyone can run, regardless of the GNU/Linux distribution they
use.</p><p>Oh, and you may also like <a href="https://www.gnu.org/software/guix/manual/en/html_node/Package-Transformation-Options.html">package transformation
options</a>,
which allow you define package variants from the command line.</p></li><li><p><em>As a system administrator</em>—and actually, we’re all system
administrators of sorts on our laptops!—, Guix’s declarative and
unified approach to configuration management should be handy. It
surely is a departure from what most people are used to, but it is
so reassuring: one configuration file is enough to specify <a href="https://www.gnu.org/software/guix/manual/en/html_node/Using-the-Configuration-System.html">all the
aspects of the system
config</a>—services,
file systems, locale, accounts—all in the same language.</p><p>That makes it surprisingly easy to deploy otherwise complex services
such as applications that depend on Web services. For instance,
setting up
<a href="https://www.gnu.org/software/guix/manual/en/html_node/Version-Control-Services.html#Cgit-Service">CGit</a>
or
<a href="https://www.gnu.org/software/guix/manual/en/html_node/Monitoring-Services.html#Zabbix-front_002dend">Zabbix</a>
is a one-liner, even though behind the scenes that involves setting
up nginx, fcgiwrap, etc. We’d love to see to what extent this helps
people self-host services—sort of similar to what
<a href="https://freedombox.org/">FreedomBox</a> and
<a href="https://yunohost.org/">YunoHost</a> have been focusing on.</p><p>With <a href="https://www.gnu.org/software/guix/manual/en/html_node/Invoking-guix-system.html"><code>guix system</code></a>
you can instantiate a configuration on your machine, or in a virtual
machine (VM) where you can test it, or in a container. You can also
provision ISO images, VM images, or container images with a complete
OS, from the same config, all with <code>guix system</code>.</p></li></ul><p>The <a href="https://www.gnu.org/software/guix/guix-refcard.pdf">quick reference
card</a> shows the
important commands. As you start diving deeper into Guix, you’ll
discover that many aspects of the system are exposed using consistent
<a href="https://www.gnu.org/software/guile/">Guile</a> programming interfaces:
<a href="https://www.gnu.org/software/guix/manual/en/html_node/Defining-Packages.html">package
definitions</a>,
<a href="https://www.gnu.org/software/guix/manual/en/html_node/Services.html">system
services</a>,
the <a href="https://www.gnu.org/software/shepherd/">“init” system</a>, and a whole
bunch of system-level libraries. We believe that makes the system very
<em>hackable</em>, and we hope you’ll find it as much fun to play with as we do.</p><p>So much for the overview!</p><h1>What’s new since 0.16.0</h1><p>For those who’ve been following along, a great many things have changed
over the last 5 months since the <a href="https://www.gnu.org/software/guix/blog/2018/gnu-guix-and-guixsd-0.16.0-released/">0.16.0
release</a>—99
people contributed over 5,700 commits during that time! Here are the
highlights:</p><ul><li>The ISO installation image now runs a cute <a href="https://www.gnu.org/software/guix/manual/en/html_node/Guided-Graphical-Installation.html">text-mode graphical
installer</a>—big
thanks to Mathieu Othacehe for writing it and to everyone who
tested it and improved it! It is similar in spirit to the Debian
installer. Whether you’re a die-hard GNU/Linux hacker or a novice
user, you’ll certainly find that this makes system installation
much less tedious than it was! The installer is fully translated
to French, German, and Spanish.</li><li>The new <a href="https://www.gnu.org/software/guix/manual/en/html_node/Running-GuixSD-in-a-VM.html">VM
image</a>
better matches user expectations: whether you want to tinker with
Guix System and see what it’s like, or whether you want to use it
as a development environment, this VM image should be more directly
useful.</li><li>The user interface was improved: aliases for common operations
<a href="https://www.gnu.org/software/guix/manual/en/html_node/Invoking-guix-package.html">such as <code>guix search</code> and <code>guix install</code></a>
are now available, diagnostics are now colorized, more operations
show a progress bar, there’s a new <code>--verbosity</code> option recognized
by all commands, and most commands are now “quiet” by default.</li><li>There’s a new <code>--with-git-url</code> <a href="https://www.gnu.org/software/guix/manual/en/html_node/Package-Transformation-Options.html">package transformation
option</a>,
that goes with <code>--with-branch</code> and <code>--with-commit</code>.</li><li>Guix now has a first-class, uniform mechanism to configure
<a href="https://www.gnu.org/software/guix/manual/en/html_node/Keyboard-Layout.html">keyboard
layout</a>—a
long overdue addition. Related to that, <a href="https://www.gnu.org/software/guix/manual/en/html_node/X-Window.html">Xorg
configuration</a>
has been streamlined with the new <code>xorg-configuration</code> record.</li><li>We introduced <code>guix pack -R</code> <a href="https://www.gnu.org/software/guix/blog/2018/tarballs-the-ultimate-container-image-format/">a while
back</a>:
it creates tarballs containing <em>relocatable</em> application bundles
that rely on user namespaces. Starting from 1.0, <code>guix pack -RR</code>
(like “reliably relocatable”?) generates relocatable binaries that
fall back to <a href="https://proot-me.github.io/">PRoot</a> on systems where
<a href="http://man7.org/linux/man-pages/man7/user_namespaces.7.html">user
namespaces</a>
are not supported.</li><li>More than 1,100 packages were added, leading to <a href="https://www.gnu.org/software/guix/packages">close to 10,000
packages</a>, 2,104
packages were updated, and several system services were
contributed.</li><li>The manual has been fully translated to
<a href="https://www.gnu.org/software/guix/manual/fr/html_node/">French</a>,
the
<a href="https://www.gnu.org/software/guix/manual/de/html_node/">German</a>
and <a href="https://www.gnu.org/software/guix/manual/es/html_node/">Spanish</a>
translations are nearing completion, and work has begun on a
<a href="https://www.gnu.org/software/guix/manual/zh-cn/html_node/">Simplified
Chinese</a>
translation. You can help <a href="https://translationproject.org/domain/guix-manual.html">translate the manual into your
language</a>
by <a href="https://translationproject.org/html/translators.html">joining the Translation
Project</a>.</li></ul><p>That’s a long list already, but you can find more details in the
<a href="https://git.savannah.gnu.org/cgit/guix.git/tree/NEWS?h=version-1.0.0"><code>NEWS</code></a>
file.</p><h1>What’s next?</h1><p>One-point-oh is a major milestone, especially for those of us who’ve
been on board for several years. But with the wealth of ideas we’ve
been collecting, it’s definitely not the end of the road!</p><p>If you’re interested in “devops” and distributed deployment, you will
certainly be happy to help in that area, those interested in OS
development might want to make <a href="https://www.gnu.org/software/shepherd/">the
Shepherd</a> more flexible and
snappy, furthering integration with <a href="https://www.gnu.org/software/guix/blog/2019/connecting-reproducible-deployment-to-a-long-term-source-code-archive/">Software
Heritage</a>
will probably be #1 on the to-do list of scientists concerned with
long-term reproducibility, programming language tinkerers may want to
push
<a href="https://www.gnu.org/software/guix/manual/en/html_node/G_002dExpressions.html#G_002dExpressions">G-expressions</a>
further, etc. Guix 1.0 is a tool that’s both serviceable for one’s
day-to-day computer usage and a great playground for the tinkerers among
us.</p><p>Whether you want to help on design, coding, maintenance, system
administration, translation, testing, artwork, web services, funding,
organizing a Guix install party… <a href="https://www.gnu.org/software/guix/contribute/">your contributions are
welcome</a>!</p><p>We’re humans—don’t hesitate to <a href="https://www.gnu.org/software/guix/contact/">get in touch with
us</a>, and enjoy Guix 1.0!</p><h4>About GNU Guix</h4><p><a href="https://www.gnu.org/software/guix">GNU Guix</a> is a transactional package
manager and an advanced distribution of the GNU system that <a href="https://www.gnu.org/distros/free-system-distribution-guidelines.html">respects
user
freedom</a>.
Guix can be used on top of any system running the kernel Linux, or it
can be used as a standalone operating system distribution for i686,
x86_64, ARMv7, and AArch64 machines.</p><p>In addition to standard package management features, Guix supports
transactional upgrades and roll-backs, unprivileged package management,
per-user profiles, and garbage collection. When used as a standalone
GNU/Linux distribution, Guix offers a declarative, stateless approach to
operating system configuration management. Guix is highly customizable
and hackable through <a href="https://www.gnu.org/software/guile">Guile</a>
programming interfaces and extensions to the
<a href="http://schemers.org">Scheme</a> language.</p></content:encoded>
<dc:date>2019-05-02T14:00:00+00:00</dc:date>
<dc:creator>Ludovic Courtès</dc:creator>
</item>
<item rdf:about="http://savannah.gnu.org/forum/forum.php?forum_id=9426">
<title>dico @ Savannah: Version 2.9</title>
<link>http://savannah.gnu.org/forum/forum.php?forum_id=9426</link>
<content:encoded><p>Version 2.9 of GNU dico is available from download from <a href="https://ftp.gnu.org/gnu/dico/dico-2.9.tar.xz">the GNU archive</a> and from <a href="https://download.gnu.org.ua/release/dico/dico-2.9.tar.xz">its main archive</a> site.
<br />
</p>
<p>This version fixes compilation on 32-bit systems.<br />
</p></content:encoded>
<dc:date>2019-04-24T06:57:18+00:00</dc:date>
<dc:creator>Sergey Poznyakoff</dc:creator>
</item>
<item rdf:about="http://savannah.gnu.org/forum/forum.php?forum_id=9425">
<title>rush @ Savannah: Version 1.9</title>
<link>http://savannah.gnu.org/forum/forum.php?forum_id=9425</link>
<content:encoded><p>Version 1.9 is available for download from <a href="https://ftp.gnu.org/gnu/rush/rush-1.9.tar.xz">GNU</a> and <a href="http://download.gnu.org.ua/release/rush/rush-1.9.tar.xz">Puszcza</a> archives. It should soon become available in the mirrors too.
<br />
</p>
<p>New in this version:
<br />
</p>
<h4>Backreference expansion</h4>
<p>Arguments to tranformations, chroot and chdir statements can contain references to parenthesized groups in the recent regular expression match. Such references are replaced with the strings that matched the corresponding groups. Syntactically, a backreference expansion is a percent sign followed by one-digit number of the subexpression (1-based, %0 refers to entire matched line). For example
<br />
</p>
<blockquote class="verbatim"><p> rule X<br />
command ^cd (.+) &amp;&amp; (.+)<br />
chdir %1<br />
set %2<br />
</p></blockquote>
<h4>User-defined variables</h4>
<p>The configuration file can define new variables or redefine the built-in ones using the <strong>setvar</strong> statement:
<br />
</p>
<blockquote class="verbatim"><p> setvar[VAR] PATTERN<br />
</p></blockquote>
<p>Here, VAR is the variable name, and PATTERN is its new value. The PATTERN is subject to variable and backreference expansion.
<br />
</p>
<p>User-defined variables can be unset using the "unsetvar" statement:
<br />
</p>
<blockquote class="verbatim"><p> unsetvar[VAR]<br />
</p></blockquote>
<p>Unsetting a built-in variable, previously redefined using the <strong>setvar</strong> statement causes the user-supplied definition to be forgotten and the built-in one restored.
<br />
</p>
<h4>Shell-like variable expansion</h4>
<p>The following shell-like notations are supported:
<br />
</p>
<blockquote class="verbatim"><p> ${VAR:-WORD} Use Default Values<br />
${VAR:=WORD} Assign Default Values<br />
${VAR:?WORD} Display Error if Null or Unset<br />
${VAR:+WORD} Use Alternate Value<br />
</p></blockquote>
<h4>New script rush-po for extracting translatable strings from the configuration</h4>
<p>The script rush-po.awk that was used in prior versions has been withdrawn.<br />
</p></content:encoded>
<dc:date>2019-04-24T06:02:12+00:00</dc:date>
<dc:creator>Sergey Poznyakoff</dc:creator>
</item>
<item rdf:about="http://savannah.gnu.org/forum/forum.php?forum_id=9424">
<title>remotecontrol @ Savannah: How hacking threats spurred secret U.S. blacklist</title>
<link>http://savannah.gnu.org/forum/forum.php?forum_id=9424</link>
<content:encoded><p>U.S. energy regulators are pursuing a risky plan to share with electric utilities a secret "don't buy" list of foreign technology suppliers, according to multiple sources.
<br />
</p>
<p><a href="https://www.eenews.net/stories/1060176111">https://www.eenews.net/stories/1060176111</a><br />
</p></content:encoded>
<dc:date>2019-04-23T21:38:53+00:00</dc:date>
<dc:creator>Stephen H. Dawson DSL</dc:creator>
</item>
<item rdf:about="http://savannah.gnu.org/forum/forum.php?forum_id=9423">
<title>gnustep @ Savannah: Main development is located at http://github.com/gnustep</title>
<link>http://savannah.gnu.org/forum/forum.php?forum_id=9423</link>
<content:encoded><p>Main development is located at <a href="http://github.com/gnustep">http://github.com/gnustep</a><br />
</p></content:encoded>
<dc:date>2019-04-23T14:25:45+00:00</dc:date>
<dc:creator>Gregory John Casamento</dc:creator>
</item>
<item rdf:about="http://savannah.gnu.org/forum/forum.php?forum_id=9422">
<title>parallel @ Savannah: GNU Parallel 20190422 ('Invitation') released [stable]</title>
<link>http://savannah.gnu.org/forum/forum.php?forum_id=9422</link>
<content:encoded><p>GNU Parallel 20190422 ('Invitation') [stable] has been released. It is available for download at: <a href="http://ftpmirror.gnu.org/parallel/">http://ftpmirror.gnu.org/parallel/</a>
<br />
</p>
<p>No new functionality was introduced so this is a good candidate for a stable release.
<br />
</p>
<h2>Invitation to 10 year reception</h2>
<p>GNU Parallel is 10 years old in a year on 2020-04-22. You are here by invited to a reception on Friday 2020-04-17.
<br />
</p>
<p>The primary reception will be held in Copenhagen, DK. Please reserve the date and email <a href="mailto:[email protected]">[email protected]</a> if you want to join.
<br />
</p>
<p>If you cannot make it, you are encouraged to host a parallel party.
<br />
</p>
<p>So far we hope to have parallel parties at:
<br />
</p>
<blockquote class="verbatim"><p> PROSA<br />
Vester Farimagsgade 37A<br />
DK-1606 København V<br />
RSVP: [email protected]<br />
<br />
PROSA<br />
Søren Frichs Vej 38 K th<br />
DK-8230 Åbyhøj<br />
RSVP: To be determined<br />
<br />
PROSA<br />
Overgade 54<br />
DK-5000 Odense C<br />
RSVP: To be determined<br />
</p></blockquote>
<p>If you want to host a party held in parallel (either in this or in a parallel universe), please let me know, so it can be announced.
<br />
</p>
<p>If you have parallel ideas for how to celebrate GNU Parallel, please post on the email list [email protected]. So far we have the following ideas:
<br />
</p>
<ul>
<li>Use GNU Parallel logo (the café wall illusion) as decoration everywhere - preferably in a moving version where the bars slide. Maybe we can borrow this <a href="https://www.youtube.com/watch?v=_XFDnFLqRFE">https://www.youtube.com/watch?v=_XFDnFLqRFE</a> or make an animation in javascript based on <a href="https://bl.ocks.org/Fil/13177d3c911fb8943cb0013086469b87">https://bl.ocks.org/Fil/13177d3c911fb8943cb0013086469b87</a>? Other illusions might be fun, too.
</li>
<li>Only serve beverages in parallel (2 or more), which may or may not be the same kind of beverage, and may or may not be served to the same person, and may or may not be served by multiple waiters in parallel
</li>
<li>Let people drink in parallel with straws (2 or more straws)
</li>
<li>Serve popcorn as snack (funny because cores and kernels are the same word in Danish, and GNU Parallel keeps cores hot)
</li>
<li>Serve saltstænger and similar parallel snacks.
</li>
<li>Serve (snack friendly) cereal ("serial") in parallel bowls.
</li>
<li>Live parallel streaming from parallel parties
</li>
<li>Play songs in parallel that use the same 4 chords: <a href="https://www.youtube.com/watch?v=5pidokakU4I">https://www.youtube.com/watch?v=5pidokakU4I</a>
</li>
<li>Play songs named parallel, serial, mutex, race condition and similar
</li>
<li>Have RC racing cars to demonstrate race condition
</li>
<li>Put a counting semaphore on the toilets
</li>
<li>Only let people leave one at a time to simulate serialized output - UNLESS they swap some clothing (to simulate half line mixing)
</li>
</ul>
<p>If you have interesting stories about or uses of GNU Parallel, please post them, so can be part of the anniversary update.
<br />
</p>
<p>Quote of the month:
<br />
</p>
<p> Y'all need some GNU parallel in your lives
<br />
-- ChaKu @ChaiLovesChai@twitter
<br />
</p>
<p>New in this release:
<br />
</p>
<ul>
<li>Invitation to the 10 years anniversary next year.
</li>
</ul>
<ul>
<li>The Austin Linux Meetup: KVM as Hypervisor and GNU Parallel <a href="https://www.meetup.com/linuxaustin/events/jbxcnqyzgbpb/">https://www.meetup.com/linuxaustin/events/jbxcnqyzgbpb/</a>
</li>
</ul>
<ul>
<li>Bug fixes and man page updates.
</li>
</ul>
<p>Get the book: GNU Parallel 2018 <a href="http://www.lulu.com/shop/ole-tange/gnu-parallel-2018/paperback/product-23558902.html">http://www.lulu.com/shop/ole-tange/gnu-parallel-2018/paperback/product-23558902.html</a>
<br />
</p>
<p>GNU Parallel - For people who live life in the parallel lane.
<br />
</p>
<h2>About GNU Parallel</h2>
<p>GNU Parallel is a shell tool for executing jobs in parallel using one or more computers. A job can be a single command or a small script that has to be run for each of the lines in the input. The typical input is a list of files, a list of hosts, a list of users, a list of URLs, or a list of tables. A job can also be a command that reads from a pipe. GNU Parallel can then split the input and pipe it into commands in parallel.
<br />
</p>
<p>If you use xargs and tee today you will find GNU Parallel very easy to use as GNU Parallel is written to have the same options as xargs. If you write loops in shell, you will find GNU Parallel may be able to replace most of the loops and make them run faster by running several jobs in parallel. GNU Parallel can even replace nested loops.
<br />
</p>
<p>GNU Parallel makes sure output from the commands is the same output as you would get had you run the commands sequentially. This makes it possible to use output from GNU Parallel as input for other programs.
<br />
</p>
<p>You can find more about GNU Parallel at: <a href="http://www.gnu.org/s/parallel/">http://www.gnu.org/s/parallel/</a>
<br />
</p>
<p>You can install GNU Parallel in just 10 seconds with:
<br />
(wget -O - pi.dk/3 || curl pi.dk/3/ || fetch -o - <a href="http://pi.dk/3">http://pi.dk/3</a>) | bash
<br />
</p>
<p>Watch the intro video on <a href="http://www.youtube.com/playlist?list=PL284C9FF2488BC6D1">http://www.youtube.com/playlist?list=PL284C9FF2488BC6D1</a>
<br />
</p>
<p>Walk through the tutorial (man parallel_tutorial). Your command line will love you for it.
<br />
</p>
<p>When using programs that use GNU Parallel to process data for publication please cite:
<br />
</p>
<p>O. Tange (2018): GNU Parallel 2018, March 2018, <a href="https://doi.org/10.5281/zenodo.1146014">https://doi.org/10.5281/zenodo.1146014</a>.
<br />
</p>
<p>If you like GNU Parallel:
<br />
</p>
<ul>
<li>Give a demo at your local user group/team/colleagues
</li>
<li>Post the intro videos on Reddit/Diaspora*/forums/blogs/ Identi.ca/Google+/Twitter/Facebook/Linkedin/mailing lists
</li>
<li>Get the merchandise <a href="https://gnuparallel.threadless.com/designs/gnu-parallel">https://gnuparallel.threadless.com/designs/gnu-parallel</a>
</li>
<li>Request or write a review for your favourite blog or magazine
</li>
<li>Request or build a package for your favourite distribution (if it is not already there)
</li>
<li>Invite me for your next conference
</li>
</ul>
<p>If you use programs that use GNU Parallel for research:
<br />
</p>
<ul>
<li>Please cite GNU Parallel in you publications (use --citation)
</li>
</ul>
<p>If GNU Parallel saves you money:
<br />
</p>
<ul>
<li>(Have your company) donate to FSF <a href="https://my.fsf.org/donate/">https://my.fsf.org/donate/</a>
</li>
</ul>
<h2>About GNU SQL</h2>
<p>GNU sql aims to give a simple, unified interface for accessing databases through all the different databases' command line clients. So far the focus has been on giving a common way to specify login information (protocol, username, password, hostname, and port number), size (database and table size), and running queries.
<br />
</p>
<p>The database is addressed using a DBURL. If commands are left out you will get that database's interactive shell.
<br />
</p>
<p>When using GNU SQL for a publication please cite:
<br />
</p>
<p>O. Tange (2011): GNU SQL - A Command Line Tool for Accessing Different Databases Using DBURLs, ;login: The USENIX Magazine, April 2011:29-32.
<br />
</p>
<h2>About GNU Niceload</h2>
<p>GNU niceload slows down a program when the computer load average (or other system activity) is above a certain limit. When the limit is reached the program will be suspended for some time. If the limit is a soft limit the program will be allowed to run for short amounts of time before being suspended again. If the limit is a hard limit the program will only be allowed to run when the system is below the limit.<br />
</p></content:encoded>
<dc:date>2019-04-21T18:20:53+00:00</dc:date>
<dc:creator>Ole Tange</dc:creator>
</item>
<item rdf:about="http://savannah.gnu.org/forum/forum.php?forum_id=9419">
<title>gnuastro @ Savannah: Gnuastro 0.9 released</title>
<link>http://savannah.gnu.org/forum/forum.php?forum_id=9419</link>
<content:encoded><p>The 9th release of GNU Astronomy Utilities (Gnuastro) is now available for download. Please see <a href="http://lists.gnu.org/archive/html/info-gnuastro/2019-04/msg00001.html">the announcement</a> for details.<br />
</p></content:encoded>
<dc:date>2019-04-17T17:54:52+00:00</dc:date>
<dc:creator>Mohammad Akhlaghi</dc:creator>
</item>
<item rdf:about="http://savannah.gnu.org/forum/forum.php?forum_id=9417">
<title>GNU Hackers Meeting: Malfunction in ghm-planning (at) gnu.org</title>
<link>http://savannah.gnu.org/forum/forum.php?forum_id=9417</link>
<content:encoded><p>Due to a problem in the alias configuration, mails sent to ghm-planning before Sun Apr 14 8:00 CEST have been silently dropped.
<br />
</p>
<p>If you sent a registration email and/or a talk proposal for the GHM 2019, please resend it.
<br />
</p>
<p>Sorry for the inconvenience!<br />
</p></content:encoded>
<dc:date>2019-04-14T07:56:27+00:00</dc:date>
<dc:creator>Jose E. Marchesi</dc:creator>
</item>
<item rdf:about="http://savannah.gnu.org/forum/forum.php?forum_id=9415">
<title>GNU Hackers Meeting: GNU Hackers' Meeting 2019 in Madrid</title>
<link>http://savannah.gnu.org/forum/forum.php?forum_id=9415</link>
<content:encoded><p>Twelve years after it's first edition in Orense, the GHM is back to Spain! This time, we will be gathering in the nice city of Madrid for hacking, learning and meeting each other.
<br />
</p>
<p>The event will have place from Wednesday 4 September to Friday 6
<br />
September, 2019.
<br />
</p>
<p>Please visit <a href="http://www.gnu.org/ghm/2019">http://www.gnu.org/ghm/2019</a> for more information on the venue and instructions on how to register and propose talks.
<br />
</p>
<p>The website will be updated as we complete the schedule and the organizational details, so stay tuned!<br />
</p></content:encoded>
<dc:date>2019-04-12T20:03:26+00:00</dc:date>
<dc:creator>Jose E. Marchesi</dc:creator>
</item>
<item rdf:about="https://gnunet.org/#gnunet-0.11.2-release">
<title>GNUnet News: 2019-04-04: GNUnet 0.11.2 released</title>
<link>https://gnunet.org/#gnunet-0.11.2-release</link>
<content:encoded><h3>
<a name="gnunet-0.11.2-release">2019-04-04: GNUnet 0.11.2 released</a>
</h3>
<p>
We are pleased to announce the release of GNUnet 0.11.2.
</p>
<p>
This is a bugfix release for 0.11.0, mostly fixing minor bugs,
improving documentation and fixing various build issues. In
terms of usability, users should be aware that there are still a large
number of known open issues in particular with respect to ease of use,
but also some critical privacy issues especially for mobile users.
Also, the nascent network is tiny (about 200 peers) and thus unlikely to
provide good anonymity or extensive amounts of interesting
information. As a result, the 0.11.2 release is still only suitable
for early adopters with some reasonable pain tolerance.
</p>
<h4>Download links</h4>
<ul>
<li><a href="http://ftpmirror.gnu.org/gnunet/gnunet-0.11.2.tar.gz">http://ftpmirror.gnu.org/gnunet/gnunet-0.11.2.tar.gz</a></li>
<li><a href="http://ftpmirror.gnu.org/gnunet/gnunet-0.11.2.tar.gz.sig">http://ftpmirror.gnu.org/gnunet/gnunet-0.11.2.tar.gz.sig</a></li>
<li><a href="http://ftpmirror.gnu.org/gnunet/gnunet-gtk-0.11.0.tar.gz">http://ftpmirror.gnu.org/gnunet/gnunet-gtk-0.11.0.tar.gz</a></li>
<li><a href="http://ftpmirror.gnu.org/gnunet/gnunet-gtk-0.11.0.tar.gz.sig">http://ftpmirror.gnu.org/gnunet/gnunet-gtk-0.11.0.tar.gz.sig</a></li>
<li><a href="http://ftpmirror.gnu.org/gnunet/gnunet-fuse-0.11.0.tar.gz">http://ftpmirror.gnu.org/gnunet/gnunet-fuse-0.11.0.tar.gz</a></li>
<li><a href="http://ftpmirror.gnu.org/gnunet/gnunet-fuse-0.11.0.tar.gz.sig">http://ftpmirror.gnu.org/gnunet/gnunet-fuse-0.11.0.tar.gz.sig</a></li>
</ul>
<p>
(gnunet-gtk and gnunet-fuse were not released again, as there were no
changes and the 0.11.0 versions are expected to continue to work fine
with gnunet-0.11.2.)
</p>
<p>
Note that due to mirror synchronization, not all links might be functional
early after the release. For direct access try <a href="http://ftp.gnu.org/gnu/gnunet/">http://ftp.gnu.org/gnu/gnunet/</a>
</p>
<p>
Note that GNUnet is now started using <tt>gnunet-arm -s</tt>. GNUnet should be
stopped using <tt>gnunet-arm -e</tt>.
</p>
<h4>Noteworthy changes in 0.11.2</h4>
<ul>
<li>gnunet-qr was rewritten in C, removing our last dependency on Python 2.x</li>
<li>REST and GNS proxy configuration options for address binding were added</li>
<li>gnunet-publish by default no longer includes creation time</li>
<li>Unreliable message ordering logic in CADET was fixed</li>
<li>Various improvements to build system and documentation</li>
</ul>
<p>
The above is just the short list, our bugtracker lists
<a href="https://bugs.gnunet.org/changelog_page.php?version_id=312">
14 individual issues</a> that were resolved since 0.11.0.
</p>
<h4>Known Issues</h4>
<ul>
<li>There are known major design issues in the TRANSPORT, ATS and CORE subsystems
which will need to be addressed in the future to achieve acceptable usability,
performance and security.</li>
<li>There are known moderate implementation limitations in CADET that
negatively impact performance. Also CADET may unexpectedly deliver messages out-of-order.</li>
<li>There are known moderate design issues in FS that also impact
usability and performance.</li>
<li>There are minor implementation limitations in SET that create
unnecessary attack surface for availability.</li>
<li>The RPS subsystem remains experimental.</li>
<li>Some high-level tests in the test-suite fail non-deterministically due to
the low-level TRANSPORT issues.</li>
</ul>
<p>
In addition to this list, you may also want to consult our bug tracker
at <a href="https://bugs.gnunet.org/">bugs.gnunet.org</a> which lists
about 190 more specific issues.
</p>
<h4>Thanks</h4>
<p>
This release was the work of many people. The following people
contributed code and were thus easily identified:
ng0, Christian Grothoff, Hartmut Goebel, Martin Schanzenbach, Devan Carpenter, Naomi Phillips and Julius Bünger.
</p></content:encoded>
<dc:date>2019-04-04T13:00:00+00:00</dc:date>
<dc:creator>GNUnet News</dc:creator>
</item>
<item rdf:about="https://gnunet.org/#gnunet-0.11.1-release">
<title>GNUnet News: 2019-04-03: GNUnet 0.11.1 released</title>
<link>https://gnunet.org/#gnunet-0.11.1-release</link>
<content:encoded><h3>
<a name="gnunet-0.11.1-release">2019-04-03: GNUnet 0.11.1 released</a>
</h3>
<p>
We are pleased to announce the release of GNUnet 0.11.1.
</p>
<p>
This is a bugfix release for 0.11.0, mostly fixing minor bugs,
improving documentation and fixing various build issues. In
terms of usability, users should be aware that there are still a large
number of known open issues in particular with respect to ease of use,
but also some critical privacy issues especially for mobile users.
Also, the nascent network is tiny (about 200 peers) and thus unlikely to
provide good anonymity or extensive amounts of interesting
information. As a result, the 0.11.1 release is still only suitable
for early adopters with some reasonable pain tolerance.
</p>
<h4>Download links</h4>
<ul>
<li><a href="http://ftpmirror.gnu.org/gnunet/gnunet-0.11.1.tar.gz">http://ftpmirror.gnu.org/gnunet/gnunet-0.11.1.tar.gz</a></li>
<li><a href="http://ftpmirror.gnu.org/gnunet/gnunet-0.11.1.tar.gz.sig">http://ftpmirror.gnu.org/gnunet/gnunet-0.11.1.tar.gz.sig</a></li>
<li><a href="http://ftpmirror.gnu.org/gnunet/gnunet-gtk-0.11.0.tar.gz">http://ftpmirror.gnu.org/gnunet/gnunet-gtk-0.11.0.tar.gz</a></li>
<li><a href="http://ftpmirror.gnu.org/gnunet/gnunet-gtk-0.11.0.tar.gz.sig">http://ftpmirror.gnu.org/gnunet/gnunet-gtk-0.11.0.tar.gz.sig</a></li>
<li><a href="http://ftpmirror.gnu.org/gnunet/gnunet-fuse-0.11.0.tar.gz">http://ftpmirror.gnu.org/gnunet/gnunet-fuse-0.11.0.tar.gz</a></li>
<li><a href="http://ftpmirror.gnu.org/gnunet/gnunet-fuse-0.11.0.tar.gz.sig">http://ftpmirror.gnu.org/gnunet/gnunet-fuse-0.11.0.tar.gz.sig</a></li>
</ul>
<p>
(gnunet-gtk and gnunet-fuse were not released again, as there were no
changes and the 0.11.0 versions are expected to continue to work fine
with gnunet-0.11.1.)
</p>
<p>
Note that due to mirror synchronization, not all links might be functional
early after the release. For direct access try <a href="http://ftp.gnu.org/gnu/gnunet/">http://ftp.gnu.org/gnu/gnunet/</a>
</p>
<p>
Note that GNUnet is now started using <tt>gnunet-arm -s</tt>. GNUnet should be
stopped using <tt>gnunet-arm -e</tt>.
</p>
<h4>Noteworthy changes in 0.11.1</h4>
<ul>
<li>gnunet-qr was rewritten in C, removing our last dependency on Python 2.x</li>
<li>REST and GNS proxy configuration options for address binding were added</li>
<li>gnunet-publish by default no longer includes creation time</li>
<li>Unreliable message ordering logic in CADET was fixed</li>
<li>Various improvements to build system and documentation</li>
</ul>
<p>
The above is just the short list, our bugtracker lists
<a href="https://bugs.gnunet.org/changelog_page.php?version_id=312">
14 individual issues</a> that were resolved since 0.11.0.
</p>
<h4>Known Issues</h4>
<ul>
<li>There are known major design issues in the TRANSPORT, ATS and CORE subsystems
which will need to be addressed in the future to achieve acceptable usability,
performance and security.</li>
<li>There are known moderate implementation limitations in CADET that
negatively impact performance. Also CADET may unexpectedly deliver messages out-of-order.</li>
<li>There are known moderate design issues in FS that also impact
usability and performance.</li>
<li>There are minor implementation limitations in SET that create
unnecessary attack surface for availability.</li>
<li>The RPS subsystem remains experimental.</li>
<li>Some high-level tests in the test-suite fail non-deterministically due to
the low-level TRANSPORT issues.</li>
</ul>
<p>
In addition to this list, you may also want to consult our bug tracker
at <a href="https://bugs.gnunet.org/">bugs.gnunet.org</a> which lists
about 190 more specific issues.
</p>
<h4>Thanks</h4>
<p>
This release was the work of many people. The following people
contributed code and were thus easily identified:
ng0, Christian Grothoff, Hartmut Goebel, Martin Schanzenbach, Devan Carpenter, Naomi Phillips and Julius Bünger.
</p></content:encoded>
<dc:date>2019-04-03T16:00:00+00:00</dc:date>
<dc:creator>GNUnet News</dc:creator>
</item>
<item rdf:about="https://gnu.org/software/guix/blog/2019/connecting-reproducible-deployment-to-a-long-term-source-code-archive/">
<title>GNU Guix: Connecting reproducible deployment to a long-term source code archive</title>
<link>https://gnu.org/software/guix/blog/2019/connecting-reproducible-deployment-to-a-long-term-source-code-archive/</link>
<content:encoded><p>GNU Guix can be used as a “package manager” to install and upgrade
software packages as is familiar to GNU/Linux users, or as an
environment manager, but it can also provision containers or virtual
machines, and manage the operating system running on your machine.</p><p>One foundation that sets it apart from other tools in these areas is
<em>reproducibility</em>. From a high-level view, Guix allows users to
<em>declare</em> complete software environments and instantiate them. They can
share those environments with others, who can replicate them or adapt
them to their needs. This aspect is key to reproducible computational
experiments: scientists need to reproduce software environments before
they can reproduce experimental results, and this is one of the things
we are focusing on in the context of the
<a href="https://guix-hpc.bordeaux.inria.fr">Guix-HPC</a> effort. At a lower
level, the project, along with others in the <a href="https://reproducible-builds.org">Reproducible
Builds</a> community, is working to ensure
that software build outputs are <a href="https://reproducible-builds.org/docs/definition/">reproducible,
bit for bit</a>.</p><p>Work on reproducibility at all levels has been making great progress.
Guix, for instance, allows you to <a href="https://www.gnu.org/software/guix/blog/2018/multi-dimensional-transactions-and-rollbacks-oh-my/">travel back in
time</a>.
That Guix can travel back in time <em>and</em> build software reproducibly is a
great step forward. But there’s still an important piece that’s missing
to make this viable: a stable source code archive. This is where
<a href="https://www.softwareheritage.org">Software Heritage</a> (SWH for short)
comes in.</p><h1>When source code vanishes</h1><p>Guix contains thousands of package definitions. Each <a href="https://www.gnu.org/software/guix/manual/en/html_node/Defining-Packages.html">package
definition</a>
specifies the package’s source code URL and hash, the package’s
dependencies, and its build procedure. Most of the time, the package’s
source code is an archive (a “tarball”) fetched from a web site, but
more and more frequently the source code is a specific revision checked
out directly from a version control system.</p><p>The obvious question, then, is: what happens if the source code URL
becomes unreachable? The whole reproducibility endeavor collapses when
source code disappears. And source code <em>does</em> disappear, or, even
worse, it can be modified in place. At GNU we’re doing a good job of
having stable hosting that keeps releases around “forever”, unchanged
(modulo rare exceptions). But a lot of free software out there is
hosted on personal web pages with a short lifetime and on commercial
hosting services that come and go.</p><p>By default Guix would look up source code by hash in the caches of our
build farms. This comes for free: the <a href="https://www.gnu.org/software/guix/manual/en/html_node/Substitutes.html">“substitute”
mechanism</a>
extends to all “build artifacts”, including downloads. However, with
limited capacity, our build farms do not keep all the source code of all
the packages for a long time. Thus, one could very well find oneself
unable to rebuild a package months or years later, simply because its
source code disappeared or moved to a different location.</p><h1>Connecting to the archive</h1><p>It quickly became clear that reproducible builds had “reproducible
source code downloads”, so to speak, as a prerequisite. The Software
Heritage archive is the missing piece that would finally allow us to
reproduce software environments years later in spite of the volatility
of code hosting sites. Software Heritage’s mission is to archive
essentially “all” the source code ever published, including version
control history. Its archive already periodically ingests release
tarballs from the GNU servers, repositories from GitHub, packages from
PyPI, and much more.</p><p><img alt="Software Heritage logo" src="https://www.gnu.org/software/guix/static/blog/img/software-heritage-logo-title.svg" /></p><p>We quickly settled on a scheme where Guix would fall back to the
Software Heritage archive whenever it fails to download source code from
its original location. That way, package definitions don’t need to be
modified: they still refer to the original source code URL, but the
downloading machinery transparently goes to Software Heritage when
needed.</p><p>There are two types of source code downloads in Guix: tarball downloads,
and version control checkouts. In the former case, resorting to
Software Heritage is easy: Guix knows the SHA256 hash of the tarball so
it can look it up by hash using <a href="https://archive.softwareheritage.org/api/1/content/raw/">the <code>/content</code> endpoint of the
archive’s
interface</a>.</p><p>Fetching version control checkouts is more involved. In this case, the
downloader would first resolve the commit identifier to obtain a
<a href="https://archive.softwareheritage.org/api/1/revision/">Software Heritage
revision</a>. The
actual code for that revision is then fetched through the
<a href="https://docs.softwareheritage.org/devel/swh-vault/api.html"><em>vault</em></a>.</p><p>The vault conveniently allows users to fetch the tarball corresponding
to a revision. However, not all revisions are readily available as
tarballs (understandably), so the vault has an interface that allows you
to request the “<em>cooking</em>” of a specific revision. Cooking is
asynchronous and can take some time. Currently, if a revision hasn’t
been cooked yet, the Guix download machinery will request it and wait
until it is available. The process can take some time but will
eventually succeed.</p><p>Success! At this point, we have essentially bridged the gap between the
stable archive that Software Heritage provides and the reproducible
software deployment pipeline of Guix. This code <a href="https://issues.guix.info/issue/33432">was
integrated</a> in November 2018,
making it the first free software distribution backed by a stable
archive.</p><h1>The challenges ahead</h1><p>This milestone was encouraging: we had seemingly achieved our goal, but
we also knew of several shortcomings. First, even though the software
we package is still primarily distributed as tarballs, Software Heritage
keeps relatively few of these tarballs. Software Heritage does ingest
tarballs, notably those found on <a href="https://ftp.gnu.org/gnu/">the GNU
servers</a>, but the primary focus is on
preserving complete version control repositories rather than release
tarballs.</p><p>It is not yet clear to us what to do with plain old tarballs. On one
hand, they are here and cannot be ignored. Furthermore, some provide
artifacts that are not in version control, such as <code>configure</code> scripts,
and often enough they are accompanied by a cryptographic signature from
the developers that allows recipients to <em>authenticate</em> the code—an
important piece of information that’s often missing from version control
history. On the other hand, version control tags are increasingly
becoming the mechanism of choice to distribute software releases. It
may be that tags will become the primary mechanism for software release
distribution soon enough.</p><p>Version control tags turn out not to be ideal either, because they’re
mutable and per-repository. Conversely, Git commit identifiers are
unambiguous and repository-independent because they’re essentially
content-addressed, but our package definitions often refer to tags, not
commits, because that makes it clearer that we’re providing an actual
release and not an arbitrary revision (this is another illustration of
<a href="https://en.wikipedia.org/wiki/Zooko's_triangle">Zooko’s triangle</a>).</p><p>This leads to another limitation that stems from the mismatch between
the way Guix and Software Heritage compute hashes over version control
checkouts: both compute a hash over a serialized representation of the
directory, but they serialize the directory in a different way (SWH
serializes directories as Git trees, while Guix uses “normalized
archives” or Nars, the format the build daemon manipulates, which is
inherited from Nix.) That prevents Guix from looking up revisions by
content hash. The solution will probably involve changing Guix to
support the same method as Software Heritage, and/or adding Guix’s method
to Software Heritage.</p><p>Having to wait for “cooking” completion can also be problematic. The
Software Heritage team is investigating the possibility to
<a href="https://forge.softwareheritage.org/T1350">automatically cook all version control
tags</a>. That way, relevant
revisions would almost always be readily available through the vault.</p><p>Similarly, we have no guarantee that software provided by Guix is
available in the archive. Our plan is to <a href="https://forge.softwareheritage.org/T1352">extend Software
Heritage</a> such that it would
periodically archive the source code of software packaged by Guix.</p><h1>Going further</h1><p>In the process of adding support for Software Heritage, Guix <a href="https://issues.guix.info/issue/33432">gained
Guile bindings to the Software Heritage HTTP
interface</a>. Here’s a couple of
things we can do:</p><pre><code class="language-scheme">(use-modules (guix swh))
;; Check whether SWH has ever crawled our repository.
(define o (lookup-origin "https://git.savannah.gnu.org/git/guix.git"))
⇒ #&lt;&lt;origin&gt; id: 86312956 …&gt;
;; It did! When was its last visit?
(define last-visit
(first (origin-visits o)))
(date-&gt;string (visit-date last-visit))
⇒ "Fri Mar 29 10:07:45Z 2019"
;; Does it have our “v0.15.0” Git tag?
(lookup-origin-revision "https://git.savannah.gnu.org/git/guix.git" "v0.15.0")
⇒ #&lt;&lt;revision&gt; id: "359fdda40f754bbf1b5dc261e7427b75463b59be" …&gt;</code></pre><p>Guix itself is a Guile library so when we combine the two, there are
interesting things we can do:</p><pre><code class="language-scheme">(use-modules (guix) (guix swh)
(gnu packages base)
(gnu packages golang))
;; This is our GNU Coreutils package.
coreutils
⇒ #&lt;package [email protected] gnu/packages/base.scm:342 1c67b40&gt;
;; Does SWH have its tarball?
(lookup-content (origin-sha256 (package-source coreutils))
"sha256")
⇒ #&lt;&lt;content&gt; checksums: (("sha1" …)) data-url: …&gt;
;; Our package for HashiCorp’s Configuration Language (HCL) is
;; built from a Git commit.
(define commit
(git-reference-commit
(origin-uri (package-source go-github-com-hashicorp-hcl))))
;; Is this particular commit available in the archive?
(lookup-revision commit)
⇒ #&lt;&lt;revision&gt; id: "23c074d0eceb2b8a5bfdbb271ab780cde70f05a8" …&gt;</code></pre><p>We’re currently using a subset of this interface, but there’s certainly
more we could do. For example, we can compute archive coverage of the
Guix packages; we can also request the archival of each package’s source
code <em>via</em> the <a href="https://archive.softwareheritage.org/api/1/origin/save/">“save code”
interface</a>—though
all this is subject to <a href="https://archive.softwareheritage.org/api/#rate-limiting">rate
limiting</a>.</p><h1>Wrap-up</h1><p>Software Heritage support in Guix creates a bridge from the stable
source code archive to reproducible software deployment with complete
provenance tracking. For the first time it gives us a software package
distribution that can be rebuilt months or years later. This is
particularly beneficial in the context of reproducible science: finally
we can describe reproducible software environments, a prerequisite for
reproducible computational experiments.</p><p>Going further, we can provide a complete software supply tool chain with
provenance tracking that links revisions in the archive to
bit-reproducible build artifacts produced by Guix. Oh and Guix itself
<a href="https://archive.softwareheritage.org/api/1/origin/git/url/https://git.savannah.gnu.org/git/guix.git/">is
archived</a>,
so we have this meta-level where we could link Guix revisions to the
revisions of packages it provides… There are still technical challenges
to overcome, but that vision is shaping up.</p><h4>About GNU Guix</h4><p><a href="https://www.gnu.org/software/guix">GNU Guix</a> is a transactional package
manager and an advanced distribution of the GNU system that <a href="https://www.gnu.org/distros/free-system-distribution-guidelines.html">respects
user
freedom</a>.
Guix can be used on top of any system running the kernel Linux, or it
can be used as a standalone operating system distribution for i686,
x86_64, ARMv7, and AArch64 machines.</p><p>In addition to standard package management features, Guix supports
transactional upgrades and roll-backs, unprivileged package management,
per-user profiles, and garbage collection. When used as a standalone
GNU/Linux distribution, Guix offers a declarative, stateless approach to
operating system configuration management. Guix is highly customizable
and hackable through <a href="https://www.gnu.org/software/guile">Guile</a>
programming interfaces and extensions to the
<a href="http://schemers.org">Scheme</a> language.</p></content:encoded>
<dc:date>2019-03-29T14:50:00+00:00</dc:date>
<dc:creator>Ludovic Courtès</dc:creator>
</item>
<item rdf:about="http://savannah.gnu.org/forum/forum.php?forum_id=9405">
<title>osip @ Savannah: osip2 [5.1.0] & exosip2 [5.1.0]</title>
<link>http://savannah.gnu.org/forum/forum.php?forum_id=9405</link>
<content:encoded><p>I have released today newer versions for both osip2 &amp; exosip2.
<br />
</p>
<p>osip is very mature. There was only one tiny feature change to allow more flexible NAPTR request (such as ENUM). A very few bugs were discovered and fixed.
<br />
</p>
<p>eXosip is also mature. However a few bugs around PRACK and retransmissions were reported and fixed. openssl support has also been updated to support more features, be more flexible and support all openssl versions. ENUM support has been introduced this year. See the ChangeLog for more!
<br />
</p>
<p>In all case, upgrading is <strong>strongly</strong> recommanded. API changes are documented in the ChangeLog: there is not much!<br />
</p></content:encoded>
<dc:date>2019-03-28T19:50:43+00:00</dc:date>
<dc:creator>Aymeric MOIZARD</dc:creator>
</item>
<item rdf:about="http://savannah.gnu.org/forum/forum.php?forum_id=9404">
<title>nano @ Savannah: GNU nano 4.0 was released</title>
<link>http://savannah.gnu.org/forum/forum.php?forum_id=9404</link>
<content:encoded><p>This version breaks with the close compatibility with Pico: nano no longer hard-wraps the current line by default when it becomes overlong, and uses smooth scrolling by default, plus two other minor changes. Further, in 3.0 indenting and unindenting became undoable, and now, with 4.0, also justifications have become undoable (to any depth), making that all of the user's actions are now undoable and redoable (with the M-U and M-E keystrokes).<br />
</p></content:encoded>
<dc:date>2019-03-27T18:36:29+00:00</dc:date>
<dc:creator>Benno Schulenberg</dc:creator>
</item>
<item rdf:about="http://www.fsf.org/news/fsf-job-opportunity-campaigns-manager-1">
<title>FSF News: FSF job opportunity: campaigns manager</title>
<link>http://www.fsf.org/news/fsf-job-opportunity-campaigns-manager-1</link>
<content:encoded><p>The Free Software Foundation (FSF), a Massachusetts 501(c)(3) charity with a worldwide mission to protect computer user freedom, seeks a motivated and talented Boston-based individual to be our full-time campaigns manager.</p>
<p>Reporting to the executive director, the campaigns manager works on our campaigns team to lead, plan, carry out, evaluate, and improve the FSF's advocacy and education campaigns. The team also works closely with other FSF departments, including licensing, operations, and tech. The position will start by taking responsibility for existing campaigns in support of the GNU Project, free software adoption, free media formats, and freedom on the network; and against Digital Restrictions Management (DRM), software patents, and proprietary software.</p>
<p>Examples of job responsibilities include, but are not limited to:</p>
<ul>
<li>Planning and participating in online and physical actions to
achieve our campaign goals;<br />
</li>
<li>Setting specific goals for each action and then measuring our
success in achieving them;<br />
</li>
<li>Doing the writing and messaging work needed to effectively explain
our campaigns and motivate people to support them;<br />
</li>
<li>Overseeing or doing the graphic design work to make our campaigns
and their Web sites attractive;<br />
</li>
<li>Supporting and attending special events, including
community-building activities and our annual LibrePlanet conference;<br />
</li>
<li>Assisting with annual online and mail fundraising efforts;<br />
</li>
<li>Working with our tech team on the technology choices and
deployments -- especially of Web publication systems like Drupal
and Plone -- for our campaign sites; and</li>
<li>Being an approachable, humble, and friendly representative of the
FSF to our worldwide community of existing supporters and the
broader public, both in person and online.<br />
</li>
</ul>
<p>Ideal candidates have at least three to five years of work experience in online issue advocacy and free software; proficiency and comfort with professional writing and publications preferred. Because the FSF works globally and seeks to have our materials distributed in as many languages as possible, multilingual candidates will have an advantage. With our small staff of fourteen, each person makes a clear contribution. We work hard, but offer a humane and fun work environment at an office located in the heart of downtown Boston. The FSF is a mature but growing organization that provides great potential for advancement; existing staff get the first chance at any new job openings.</p>
<h2>Benefits and salary</h2>
<p>This job is a union position that must be worked on-site at the FSF's downtown Boston office. The salary is fixed at $63,253/year and is non-negotiable. Other benefits include:</p>
<ul>
<li>Full individual or family health coverage through Blue Cross/Blue Shield's HMO Blue program;<br />
</li>
<li>Subsidized dental plan;<br />
</li>
<li>Four weeks of paid vacation annually;<br />
</li>
<li>Seventeen paid holidays annually;<br />
</li>
<li>Weekly remote work allowance;<br />
</li>
<li>Public transit commuting cost reimbursement;<br />
</li>
<li>403(b) program through TIAA with employer match;<br />
</li>
<li>Yearly cost-of-living pay increases (based on government guidelines);<br />
</li>
<li>Healthcare expense reimbursement budget;<br />
</li>
<li>Ergonomic budget;<br />
</li>
<li>Relocation (to Boston area) expense reimbursement;<br />
</li>
<li>Conference travel and professional development opportunities; and</li>
<li>Potential for an annual performance bonus.</li>
</ul>
<h2>Application instructions</h2>
<p>Applications must be submitted via email to <a href="mailto:[email protected]">[email protected]</a>. The email must contain the subject line "Campaigns manager". A complete application should include:</p>
<ul>
<li>Cover letter, including a brief example of a time you motivated and organized others to take action on an issue important to you;<br />
</li>
<li>Resume;<br />
</li>
<li>Two recent writing samples;<br />
</li>
<li>Links to any talks you have given (optional); and<br />
</li>
<li>Graphic design samples (optional).</li>
</ul>
<p>All materials must be in a free format (such as plain text, PDF, or OpenDocument). Email submissions that do not follow these instructions will probably be overlooked. No phone calls, please.</p>
<p><strong>Applications will be reviewed on a rolling basis until the position is filled. To guarantee consideration, submit your application by Sunday, April 28th.</strong><br />
</p>
<p>The FSF is an equal opportunity employer and will not discriminate against any employee or application for employment on the basis of race, color, marital status, religion, age, sex, sexual orientation, national origin, handicap, or any other legally protected status recognized by federal, state or local law. We value diversity in our workplace. </p>
<h3>About the Free Software Foundation</h3>
<p>The Free Software Foundation, founded in 1985, is dedicated to promoting computer users' right to use, study, copy, modify, and redistribute computer programs. The FSF promotes the development and use of free (as in freedom) software -- particularly the GNU operating system and its GNU/Linux variants -- and free documentation for free software. The FSF also helps to spread awareness of the ethical and political issues of freedom in the use of software, and its Web sites, located at fsf.org and gnu.org, are an important source of information about GNU/Linux. Donations to support the FSF's work can be made at <a href="https://donate.fsf.org">https://donate.fsf.org</a>. We are based in Boston, MA, USA.</p></content:encoded>
<dc:date>2019-03-25T20:15:00+00:00</dc:date>
<dc:creator>FSF News</dc:creator>
</item>
<item rdf:about="http://www.fsf.org/news/openstreetmap-and-deborah-nicholson-win-2018-fsf-awards">
<title>FSF News: OpenStreetMap and Deborah Nicholson win 2018 FSF Awards</title>
<link>http://www.fsf.org/news/openstreetmap-and-deborah-nicholson-win-2018-fsf-awards</link>
<content:encoded><p><em>BOSTON, Massachusetts, USA -- Saturday, March 23, 2019 -- The Free
Software Foundation (FSF) recognizes <a href="https://www.openstreetmap.org/">OpenStreetMap</a> with the 2018
Free Software Award for Projects of Social Benefit and Deborah
Nicholson with the Award for the Advancement of Free Software. FSF
president Richard M. Stallman presented the awards today in a yearly
ceremony during the LibrePlanet 2019 conference at the Massachusetts
Institute of Technology (MIT).</em></p>
<p>The <a href="https://www.fsf.org/awards/sb-award/">Award for Projects of Social Benefit</a> is presented to a
project or team responsible for applying free software, or the ideas
of the free software movement, to intentionally and significantly
benefit society. This award stresses the use of free software in
service to humanity.</p>
<p><img alt="Richard Stallman with Free Software Awards winners Deborah Nicholson and Kate Chapman" src="https://static.fsf.org/nosvn/libreplanet/2019/photos/free-software-awards/both.jpg" style="float: right; width: 250px; margin: 10px 0px 10px 10px;" /> </p>
<p>This year the FSF awarded OpenStreetMap and the award was accepted by
Kate Chapman, chairperson of the OpenStreetMap Foundation and
co-founder of the Humanitarian OpenStreetMap Team (HOT).</p>
<p>OpenStreetMap is a collaborative project to create a free editable map
of the world. Founded by Steve Coast in the UK in 2004, OpenStreetMap
is built by a community of over one million community members and has
found its application on thousands of Web sites, mobile apps, and
hardware devices. OpenStreetMap is the only truly global service
without restrictions on use or availability of map information.</p>
<p>Stallman emphasized the importance of OpenStreetMap in a time where
geotech and geo-thinking are highly prevalent. "It has been clear for
decades that map data are important. Therefore we need a free
collection of map data. The name OpenStreetMap doesn't say so
explicitly, but its map data is free. It is the free replacement that
the Free World needs."</p>
<p>Kate thanked the Free Software Foundation and the large community of
contributors of OpenStreetMap. "In 2004, much of the geospatial data
was either extraordinarily expensive or unavailable. Our strong
community of people committed to free and open map information has
changed that. Without the leadership before us from groups such as the
Free Software Foundation, we would not have been able to grow and
develop to the resource we are today."</p>
<p>The <a href="https://www.fsf.org/awards/fs-award">Award for the Advancement of Free Software</a> goes to an
individual who has made a great contribution to the progress and
development of free software through activities that accord with the
spirit of free software.</p>
<p><img alt="Richard Stallman presenting Free Software Award to Deborah Nicholson" src="https://static.fsf.org/nosvn/libreplanet/2019/photos/free-software-awards/deb.jpg" style="float: right; width: 250px; margin: 10px 0px 10px 10px;" /> </p>
<p>This year it was presented to Deborah Nicholson, who, motivated by the
intersection of technology and social justice, advocates access to
political information, unfettered freedom of speech and assembly, and
civil liberties in our increasingly digital world. She joined the free
software movement in 2006 after years of local organizing for free
speech, marriage equality, government transparency and access to the
political process. The Free Software Foundation recognizes her as an
exceptional opinion leader, activist and community advocate.</p>
<p>Deborah is the director of community operations at the <a href="https://sfconservancy.org">Software
Freedom Conservancy</a>, where she supports the work of its member
organizations and facilitates collaboration with the wider free
software community. She has served as the membership coordinator for
the <a href="https://www.fsf.org">Free Software Foundation</a>, where she created the Women's
Caucus to increase recruitment and retention of women in the free
software community. She has been widely recognized for her volunteer
work with <a href="https://mediagoblin.org/">GNU MediaGoblin</a>, a federated media-publishing platform,
and <a href="https://blog.openhatch.org/2017/celebrating-our-successes-and-winding-down-as-an-organization/">OpenHatch</a>, free software's welcoming committee. She continues
her work as a founding organizer of the <a href="http://seagl.org/">Seattle GNU/Linux
Conference</a>, an annual event dedicated to surfacing new voices and
welcoming new people to the free software community.</p>
<p>Stallman praised her body of work and her unremitting and widespread
contributions to the free software community. "Deborah continuously
reaches out to, and engages, new audiences with her message on the
need for free software in any version of the future."</p>
<p>Deborah continued: "Free software is critically important for
autonomy, privacy and a healthy democracy -- but it can't achieve that
if it is only accessible for some, or if it is alienating for large
swathes of people. That's why it's so important that we continue
surfacing new voices, making room for non-coders and welcoming new
contributors into the free software community. I also find that in
addition to helping us build a better, bigger movement, the work of
welcoming is extremely rewarding."</p>
<p>Nominations for both awards are submitted by members of the public,
then evaluated by an award committee composed of previous winners and
FSF founder and president Richard Stallman.</p>
<p>More information about both awards, including the full list of
previous winners, can be found at <a href="https://www.fsf.org/awards">https://www.fsf.org/awards</a>.</p>
<h1><em>About the Free Software Foundation</em></h1>
<p>The Free Software Foundation, founded in 1985, is dedicated to
promoting computer users' right to use, study, copy, modify, and
redistribute computer programs. The FSF promotes the development and
use of free (as in freedom) software -- particularly the GNU operating
system and its GNU/Linux variants -- and free documentation for free
software. The FSF also helps to spread awareness of the ethical and
political issues of freedom in the use of software, and its Web sites,
located at <a href="https://fsf.org">https://fsf.org</a> and <a href="https://gnu.org">https://gnu.org</a>, are an important
source of information about GNU/Linux. Donations to support the FSF's
work can be made at <a href="https://my.fsf.org/donate">https://my.fsf.org/donate</a>. Its headquarters are
in Boston, MA, USA.</p>
<p>More information about the FSF, as well as important information for
journalists and publishers, is at <a href="https://www.fsf.org/press">https://www.fsf.org/press</a>.</p>
<h1><em>Media Contacts</em></h1>
<p>John Sullivan <br />
Executive Director <br />
Free Software Foundation <br />
+1 (617) 542 5942 <br />
<a href="mailto:[email protected]">[email protected]</a></p>
<p><em>Photo credits: Copyright Š 2019 Madi Muhlberg, photos licensed under CC-BY 4.0.</em></p></content:encoded>
<dc:date>2019-03-23T23:30:00+00:00</dc:date>
<dc:creator>FSF News</dc:creator>
</item>
<item rdf:about="http://www.fsf.org/news/openstreetmap-and-deborah-nicholson-win-2019-fsf-awards">
<title>FSF News: OpenStreetMap and Deborah Nicholson win 2019 FSF Awards</title>
<link>http://www.fsf.org/news/openstreetmap-and-deborah-nicholson-win-2019-fsf-awards</link>
<content:encoded><p><em>BOSTON, Massachusetts, USA -- Saturday, March 23, 2019-- The Free
Software Foundation (FSF) recognizes <a href="https://www.openstreetmap.org/">OpenStreetMap</a> with the 2018
Free Software Award for Projects of Social Benefit and Deborah
Nicholson with the Award for the Advancement of Free Software. FSF
president Richard M. Stallman presented the awards today in a yearly
ceremony during the LibrePlanet 2019 conference at the Massachusetts
Institute of Technology (MIT).</em></p>
<p>The <a href="https://www.fsf.org/awards/sb-award/">Award for Projects of Social Benefit</a> is presented to a
project or team responsible for applying free software, or the ideas
of the free software movement, to intentionally and significantly
benefit society. This award stresses the use of free software in
service to humanity.</p>
<p><img alt="Richard Stallman with Free Software Awards winners Deborah Nicholson and Kate Chapman" src="https://static.fsf.org/nosvn/libreplanet/2019/photos/free-software-awards/both.jpg" style="float: right; width: 250px; margin: 10px 0px 10px 10px;" /> </p>
<p>This year the FSF awarded OpenStreetMap and the award was accepted by
Kate Chapman, chairperson of the OpenStreetMap Foundation and
co-founder of the Humanitarian OpenStreetMap Team (HOT).</p>
<p>OpenStreetMap is a collaborative project to create a free editable map
of the world. Founded by Steve Coast in the UK in 2004, OpenStreetMap
is built by a community of over one million community members and has
found its application on thousands of Web sites, mobile apps, and
hardware devices. OpenStreetMap is the only truly global service
without restrictions on use or availability of map information.</p>
<p>Stallman emphasized the importance of OpenStreetMap in a time where
geotech and geo-thinking are highly prevalent. "It has been clear for
decades that map data are important. Therefore we need a free
collection of map data. The name OpenStreetMap doesn't say so
explicitly, but its map data is free. It is the free replacement that
the Free World needs."</p>
<p>Kate thanked the Free Software Foundation and the large community of
contributors of OpenStreetMap. "In 2004, much of the geospatial data
was either extraordinarily expensive or unavailable. Our strong
community of people committed to free and open map information has
changed that. Without the leadership before us from groups such as the
Free Software Foundation, we would not have been able to grow and
develop to the resource we are today."</p>
<p>The <a href="https://www.fsf.org/awards/fs-award">Award for the Advancement of Free Software</a> goes to an
individual who has made a great contribution to the progress and
development of free software through activities that accord with the
spirit of free software.</p>
<p><img alt="Richard Stallman presenting Free Software Award to Deborah Nicholson" src="https://static.fsf.org/nosvn/libreplanet/2019/photos/free-software-awards/deb.jpg" style="float: right; width: 250px; margin: 10px 0px 10px 10px;" /> </p>
<p>This year it was presented to Deborah Nicholson, who, motivated by the
intersection of technology and social justice, advocates access to
political information, unfettered freedom of speech and assembly, and
civil liberties in our increasingly digital world. She joined the free
software movement in 2006 after years of local organizing of free
speech, marriage equality, government transparency and access to the
political process. The Free Software Foundation recognizes her as an
exceptional opinion leader, activist and community advocate.</p>
<p>Deborah is the director of community operations at the <a href="https://sfconservancy.org">Software
Freedom Conservancy</a>, where she supports the work of its member
organizations and facilitates collaboration with the wider free
software community. She has served as the membership coordinator for
the <a href="https://www.fsf.org">Free Software Foundation</a>, where she created the Women's
Caucus to increase recruitment and retention of women in the free
software community. She has been widely recognized for her volunteer
work with <a href="https://mediagoblin.org/">GNU MediaGoblin</a>, a federated media-publishing platform,
and <a href="https://blog.openhatch.org/2017/celebrating-our-successes-and-winding-down-as-an-organization/">OpenHatch</a>, free software's welcoming committee. She continues
her work as a founding organizer of the <a href="http://seagl.org/">Seattle GNU/Linux
Conference</a>, an annual event dedicated to surfacing new voices and
welcoming new people to the free software community.</p>
<p>Stallman praised her body of work and her unremitting and widespread
contributions to the free software community. "Deborah continuously
reaches out to, and engages, new audiences with her message on the
need for free software in any version of the future."</p>
<p>Deborah continued: "Free software is critically important for
autonomy, privacy and a healthy democracy -- but it can't achieve that
if it is only accessible for some, or if it is alienating for large
swathes of people. That's why it's so important that we continue
surfacing new voices, making room for non-coders and welcoming new
contributors into the free software community. I also find that in
addition to helping us build a better, bigger movement, the work of
welcoming is extremely rewarding."</p>
<p>Nominations for both awards are submitted by members of the public,
then evaluated by an award committee composed of previous winners and
FSF founder and president Richard Stallman.</p>
<p>More information about both awards, including the full list of
previous winners, can be found at <a href="https://www.fsf.org/awards">https://www.fsf.org/awards</a>.</p>
<h1><em>About the Free Software Foundation</em></h1>
<p>The Free Software Foundation, founded in 1985, is dedicated to
promoting computer users' right to use, study, copy, modify, and
redistribute computer programs. The FSF promotes the development and
use of free (as in freedom) software -- particularly the GNU operating
system and its GNU/Linux variants -- and free documentation for free
software. The FSF also helps to spread awareness of the ethical and
political issues of freedom in the use of software, and its Web sites,
located at <a href="https://fsf.org">https://fsf.org</a> and <a href="https://gnu.org">https://gnu.org</a>, are an important
source of information about GNU/Linux. Donations to support the FSF's
work can be made at <a href="https://my.fsf.org/donate">https://my.fsf.org/donate</a>. Its headquarters are
in Boston, MA, USA.</p>
<p>More information about the FSF, as well as important information for
journalists and publishers, is at <a href="https://www.fsf.org/press">https://www.fsf.org/press</a>.</p>
<h1><em>Media Contacts</em></h1>
<p>John Sullivan <br />
Executive Director <br />
Free Software Foundation <br />
+1 (617) 542 5942 <br />
<a href="mailto:[email protected]">[email protected]</a></p>
<p><em>Photo credits: Copyright Š 2019 Madi Muhlberg, photos licensed under CC-BY 4.0.</em></p></content:encoded>
<dc:date>2019-03-23T22:59:48+00:00</dc:date>
<dc:creator>FSF News</dc:creator>
</item>
</rdf:RDF>
| 323,392 | Common Lisp | .l | 3,916 | 79.823544 | 8,376 | 0.744333 | JadedCtrl/rsss | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:31 AM (Europe/Amsterdam) | 9ac763e8b0e74dba0c024a5190646af75d4a5e842deb60770bb926677e9c3441 | 38,883 | [
-1
] |
38,884 | atom.xml | JadedCtrl_rsss/t/atom.xml | <?xml version="1.0" encoding="utf-8" standalone="yes" ?>
<feed xmlns="http://www.w3.org/2005/Atom">
<title>Planet GNU</title>
<link rel="self" href="https://planet.gnu.org/atom.xml"/>
<link href="https://planet.gnu.org/"/>
<id>https://planet.gnu.org/atom.xml</id>
<updated>2019-07-09T17:55:32+00:00</updated>
<generator uri="http://intertwingly.net/code/venus/">http://intertwingly.net/code/venus/</generator>
<entry xml:lang="en">
<title type="html" xml:lang="en">June 2019: Photos from Brno</title>
<link href="http://www.fsf.org/blogs/rms/photo-blog-2019-june-brno"/>
<id>http://www.fsf.org/blogs/rms/photo-blog-2019-june-brno</id>
<updated>2019-07-09T15:39:21+00:00</updated>
<summary type="html" xml:lang="en"></summary>
<content type="html" xml:lang="en"><div style="border-style: solid; border-width: 2px; text-align: left; margin: 4px 50px 4px 50px; padding-top: 4px; padding-left: 5px; padding-right: 5px;">
<p>Free Software Foundation president Richard Stallman (RMS) was in
<strong>Brno, Czech Republic</strong> on June 6, 2019, to give two speeches.</p>
<p>In the morning, he took part in the <a href="https://www.smartcityfair.cz/en/">URBIS Smart City Fair</a>, at the Brno Fair Grounds, giving his speech
"Computing, freedom, and privacy."<sup style="font-size: 8px;"><a href="https://static.fsf.org/fsforg/rss/blogs.xml#fn1" id="ref1">1</a></sup></p>
<p style="text-align: center;">
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-fair-grounds/20190606-brno-c-2019-veletrhy-brno-a-s-cc-by-4-0-1-thumb.jpg" style="margin-top: 4px;" width="265" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-fair-grounds/20190606-brno-c-2019-veletrhy-brno-a-s-cc-by-4-0-2-thumb.jpg" style="margin-top: 4px;" width="265" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-fair-grounds/20190606-brno-c-2019-veletrhy-brno-a-s-cc-by-4-0-3-thumb.jpg" style="margin-top: 4px;" width="530" />
</p>
<p style="padding: 0px 20px 0px 20px; margin-top: 1px; text-align: center;">
<em>(Copyright © 2019 Veletrhy Brno, a. s. Photos licensed under <a href="http://creativecommons.org/licenses/by/4.0/">CC BY 4.0</a>.)</em>
<br style="margin-bottom: 15px;" />
</p><p>In the afternoon, at the University Cinema Scala, he gave his
speech "The free software movement and the GNU/Linux operating
system," to about three hundred people.
</p><p style="text-align: center;">
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-jan-prokopius-cc-by-4-0-1-thumb.jpg" style="margin-top: 4px;" width="530" />
</p><p style="padding: 0px 20px 0px 20px; margin-top: 1px; text-align: center;">
<em>(Copyright © 2019 Pavel Loutocký. Photos licensed under <a href="http://creativecommons.org/licenses/by/4.0/">CC BY 4.0</a>.)</em>
<br style="margin-bottom: 15px;" />
</p><p style="text-align: center;">
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-047-thumb.jpg" style="margin-top: 4px;" width="176" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-050-thumb.jpg" style="margin-top: 4px;" width="176" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-051-thumb.jpg" style="margin-top: 4px;" width="176" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-052-thumb.jpg" style="margin-top: 4px;" width="265" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-053-thumb.jpg" style="margin-top: 4px;" width="265" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-054-thumb.jpg" style="margin-top: 4px;" width="176" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-055-thumb.jpg" style="margin-top: 4px;" width="176" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-056-thumb.jpg" style="margin-top: 4px;" width="176" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-057-thumb.jpg" style="margin-top: 4px;" width="176" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-058-thumb.jpg" style="margin-top: 4px;" width="176" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-064-thumb.jpg" style="margin-top: 4px;" width="176" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-063-thumb.jpg" style="margin-top: 4px;" width="530" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-066-thumb.jpg" style="margin-top: 4px;" width="176" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-069-thumb.jpg" style="margin-top: 4px;" width="176" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-070-thumb.jpg" style="margin-top: 4px;" width="176" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-071-thumb.jpg" style="margin-top: 4px;" width="176" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-073-thumb.jpg" style="margin-top: 4px;" width="176" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-074-thumb.jpg" style="margin-top: 4px;" width="176" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-068-thumb.jpg" style="margin-top: 4px;" width="265" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-072-thumb.jpg" style="margin-top: 4px;" width="265" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-075-thumb.jpg" style="margin-top: 4px;" width="530" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-076-thumb.jpg" style="margin-top: 4px;" width="530" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-078-thumb.jpg" style="margin-top: 4px;" width="530" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-079-thumb.jpg" style="margin-top: 4px;" width="132" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-080-thumb.jpg" style="margin-top: 4px;" width="133" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-081-thumb.jpg" style="margin-top: 4px;" width="133" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-082-thumb.jpg" style="margin-top: 4px;" width="132" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-083-thumb.jpg" style="margin-top: 4px;" width="132" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-084-thumb.jpg" style="margin-top: 4px;" width="133" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-085-thumb.jpg" style="margin-top: 4px;" width="133" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-086-thumb.jpg" style="margin-top: 4px;" width="132" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-087-thumb.jpg" style="margin-top: 4px;" width="132" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-088-thumb.jpg" style="margin-top: 4px;" width="133" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-090-thumb.jpg" style="margin-top: 4px;" width="133" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-091-thumb.jpg" style="margin-top: 4px;" width="132" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-092-thumb.jpg" style="margin-top: 4px;" width="132" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-093-thumb.jpg" style="margin-top: 4px;" width="133" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-094-thumb.jpg" style="margin-top: 4px;" width="133" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-095-thumb.jpg" style="margin-top: 4px;" width="132" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-114-thumb.jpg" style="margin-top: 4px;" width="176" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-115-thumb.jpg" style="margin-top: 4px;" width="176" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-116-thumb.jpg" style="margin-top: 4px;" width="176" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-117-thumb.jpg" style="margin-top: 4px;" width="265" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-120-thumb.jpg" style="margin-top: 4px;" width="265" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-121-thumb.jpg" style="margin-top: 4px;" width="530" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-124-thumb.jpg" style="margin-top: 4px;" width="176" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-126-thumb.jpg" style="margin-top: 4px;" width="176" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-128-thumb.jpg" style="margin-top: 4px;" width="176" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-132-thumb.jpg" style="margin-top: 4px;" width="530" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-131-thumb.jpg" style="margin-top: 4px;" width="176" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-133-thumb.jpg" style="margin-top: 4px;" width="176" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-134-thumb.jpg" style="margin-top: 4px;" width="176" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-135-thumb.jpg" style="margin-top: 4px;" width="176" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-136-thumb.jpg" style="margin-top: 4px;" width="176" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-140-thumb.jpg" style="margin-top: 4px;" width="176" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-137-thumb.jpg" style="margin-top: 4px;" width="530" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-141-thumb.jpg" style="margin-top: 4px;" width="530" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-143-thumb.jpg" style="margin-top: 4px;" width="176" /><img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-145-thumb.jpg" style="margin-top: 4px;" width="176" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-146-thumb.jpg" style="margin-top: 4px;" width="176" />
<img alt="" src="https://static.fsf.org/static/nosvn/rms-photos/20190606-brno-scala/20190606-brno-c-2019-pavel-loutocky-cc-by-4-0-144-thumb.jpg" style="margin-top: 4px;" width="530" />
</p>
<p style="padding: 0px 20px 0px 20px; margin-top: 1px; text-align: center;">
<em>(Copyright © 2019 Pavel Loutocký. Photos licensed under <a href="http://creativecommons.org/licenses/by/4.0/">CC BY 4.0</a>.)</em>
<br style="margin-bottom: 15px;" />
</p><p style="text-align: center;"><strong>Thank you to everyone who made this visit possible!</strong></p>
<p style="text-align: center;">If you're in the area, please fill out our contact form, so
that we can inform you about future events in and around <a href="https://my.fsf.org/civicrm/profile/create?gid=578&amp;reset=1">Brno</a>.
</p>
<p style="text-align: center;">Please see <a href="http://www.fsf.org/events">www.fsf.org/events</a> for a full
list of all of RMS's confirmed engagements, <br /> and contact <a href="mailto:[email protected]">[email protected]</a> if you'd like
him to come speak.</p>
<hr />
<sup id="fn1">1. The recording will soon be posted on <a href="http://audio-video.gnu.org">our audio-video archive</a>.<a href="https://static.fsf.org/fsforg/rss/blogs.xml#ref1" title="Jump back to footnote 1 in the text.">↩</a></sup><br /></div></content>
<author>
<name>FSF Blogs</name>
<uri>http://www.fsf.org/blogs/recent-blog-posts</uri>
</author>
<source>
<title type="html">FSF blogs</title>
<subtitle type="html">Writing by representatives of the Free Software Foundation.</subtitle>
<link rel="self" href="http://static.fsf.org/fsforg/rss/blogs.xml"/>
<id>http://www.fsf.org/blogs/recent-blog-posts</id>
</source>
</entry>
<entry xml:lang="en">
<title type="html" xml:lang="en">Racket is an acceptable Python</title>
<link href="http://dustycloud.org/blog/racket-is-an-acceptable-python/"/>
<id>tag:dustycloud.org,2019-07-09:blog/racket-is-an-acceptable-python/</id>
<updated>2019-07-09T14:27:00+00:00</updated>
<summary type="html" xml:lang="en"></summary>
<content type="html" xml:lang="en"><p>A little over a decade ago, there were some popular blogposts about whether
<a class="reference external" href="http://www.randomhacks.net/2005/12/03/why-ruby-is-an-acceptable-lisp/">Ruby was an acceptable Lisp</a>
or whether even
<a class="reference external" href="https://steve-yegge.blogspot.com/2006/04/lisp-is-not-acceptable-lisp.html">Lisp was an acceptable Lisp</a>.
Peter Norvig was also writing at the time
<a class="reference external" href="https://norvig.com/python-lisp.html">introducing Python to Lisp programmers</a>.
Lisp, those in the know knew, was the right thing to strive for, and yet
seemed unattainable for anything aimed for production since the AI Winter
shattered Lisp's popularity in the 80s/early 90s.
If you can't get Lisp, what's closest thing you can get?</p>
<p>This was around the time I was starting to program; I had spent some
time configuring my editor with Emacs Lisp and loved every moment I
got to do it; I read some Lisp books and longed for more.
And yet when I tried to "get things done" in the language, I just
couldn't make as much headway as I could with my preferred language
for practical projects at the time: Python.</p>
<p>Python was great... mostly.
It was easy to read, it was easy to write, it was easy-ish to teach
to newcomers.
(Python's intro material is better than most, but <a class="reference external" href="https://mlemmer.org/">my spouse</a> has talked before about some major pitfalls
that the Python documentation has which make getting started
unnecessarily hard.
You can
<a class="reference external" href="https://www.youtube.com/watch?v=pv0lLciMI24&amp;t=4220s">hear her talk about that</a>
at this talk we co-presented on at last year's RacketCon.)
I ran a large free software project on a Python codebase, and it was
easy to get new contributors; the barrier to entry to becoming a
programmer with Python was low.
I consider that to be a feature, and it certainly helped me bootstrap
my career.</p>
<p>Most importantly of all though, Python was easy to pick up and run with
because no matter what you wanted to do, either the tools came built
in or the Python ecosystem had enough of the pieces nearby that building
what you wanted was usually fairly trivial.</p>
<p>But Python has its limitations, and I always longed for a lisp.
For a brief time, I thought I could get there by contributing to the
<a class="reference external" href="https://hy.readthedocs.io/en/stable/">Hy project</a>, which was a lisp
that transformed itself into the Python AST.
"Why write Python in a syntax that's easy to read when you could add
a bunch of parentheses to it instead?" I would joke when I talked about
it.
Believe it or not though, I do consider lisps easier to read, once you
are comfortable to understand their syntax.
I certainly find them easier to write and modify.
And I longed for the metaprogramming aspects of Lisp.</p>
<p>Alas, Hy didn't really reach my dream.
That macro expansion made debugging a nightmare as Hy would lose track
of where the line numbers are; it wasn't until that when I really realized
that without line numbers, you're just lost in terms of debugging in
Python-land.
That and Python didn't really have the right primitives; immutable
datastructures for whatever reason never became first class, meaning
that functional programming was hard, "cons" didn't really exist
(actually this doesn't matter as much as people might think), recursive
programming isn't really as possible without tail call elimination, etc
etc etc.</p>
<p>But I missed parentheses.
I longed for parentheses.
I <em>dreamed in</em> parentheses.
I'm not kidding, the only dreams I've ever had in code were in lisp,
and it's happened multiple times, programs unfolding before me.
The structure of lisp makes the flow of code so clear, and there's
simply nothing like the comfort of developing in front of a lisp REPL.</p>
<p>Yet to choose to use a lisp seemed to mean opening myself up to
eternal yak-shaving of developing packages that were already available
on the Python Package Index or limiting my development community an
elite group of Emacs users.
When I was in Python, I longed for the beauty of a Lisp; when I was in
a Lisp, I longed for the ease of Python.</p>
<p>All this changed when I discovered Racket:</p>
<ul class="simple">
<li>Racket comes with a full-featured editor named DrRacket built-in
that's damn nice to use.
It has all the features that make lisp hacking comfortable previously
mostly only to Emacs users: parenthesis balancing, comfortable REPL
integration, etc etc.
But if you want to use Emacs, you can use racket-mode.
Win-win.</li>
<li>Racket has intentionally been built as an educational language, not
unlike Python.
One of the core audiences of Racket is middle schoolers, and it even
comes with a built-in game engine for kids.</li>
<li>My spouse and I even taught classes about how to learn to program for
<a class="reference external" href="https://dustycloud.org/misc/digital-humanities/">humanities academics</a>
using Racket.
We found the age-old belief that "lisp syntax is just too hard" is
simply false; the main thing that most people lack is decent lisp-friendly
tooling with a low barrier to entry, and DrRacket provides that.
The only people who were afraid of the parentheses turned out to be people
who already knew how to program.
Those who didn't even praised the syntax for its clarity and the way
the editor could help show you when you made a syntax error
(DrRacket is very good at that).
"Lisp is too hard to learn" is a lie; if middle schoolers can learn it,
so can more seasoned programmers.</li>
<li>Racket might even be <em>more</em> batteries included than Python.
At least all the batteries that come included are generally nicer;
<a class="reference external" href="https://docs.racket-lang.org/gui/">Racket's GUI library</a> is the only
time I've ever had fun in my life writing GUI programs (and they're cross
platform too).
Constructing pictures with its <a class="reference external" href="https://docs.racket-lang.org/pict/index.html">pict</a>
library is a delight.
Plotting graphs with <a class="reference external" href="https://docs.racket-lang.org/plot/index.html">plot</a>
is an incredible experience.
Writing documentation with
<a class="reference external" href="https://docs.racket-lang.org/scribble/index.html">Scribble</a>
is the best non-org-mode experience I've ever had, but has the
advantage over org-mode in that your document is just inverted code.
I could go on.
And these are just some packages bundled with Racket; the
<a class="reference external" href="https://pkgs.racket-lang.org">Package repository</a> contains much more.</li>
<li>Racket's documentation is, in my experience, unparalleled.
The <a class="reference external" href="https://docs.racket-lang.org/guide/index.html">Racket Guide</a> walks
you through all the key concepts, and the
<a class="reference external" href="https://docs.racket-lang.org/reference/index.html">Racket Reference</a>
has everything else you need.</li>
<li>The tutorials are also wonderful; the
<a class="reference external" href="https://docs.racket-lang.org/quick/index.html">introductory tutorial</a>
gets your feet wet not through composing numbers or strings but by
building up pictures.
Want to learn more?
The next two tutorials show you how to
<a class="reference external" href="https://docs.racket-lang.org/continue/index.html">build web applications</a>
and then
<a class="reference external" href="https://docs.racket-lang.org/more/index.html">build your own web server</a>.</li>
<li>Like Python, even though Racket has its roots in education, it is more than
ready for serious practical use.
These days, when I want to build something and get it done quickly
and efficiently, I reach for Racket first.</li>
</ul>
<p>Racket is a great Lisp, but it's also an acceptable Python.
Sometimes you really can have it all.</p></content>
<author>
<name>Christopher Lemmer Webber</name>
<uri>http://dustycloud.org/</uri>
</author>
<source>
<title type="html">DustyCloud Brainstorms</title>
<link rel="self" href="http://dustycloud.org/blog/index.xml"/>
<id>http://dustycloud.org/</id>
</source>
</entry>
<entry xml:lang="en">
<title type="html" xml:lang="en">DW5821e firmware update integration in ModemManager and fwupd</title>
<link href="https://sigquit.wordpress.com/2019/07/03/dw5821e-firmware-update-integration-in-modemmanager-and-fwupd/"/>
<id>http://sigquit.wordpress.com/?p=1220</id>
<updated>2019-07-03T13:27:10+00:00</updated>
<summary type="html" xml:lang="en"></summary>
<content type="html" xml:lang="en"><p><img alt="" class="aligncenter size-full wp-image-1222" height="522" src="https://sigquit.files.wordpress.com/2019/07/dw5821e-image.png?w=604&amp;h=522" width="604" /></p>
<p>The <strong>Dell Wireless 5821e</strong> module is a <a href="https://www.qualcomm.com/products/snapdragon-modems-4g-lte-x20" rel="noopener" target="_blank">Qualcomm SDX20</a> based LTE Cat16 device. This modem can work in either MBIM mode or QMI mode, and provides different USB layouts for each of the modes. In Linux kernel based and Windows based systems, the MBIM mode is the default one, because it provides easy integration with the OS (e.g. no additional drivers or connection managers required in Windows) and also provides all the features that QMI provides through QMI over MBIM operations.</p>
<p>The firmware update process of this DW5821e module is integrated in your GNU/Linux distribution, since <a href="https://lists.freedesktop.org/archives/modemmanager-devel/2019-January/006983.html" rel="noopener" target="_blank">ModemManager 1.10.0</a> and <a href="https://groups.google.com/forum/#!msg/fwupd/HXavD9QqW4Q/WAsKVunxBQAJ" rel="noopener" target="_blank">fwupd 1.2.6</a>. There is no official firmware released in the LVFS (yet) but the setup is completely ready to be used, just waiting for Dell to publish an initial official firmware release.</p>
<p>The firmware update integration between ModemManager and fwupd involves different steps, which I’ll try to describe here so that it’s clear how to add support for more devices in the future.</p>
<h2>1) ModemManager reports expected update methods, firmware version and device IDs</h2>
<p>The Firmware interface in the modem object exposed in DBus contains, since MM 1.10, a new <a href="https://www.freedesktop.org/software/ModemManager/api/latest/gdbus-org.freedesktop.ModemManager1.Modem.Firmware.html#gdbus-property-org-freedesktop-ModemManager1-Modem-Firmware.UpdateSettings" rel="noopener" target="_blank">UpdateSettings</a> property that provides a bitmask specifying which is the expected firmware update method (or methods) required for a given module, plus a dictionary of key-value entries specifying settings applicable to each of the update methods.</p>
<p>In the case of the DW5821e, two update methods are reported in the bitmask: “<strong>fastboot</strong>” and “<strong>qmi-pdc</strong>“, because both are required to have a complete firmware upgrade procedure. “fastboot” would be used to perform the system upgrade by using an OTA update file, and “qmi-pdc” would be used to install the per-carrier configuration files after the system upgrade has been done.</p>
<p>The list of settings provided in the dictionary contain the two mandatory fields required for all devices that support at least one firmware update method: “device-ids” and “version”. These two fields are designed so that fwupd can fully rely on them during its operation:</p>
<ul>
<li>The “<strong>device-ids</strong>” field will include a list of strings providing the device IDs associated to the device, sorted from the most specific to the least specific. These device IDs are the ones that fwupd will use to build the GUIDs required to match a given device to a given firmware package. The DW5821e will expose four different device IDs:
<ul>
<li>“USB\<strong>VID_413C</strong>“: specifying this is a Dell-branded device.</li>
<li>“USB\VID_413C&amp;<strong>PID_81D7</strong>“: specifying this is a DW5821e module.</li>
<li>“USB\VID_413C&amp;PID_81D7&amp;<strong>REV_0318</strong>“: specifying this is hardware revision 0x318 of the DW5821e module.</li>
<li>“USB\VID_413C&amp;PID_81D7&amp;REV_0318&amp;<strong>CARRIER_VODAFONE</strong>“: specifying this is hardware revision 0x318 of the DW5821e module running with a Vodafone-specific carrier configuration.</li>
</ul>
</li>
<li>The “<strong>version</strong>” field will include the firmware version string of the module, using the same format as used in the firmware package files used by fwupd. This requirement is obviously very important, because if the format used is different, the simple version string comparison used by fwupd (literally ASCII string comparison) would not work correctly. It is also worth noting that if the carrier configuration is also versioned, the version string should contain not only the version of the system, but also the version of the carrier configuration. The DW5821e will expose a firmware version including both, e.g. “T77W968.F1.1.1.1.1.VF.001” (system version being F1.1.1.1.1 and carrier config version being “VF.001”)</li>
<li>In addition to the mandatory fields, the dictionary exposed by the DW5821e will also contain a “<strong>fastboot-at</strong>” field specifying which AT command can be used to switch the module into fastboot download mode.</li>
</ul>
<h2>2) fwupd matches GUIDs and checks available firmware versions</h2>
<p>Once fwupd detects a modem in ModemManager that is able to expose the correct UpdateSettings property in the Firmware interface, it will add the device as a known device that may be updated in its own records. The device exposed by fwupd will contain the <a href="https://en.wikipedia.org/wiki/Universally_unique_identifier" rel="noopener" target="_blank"><strong>GUIDs</strong></a> built from the “device-ids” list of strings exposed by ModemManager. E.g. for the “USB\VID_413C&amp;PID_81D7&amp;REV_0318&amp;CARRIER_VODAFONE” device ID, fwupd will use GUID “b595e24b-bebb-531b-abeb-620fa2b44045”.</p>
<p>fwupd will then be able to look for firmware packages (CAB files) available in the <a href="https://fwupd.org/" rel="noopener" target="_blank">LVFS</a> that are associated to any of the GUIDs exposed for the DW5821e.</p>
<p>The CAB files packaged for the LVFS will contain one single firmware OTA file plus one carrier MCFG file for each supported carrier in the give firmware version. The CAB files will also contain one “metainfo.xml” file for each of the supported carriers in the released package, so that per-carrier firmware upgrade paths are available: only firmware updates for the currently used carrier should be considered. E.g. we don’t want users running with the Vodafone carrier config to get notified of upgrades to newer firmware versions that aren’t certified for the Vodafone carrier.</p>
<p>Each of the CAB files with multiple “metainfo.xml” files will therefore be associated to multiple GUID/version pairs. E.g. the same CAB file will be valid for the following GUIDs (using Device ID instead of GUID for a clearer explanation, but really the match is per GUID not per Device ID):</p>
<ul>
<li>Device ID “USB\VID_413C&amp;PID_81D7&amp;REV_0318&amp;CARRIER_VODAFONE” providing version “T77W968.F1.2.2.2.2.VF.002”</li>
<li>Device ID “USB\VID_413C&amp;PID_81D7&amp;REV_0318&amp;CARRIER_TELEFONICA” providing version “T77W968.F1.2.2.2.2.TF.003”</li>
<li>Device ID “USB\VID_413C&amp;PID_81D7&amp;REV_0318&amp;CARRIER_VERIZON” providing version “T77W968.F1.2.2.2.2.VZ.004”</li>
<li>… and so on.</li>
</ul>
<p>Following our example, fwupd will detect our device exposing device ID “USB\VID_413C&amp;PID_81D7&amp;REV_0318&amp;CARRIER_VODAFONE” and version “T77W968.F1.1.1.1.1.VF.001” in ModemManager and will be able to find a CAB file for the same device ID providing a newer version “T77W968.F1.2.2.2.2.VF.002” in the LVFS. The firmware update is possible!</p>
<h2>3) fwupd requests device inhibition from ModemManager</h2>
<p>In order to perform the firmware upgrade, fwupd requires full control of the modem. Therefore, when the firmware upgrade process starts, fwupd will use the new <a href="https://www.freedesktop.org/software/ModemManager/api/latest/gdbus-org.freedesktop.ModemManager1.html#gdbus-method-org-freedesktop-ModemManager1.InhibitDevice" rel="noopener" target="_blank">InhibitDevice</a>(TRUE) method in the Manager DBus interface of ModemManager to request that a specific modem with a specific uid should be inhibited. Once the device is inhibited in ModemManager, it will be disabled and removed from the list of modems in DBus, and no longer used until the inhibition is removed.</p>
<p>The inhibition may be removed by calling InhibitDevice(FALSE) explicitly once the firmware upgrade is finished, and will also be automatically removed if the program that requested the inhibition disappears from the bus.</p>
<h2>4) fwupd downloads CAB file from LVFS and performs firmware update</h2>
<p>Once the modem is inhibited in ModemManager, fwupd can right away start the firmware update process. In the case of the DW5821e, the firmware update requires two different methods and two different upgrade cycles.</p>
<p>The first step would be to reboot the module into <strong>fastboot</strong> download mode using the AT command specified by ModemManager in the “at-fastboot” entry of the “UpdateSettings” property dictionary. After running the AT command, the module will reset itself and reboot with a completely different USB layout (and different vid:pid) that fwupd can detect as being the same device as before but in a different working mode. Once the device is in fastboot mode, fwupd will download and install the OTA file using the fastboot protocol, as defined in the “flashfile.xml” file provided in the CAB file:</p>
<pre>&lt;parts interface="AP"&gt;
&lt;part operation="flash" partition="ota" filename="T77W968.F1.2.2.2.2.AP.123_ota.bin" MD5="f1adb38b5b0f489c327d71bfb9fdcd12"/&gt;
&lt;/parts&gt;</pre>
<p>Once the OTA file is completely downloaded and installed, fwupd will trigger a reset of the module also using the fastboot protocol, and the device will boot from scratch on the newly installed firmware version. During this initial boot, the module will report itself running in a “default” configuration not associated to any carrier, because the OTA file update process involves fully removing all installed carrier-specific MCFG files.</p>
<p>The second upgrade cycle performed by fwupd once the modem is detected again involves downloading all carrier-specific MCFG files one by one into the module using the <strong>QMI PDC</strong> protocol. Once all are downloaded, fwupd will activate the specific carrier configuration that was previously active before the download was started. E.g. if the module was running with the Vodafone-specific carrier configuration before the upgrade, fwupd will select the Vodafone-specific carrier configuration after the upgrade. The module would be reseted one last time using the QMI DMS protocol as a last step of the upgrade procedure.</p>
<h2>5) fwupd removes device inhibition from ModemManager</h2>
<p>The upgrade logic will finish by removing the device inhibition from ModemManager using InhibitDevice(FALSE) explicitly. At that point, ModemManager would re-detect and re-probe the modem from scratch, which should already be running in the newly installed firmware and with the newly selected carrier configuration.</p></content>
<author>
<name>aleksander</name>
<uri>https://sigquit.wordpress.com</uri>
</author>
<source>
<title type="html">GNU Planet – SIGQUIT</title>
<subtitle type="html">... and core dumped</subtitle>
<link rel="self" href="https://sigquit.wordpress.com/category/planets/gnu-planet/feed/"/>
<id>https://sigquit.wordpress.com</id>
</source>
</entry>
<entry xml:lang="en">
<title type="html" xml:lang="en">Version 2.0</title>
<link href="http://savannah.gnu.org/forum/forum.php?forum_id=9461"/>
<id>http://savannah.gnu.org/forum/forum.php?forum_id=9461</id>
<updated>2019-07-01T08:15:26+00:00</updated>
<summary type="html" xml:lang="en"></summary>
<content type="html" xml:lang="en"><p>Version 2.0 is available for download from <a href="https://ftp.gnu.org/gnu/rush/rush-2.0.tar.xz">GNU</a> and <a href="http://download.gnu.org.ua/release/rush/rush-2.0.tar.xz">Puszcza</a> archives.
<br />
</p>
<p>This release features a complete rewrite of the configuration support. It introduces a new configuration file syntax that offers a large set of control structures and transformation instructions for handling arbitrary requests. Please see the documentation for details.
<br />
</p>
<p>Backward compatibility with prior releases is retained and old configuration syntax is still supported. This ensures that existing installations will remain operational without any changes. Nevertheless, system administrators are encouraged to switch to the new syntax as soon as possible.<br />
</p></content>
<author>
<name>Sergey Poznyakoff</name>
<uri>http://savannah.gnu.org/news/atom.php?group=rush</uri>
</author>
<source>
<title type="html">GNU Rush - News</title>
<link rel="self" href="http://savannah.gnu.org/news/atom.php?group=rush"/>
<id>http://savannah.gnu.org/news/atom.php?group=rush</id>
</source>
</entry>
<entry xml:lang="en">
<title type="html" xml:lang="non-html">GNU Guile 2.2.6 released</title>
<link href="https://www.gnu.org/software/guile/news/gnu-guile-226-released.html"/>
<id>https://www.gnu.org/software/guile/news/gnu-guile-226-released.html</id>
<updated>2019-06-30T21:55:00+00:00</updated>
<summary type="html" xml:lang="non-html"></summary>
<content type="html" xml:lang="en"><p>We are pleased to announce GNU Guile 2.2.6, the sixth bug-fix
release in the new 2.2 stable release series. This release represents
11 commits by 4 people since version 2.2.5. First and foremost, it
fixes a <a href="https://issues.guix.gnu.org/issue/36350">regression</a> introduced
in 2.2.5 that would break Guile’s built-in HTTP server.</p><p>See the <a href="https://lists.gnu.org/archive/html/guile-devel/2019-06/msg00059.html">release
announcement</a>
for details.</p></content>
<author>
<name>Ludovic Courtès</name>
<email>[email protected]</email>
</author>
<source>
<title type="html">GNU's programming and extension language</title>
<subtitle type="html">Recent Posts</subtitle>
<link rel="self" href="https://www.gnu.org/software/guile/news/feed.xml"/>
<id>https://www.gnu.org/software/guile</id>
</source>
</entry>
<entry xml:lang="en">
<title type="html" xml:lang="en">Malayalam team re-established</title>
<link href="http://savannah.gnu.org/forum/forum.php?forum_id=9459"/>
<id>http://savannah.gnu.org/forum/forum.php?forum_id=9459</id>
<updated>2019-06-29T06:54:45+00:00</updated>
<summary type="html" xml:lang="en"></summary>
<content type="html" xml:lang="en"><p>After more than 8 years of being orphaned, Malayalam team is active again. The new team leader, Aiswarya Kaitheri Kandoth, made a new translation of the <a href="https://www.gnu.org/philosophy/free-sw.html">Free Software Definition</a>, so now we have 41 translations of that page!
<br />
</p>
<p>Currently, Malayalam the only active translation team of official languages of India. It is a Dravidian language spoken by about 40 million people worldwide, with the most speakers living in the Indian state of Kerala. Like many Indian languages, it uses a syllabic script derived from Brahmi.
<br />
</p>
<p><a href="https://www.gnu.org/software/gnun/reports/report-ml.html#complete">Links to up-to-date translations</a> are shown on the automatically generated <a href="https://www.gnu.org/software/gnun/reports/report-ml.html">report page</a>.<br />
</p></content>
<author>
<name>Ineiev</name>
<uri>http://savannah.gnu.org/news/atom.php?group=trans-coord</uri>
</author>
<source>
<title type="html">GNU Web Translation Coordination - News</title>
<link rel="self" href="http://savannah.gnu.org/news/atom.php?group=trans-coord"/>
<id>http://savannah.gnu.org/news/atom.php?group=trans-coord</id>
</source>
</entry>
<entry xml:lang="en">
<title type="html" xml:lang="en">How do Spritely's actor and storage layers tie together?</title>
<link href="http://dustycloud.org/blog/how-do-spritelys-actor-and-storage-layers-tie-together/"/>
<id>tag:dustycloud.org,2019-06-27:blog/how-do-spritelys-actor-and-storage-layers-tie-together/</id>
<updated>2019-06-27T18:15:00+00:00</updated>
<summary type="html" xml:lang="en"></summary>
<content type="html" xml:lang="en"><p>I've been hacking away at <a class="reference external" href="https://gitlab.com/spritely">Spritely</a>
(see <a class="reference external" href="https://dustycloud.org/blog/tag/spritely/">previously</a>).
Recently I've been making progress on both the actor model
(<a class="reference external" href="https://gitlab.com/spritely/goblins">goblins</a> and its rewrite
<a class="reference external" href="https://gitlab.com/spritely/goblinoid">goblinoid</a>) as well as
the storage layers (currently called
<a class="reference external" href="https://gitlab.com/dustyweb/magenc/blob/master/magenc/scribblings/intro.org">Magenc</a>
and <a class="reference external" href="https://gitlab.com/spritely/crystal/blob/master/crystal/scribblings/intro.org">Crystal</a>,
but we are talking about probably renaming the both of them into a
suite called "datashards"... yeah, everything is moving and changing
fast right now.)</p>
<p>In the <a class="reference external" href="https://webchat.freenode.net/?channels=spritely">#spritely channel on freenode</a>
a friend asked, what is the big picture idea here?
Both the actor model layer and the storage layer describe themselves
as using "capabilities" (or more precisely "object capabilities" or
"ocaps") but they seem to be implemented differently.
How does it all tie together?</p>
<p>A great question!
I think the first point of confusion is that while both follow the
ocap paradigm (which is to say, reference/possession-based authority...
possessing the capability gives you access, and it does not matter what
your identity is for the most part for access control), they are
implemented very differently because they are solving different problems.
The storage system is based on encrypted, persistent data, with its ideas
drawn from <a class="reference external" href="https://tahoe-lafs.org/trac/tahoe-lafs">Tahoe-LAFS</a> and
<a class="reference external" href="https://freenetproject.org/">Freenet</a>, and the way that capabilities
work is based on possession of cryptographic keys (which are themselves
embedded/referenced in the URIs).
The actor model, on the other hand, is based on holding onto a
reference to a unique, unguessable URL (well, that's a bit of an
intentional oversimplification for the sake of this explaination but
we'll run with it) where the actor at that URL is "live" and communicated
with via message passing.
(Most of the ideas from this come from <a class="reference external" href="http://erights.org/">E</a> and
<a class="reference external" href="http://waterken.sourceforge.net/">Waterken</a>.)
Actors are connected to each other over secure channels to prevent
eavesdropping or leakage of the capabilities.</p>
<p>So yeah, how do these two seemingly very different layers tie together?
As usual, I find that I most easily explain things via narrative, so
let's imagine the following game scenario: Alice is in a room with a goblin.
First Alice sees the goblin, then Alice attacks the goblin, then the
goblin and Alice realize that they are not so different and become
best friends.</p>
<p>The goblin and Alice both manifest in this universe as live actors.
When Alice walks into the room (itself an actor), the room gives Alice
a reference to the goblin actor.
To "see" the goblin, Alice sends a message to it asking for its
description.
It replies with its datashards storage URI with its 3d model and associated
textures.
Alice can now query the storage system to reconstruct these models and
textures from the datashards storage systems she uses.
(The datashards storage systems themselves can't actually see the
contents if they don't have the capability itself; this is much safer
for peers to help the network share data because they can help route
things through the network without personally knowing or being
responsible for what the contents of those messages are.
It could also be possible for the goblin to provide Alice with a direct
channel to a storage system to retrieve its assets from.)
Horray, Alice got the 3d model and images!
Now she can see the goblin.</p>
<p>Assuming that the goblin is an enemy, Alice attacks!
Attacking is common in this game universe, and there is no reason
necessarily to keep around attack messages, so sending a message to
the goblin is just a one-off transient message... there's no need
to persist it in the storage system.</p>
<p>The attack misses!
The goblin shouts, "Wait!" and makes its case, that both of them are
just adventurers in this room, and shouldn't they both be friends?
Alice is touched and halts her attack.
These messages are also sent transiently; while either party could
log them, they are closer to an instant messenger or IRC conversation
rather than something intended to be persisted long-term.</p>
<p>They exchange their mailbox addresses and begin sending each other
letters.
These, however, are intended to be persisted; when Alice receives a
message from the goblin in her mailbox (or vice versa), the message
received contains the datashards URI to the letter, which Alice can
then retrieve from the appropriate store.
She can then always refer to this message, and she can choose whether
or not to persist it locally or elsewhere.
Since the letter has its own storage URI, when Alice constructs a
reply, she can clearly mark that it was in reference to the previous
letter.
Even if Alice or the goblin's servers go down, either can continue
to refer to these letters.
Alice and the goblin have the freedom to choose what storage systems
they wish, whether targeted/direct/local or via a public peer to peer
routing system, with reasonable assumptions (given the continued
strength of the underlying cryptographic algorithms used) that the
particular entities storing or forwarding their data cannot read its
content.</p>
<p>And so it is: live references of actors are able to send live,
transient messages, but can only be sent to other actors whose
(unguessable/unforgeable) address you have.
This allows for highly dynamic and expressive interactions while
retaining security.
Datashards URIs allow for the storage and retrieval of content which
can continue to be persisted by interested parties, even if the
originating host goes down.</p>
<p>There are some things I glossed over in this writeup.
The particular ways that the actors' addresses and references work is
one thing (unguessable http based capability URLs on their own
have <a class="reference external" href="https://www.w3.org/TR/capability-urls/">leakage problems</a>
due to the way various web technologies are implemented, and
not even every actor reference needs to be a long-lived URI;
see <a class="reference external" href="http://erights.org/elib/distrib/captp/index.html">CapTP for more details</a>),
how to establish connections between actor processes/servers
(we can reuse TLS, or even better, something like tor's onion services),
so are how interactions such as fighting can be scoped to a
room (<a class="reference external" href="https://www.uni-weimar.de/fileadmin/user/fak/medien/professuren/Virtual_Reality/documents/publications/capsec_vr2008_preprint.pdf">this paper</a>
explains how), as well as how we can map human meaningful names
onto unguessable identifiers (the answer there is
<a class="reference external" href="https://github.com/cwebber/rebooting-the-web-of-trust-spring2018/blob/petnames/draft-documents/making-dids-invisible-with-petnames.md">petnames</a>).
But I have plans for this and increasing confidence that it will come
together... I think we're already on track.</p>
<p>Hopefully this writeup brings some clarity on how some of the
components will work together, though!</p></content>
<author>
<name>Christopher Lemmer Webber</name>
<uri>http://dustycloud.org/</uri>
</author>
<source>
<title type="html">DustyCloud Brainstorms</title>
<link rel="self" href="http://dustycloud.org/blog/index.xml"/>
<id>http://dustycloud.org/</id>
</source>
</entry>
<entry xml:lang="en">
<title type="html" xml:lang="en">GNU Spotlight with Mike Gerwitz: 17 new GNU releases in June!</title>
<link href="http://www.fsf.org/blogs/community/gnu-spotlight-with-mike-gerwitz-17-new-gnu-releases-in-june"/>
<id>http://www.fsf.org/blogs/community/gnu-spotlight-with-mike-gerwitz-17-new-gnu-releases-in-june</id>
<updated>2019-06-27T16:08:17+00:00</updated>
<summary type="html" xml:lang="en"></summary>
<content type="html" xml:lang="en"><ul>
<li><a href="https://www.gnu.org/software/apl/">apl-1.8</a></li>
<li><a href="https://www.gnu.org/software/artanis/">artanis-0.3.2</a></li>
<li><a href="https://www.gnu.org/software/dr-geo/">dr-geo-19.06a</a></li>
<li><a href="https://www.gnu.org/software/gawk/">gawk-5.0.1</a></li>
<li><a href="https://www.gnu.org/software/gengetopt/">gengetopt-2.23</a></li>
<li><a href="https://www.gnu.org/software/gnunet/">gnunet-0.11.5</a></li>
<li><a href="https://www.gnu.org/software/guile/">guile-2.2.5</a></li>
<li><a href="https://www.gnu.org/software/gnuzilla/">icecat-60.7.0-gnu1</a></li>
<li><a href="https://www.gnu.org/software/libmicrohttpd/">libmicrohttpd-0.9.64</a></li>
<li><a href="https://www.gnu.org/software/libredwg/">libredwg-0.8</a></li>
<li><a href="https://www.gnu.org/software/mailutils/">mailutils-3.7</a></li>
<li><a href="https://www.gnu.org/software/mit-scheme/">mit-scheme-10.1.9</a></li>
<li><a href="https://www.gnu.org/software/nano/">nano-4.3</a></li>
<li><a href="https://www.gnu.org/software/nettle/">nettle-3.5</a></li>
<li><a href="https://www.gnu.org/software/parallel/">parallel-20190622</a></li>
<li><a href="https://www.gnu.org/software/unifont/">unifont-12.1.02</a></li>
<li><a href="https://www.gnu.org/software/units/">units-2.19</a></li>
</ul>
<p>For announcements of most new GNU releases, subscribe to the info-gnu
mailing list: <a href="https://lists.gnu.org/mailman/listinfo/info-gnu">https://lists.gnu.org/mailman/listinfo/info-gnu</a>.</p>
<p>To download: nearly all GNU software is available from
<a href="https://ftp.gnu.org/gnu/">https://ftp.gnu.org/gnu/</a>, or preferably one of its mirrors from
<a href="https://www.gnu.org/prep/ftp.html">https://www.gnu.org/prep/ftp.html</a>. You can use the URL
<a href="https://ftpmirror.gnu.org/">https://ftpmirror.gnu.org/</a> to be automatically redirected to a
(hopefully) nearby and up-to-date mirror.</p>
<p>A number of GNU packages, as well as the GNU operating system as a
whole, are looking for maintainers and other assistance: please see
<a href="https://www.gnu.org/server/takeaction.html#unmaint">https://www.gnu.org/server/takeaction.html#unmaint</a> if you'd like to
help. The general page on how to help GNU is at
<a href="https://www.gnu.org/help/help.html">https://www.gnu.org/help/help.html</a>.</p>
<p>If you have a working or partly working program that you'd like
to offer to the GNU project as a GNU package, see
<a href="https://www.gnu.org/help/evaluation.html">https://www.gnu.org/help/evaluation.html</a>.</p>
<p>As always, please feel free to write to us at <a href="mailto:[email protected]">[email protected]</a>
with any GNUish questions or suggestions for future installments.</p></content>
<author>
<name>FSF Blogs</name>
<uri>http://www.fsf.org/blogs/recent-blog-posts</uri>
</author>
<source>
<title type="html">FSF blogs</title>
<subtitle type="html">Writing by representatives of the Free Software Foundation.</subtitle>
<link rel="self" href="http://static.fsf.org/fsforg/rss/blogs.xml"/>
<id>http://www.fsf.org/blogs/recent-blog-posts</id>
</source>
</entry>
<entry xml:lang="en">
<title type="html" xml:lang="en">fibs, lies, and benchmarks</title>
<link href="http://wingolog.org/archives/2019/06/26/fibs-lies-and-benchmarks"/>
<id>http://wingolog.org/2019/06/26/fibs-lies-and-benchmarks</id>
<updated>2019-06-26T10:34:11+00:00</updated>
<summary type="html" xml:lang="en"></summary>
<content type="html" xml:lang="en"><div><p>Friends, consider the recursive Fibonacci function, expressed most lovelily in Haskell:</p><pre>fib 0 = 0
fib 1 = 1
fib n = fib (n-1) + fib (n-2)
</pre><p>Computing elements of the Fibonacci sequence ("Fibonacci numbers") is a common microbenchmark. Microbenchmarks are like a <a href="https://en.wikipedia.org/wiki/Suzuki_method">Suzuki exercises for learning violin</a>: not written to be good tunes (good programs), but rather to help you improve a skill.</p><p>The <tt>fib</tt> microbenchmark teaches language implementors to improve recursive function call performance.</p><p>I'm writing this article because after adding native code generation to Guile, I wanted to check how Guile was doing relative to other language implementations. The results are mixed. We can start with the most favorable of the comparisons: Guile present versus Guile of the past.</p><p></p><center><img src="http://wingolog.org/pub/guile-versions.png" /><br /></center><p>I collected these numbers on my i7-7500U CPU @ 2.70GHz 2-core laptop, with no particular performance tuning, running each benchmark 10 times, waiting 2 seconds between measurements. The bar value indicates the median elapsed time, and above each bar is an overlayed histogram of all results for that scenario. Note that the y axis is on a log scale. The 2.9.3* version corresponds to unreleased Guile from git.</p><p>Good news: Guile has been getting significantly faster over time! Over decades, true, but I'm pleased.</p><p><b>where are we? static edition</b></p><p>How good are Guile's numbers on an absolute level? It's hard to say because there's no absolute performance oracle out there. However there are relative performance oracles, so we can try out perhaps some other language implementations.</p><p>First up would be the industrial C compilers, GCC and LLVM. We can throw in a few more "static" language implementations as well: compilers that completely translate to machine code ahead-of-time, with no type feedback, and a minimal run-time.</p><p></p><center><img src="http://wingolog.org/pub/static-languages.png" /><br /></center><p>Here we see that GCC is doing best on this benchmark, completing in an impressive 0.304 seconds. It's interesting that the result differs so much from clang. I had a look at the disassembly for GCC and I see:</p><pre>fib:
push %r12
mov %rdi,%rax
push %rbp
mov %rdi,%rbp
push %rbx
cmp $0x1,%rdi
jle finish
mov %rdi,%rbx
xor %r12d,%r12d
again:
lea -0x1(%rbx),%rdi
sub $0x2,%rbx
callq fib
add %rax,%r12
cmp $0x1,%rbx
jg again
and $0x1,%ebp
lea 0x0(%rbp,%r12,1),%rax
finish:
pop %rbx
pop %rbp
pop %r12
retq
</pre><p>It's not quite straightforward; what's the loop there for? It turns out that <a href="https://stackoverflow.com/a/10058823">GCC inlines one of the recursive calls to <tt>fib</tt></a>. The microbenchmark is no longer measuring call performance, because GCC managed to reduce the number of calls. If I had to guess, I would say this optimization doesn't have a wide applicability and is just to game benchmarks. In that case, well played, GCC, well played.</p><p>LLVM's compiler (clang) looks more like what we'd expect:</p><pre>fib:
push %r14
push %rbx
push %rax
mov %rdi,%rbx
cmp $0x2,%rdi
jge recurse
mov %rbx,%rax
add $0x8,%rsp
pop %rbx
pop %r14
retq
recurse:
lea -0x1(%rbx),%rdi
<b>callq fib</b>
mov %rax,%r14
add $0xfffffffffffffffe,%rbx
mov %rbx,%rdi
<b>callq fib</b>
add %r14,%rax
add $0x8,%rsp
pop %rbx
pop %r14
retq
</pre><p>I bolded the two recursive calls.</p><p>Incidentally, the <tt>fib</tt> as implemented by GCC and LLVM isn't quite the same program as Guile's version. If the result gets too big, GCC and LLVM will overflow, whereas in Guile we overflow into a <a href="https://wingolog.org/archives/2019/05/23/bigint-shipping-in-firefox">bignum</a>. Also in C, it's possible to "smash the stack" if you recurse too much; compilers and run-times attempt to mitigate this danger but it's not completely gone. In Guile <a href="https://wingolog.org/archives/2014/03/17/stack-overflow">you can recurse however much you want</a>. Finally in Guile you can interrupt the process if you like; the compiled code is instrumented with safe-points that can be used to run profiling hooks, debugging, and so on. Needless to say, this is not part of C's mission.</p><p>Some of these additional features can be implemented with no significant performance cost (e.g., via guard pages). But it's fair to expect that they have some amount of overhead. More on that later.</p><p>The other compilers are OCaml's <tt>ocamlopt</tt>, coming in with a very respectable result; Go, also doing well; and V8 WebAssembly via Node. As you know, you can compile C to WebAssembly, and then V8 will compile that to machine code. In practice it's just as static as any other compiler, but the generated assembly is a bit more involved:</p><pre>
fib_tramp:
jmp fib
fib:
push %rbp
mov %rsp,%rbp
pushq $0xa
push %rsi
sub $0x10,%rsp
mov %rsi,%rbx
mov 0x2f(%rbx),%rdx
mov %rax,-0x18(%rbp)
cmp %rsp,(%rdx)
jae stack_check
post_stack_check:
cmp $0x2,%eax
jl return_n
lea -0x2(%rax),%edx
mov %rbx,%rsi
mov %rax,%r10
mov %rdx,%rax
mov %r10,%rdx
callq fib_tramp
mov -0x18(%rbp),%rbx
sub $0x1,%ebx
mov %rax,-0x20(%rbp)
mov -0x10(%rbp),%rsi
mov %rax,%r10
mov %rbx,%rax
mov %r10,%rbx
callq fib_tramp
return:
mov -0x20(%rbp),%rbx
add %ebx,%eax
mov %rbp,%rsp
pop %rbp
retq
return_n:
jmp return
stack_check:
callq WasmStackGuard
mov -0x10(%rbp),%rbx
mov -0x18(%rbp),%rax
jmp post_stack_check
</pre><p>Apparently <tt>fib</tt> compiles to a function of two arguments, the first passed in <tt>rsi</tt>, and the second in <tt>rax</tt>. (V8 uses a custom calling convention for its compiled WebAssembly.) The first synthesized argument is a handle onto run-time data structures for the current thread or isolate, and in the function prelude there's a check to see that the function has enough stack. V8 uses these stack checks also to handle interrupts, for when a web page is stuck in JavaScript.</p><p>Otherwise, it's a more or less normal function, with a bit more register/stack traffic than would be strictly needed, but pretty good.</p><p><b>do optimizations matter?</b></p><p>You've heard of Moore's Law -- though it doesn't apply any more, it roughly translated into hardware doubling in speed every 18 months. (Yes, I know it wasn't precisely that.) There is a corresponding rule of thumb for compiler land, <a href="http://proebsting.cs.arizona.edu/law.html">Proebsting's Law</a>: compiler optimizations make software twice as fast every 18 <i>years</i>. Zow!</p><p>The previous results with GCC and LLVM were with optimizations enabled (-O3). One way to measure Proebsting's Law would be to compare the results with -O0. Obviously in this case the program is small and we aren't expecting much work out of the optimizer, but it's interesting to see anyway:</p><p></p><center><img src="http://wingolog.org/pub/optimization-levels.png" /><br /></center><p>Answer: optimizations don't matter much for this benchark. This investigation does give a good baseline for compilers from high-level languages, like Guile: in the absence of clever trickery like the recursive inlining thing GCC does and in the absence of industrial-strength instruction selection, what's a good baseline target for a compiler? Here we see for this benchmark that it's somewhere between 420 and 620 milliseconds or so. Go gets there, and OCaml does even better.</p><p><b>how is time being spent, anyway?</b></p><p>Might we expect V8/WebAssembly to get there soon enough, or is the stack check that costly? How much time does one stack check take anyway? For that we'd have to determine the number of recursive calls for a given invocation.</p><p>Friends, it's not entirely clear to me why this is, but I instrumented a copy of <tt>fib</tt>, and I found that the number of calls in <tt>fib(<i>n</i>)</tt> was a more or less constant factor of the result of calling <tt>fib</tt>. That ratio converges to twice the golden ratio, which means that since <tt>fib(n+1) ~= φ * fib(n)</tt>, then the number of calls in <tt>fib(n)</tt> is approximately <tt>2 * fib(n+1)</tt>. I scratched my head for a bit as to why this is and I gave up; the Lord works in mysterious ways.</p><p>Anyway for <tt>fib(40)</tt>, that means that there are around 3.31e8 calls, absent GCC shenanigans. So that would indicate that each call for clang takes around 1.27 ns, which at turbo-boost speeds on this machine is 4.44 cycles. At maximum throughput (4 IPC), that would indicate 17.8 instructions per call, and indeed on the <tt>n &gt; 2</tt> path I count 17 instructions.</p><p>For WebAssembly I calculate 2.25 nanoseconds per call, or 7.9 cycles, or 31.5 (fused) instructions at max IPC. And indeed counting the extra jumps in the trampoline, I get 33 cycles on the recursive path. I count 4 instructions for the stack check itself, one to save the current isolate, and two to shuffle the current isolate into place for the recursive calls. But, compared to clang, V8 puts 6 words on the stack per call, as opposed to only 4 for LLVM. I think with better interprocedural register allocation for the isolate (i.e.: reserve a register for it), V8 could get a nice boost for call-heavy workloads.</p><p><b>where are we? dynamic edition</b></p><p>Guile doesn't aim to replace C; it's different. It has garbage collection, an integrated debugger, and a compiler that's available at run-time, it is dynamically typed. It's perhaps more fair to compare to languages that have some of these characteristics, so I ran these tests on versions of recursive <tt>fib</tt> written in a number of languages. Note that all of the numbers in this post include start-up time.</p><p></p><center><img src="http://wingolog.org/pub/dynamic-languages.png" /><br /></center><p>Here, the ocamlc line is the same as before, but using the bytecode compiler instead of the native compiler. It's a bit of an odd thing to include but it performs so well I just had to include it.</p><p>I think the real takeaway here is that Chez Scheme has fantastic performance. I have not been able to see the disassembly -- does it do the trick like GCC does? -- but the numbers are great, and I can see why Racket decided to rebase its implementation on top of it.</p><p>Interestingly, as far as I understand, Chez implements stack checks in the straightfoward way (an inline test-and-branch), not with a guard page, and instead of using the stack check as a generic ability to interrupt a computation in a timely manner as V8 does, Chez emits a <a href="https://www.scheme.com/csug8/system.html#./system:s89">separate interrupt check</a>. I would like to be able to see Chez's disassembly but haven't gotten around to figuring out how yet.</p><p>Since I originally published this article, I added a LuaJIT entry as well. As you can see, LuaJIT performs as well as Chez in this benchmark.</p><p>Haskell's call performance is surprisingly bad here, beaten even by OCaml's bytecode compiler; is this the cost of laziness, or just a lacuna of the implementation? I do not know. I do know I have this mental image that Haskell is a good compiler but apparently if that's the standard, so is Guile :)</p><p>Finally, in this comparison section, I was not surprised by cpython's relatively poor performance; we know cpython is not fast. I think though that it just goes to show how little these microbenchmarks are worth when it comes to user experience; like many of you I use plenty of Python programs in my daily work and don't find them slow at all. Think of micro-benchmarks like x-ray diffraction; they can reveal the hidden substructure of DNA but they say nothing at all about the organism.</p><p><b>where to now?</b></p><p>Perhaps you noted that in the last graph, the Guile and Chez lines were labelled "(lexical)". That's because instead of running this program:</p><pre>(define (fib n)
(if (&lt; n 2)
n
(+ (fib (- n 1)) (fib (- n 2)))))
</pre><p>They were running this, instead:</p><pre>(define (fib n)
(define (fib* n)
(if (&lt; n 2)
n
(+ (fib* (- n 1)) (fib* (- n 2)))))
(fib* n))
</pre><p>The thing is, historically, Scheme programs have treated top-level definitions as being mutable. This is because you don't know the extent of the top-level scope -- there could always be someone else who comes and adds a new definition of <tt>fib</tt>, effectively mutating the existing definition in place.</p><p>This practice has its uses. It's useful to be able to go in to a long-running system and change a definition to fix a bug or add a feature. It's also a useful way of developing programs, to incrementally build the program bit by bit.</p><p></p><center><img src="http://wingolog.org/pub/top-level-vs-lexical.png" /><br /></center><p>But, I would say that as someone who as written and maintained a lot of Scheme code, it's not a normal occurence to mutate a top-level binding on purpose, and it has a significant performance impact. If the compiler knows the target to a call, that unlocks a number of important optimizations: type check elision on the callee, more optimal closure representation, smaller stack frames, possible contification (turning calls into jumps), argument and return value count elision, representation specialization, and so on.</p><p>This overhead is especially egregious for calls inside modules. Scheme-the-language only gained modules relatively recently -- relative to the history of scheme -- and one of the aspects of modules is precisely to allow reasoning about top-level module-level bindings. This is why running Chez Scheme with the <tt>--program</tt> option is generally faster than <tt>--script</tt> (which I used for all of these tests): it opts in to the "newer" specification of what a top-level binding is.</p><p>In Guile we would probably like to move towards a more static way of treating top-level bindings, at least those within a single compilation unit. But we haven't done so yet. It's probably the most important single optimization we can make over the near term, though.</p><p>As an aside, it seems that LuaJIT also shows a similar performance differential for <tt>local function fib(n)</tt> versus just plain <tt>function fib(n)</tt>.</p><p>It's true though that even absent lexical optimizations, top-level calls can be made more efficient in Guile. I am not sure if we can reach Chez with the current setup of having a <a href="https://www.gnu.org/software/guile/docs/master/guile.html/Just_002dIn_002dTime-Native-Code.html#Just_002dIn_002dTime-Native-Code">template JIT</a>, because we need two return addresses: one virtual (for bytecode) and one "native" (for JIT code). Register allocation is also something to improve but it turns out to not be so important for <tt>fib</tt>, as there are few live values and they need to spill for the recursive call. But, we can avoid some of the indirection on the call, probably using an inline cache associated with the callee; Chez has had this optimization since 1984!</p><p><b>what guile learned from <tt>fib</tt></b></p><p>This exercise has been useful to speed up Guile's procedure calls, as you can see for the difference between the latest Guile 2.9.2 release and what hasn't been released yet (2.9.3).</p><p>To decide what improvements to make, I extracted the assembly that Guile generated for <tt>fib</tt> to a standalone file, and tweaked it in a number of ways to determine what the potential impact of different scenarios was. Some of the detritus from this investigation is <a href="https://gitlab.com/wingo/fib-asm-tinkering">here</a>.</p><p>There were three big performance improvements. One was to avoid eagerly initializing the slots in a function's stack frame; this took a surprising amount of run-time. Fortunately the rest of the toolchain like the local variable inspector was already ready for this change.</p><p>Another thing that became clear from this investigation was that our stack frames were too large; there was too much memory traffic. I was able to improve this in the lexical-call by adding an optimization to elide useless closure bindings. Usually in Guile when you call a procedure, you pass the callee as the 0th parameter, then the arguments. This is so the procedure has access to its closure. For some "well-known" procedures -- procedures whose callers can be enumerated -- we optimize to pass a specialized representation of the closure instead ("closure optimization"). But for well-known procedures with no free variables, there's no closure, so we were just passing a throwaway value (<tt>#f</tt>). An unhappy combination of Guile's current calling convention being stack-based and a strange outcome from the slot allocator meant that frames were a couple words too big. Changing to allow a custom calling convention in this case sped up <tt>fib</tt> considerably.</p><p>Finally, and also significantly, Guile's JIT code generation used to manually handle calls and returns via manual stack management and indirect jumps, instead of using the platform calling convention and the C stack. This is to allow <a href="https://wingolog.org/archives/2014/03/17/stack-overflow">unlimited stack growth</a>. However, it turns out that the indirect jumps at return sites were stalling the pipeline. Instead we switched to use call/return but keep our manual stack management; this allows the CPU to use its return address stack to predict return targets, speeding up code.</p><p><b>et voilà</b></p><p>Well, long article! Thanks for reading. There's more to do but I need to hit the publish button and pop this off my stack. Until next time, happy hacking!</p></div></content>
<author>
<name>Andy Wingo</name>
<uri>http://wingolog.org/</uri>
</author>
<source>
<title type="html">wingolog</title>
<subtitle type="html">A mostly dorky weblog by Andy Wingo</subtitle>
<link rel="self" href="http://wingolog.org/feed/atom"/>
<id>http://wingolog.org/feed/atom</id>
</source>
</entry>
<entry xml:lang="en">
<title type="html" xml:lang="en">GNU Emacs T-shirts available now at the GNU Press Shop</title>
<link href="http://www.fsf.org/blogs/gnu-press/emacs-t-shirts-available-now-at-the-gnu-press-shop"/>
<id>http://www.fsf.org/blogs/gnu-press/emacs-t-shirts-available-now-at-the-gnu-press-shop</id>
<updated>2019-06-25T19:20:00+00:00</updated>
<summary type="html" xml:lang="en"></summary>
<content type="html" xml:lang="en"><p><img alt="zoe modeling emacs tee" src="https://shop.fsf.org/sites/default/files/styles/product_zoom/public/Emacs%20shirt%20three%20quarter.jpg" style="margin-top: 4px;" width="300" /> </p>
<p>Have you been waiting with bated breath for the opportunity to show your love for GNU Emacs, the text editor that also does everything else, with a nifty T-shirt? Wait no longer. The GNU Press Shop now has GNU Emacs logo T-shirts in unisex sizes S through XXXL. Order one at <a href="https://shop.fsf.org/tshirts-hoodies/gnu-emacs-logo-t-shirt">https://shop.fsf.org/tshirts-hoodies/gnu-emacs-logo-t-shirt</a>, and we'll ship it to you sooner than you can say "extensible, customizable, self-documenting, real-time display editor."</p>
<p>All GNU Press Shop purchases support the Free Software Foundation's efforts to free all software, and <a href="https://my.fsf.org/join">FSF associate members</a> get a 20% discount off of all purchases.</p></content>
<author>
<name>FSF Blogs</name>
<uri>http://www.fsf.org/blogs/recent-blog-posts</uri>
</author>
<source>
<title type="html">FSF blogs</title>
<subtitle type="html">Writing by representatives of the Free Software Foundation.</subtitle>
<link rel="self" href="http://static.fsf.org/fsforg/rss/blogs.xml"/>
<id>http://www.fsf.org/blogs/recent-blog-posts</id>
</source>
</entry>
<entry xml:lang="en">
<title type="html" xml:lang="en">Let's Just Be Weird Together</title>
<link href="http://dustycloud.org/blog/lets-just-be-weird-together/"/>
<id>tag:dustycloud.org,2019-06-25:blog/lets-just-be-weird-together/</id>
<updated>2019-06-25T18:10:00+00:00</updated>
<summary type="html" xml:lang="en"></summary>
<content type="html" xml:lang="en"><div class="figure">
<img alt="ascii art of weird tea mugs with steam" src="http://dustycloud.org/etc/images/blog/ljbwt.gif" />
</div>
<p>Approximately a month ago was <a class="reference external" href="https://mlemmer.org/">Morgan</a> and I's
10 year wedding anniversary.
To commemorate that, and as a surprise gift, I made the above ascii
art and animation.</p>
<p>Actually, it's not just an animation, it's a program, and one
<a class="reference external" href="https://gitlab.com/dustyweb/dos-hurd/blob/master/dos-hurd/examples/ljbwt.rkt">you can run</a>.
As a side note, I originally thought I'd write up how I made it,
but I kept procrastinating on that and it lead me to putting off
writing this post for about a month.
Oh well, all I'll say for now is that it lead to a
<a class="reference external" href="https://gitlab.com/spritely/goblinoid">major rewrite</a> of one of
the <a class="reference external" href="https://gitlab.com/spritely/goblins">main components of Spritely</a>.
But that's something to speak of for another time, I suppose.</p>
<p>Back to the imagery!
Morgan was surprised to see the animation, and yet the image itself
wasn't a surprise.
That's because the design is actually built off of one we collaborated
on together:</p>
<div class="figure">
<img alt="embroidery of weird tea mugs with steam" src="http://dustycloud.org/etc/images/blog/ljbwt-embroidery-scaled.jpg" />
</div>
<p>I did the sketch for it and Morgan embroidered it.
The plan is to put this above the tea station we set up in the reading
area of our house.</p>
<p>The imagery and phrasing captures the philosophy of Morgan and I's
relationship.
We're both weird and deeply imperfect people, maybe even in some ways
broken.
But that's okay.
We don't expect each other to change or become something else... we
just try to become the best weird pairing we can together.
I think that strategy has worked out for us.</p>
<p>Thanks for all the happy times so far, Morgan.
I look forward to many weird years ahead.</p></content>
<author>
<name>Christopher Lemmer Webber</name>
<uri>http://dustycloud.org/</uri>
</author>
<source>
<title type="html">DustyCloud Brainstorms</title>
<link rel="self" href="http://dustycloud.org/blog/index.xml"/>
<id>http://dustycloud.org/</id>
</source>
</entry>
<entry xml:lang="en">
<title type="html" xml:lang="en">Drop the journalism charges against Julian Assange</title>
<link href="http://www.fsf.org/blogs/rms/drop-the-journalism-charges-against-julian-assange"/>
<id>http://www.fsf.org/blogs/rms/drop-the-journalism-charges-against-julian-assange</id>
<updated>2019-06-25T17:50:06+00:00</updated>
<summary type="html" xml:lang="en"></summary>
<content type="html" xml:lang="en"><p>The US government has persecuted Julian Assange for a decade for
Wikileaks' journalism, and now <a href="https://theintercept.com/2019/05/24/the-indictment-of-julian-assange-under-the-espionage-act-is-a-threat-to-the-press-and-the-american-people/">seeks to use his case to label the
publishing of leaked secret information as spying.</a></p>
<p>The Free Software Foundation stands for freedom of publication and due
process, because they are necessary to exercise and uphold the
software freedom we campaign for. The attack on journalism threatens
freedom of publication; the twisting of laws to achieve an unstated
aim threatens due process of law. The FSF therefore calls on the
United States to drop all present and future charges against Julian
Assange relating to Wikileaks activities.</p>
<p>Accusations against Assange that are unrelated to journalism should be
pursued or not pursued based on their merits, giving him neither
better nor worse treatment on account of his journalism.</p></content>
<author>
<name>FSF Blogs</name>
<uri>http://www.fsf.org/blogs/recent-blog-posts</uri>
</author>
<source>
<title type="html">FSF blogs</title>
<subtitle type="html">Writing by representatives of the Free Software Foundation.</subtitle>
<link rel="self" href="http://static.fsf.org/fsforg/rss/blogs.xml"/>
<id>http://www.fsf.org/blogs/recent-blog-posts</id>
</source>
</entry>
<entry xml:lang="en">
<title type="html" xml:lang="en">libredwg-0.8 released</title>
<link href="http://savannah.gnu.org/forum/forum.php?forum_id=9457"/>
<id>http://savannah.gnu.org/forum/forum.php?forum_id=9457</id>
<updated>2019-06-25T09:55:44+00:00</updated>
<summary type="html" xml:lang="en"></summary>
<content type="html" xml:lang="en"><p>This is a major release, adding the new dynamic API, read and write
<br />
all header and object fields by name. Many of the old dwg_api.h field
<br />
accessors are deprecated.
<br />
More here: <a href="https://www.gnu.org/software/libredwg/">https://www.gnu.org/software/libredwg/</a> and <a href="http://git.savannah.gnu.org/cgit/libredwg.git/tree/NEWS">http://git.savannah.gnu.org/cgit/libredwg.git/tree/NEWS</a>
<br />
</p>
<p>Here are the compressed sources:
<br />
<a href="http://ftp.gnu.org/gnu/libredwg/libredwg-0.8.tar.gz">http://ftp.gnu.org/gnu/libredwg/libredwg-0.8.tar.gz</a> (9.8MB)
<br />
<a href="http://ftp.gnu.org/gnu/libredwg/libredwg-0.8.tar.xz">http://ftp.gnu.org/gnu/libredwg/libredwg-0.8.tar.xz</a> (3.7MB)
<br />
</p>
<p>Here are the GPG detached signatures[*]:
<br />
<a href="http://ftp.gnu.org/gnu/libredwg/libredwg-0.8.tar.gz.sig">http://ftp.gnu.org/gnu/libredwg/libredwg-0.8.tar.gz.sig</a>
<br />
<a href="http://ftp.gnu.org/gnu/libredwg/libredwg-0.8.tar.xz.sig">http://ftp.gnu.org/gnu/libredwg/libredwg-0.8.tar.xz.sig</a>
<br />
</p>
<p>Use a mirror for higher download bandwidth:
<br />
<a href="https://www.gnu.org/order/ftp.html">https://www.gnu.org/order/ftp.html</a>
<br />
</p>
<p>Here are more binaries:
<br />
<a href="https://github.com/LibreDWG/libredwg/releases/tag/0.8">https://github.com/LibreDWG/libredwg/releases/tag/0.8</a>
<br />
</p>
<p>Here are the SHA256 checksums:
<br />
</p>
<p>087f0806220a0a33a9aab2c2763266a69e12427a5bd7179cff206289e60fe2fd libredwg-0.8.tar.gz
<br />
0487c84e962a4dbcfcf3cbe961294b74c1bebd89a128b4929a1353bc7f58af26 libredwg-0.8.tar.xz
<br />
</p>
<p>[*] Use a .sig file to verify that the corresponding file (without the
<br />
.sig suffix) is intact. First, be sure to download both the .sig file
<br />
and the corresponding tarball. Then, run a command like this:
<br />
</p>
<p> gpg --verify libredwg-0.8.tar.gz.sig
<br />
</p>
<p>If that command fails because you don't have the required public key,
<br />
then run this command to import it:
<br />
</p>
<p> gpg --keyserver keys.gnupg.net --recv-keys B4F63339E65D6414
<br />
</p>
<p>and rerun the 'gpg --verify' command.<br />
</p></content>
<author>
<name>Reini Urban</name>
<uri>http://savannah.gnu.org/news/atom.php?group=libredwg</uri>
</author>
<source>
<title type="html">LibreDWG - News</title>
<link rel="self" href="http://savannah.gnu.org/news/atom.php?group=libredwg"/>
<id>http://savannah.gnu.org/news/atom.php?group=libredwg</id>
</source>
</entry>
<entry xml:lang="en">
<title type="html" xml:lang="en">GNU APL 1.8 Released</title>
<link href="http://savannah.gnu.org/forum/forum.php?forum_id=9456"/>
<id>http://savannah.gnu.org/forum/forum.php?forum_id=9456</id>
<updated>2019-06-23T13:03:32+00:00</updated>
<summary type="html" xml:lang="en"></summary>
<content type="html" xml:lang="en"><p>I am happy to announce that GNU APL 1.8 has been released.
<br />
</p>
<p>GNU APL is a free implementation of the ISO standard 13751 aka.
<br />
"Programming Language APL, Extended",
<br />
</p>
<p>This release contains:
<br />
</p>
<ul>
<li>bug fixes,
</li>
</ul>
<ul>
<li>⎕DLX (Donald Knuth's Dancing Links Algorithm),
</li>
</ul>
<ul>
<li>⎕FFT (fast fourier transforms; real, complex, and windows),
</li>
</ul>
<ul>
<li>⎕GTK (create GUI windows from APL),
</li>
</ul>
<ul>
<li>⎕RE (regular expressions), and
</li>
</ul>
<ul>
<li>user-defined APL commands.
</li>
</ul>
<p>Also, you can now call GNU APL from Python.<br />
</p></content>
<author>
<name>Jürgen Sauermann</name>
<uri>http://savannah.gnu.org/news/atom.php?group=apl</uri>
</author>
<source>
<title type="html">GNU APL - News</title>
<link rel="self" href="http://savannah.gnu.org/news/atom.php?group=apl"/>
<id>http://savannah.gnu.org/news/atom.php?group=apl</id>
</source>
</entry>
<entry xml:lang="en">
<title type="html" xml:lang="en">Release 2.3 is imminent - please test.</title>
<link href="http://savannah.gnu.org/forum/forum.php?forum_id=9453"/>
<id>http://savannah.gnu.org/forum/forum.php?forum_id=9453</id>
<updated>2019-06-22T09:29:29+00:00</updated>
<summary type="html" xml:lang="en"></summary>
<content type="html" xml:lang="en"><p>New Features
<br />
Seek Locations in Scores
<br />
Specify type of object sought
<br />
Or valid note range
<br />
Or any custom condition
<br />
Creates a clickable list of locations
<br />
Each location is removed from list once visited
<br />
Syntax highlighting in LilyPond view
<br />
Playback Start/End markers draggable
<br />
Source window navigation by page number
<br />
Page number always visible
<br />
Rapid marking of passages
<br />
Two-chord Tremolos
<br />
Allowing breaks at half-measure for whole movement
<br />
Also breaks at every beat
<br />
Passages
<br />
Mark Passages of music
<br />
Perform tasks on the marked passages
<br />
Swapping musical material with staff below implemented
<br />
Search for lost scores
<br />
Interval-based
<br />
Searches whole directory hierarchy
<br />
Works for transposed scores
<br />
Compare Scores
<br />
Index Collection of Scores
<br />
All scores below a start directory indexed
<br />
Index includes typeset incipit for music
<br />
Title, Composer, Instrumentation, Score Comment fields
<br />
Sort by composer surname
<br />
Filter by any Scheme condition
<br />
Open files by clicking on them in Index
<br />
Intelligent File Opening
<br />
Re-interprets file paths for moved file systems
<br />
Improved Score etc editor appearance
<br />
Print History
<br />
History records what part of the score was printed
<br />
Date and printer included
<br />
Improvements to Scheme Editor
<br />
Title bar shows open file
<br />
Save dialog gives help
<br />
Colors now differentiate palettes, titles etc. in main display
<br />
Swapping Display and Source positions
<br />
for switching between entering music and editing
<br />
a single keypress or MIDI command
<br />
Activate object from keyboard
<br />
Fn2 key equivalent to mouse-right click
<br />
Shift and Control right-click via Shift-Fn2 and Control-Fn2
<br />
Help via Email
<br />
Auto-translation to Spanish
<br />
</p>
<p>Bug Fixes
<br />
</p>
<p> Adding buttons to palettes no longer brings hidden buttons back
<br />
</p>
<p> MIDI playback of empty measures containing non-notes
<br />
</p>
<p> Instrument name with Ambitus clash in staff properties menu fixed
<br />
</p>
<p> Visibility of emmentaler glyphs fixed
<br />
</p>
<p> Update of layout on staff to voice change
<br />
</p>
<p> Open Recent anomalies fixed
<br />
</p>
<p> Failures to translate menu titles and palettes fixed<br />
</p></content>
<author>
<name>Richard Shann</name>
<uri>http://savannah.gnu.org/news/atom.php?group=denemo</uri>
</author>
<source>
<title type="html">Denemo - News</title>
<link rel="self" href="http://savannah.gnu.org/news/atom.php?group=denemo"/>
<id>http://savannah.gnu.org/news/atom.php?group=denemo</id>
</source>
</entry>
<entry xml:lang="en">
<title type="html" xml:lang="en">GNU Parallel 20190622 ('HongKong') released</title>
<link href="http://savannah.gnu.org/forum/forum.php?forum_id=9451"/>
<id>http://savannah.gnu.org/forum/forum.php?forum_id=9451</id>
<updated>2019-06-21T13:36:51+00:00</updated>
<summary type="html" xml:lang="en"></summary>
<content type="html" xml:lang="en"><p>GNU Parallel 20190622 ('HongKong') has been released. It is available for download at: <a href="http://ftpmirror.gnu.org/parallel/">http://ftpmirror.gnu.org/parallel/</a>
<br />
</p>
<p>GNU Parallel is 10 years old in a year on 2020-04-22. You are here by invited to a reception on Friday 2020-04-17.
<br />
</p>
<p>See <a href="https://www.gnu.org/software/parallel/10-years-anniversary.html">https://www.gnu.org/software/parallel/10-years-anniversary.html</a>
<br />
</p>
<p>Quote of the month:
<br />
</p>
<p> I want to make a shout-out for @GnuParallel, it's a work of beauty and power
<br />
-- Cristian Consonni @CristianCantoro
<br />
</p>
<p>New in this release:
<br />
</p>
<ul>
<li>--shard can now take a column name and optionally a perl expression. Similar to --group-by and replacement strings.
</li>
</ul>
<ul>
<li>Using AWK and R to parse 25tb <a href="https://livefreeordichotomize.com/2019/06/04/using_awk_and_r_to_parse_25tb/">https://livefreeordichotomize.com/2019/06/04/using_awk_and_r_to_parse_25tb/</a>
</li>
</ul>
<ul>
<li>Parallel and Visual testing with Behat <a href="http://parallelandvisualtestingwithbehat.blogspot.com/p/blog-page.html">http://parallelandvisualtestingwithbehat.blogspot.com/p/blog-page.html</a>
</li>
</ul>
<ul>
<li>维基百科，自由的百科全书<a href="https://zh.wikipedia.org/wiki/GNU_parallel">https://zh.wikipedia.org/wiki/GNU_parallel</a>
</li>
</ul>
<ul>
<li>Bug fixes and man page updates.
</li>
</ul>
<p>Get the book: GNU Parallel 2018 <a href="http://www.lulu.com/shop/ole-tange/gnu-parallel-2018/paperback/product-23558902.html">http://www.lulu.com/shop/ole-tange/gnu-parallel-2018/paperback/product-23558902.html</a>
<br />
</p>
<p>GNU Parallel - For people who live life in the parallel lane.
<br />
</p>
<h2>About GNU Parallel</h2>
<p>GNU Parallel is a shell tool for executing jobs in parallel using one or more computers. A job can be a single command or a small script that has to be run for each of the lines in the input. The typical input is a list of files, a list of hosts, a list of users, a list of URLs, or a list of tables. A job can also be a command that reads from a pipe. GNU Parallel can then split the input and pipe it into commands in parallel.
<br />
</p>
<p>If you use xargs and tee today you will find GNU Parallel very easy to use as GNU Parallel is written to have the same options as xargs. If you write loops in shell, you will find GNU Parallel may be able to replace most of the loops and make them run faster by running several jobs in parallel. GNU Parallel can even replace nested loops.
<br />
</p>
<p>GNU Parallel makes sure output from the commands is the same output as you would get had you run the commands sequentially. This makes it possible to use output from GNU Parallel as input for other programs.
<br />
</p>
<p>You can find more about GNU Parallel at: <a href="http://www.gnu.org/s/parallel/">http://www.gnu.org/s/parallel/</a>
<br />
</p>
<p>You can install GNU Parallel in just 10 seconds with:
<br />
(wget -O - pi.dk/3 || curl pi.dk/3/ || fetch -o - <a href="http://pi.dk/3">http://pi.dk/3</a>) | bash
<br />
</p>
<p>Watch the intro video on <a href="http://www.youtube.com/playlist?list=PL284C9FF2488BC6D1">http://www.youtube.com/playlist?list=PL284C9FF2488BC6D1</a>
<br />
</p>
<p>Walk through the tutorial (man parallel_tutorial). Your command line will love you for it.
<br />
</p>
<p>When using programs that use GNU Parallel to process data for publication please cite:
<br />
</p>
<p>O. Tange (2018): GNU Parallel 2018, March 2018, <a href="https://doi.org/10.5281/zenodo.1146014">https://doi.org/10.5281/zenodo.1146014</a>.
<br />
</p>
<p>If you like GNU Parallel:
<br />
</p>
<ul>
<li>Give a demo at your local user group/team/colleagues
</li>
<li>Post the intro videos on Reddit/Diaspora*/forums/blogs/ Identi.ca/Google+/Twitter/Facebook/Linkedin/mailing lists
</li>
<li>Get the merchandise <a href="https://gnuparallel.threadless.com/designs/gnu-parallel">https://gnuparallel.threadless.com/designs/gnu-parallel</a>
</li>
<li>Request or write a review for your favourite blog or magazine
</li>
<li>Request or build a package for your favourite distribution (if it is not already there)
</li>
<li>Invite me for your next conference
</li>
</ul>
<p>If you use programs that use GNU Parallel for research:
<br />
</p>
<ul>
<li>Please cite GNU Parallel in you publications (use --citation)
</li>
</ul>
<p>If GNU Parallel saves you money:
<br />
</p>
<ul>
<li>(Have your company) donate to FSF <a href="https://my.fsf.org/donate/">https://my.fsf.org/donate/</a>
</li>
</ul>
<h2>About GNU SQL</h2>
<p>GNU sql aims to give a simple, unified interface for accessing databases through all the different databases' command line clients. So far the focus has been on giving a common way to specify login information (protocol, username, password, hostname, and port number), size (database and table size), and running queries.
<br />
</p>
<p>The database is addressed using a DBURL. If commands are left out you will get that database's interactive shell.
<br />
</p>
<p>When using GNU SQL for a publication please cite:
<br />
</p>
<p>O. Tange (2011): GNU SQL - A Command Line Tool for Accessing Different Databases Using DBURLs, ;login: The USENIX Magazine, April 2011:29-32.
<br />
</p>
<h2>About GNU Niceload</h2>
<p>GNU niceload slows down a program when the computer load average (or other system activity) is above a certain limit. When the limit is reached the program will be suspended for some time. If the limit is a soft limit the program will be allowed to run for short amounts of time before being suspended again. If the limit is a hard limit the program will only be allowed to run when the system is below the limit.<br />
</p></content>
<author>
<name>Ole Tange</name>
<uri>http://savannah.gnu.org/news/atom.php?group=parallel</uri>
</author>
<source>
<title type="html">GNU Parallel - build and execute command lines from standard input in parallel - News</title>
<link rel="self" href="http://savannah.gnu.org/news/atom.php?group=parallel"/>
<id>http://savannah.gnu.org/news/atom.php?group=parallel</id>
</source>
</entry>
<entry xml:lang="en">
<title type="html" xml:lang="en">Version 3.7</title>
<link href="http://savannah.gnu.org/forum/forum.php?forum_id=9450"/>
<id>http://savannah.gnu.org/forum/forum.php?forum_id=9450</id>
<updated>2019-06-21T13:15:09+00:00</updated>
<summary type="html" xml:lang="en"></summary>
<content type="html" xml:lang="en"><p>Version 3.7 of GNU mailutils is <a href="https://ftp.gnu.org/gnu/mailutils/mailutils-3.7.tar.gz">available for download</a>.
<br />
</p>
<p>This version introduces a new format for mailboxes: <strong>dotmail</strong>. Dotmail is a replacement for traditional mbox format, proposed by
<br />
Kurt Hackenberg. A dotmail mailbox is a single disk file, where messages are stored sequentially. Each message ends with a single
<br />
dot (similar to the format used in the SMTP DATA command). A dot appearing at the start of the line is doubled, to prevent it from being interpreted as end of message marker.
<br />
</p>
<p>For a complete list of changes, please see the <a href="http://git.savannah.gnu.org/cgit/mailutils.git/plain/NEWS?id=8a92bd208e5cf9f2a9f6b347051bf824b8c0995c">NEWS file</a>.<br />
</p></content>
<author>
<name>Sergey Poznyakoff</name>
<uri>http://savannah.gnu.org/news/atom.php?group=mailutils</uri>
</author>
<source>
<title type="html">GNU Mailutils - News</title>
<link rel="self" href="http://savannah.gnu.org/news/atom.php?group=mailutils"/>
<id>http://savannah.gnu.org/news/atom.php?group=mailutils</id>
</source>
</entry>
<entry xml:lang="en">
<title type="html" xml:lang="non-html">GNU Guile 2.2.5 released</title>
<link href="https://www.gnu.org/software/guile/news/gnu-guile-225-released.html"/>
<id>https://www.gnu.org/software/guile/news/gnu-guile-225-released.html</id>
<updated>2019-06-20T11:20:00+00:00</updated>
<summary type="html" xml:lang="non-html"></summary>
<content type="html" xml:lang="en"><p>We are pleased to announce GNU Guile 2.2.5, the fifth bug-fix
release in the new 2.2 stable release series. This release represents
100 commits by 11 people since version 2.2.4. It fixes bugs that
had accumulated over the last few months, notably in the SRFI-19 date
and time library and in the <code>(web uri)</code> module. This release also
greatly improves performance of bidirectional pipes, and introduces the
new <code>get-bytevector-some!</code> binary input primitive that made it possible.</p><p>Guile 2.2.5 can be downloaded from <a href="https://www.gnu.org/software/guile/download">the usual
places</a>.</p><p>See the <a href="https://lists.gnu.org/archive/html/guile-devel/2019-06/msg00045.html">release
announcement</a>
for details.</p><p>Besides, we remind you that Guile 3.0 is in the works, and that you can
try out <a href="https://www.gnu.org/software/guile/news/gnu-guile-292-beta-released.html">version 2.9.2, which is the latest beta release of what will
become
3.0</a>.</p><p>Enjoy!</p></content>
<author>
<name>Ludovic Courtès</name>
<email>[email protected]</email>
</author>
<source>
<title type="html">GNU's programming and extension language</title>
<subtitle type="html">Recent Posts</subtitle>
<link rel="self" href="https://www.gnu.org/software/guile/news/feed.xml"/>
<id>https://www.gnu.org/software/guile</id>
</source>
</entry>
<entry xml:lang="en">
<title type="html" xml:lang="en">Double the movement: Inspire someone to explore free software</title>
<link href="http://www.fsf.org/blogs/community/double-the-movement-inspire-someone-to-explore-free-software"/>
<id>http://www.fsf.org/blogs/community/double-the-movement-inspire-someone-to-explore-free-software</id>
<updated>2019-06-19T21:03:10+00:00</updated>
<summary type="html" xml:lang="en"></summary>
<content type="html" xml:lang="en"><p><img alt="double the movement" src="https://static.fsf.org/nosvn/images/badges/Spring19-dark-age.png" style="margin-top: 4px;" width="540" /> </p>
<p>Thank you for being part of our exceptionally generous community. Your
interest in our mission is what got us where we are, in position to
succeed if we keep at it. While it's incredible to have hundreds of
thousands of subscribers around the world, we need to connect with
millions if we're to realize a world free of proprietary software. This
spring, we have set ourselves goals to reach 200 new members and
400 donations before July 15th, and to achieve them, we need your
help. Please take this moment to publicly share your passion for free
software. If each free software supporter inspires just one other, we
can double our strength.</p>
<p>We tasked free software designer <a href="https://raghukamath.com/">Raghavendra Kamath</a> with creating
some inspiring visual images to help us spread our message
further. You can find these banners and profile images, including
their embed codes, <a href="https://www.fsf.org/resources/badges">here</a>. Sharing these images online might inspire
someone to explore free software, and may give reasons for you to
educate your friends and family about why free software matters. Use
the hashtag #ISupportFreeSoftware when you share the images online or
on your social media. </p>
<p>Here are some more ways to help grow our movement:</p>
<ul>
<li>
<p>If you can spare a monthly $10 ($5 for students), your contribution
in the form of an <a href="https://my.fsf.org/join?pk_campaign=fr_sp2019&amp;pk_source=email1">Associate Membership</a> is the strongest vote of
confidence you can give us. For less than a subscription to a
<a href="https://www.defectivebydesign.org/">Digital Restrictions Management</a> (DRM)-controlled streaming service,
your membership will serve as a testament that our work is used,
read, and making its way through the world. In appreciation, we
offer Associate Members many <a href="https://www.fsf.org/associate/benefits">benefits</a>.</p>
</li>
<li>
<p>Inspire someone you know to become an Associate Member, or gift
a membership to a friend following the <a href="https://www.fsf.org/associate/gift">instructions in this
link</a>. </p>
</li>
<li>
<p><a href="https://my.fsf.org/donate?pk_campaign=fr_sp2019&amp;pk_source=email1">Donate</a> any amount suitable to your household, and have a look
at <a href="https://www.fsf.org/about/ways-to-donate">other ways to donate</a> to see if there is a simple action you
can take to give your support to the FSF. </p>
</li>
<li>
<p>Start a conversation about free software and why you support the FSF
with someone you know.</p>
</li>
<li>
<p><a href="https://www.fsf.org/share">Share</a> your victories and experiences with free software online
or in person with your community. Please use the <a href="https://www.fsf.org/resources/badges">images
provided</a> and the hashtag #ISupportFreeSoftware to help
stimulate other people to do the same.</p>
</li>
</ul>
<p>Your generosity and outspokenness fuel our message and allow us to
continue to advocate on your behalf. Our fourteen hardworking staff
use your contributions wisely, earning yet another best possible
rating of four stars from Charity Navigator this last year. You can
read our <a href="https://www.fsf.org/about/financial">financial statements</a> and our <a href="https://www.fsf.org/annual-reports">annual reports</a>
online.</p>
<p>Individual financial contributions and spreading the word like this
are forms of activism we need much more of if we're to overcome
trillions of proprietary software dollars. We need to grow and
diversify if we're to make respect for user freedom the default,
rather than a constantly endangered niche. We've shown that with your
support we can succeed together against far greater resources -- thank
you for sticking with us and giving everything you can to bring about
a brighter future.</p>
<p><a href="https://www.fsf.org/appeal">Read more about our online appeal!</a></p></content>
<author>
<name>FSF Blogs</name>
<uri>http://www.fsf.org/blogs/recent-blog-posts</uri>
</author>
<source>
<title type="html">FSF blogs</title>
<subtitle type="html">Writing by representatives of the Free Software Foundation.</subtitle>
<link rel="self" href="http://static.fsf.org/fsforg/rss/blogs.xml"/>
<id>http://www.fsf.org/blogs/recent-blog-posts</id>
</source>
</entry>
<entry xml:lang="en">
<title type="html" xml:lang="en">Event - GNU Hackers Meeting (Madrid, Spain)</title>
<link href="http://www.fsf.org/events/event-20190904-madrid-gnuhackersmeeting"/>
<id>http://www.fsf.org/events/event-20190904-madrid-gnuhackersmeeting</id>
<updated>2019-06-19T16:35:12+00:00</updated>
<summary type="html" xml:lang="en"></summary>
<content type="html" xml:lang="en"><p>Twelve years after it's first edition in Orense, the GNU Hackers
Meeting (2019-09-04–06) will help in Spain again. This is an
opportunity to meet, hack, and learn with other free software
enthusiasts.</p>
<p>See <a href="https://www.gnu.org/ghm/2019/">event page</a> for registration, call-for-talks, accommodations,
transportation, and other information.</p>
<p><strong>Location:</strong> <em><a href="http://www.etsisi.upm.es/">ETSISI</a> (Escuela Técnica Superior de Ingeniería de Sistemas Informáticos), Universidad Politécnica de Madrid, Calle Alan Turing s/n (Carretera de Valencia Km 7), 28031 Madrid, España</em></p>
<p>Please fill out our contact form, so that <a href="https://my.fsf.org/civicrm/profile/create?gid=69&amp;reset=1">we
can contact you about future events in and around Madrid.</a></p></content>
<author>
<name>FSF Events</name>
<uri>http://www.fsf.org/events/aggregator</uri>
</author>
<source>
<title type="html">Events</title>
<subtitle type="html">Site Events</subtitle>
<link rel="self" href="http://static.fsf.org/fsforg/rss/events.xml"/>
<id>http://www.fsf.org/events/aggregator</id>
</source>
</entry>
<entry xml:lang="en">
<title type="html" xml:lang="en">Richard Stallman - "Are we facing surveillance like in China?" (Frankurt, Germany)</title>
<link href="http://www.fsf.org/events/rms-20190715-frankfurt"/>
<id>http://www.fsf.org/events/rms-20190715-frankfurt</id>
<updated>2019-06-18T08:15:00+00:00</updated>
<summary type="html" xml:lang="en"></summary>
<content type="html" xml:lang="en"><blockquote><p>Digital technology has enabled governments to impose surveillance
that Stalin could only dream of, making it next to impossible to
talk with a reporter (or do most things) unmonitored. This puts
democracy and human rights danger, as illustrated by the
totalitarian regime of China today.</p>
<p>Stallman will present the absolute upper limit on surveillance
of the public compatible with democracy, and present ways to
design systems that don't collect dossiers on people, except those
designated by courts based on valid specific suspicion of crime.</p></blockquote>
<p>This speech by Richard Stallman will be nontechnical, admission is
gratis, and the public is encouraged to attend.</p>
<p><strong>Location:</strong> <em>Festsaal, Casino (<a href="http://www.uni-frankfurt.de/73177180/GU_Lageplan_Campus_Westend_0318_Mensa_Bib_ENGL.pdf?">#7</a>),
Campus Westend, Johann Wolfgang Goethe-Universität Frankfurt am Main,
GrĂźneburgplatz 1, 60323 Frankfurt</em></p>
<p>Please fill out our contact form, so that <a href="https://my.fsf.org/civicrm/profile/create?gid=393&amp;reset=1">we
can contact you about future events in and around Frankfurt.</a></p></content>
<author>
<name>FSF Events</name>
<uri>http://www.fsf.org/events/aggregator</uri>
</author>
<source>
<title type="html">Events</title>
<subtitle type="html">Site Events</subtitle>
<link rel="self" href="http://static.fsf.org/fsforg/rss/events.xml"/>
<id>http://www.fsf.org/events/aggregator</id>
</source>
</entry>
<entry xml:lang="en">
<title type="html" xml:lang="en">Substitutes are now available as lzip</title>
<link href="https://gnu.org/software/guix/blog/2019/substitutes-are-now-available-as-lzip/"/>
<id>https://gnu.org/software/guix/blog/2019/substitutes-are-now-available-as-lzip/</id>
<updated>2019-06-17T12:30:00+00:00</updated>
<summary type="html" xml:lang="en"></summary>
<content type="html" xml:lang="en"><p>For a long time, our build farm at ci.guix.gnu.org has been delivering
<a href="https://www.gnu.org/software/guix/manual/en/html_node/Substitutes.html">substitutes</a>
(pre-built binaries) compressed with gzip. Gzip was never the best
choice in terms of compression ratio, but it was a reasonable and
convenient choice: it’s rock-solid, and zlib made it easy for us to have
<a href="https://git.savannah.gnu.org/cgit/guix.git/tree/guix/zlib.scm">Guile
bindings</a>
to perform in-process compression in our multi-threaded <a href="https://www.gnu.org/software/guix/manual/en/html_node/Invoking-guix-publish.html"><code>guix publish</code></a>
server.</p><p>With the exception of building software from source, downloads take the
most time of Guix package upgrades. If users can download less,
upgrades become faster, and happiness ensues. Time has come to improve
on this, and starting from early June, Guix can publish and fetch
<a href="https://nongnu.org/lzip/">lzip</a>-compressed substitutes, in addition to
gzip.</p><h1>Lzip</h1><p><a href="https://nongnu.org/lzip/">Lzip</a> is a relatively little-known
compression format, initially developed by Antonio Diaz Diaz ca. 2013.
It has several C and C++ implementations with surprisingly few lines of
code, which is always reassuring. One of its distinguishing features is
a very good compression ratio with reasonable CPU and memory
requirements, <a href="https://nongnu.org/lzip/lzip_benchmark.html">according to benchmarks published by the
authors</a>.</p><p><a href="https://nongnu.org/lzip/lzlib.html">Lzlib</a> provides a well-documented C
interface and Pierre Neidhardt set out to write bindings for that
library, which eventually landed as the <a href="https://git.savannah.gnu.org/cgit/guix.git/tree/guix/lzlib.scm"><code>(guix lzlib)</code>
module</a>.</p><p>With this in place we were ready to start migrating our tools, and then
our build farm, to lzip compression, so we can all enjoy smaller
downloads. Well, easier said than done!</p><h1>Migrating</h1><p>The compression format used for substitutes is not a core component like
it can be in “traditional” binary package formats <a href="https://lwn.net/Articles/789449/">such as
<code>.deb</code></a> since Guix is conceptually a
“source-based” distro. However, deployed Guix installations did not
support lzip, so we couldn’t just switch our build farm to lzip
overnight; we needed to devise a transition strategy.</p><p>Guix asks for the availability of substitutes over HTTP. For example, a
question such as:</p><blockquote><p>“Dear server, do you happen to have a binary of
<code>/gnu/store/6yc4ngrsig781bpayax2cg6pncyhkjpq-emacs-26.2</code> that I could download?”</p></blockquote><p>translates into prose to an HTTP GET of
<a href="https://ci.guix.gnu.org/6yc4ngrsig781bpayax2cg6pncyhkjpq.narinfo">https://ci.guix.gnu.org/6yc4ngrsig781bpayax2cg6pncyhkjpq.narinfo</a>,
which returns something like:</p><pre><code>StorePath: /gnu/store/6yc4ngrsig781bpayax2cg6pncyhkjpq-emacs-26.2
URL: nar/gzip/6yc4ngrsig781bpayax2cg6pncyhkjpq-emacs-26.2
Compression: gzip
NarHash: sha256:0h2ibqpqyi3z0h16pf7ii6l4v7i2wmvbrxj4ilig0v9m469f6pm9
NarSize: 134407424
References: 2dk55i5wdhcbh2z8hhn3r55x4873iyp1-libxext-1.3.3 …
FileSize: 48501141
System: x86_64-linux
Deriver: 6xqibvc4v8cfppa28pgxh0acw9j8xzhz-emacs-26.2.drv
Signature: 1;berlin.guixsd.org;KHNpZ25hdHV…</code></pre><p>(This narinfo format is inherited from <a href="https://nixos.org/nix/">Nix</a> and
implemented
<a href="https://git.savannah.gnu.org/cgit/guix.git/tree/guix/scripts/substitute.scm?id=121d9d1a7a2406a9b1cbe22c34343775f5955b34#n283">here</a>
and
<a href="https://git.savannah.gnu.org/cgit/guix.git/tree/guix/scripts/publish.scm?id=121d9d1a7a2406a9b1cbe22c34343775f5955b34#n265">here</a>.)
This tells us we can download the actual binary from
<code>/nar/gzip/…-emacs-26.2</code>, and that it will be about 46 MiB (the
<code>FileSize</code> field.) This is what <code>guix publish</code> serves.</p><p>The trick we came up with was to allow <code>guix publish</code> to advertise
several URLs, one per compression format. Thus, for recently-built
substitutes, we get something <a href="https://ci.guix.gnu.org/mvhaar2iflscidl0a66x5009r44fss15.narinfo">like
this</a>:</p><pre><code>StorePath: /gnu/store/mvhaar2iflscidl0a66x5009r44fss15-gimp-2.10.12
URL: nar/gzip/mvhaar2iflscidl0a66x5009r44fss15-gimp-2.10.12
Compression: gzip
FileSize: 30872887
URL: nar/lzip/mvhaar2iflscidl0a66x5009r44fss15-gimp-2.10.12
Compression: lzip
FileSize: 18829088
NarHash: sha256:10n3nv3clxr00c9cnpv6x7y2c66034y45c788syjl8m6ga0hbkwy
NarSize: 94372664
References: 05zlxc7ckwflz56i6hmlngr86pmccam2-pcre-8.42 …
System: x86_64-linux
Deriver: vi2jkpm9fd043hm0839ibbb42qrv5xyr-gimp-2.10.12.drv
Signature: 1;berlin.guixsd.org;KHNpZ25hdHV…</code></pre><p>Notice that there are two occurrences of the <code>URL</code>, <code>Compression</code>, and
<code>FileSize</code> fields: one for gzip, and one for lzip. Old Guix instances
will just pick the first one, gzip; newer Guix will pick whichever
supported method provides the smallest <code>FileSize</code>, usually lzip. This
will make migration trivial in the future, should we add support for
other compression methods.</p><p>Users need to upgrade their Guix daemon to benefit from lzip. On a
“foreign distro”, simply run <code>guix pull</code> as root. On standalone Guix
systems, run <code>guix pull &amp;&amp; sudo guix system reconfigure /etc/config.scm</code>. In both cases, the daemon has to be restarted, be it
with <code>systemctl restart guix-daemon.service</code> or with <code>herd restart guix-daemon</code>.</p><h1>First impressions</h1><p>This new gzip+lzip scheme has been deployed on ci.guix.gnu.org for a
week. Specifically, we run <code>guix publish -C gzip:9 -C lzip:9</code>, meaning
that we use the highest compression ratio for both compression methods.</p><p>Currently, only a small subset of the package substitutes are available
as both lzip and gzip; those that were already available as gzip have
not been recompressed. The following Guile program that taps into the
API of <a href="https://www.gnu.org/software/guix/manual/en/html_node/Invoking-guix-weather.html"><code>guix weather</code></a>
allows us to get some insight:</p><pre><code class="language-scheme">(use-modules (gnu) (guix)
(guix monads)
(guix scripts substitute)
(srfi srfi-1)
(ice-9 match))
(define all-packages
(@@ (guix scripts weather) all-packages))
(define package-outputs
(@@ (guix scripts weather) package-outputs))
(define (fetch-lzip-narinfos)
(mlet %store-monad ((items (package-outputs (all-packages))))
(return
(filter (lambda (narinfo)
(member "lzip" (narinfo-compressions narinfo)))
(lookup-narinfos "https://ci.guix.gnu.org" items)))))
(define (lzip/gzip-ratio narinfo)
(match (narinfo-file-sizes narinfo)
((gzip lzip)
(/ lzip gzip))))
(define (average lst)
(/ (reduce + 0 lst)
(length lst) 1.))</code></pre><p>Let’s explore this at the
<a href="https://en.wikipedia.org/wiki/Read%E2%80%93eval%E2%80%93print_loop">REPL</a>:</p><pre><code class="language-scheme">scheme@(guile-user)&gt; (define lst
(with-store s
(run-with-store s (fetch-lzip-narinfos))))
computing 9,897 package derivations for x86_64-linux...
updating substitutes from 'https://ci.guix.gnu.org'... 100.0%
scheme@(guile-user)&gt; (length lst)
$4 = 2275
scheme@(guile-user)&gt; (average (map lzip/gzip-ratio lst))
$5 = 0.7398994395478715</code></pre><p>As of this writing, around 20% of the package substitutes are
available as lzip, so take the following stats with a grain of salt.
Among those, the lzip-compressed substitute is on average 26% smaller
than the gzip-compressed one. What if we consider only packages bigger
than 5 MiB uncompressed?</p><pre><code class="language-scheme">scheme@(guile-user)&gt; (define biggest
(filter (lambda (narinfo)
(&gt; (narinfo-size narinfo)
(* 5 (expt 2 20))))
lst))
scheme@(guile-user)&gt; (average (map lzip/gzip-ratio biggest))
$6 = 0.5974238562384483
scheme@(guile-user)&gt; (length biggest)
$7 = 440</code></pre><p>For those packages, lzip yields substitutes that are 40% smaller on
average. Pretty nice! Lzip decompression is slightly more
CPU-intensive than gzip decompression, but downloads are
bandwidth-bound, so the benefits clearly outweigh the costs.</p><h1>Going forward</h1><p>The switch from gzip to lzip has the potential to make upgrades “feel”
faster, and that is great in itself.</p><p>Fundamentally though, we’ve always been looking in this project at
peer-to-peer solutions with envy. Of course, the main motivation is to
have a community-supported and resilient infrastructure, rather than a
centralized one, and that vision goes <a href="https://www.gnu.org/software/guix/blog/2017/reproducible-builds-a-status-update/">hand-in-hand with reproducible
builds</a>.</p><p>We started working on <a href="https://issues.guix.gnu.org/issue/33899">an extension to publish and fetch
substitutes</a> over
<a href="https://ipfs.io/">IPFS</a>. Thanks to its content-addressed nature, IPFS
has the potential to further reduce the amount of data that needs to be
downloaded on an upgrade.</p><p>The good news is that IPFS developers are also <a href="https://github.com/ipfs/package-managers">interested in working
with package manager
developers</a>, and I bet
there’ll be interesting discussions at <a href="https://camp.ipfs.io/">IPFS
Camp</a> in just a few days. We’re eager to pursue
our IPFS integration work, and if you’d like to join us and hack the
good hack, <a href="https://www.gnu.org/software/guix/contact/">let’s get in
touch!</a></p><h4>About GNU Guix</h4><p><a href="https://www.gnu.org/software/guix">GNU Guix</a> is a transactional package
manager and an advanced distribution of the GNU system that <a href="https://www.gnu.org/distros/free-system-distribution-guidelines.html">respects
user
freedom</a>.
Guix can be used on top of any system running the kernel Linux, or it
can be used as a standalone operating system distribution for i686,
x86_64, ARMv7, and AArch64 machines.</p><p>In addition to standard package management features, Guix supports
transactional upgrades and roll-backs, unprivileged package management,
per-user profiles, and garbage collection. When used as a standalone
GNU/Linux distribution, Guix offers a declarative, stateless approach to
operating system configuration management. Guix is highly customizable
and hackable through <a href="https://www.gnu.org/software/guile">Guile</a>
programming interfaces and extensions to the
<a href="http://schemers.org">Scheme</a> language.</p></content>
<author>
<name>Ludovic Courtès</name>
<uri>https://gnu.org/software/guix/blog/</uri>
</author>
<source>
<title type="html">GNU Guix — Blog</title>
<link rel="self" href="https://www.gnu.org/software/guix/news/feed.xml"/>
<id>https://gnu.org/software/guix/feeds/blog.atom</id>
</source>
</entry>
<entry xml:lang="en">
<title type="html" xml:lang="en">2019-06-05: GNUnet 0.11.5 released</title>
<link href="https://gnunet.org/#gnunet-0.11.5-release"/>
<id>https://gnunet.org/#gnunet-0.11.5-release</id>
<updated>2019-06-05T00:00:00+00:00</updated>
<summary type="html" xml:lang="en"></summary>
<content type="html" xml:lang="en"><h3>
<a name="gnunet-0.11.5-release">2019-06-05: GNUnet 0.11.5 released</a>
</h3>
<p>
We are pleased to announce the release of GNUnet 0.11.5.
</p>
<p>
This is a bugfix release for 0.11.4, mostly fixing a few
minor bugs and improving performance, in particular for
identity management with a large number of egos.
In the wake of this release, we also launched the
<a href="https://rest.gnunet.org">REST API documentation</a>.
In
terms of usability, users should be aware that there are still a large
number of known open issues in particular with respect to ease of use,
but also some critical privacy issues especially for mobile users.
Also, the nascent network is tiny (about 200 peers) and thus unlikely to
provide good anonymity or extensive amounts of interesting
information. As a result, the 0.11.5 release is still only suitable
for early adopters with some reasonable pain tolerance.
</p>
<h4>Download links</h4>
<ul>
<li><a href="http://ftpmirror.gnu.org/gnunet/gnunet-0.11.5.tar.gz">http://ftpmirror.gnu.org/gnunet/gnunet-0.11.5.tar.gz</a></li>
<li><a href="http://ftpmirror.gnu.org/gnunet/gnunet-0.11.5.tar.gz.sig">http://ftpmirror.gnu.org/gnunet/gnunet-0.11.5.tar.gz.sig</a></li>
<li><a href="http://ftpmirror.gnu.org/gnunet/gnunet-gtk-0.11.5.tar.gz">http://ftpmirror.gnu.org/gnunet/gnunet-gtk-0.11.5.tar.gz</a></li>
<li><a href="http://ftpmirror.gnu.org/gnunet/gnunet-gtk-0.11.5.tar.gz.sig">http://ftpmirror.gnu.org/gnunet/gnunet-gtk-0.11.5.tar.gz.sig</a></li>
<li><a href="http://ftpmirror.gnu.org/gnunet/gnunet-fuse-0.11.0.tar.gz">http://ftpmirror.gnu.org/gnunet/gnunet-fuse-0.11.0.tar.gz</a></li>
<li><a href="http://ftpmirror.gnu.org/gnunet/gnunet-fuse-0.11.0.tar.gz.sig">http://ftpmirror.gnu.org/gnunet/gnunet-fuse-0.11.0.tar.gz.sig</a></li>
</ul>
<p>
gnunet-gtk saw some minor changes to adopt it to API changes in the main code
related to the identity improvements.
gnunet-fuse was not released again, as there were no
changes and the 0.11.0 version is expected to continue to work fine
with gnunet-0.11.5.
</p>
<p>
Note that due to mirror synchronization, not all links might be functional
early after the release. For direct access try <a href="http://ftp.gnu.org/gnu/gnunet/">http://ftp.gnu.org/gnu/gnunet/</a>
</p>
<h4>Noteworthy changes in 0.11.5 (since 0.11.4)</h4>
<ul>
<li>
<tt>gnunet-identity</tt> is much faster when creating or deleting
egos given a large number of existing egos.
</li>
<li>
GNS now supports CAA records.
</li>
<li>
Documentation, comments and code quality was improved.
</li>
</ul>
<h4>Known Issues</h4>
<ul>
<li>
There are known major design issues in the TRANSPORT, ATS and CORE subsystems
which will need to be addressed in the future to achieve acceptable usability,
performance and security.
</li>
<li>
There are known moderate implementation limitations in CADET that
negatively impact performance. Also CADET may unexpectedly deliver messages out-of-order.
</li>
<li>
There are known moderate design issues in FS that also impact
usability and performance.
</li>
<li>
There are minor implementation limitations in SET that create
unnecessary attack surface for availability.
</li>
<li>
The RPS subsystem remains experimental.
</li>
<li>
Some high-level tests in the test-suite fail non-deterministically due to
the low-level TRANSPORT issues.
</li>
</ul>
<p>
In addition to this list, you may also want to consult our bug tracker
at <a href="https://bugs.gnunet.org/">bugs.gnunet.org</a> which lists
about 190 more specific issues.
</p>
<h4>Thanks</h4>
<p>
This release was the work of many people. The following people
contributed code and were thus easily identified:
Christian Grothoff, Florian Dold, Marcello Stanisci, ng0, Martin Schanzenbach and Bernd Fix.
</p></content>
<author>
<name>GNUnet News</name>
<uri>https://gnunet.org</uri>
</author>
<source>
<title type="html">GNUnet.org</title>
<subtitle type="html">News from GNUnet</subtitle>
<link rel="self" href="https://gnunet.org/rss.xml"/>
<id>https://gnunet.org</id>
</source>
</entry>
<entry xml:lang="en">
<title type="html" xml:lang="en">2.23 released</title>
<link href="http://savannah.gnu.org/forum/forum.php?forum_id=9442"/>
<id>http://savannah.gnu.org/forum/forum.php?forum_id=9442</id>
<updated>2019-06-04T08:41:09+00:00</updated>
<summary type="html" xml:lang="en"></summary>
<content type="html" xml:lang="en"><p>New version (2.23) was released. Main changes were in build system, so please report any issues you notice.<br />
</p></content>
<author>
<name>Gray Wolf</name>
<uri>http://savannah.gnu.org/news/atom.php?group=gengetopt</uri>
</author>
<source>
<title type="html">GNU Gengetopt - News</title>
<link rel="self" href="http://savannah.gnu.org/news/atom.php?group=gengetopt"/>
<id>http://savannah.gnu.org/news/atom.php?group=gengetopt</id>
</source>
</entry>
<entry xml:lang="en">
<title type="html" xml:lang="en">pictie, my c++-to-webassembly workbench</title>
<link href="http://wingolog.org/archives/2019/06/03/pictie-my-c-to-webassembly-workbench"/>
<id>http://wingolog.org/2019/06/03/pictie-my-c-to-webassembly-workbench</id>
<updated>2019-06-03T10:10:38+00:00</updated>
<summary type="html" xml:lang="en"></summary>
<content type="html" xml:lang="en"><div><p>Hello, interwebs! Today I'd like to share a little skunkworks project with y'all: <a href="https://github.com/wingo/pictie">Pictie</a>, a workbench for WebAssembly C++ integration on the web.</p><p><b id="pictie-status">loading pictie...</b></p><div id="pictie-log"></div><form hidden="1" id="pictie-form">
<label for="entry" id="pictie-prompt">&gt; </label>
<input id="pictie-entry" name="entry" size="40" type="text" />
</form><p>&lt;noscript&gt;
JavaScript disabled, no pictie demo. See <a href="https://github.com/wingo/pictie/">the pictie web page</a> for more information.
&lt;/noscript&gt;&gt;&amp;&amp;&lt;&amp;&gt;&gt;&gt;&amp;&amp;&gt;&lt;&lt;&gt;&gt;&amp;&amp;&lt;&gt;&lt;&gt;&gt;</p><p><b>wtf just happened????!?</b></p><p>So! If everything went well, above you have some colors and a prompt that accepts Javascript expressions to evaluate. If the result of evaluating a JS expression is a painter, we paint it onto a canvas.</p><p>But allow me to back up a bit. These days everyone is talking about WebAssembly, and I think with good reason: just as many of the world's programs run on JavaScript today, tomorrow much of it will also be in languages compiled to WebAssembly. JavaScript isn't going anywhere, of course; it's around for the long term. It's the "also" aspect of WebAssembly that's interesting, that it appears to be a computing substrate that is compatible with JS and which can extend the range of the kinds of programs that can be written for the web.</p><p>And yet, it's early days. What are programs of the future going to look like? What elements of the web platform will be needed when we have systems composed of WebAssembly components combined with JavaScript components, combined with the browser? Is it all going to work? Are there missing pieces? What's the status of the toolchain? What's the developer experience? What's the user experience?</p><p>When you look at the current set of applications targetting WebAssembly in the browser, mostly it's games. While compelling, games don't provide a whole lot of insight into the shape of the future web platform, inasmuch as there doesn't have to be much JavaScript interaction when you have an already-working C++ game compiled to WebAssembly. (Indeed, much of the incidental interactions with JS that are currently necessary -- bouncing through JS in order to call WebGL -- people are actively working on removing all of that overhead, so that WebAssembly can call platform facilities (WebGL, etc) directly. But I digress!)</p><p>For WebAssembly to really succeed in the browser, there should also be incremental stories -- what does it look like when you start to add WebAssembly modules to a system that is currently written mostly in JavaScript?</p><p>To find out the answers to these questions and to evaluate potential platform modifications, I needed a small, standalone test case. So... I wrote one? It seemed like a good idea at the time.</p><p><b>pictie is a test bed</b></p><p>Pictie is a simple, standalone C++ graphics package implementing an algebra of painters. It was created not to be a great graphics package but rather to be a test-bed for compiling C++ libraries to WebAssembly. You can read more about it on <a href="https://github.com/wingo/pictie">its github page</a>.</p><p>Structurally, pictie is a modern C++ library with a functional-style interface, smart pointers, reference types, lambdas, and all the rest. We use emscripten to compile it to WebAssembly; you can see more information on how that's done in the repository, or check the <a href="https://github.com/wingo/pictie/blob/master/README.md#webassembly">README</a>.</p><p>Pictie is inspired by Peter Henderson's "Functional Geometry" (<a href="http://pmh-systems.co.uk/phAcademic/papers/funcgeo.pdf">1982</a>, <a href="https://eprints.soton.ac.uk/257577/1/funcgeo2.pdf">2002</a>). "Functional Geometry" inspired the <a href="https://sarabander.github.io/sicp/html/2_002e2.xhtml#g_t2_002e2_002e4">Picture language</a> from the well-known <i>Structure and Interpretation of Computer Programs</i> computer science textbook.</p><p><b>prototype in action</b></p><p>So far it's been surprising how much stuff just works. There's still lots to do, but just getting a C++ library on the web is pretty easy! I advise you to take a look to see the details.</p><p>If you are thinking of dipping your toe into the WebAssembly water, maybe take a look also at Pictie when you're doing your back-of-the-envelope calculations. You can use it or a prototype like it to determine the effects of different compilation options on compile time, load time, throughput, and network trafic. You can check if the different binding strategies are appropriate for your C++ idioms; Pictie currently uses <a href="https://emscripten.org/docs/porting/connecting_cpp_and_javascript/embind.html">embind</a> <a href="https://github.com/wingo/pictie/blob/master/pictie.bindings.cc">(source)</a>, but <a href="https://emscripten.org/docs/porting/connecting_cpp_and_javascript/embind.html">I would like to compare to WebIDL as well</a>. You might also use it if you're considering what shape your C++ library should have to have a minimal overhead in a WebAssembly context.</p><p>I use Pictie as a test-bed when working on the web platform; the <a href="https://github.com/tc39/proposal-weakrefs">weakref proposal</a> which adds finalization, <a href="https://github.com/emscripten-core/emscripten/pull/8687">leak detection</a>, and working on the binding layers around Emscripten. Eventually I'll be able to use it in other contexts as well, with the <a href="https://github.com/WebAssembly/webidl-bindings/blob/master/proposals/webidl-bindings/Explainer.md">WebIDL bindings</a> proposal, typed objects, and <a href="https://github.com/WebAssembly/webidl-bindings/blob/master/proposals/webidl-bindings/Explainer.md">GC</a>.</p><p><b>prototype the web forward</b></p><p>As the browser and adjacent environments have come to dominate programming in practice, we lost a bit of the delightful variety from computing. JS is a great language, but it shouldn't be the only medium for programs. WebAssembly is part of this future world, waiting in potentia, where applications for the web can be written in any of a number of languages. But, this future world will only arrive if it "works" -- if all of the various pieces, from standards to browsers to toolchains to virtual machines, only if all of these pieces fit together in some kind of sensible way. Now is the early phase of annealing, when the platform as a whole is actively searching for its new low-entropy state. We're going to need a lot of prototypes to get from here to there. In that spirit, may your prototypes be numerous and soon replaced. Happy annealing!</p></div></content>
<author>
<name>Andy Wingo</name>
<uri>http://wingolog.org/</uri>
</author>
<source>
<title type="html">wingolog</title>
<subtitle type="html">A mostly dorky weblog by Andy Wingo</subtitle>
<link rel="self" href="http://wingolog.org/feed/atom"/>
<id>http://wingolog.org/feed/atom</id>
</source>
</entry>
<entry xml:lang="en">
<title type="html" xml:lang="en">GNU Unifont 12.1.02 Released</title>
<link href="http://savannah.gnu.org/forum/forum.php?forum_id=9440"/>
<id>http://savannah.gnu.org/forum/forum.php?forum_id=9440</id>
<updated>2019-06-01T22:43:49+00:00</updated>
<summary type="html" xml:lang="en"></summary>
<content type="html" xml:lang="en"><p><strong>1 June 2019</strong> Unifont 12.1.02 is now available. This version introduces a <strong>Japanese TrueType version</strong>, unifont_jp, replacing over 10,000 ideographs from the default Unifont build with kanji from the public domain Jiskan16 font. This version also contains redrawn Devanagari and Bengali glyphs. Full details are in the ChangeLog file.
<br />
</p>
<p>Download this release at:
<br />
</p>
<p><a href="https://ftpmirror.gnu.org/unifont/unifont-12.1.02/">https://ftpmirror.gnu.org/unifont/unifont-12.1.02/</a>
<br />
</p>
<p>or if that fails,
<br />
</p>
<p><a href="https://ftp.gnu.org/gnu/unifont/unifont-12.1.02/">https://ftp.gnu.org/gnu/unifont/unifont-12.1.02/</a>
<br />
</p>
<p>or, as a last resort,
<br />
</p>
<p><a href="ftp://ftp.gnu.org/gnu/unifont/unifont-12.1.02/">ftp://ftp.gnu.org/gnu/unifont/unifont-12.1.02/</a><br />
</p></content>
<author>
<name>Paul Hardy</name>
<uri>http://savannah.gnu.org/news/atom.php?group=unifont</uri>
</author>
<source>
<title type="html">Unifont - News</title>
<link rel="self" href="http://savannah.gnu.org/news/atom.php?group=unifont"/>
<id>http://savannah.gnu.org/news/atom.php?group=unifont</id>
</source>
</entry>
<entry xml:lang="en">
<title type="html" xml:lang="en">CANCELLED - Richard Stallman - "The Free Software Movement" (Mayhew, MS)</title>
<link href="http://www.fsf.org/events/rms-20190622-mayhew"/>
<id>http://www.fsf.org/events/rms-20190622-mayhew</id>
<updated>2019-05-30T17:10:00+00:00</updated>
<summary type="html" xml:lang="en"></summary>
<content type="html" xml:lang="en"><strike><blockquote>The Free Software Movement campaigns for computer users'
freedom to cooperate and control their own computing. The Free
Software Movement developed the GNU operating system, typically used
together with the kernel Linux, specifically to make these freedoms
possible.</blockquote></strike>
<strike></strike><p><strike>This speech by Richard Stallman will be nontechnical, admission is
gratis, and the public is encouraged to attend.</strike>
<strike></strike></p><p><strike><strong>Location:</strong> <em>Lyceum, 8731 South Frontage Rd., Mayhew, MS 39753</em></strike>
<strike></strike></p><p><strike>Please fill out our contact form, so that <a href="https://my.fsf.org/civicrm/profile/create?gid=581&amp;reset=1">we
can contact you about future events in and around Mayhew.</a></strike>
</p><p>The event this speech was going to be part of has been cancelled.</p></content>
<author>
<name>FSF Events</name>
<uri>http://www.fsf.org/events/aggregator</uri>
</author>
<source>
<title type="html">Events</title>
<subtitle type="html">Site Events</subtitle>
<link rel="self" href="http://static.fsf.org/fsforg/rss/events.xml"/>
<id>http://www.fsf.org/events/aggregator</id>
</source>
</entry>
<entry xml:lang="en">
<title type="html" xml:lang="en">Richard Stallman - "Free software and your freedom" (Vienna, Austria)</title>
<link href="http://www.fsf.org/events/rms-20190607-vienna"/>
<id>http://www.fsf.org/events/rms-20190607-vienna</id>
<updated>2019-05-30T16:55:00+00:00</updated>
<summary type="html" xml:lang="en"></summary>
<content type="html" xml:lang="en"><p>
</p><blockquote>
Most computers now contain at least some free software. This success makes it more important than ever to know about the ideas behind free software. Users should be aware of the freedoms it gives us and how to make use of it.
</blockquote>
<blockquote>
As opposed to secrecy and profit orientation, free access to and sharing of knowledge and ideas have the potential to change the world. Knowledge should be treated as a common good. This revolutionary idea was the base on which GNU/Linux and the free and collaborative encyclopedia Wikipedia were built.
</blockquote>
<p></p>
<p>This speech by Richard Stallman will be nontechnical, admission is
gratis, and the public is encouraged to attend.</p>
<p><strong>Location:</strong> <em>Hall: FS0.01, Fachhochschule FH Technikum Wien, Höchstädtplatz 6, KG Brigittenau, 1200 Wien, Österreich</em></p>
<p>Please fill out our contact form, so that <a href="https://my.fsf.org/civicrm/profile/create?gid=300&amp;reset=1">we
can contact you about future events in and around Vienna.</a></p></content>
<author>
<name>FSF Events</name>
<uri>http://www.fsf.org/events/aggregator</uri>
</author>
<source>
<title type="html">Events</title>
<subtitle type="html">Site Events</subtitle>
<link rel="self" href="http://static.fsf.org/fsforg/rss/events.xml"/>
<id>http://www.fsf.org/events/aggregator</id>
</source>
</entry>
<entry xml:lang="en">
<title type="html" xml:lang="non-html">Join the Guile and Guix Days in Strasbourg, June 21–22!</title>
<link href="https://www.gnu.org/software/guile/news/join-guile-guix-days-strasbourg-2019.html"/>
<id>https://www.gnu.org/software/guile/news/join-guile-guix-days-strasbourg-2019.html</id>
<updated>2019-05-28T09:11:00+00:00</updated>
<summary type="html" xml:lang="non-html"></summary>
<content type="html" xml:lang="en"><p>We’re organizing Guile Days at the University of Strasbourg, France,
<a href="https://journeesperl.fr/jp2019/">co-located with the Perl Workshop</a>,
on June 21st and 22nd.</p><p><img alt="Guile Days 2019" src="https://www.gnu.org/software/guile/static/base/img/guile-days-2019.png" /></p><p><em><em>Update</em>: The program is now complete, <a href="https://journeesperl.fr/jp2019/schedule?day=2019-06-21">view the schedule
on-line</a>.</em></p><p>The schedule is not complete yet, but we can already announce a couple
of events:</p><ul><li><em>Getting Started with GNU Guix</em> will be an introductory hands-on
session to <a href="https://www.gnu.org/software/guix/">Guix</a>, targeting an
audience of people who have some experience with GNU/Linux but are
new to Guix.</li><li>During a “<em>code buddy</em>” session, experienced Guile programmers will
be here to get you started programming in Guile, and to answer
questions and provide guidance while you hack at your pace on the
project of your choice.</li></ul><p>If you’re already a Guile or Guix user or developer, consider submitting
by June 8th, <a href="https://journeesperl.fr/jp2019/newtalk">on the web site</a>,
talks on topics such as:</p><ul><li><p>The neat Guile- or Guix-related project you’ve been working on.</p></li><li><p>Cool Guile hacking topics—Web development, databases, system
development, graphical user interfaces, shells, you name it!</p></li><li><p>Fancy Guile technology—concurrent programming with Fibers, crazy
macrology, compiler front-ends, JIT compilation and Guile 3,
development environments, etc.</p></li><li><p>Guixy things: on Guix subsystems, services, the Shepherd, Guile
development with Guix, all things OS-level in Guile, Cuirass,
reproducible builds, bootstrapping, Mes and Gash, all this!</p></li></ul><p>You can also propose hands-on workshops, which could last anything from
an hour to a day. We expect newcomers at this event, people who don’t
know Guile and Guix and want to learn about it. Consider submitting
introductory workshops on Guile and Guix!</p><p>We encourage submissions from people in communities usually
underrepresented in free software, including women, people in sexual
minorities, or people with disabilities.</p><p>We want to make this event a pleasant experience for everyone, and
participation is subject to a <a href="https://journeesperl.fr/jp2019/conduct.html">code of
conduct</a>.</p><p>Many thanks to the organizers of the <a href="https://journeesperl.fr/jp2019/">Perl
Workshop</a> and to the sponsors of the
event: RENATER, Université de Strasbourg, X/Stra, and Worteks.</p></content>
<author>
<name>Ludovic Courtès</name>
<email>[email protected]</email>
</author>
<source>
<title type="html">GNU's programming and extension language</title>
<subtitle type="html">Recent Posts</subtitle>
<link rel="self" href="https://www.gnu.org/software/guile/news/feed.xml"/>
<id>https://www.gnu.org/software/guile</id>
</source>
</entry>
<entry xml:lang="en">
<title type="html" xml:lang="en">Richard Stallman - "Computing, freedom, and privacy" (Brno, Czech Republic)</title>
<link href="http://www.fsf.org/events/rms-20190606-brno-smartcity"/>
<id>http://www.fsf.org/events/rms-20190606-brno-smartcity</id>
<updated>2019-05-24T13:35:00+00:00</updated>
<summary type="html" xml:lang="en"></summary>
<content type="html" xml:lang="en"><blockquote>The way digital technology is developing, it threatens our
freedom, within our computers and in the internet. What are the
threats? What must we change?</blockquote>
<p>This speech by Richard Stallman will be nontechnical, admission to just the speech is gratis—<a href="https://my.fsf.org/civicrm/profile/create?gid=580&amp;reset=1">provided you register via the FSF link</a>—and the public is encouraged to attend.</p>
<p><strong>Location:</strong> <em>Pavilion G1, Digital City Stage, Brno Fair Grounds (BVV), URBIS Smart City Fair, Výstaviště 405/1, 603 00 </em></p>
<p><a href="https://my.fsf.org/civicrm/profile/create?gid=580&amp;reset=1">Please register, so that we can accommodate all the people who wish to
attend</a>.</p>
<p>Please fill out our contact form, so that <a href="https://my.fsf.org/civicrm/profile/create?gid=578&amp;reset=1">we
can contact you about future events in and around Brno.</a></p></content>
<author>
<name>FSF Events</name>
<uri>http://www.fsf.org/events/aggregator</uri>
</author>
<source>
<title type="html">Events</title>
<subtitle type="html">Site Events</subtitle>
<link rel="self" href="http://static.fsf.org/fsforg/rss/events.xml"/>
<id>http://www.fsf.org/events/aggregator</id>
</source>
</entry>
<entry xml:lang="en">
<title type="html" xml:lang="en">lightening run-time code generation</title>
<link href="http://wingolog.org/archives/2019/05/24/lightening-run-time-code-generation"/>
<id>http://wingolog.org/2019/05/24/lightening-run-time-code-generation</id>
<updated>2019-05-24T08:44:56+00:00</updated>
<summary type="html" xml:lang="en"></summary>
<content type="html" xml:lang="en"><div><p>The upcoming Guile 3 release will have just-in-time native code generation. Finally, amirite? There's lots that I'd like to share about that and I need to start somewhere, so this article is about one piece of it: <a href="https://gitlab.com/wingo/lightening">Lightening, a library to generate machine code</a>.</p><p><b>on lightning</b></p><p>Lightening is a fork of <a href="https://www.gnu.org/software/lightning/">GNU Lightning</a>, adapted to suit the needs of Guile. In fact at first we chose to use GNU Lightning directly, "vendored" into the Guile source respository via the <a href="https://git-scm.com/book/en/v1/Git-Tools-Subtree-Merging">git subtree mechanism</a>. (I see that in the meantime, <tt>git</tt> gained a kind of a <a href="https://github.com/git/git/blob/master/contrib/subtree/git-subtree.txt"><tt>subtree</tt> command</a>; one day I will have to figure out what it's for.)</p><p><a href="https://www.gnu.org/software/lightning/">GNU Lightning</a> has lots of things going for it. It has support for many architectures, even things like Itanium that I don't really care about but which a couple Guile users use. It abstracts the differences between e.g. x86 and ARMv7 behind a common API, so that in Guile I don't need to duplicate the JIT for each back-end. Such an abstraction can have a slight performance penalty, because maybe it missed the opportunity to generate optimal code, but this is acceptable to me: I was more concerned about the maintenance burden, and GNU Lightning seemed to solve that nicely.</p><p>GNU Lightning also has <a href="https://www.gnu.org/software/lightning/manual/">fantastic documentation</a>. It's written in C and not C++, which is the right thing for Guile at this time, and it's also released under the LGPL, which is Guile's license. As it's a GNU project there's a good chance that GNU Guile's needs might be taken into account if any changes need be made.</p><p>I mentally associated Paolo Bonzini with the project, who I knew was a good no-nonsense hacker, as he used Lightning for a <a href="http://smalltalk.gnu.org/">smalltalk implementation</a>; and I knew also that Matthew Flatt used Lightning in <a href="https://racket-lang.org/">Racket</a>. Then I looked in the source code to see architecture support and was pleasantly surprised to see MIPS, POWER, and so on, so I went with GNU Lightning for Guile in our <a href="https://www.gnu.org/software/guile/news/gnu-guile-291-beta-released.html">2.9.1 release last October</a>.</p><p><b>on lightening the lightning</b></p><p>When I chose GNU Lightning, I had in mind that it was a very simple library to cheaply write machine code into buffers. (Incidentally, if you have never worked with this stuff, I remember a time when I was pleasantly surprised to realize that an assembler could be a library and not just a program that processes text. A CPU interprets machine code. Machine code is just bytes, and you can just write C (or Scheme, or whatever) functions that write bytes into buffers, and pass those buffers off to the CPU. Now you know!)</p><p>Anyway indeed GNU Lightning 1.4 or so was that very simple library that I had in my head. I needed simple because I would need to debug any problems that came up, and I didn't want to add more complexity to the C side of Guile -- eventually I should be migrating this code over to Scheme anyway. And, of course, simple can mean fast, and I needed fast code generation.</p><p>However, GNU Lightning has a new release series, the 2.x series. This series is a rewrite in a way of the old version. On the plus side, this new series adds all of the weird architectures that I was pleasantly surprised to see. The old 1.4 didn't even have much x86-64 support, much less AArch64.</p><p>This new GNU Lightning 2.x series fundamentally changes the way the library works: instead of having a <a href="https://www.gnu.org/software/lightning/manual/html_node/The-instruction-set.html#The-instruction-set"><tt>jit_ldr_f</tt></a> function that directly emits code to load a <tt>float</tt> from memory into a floating-point register, the <tt>jit_ldr_f</tt> function now creates a node in a graph. Before code is emitted, that graph is optimized, some register allocation happens around call sites and for temporary values, dead code is elided, and so on, then the graph is traversed and code emitted.</p><p>Unfortunately this wasn't really what I was looking for. The optimizations were a bit opaque to me and I just wanted something simple. Building the graph took more time than just emitting bytes into a buffer, and it takes more memory as well. When I found bugs, I couldn't tell whether they were related to my usage or in the library itself.</p><p>In the end, the node structure wasn't paying its way for me. But I couldn't just go back to the 1.4 series that I remembered -- it didn't have the architecture support that I needed. Faced with the choice between changing GNU Lightning 2.x in ways that went counter to its upstream direction, switching libraries, or refactoring GNU Lightning to be something that I needed, I chose the latter.</p><p><b>in which our protagonist cannot help himself</b></p><p>Friends, I regret to admit: I named the new thing "Lightening". True, it is a lightened Lightning, yes, but I am aware that it's horribly confusing. Pronounced like almost the same, visually almost identical -- I am a bad person. Oh well!!</p><p>I ported some of the existing GNU Lightning backends over to Lightening: ia32, x86-64, ARMv7, and AArch64. I deleted the backends for Itanium, HPPA, Alpha, and SPARC; they have no Debian ports and there is no situation in which I can afford to do QA on them. I would gladly accept contributions for PPC64, MIPS, RISC-V, and maybe S/390. At this point I reckon it takes around 20 hours to port an additional backend from GNU Lightning to Lightening.</p><p>Incidentally, if you need a code generation library, consider your choices wisely. It is likely that Lightening is not right for you. If you can afford platform-specific code and you need C, Lua's <a href="https://luajit.org/dynasm.html">DynASM</a> is probably the right thing for you. If you are in C++, copy the <a href="https://searchfox.org/mozilla-central/source/js/src/jit/arm/MacroAssembler-arm.cpp">assemblers</a> from a <a href="https://trac.webkit.org/browser/webkit/trunk/Source/JavaScriptCore/assembler">JavaScript</a> <a href="https://chromium.googlesource.com/v8/v8.git/+/refs/heads/master/src/x64/assembler-x64.h">engine</a> -- C++ offers much more type safety, capabilities for optimization, and ergonomics.</p><p>But if you can only afford one emitter of JIT code for all architectures, you need simple C, you don't need register allocation, you want a simple library to just include in your source code, and you are good with the LGPL, then Lightening could be a thing for you. Check the <a href="https://gitlab.com/wingo/lightening">gitlab page</a> for info on how to test Lightening and how to include it into your project.</p><p><b>giving it a spin</b></p><p>Yesterday's <a href="https://lists.gnu.org/archive/html/guile-devel/2019-05/msg00030.html">Guile 2.9.2 release</a> includes Lightening, so you can give it a spin. The switch to Lightening allowed us to lower our JIT optimization threshold by a factor of 50, letting us generate fast code sooner. If you try it out, let <tt>#guile</tt> on freenode know how it went. In any case, happy hacking!</p></div></content>
<author>
<name>Andy Wingo</name>
<uri>http://wingolog.org/</uri>
</author>
<source>
<title type="html">wingolog</title>
<subtitle type="html">A mostly dorky weblog by Andy Wingo</subtitle>
<link rel="self" href="http://wingolog.org/feed/atom"/>
<id>http://wingolog.org/feed/atom</id>
</source>
</entry>
<entry xml:lang="en">
<title type="html" xml:lang="non-html">GNU Guile 2.9.2 (beta) released</title>
<link href="https://www.gnu.org/software/guile/news/gnu-guile-292-beta-released.html"/>
<id>https://www.gnu.org/software/guile/news/gnu-guile-292-beta-released.html</id>
<updated>2019-05-23T21:00:00+00:00</updated>
<summary type="html" xml:lang="non-html"></summary>
<content type="html" xml:lang="en"><p>We are delighted to announce GNU Guile 2.9.2, the second beta release in
preparation for the upcoming 3.0 stable series. See the <a href="https://lists.gnu.org/archive/html/guile-devel/2019-05/msg00030.html">release
announcement</a>
for full details and a download link.</p><p>This release extends just-in-time (JIT) native code generation support
to the ia32, ARMv7, and AArch64 architectures. Under the hood, we
swapped out GNU Lightning for a related fork called
<a href="https://gitlab.com/wingo/lightening/">Lightening</a>, which was better
adapted to Guile's needs.</p><p>GNU Guile 2.9.2 is a beta release, and as such offers no API or ABI
stability guarantees. Users needing a stable Guile are advised to stay
on the stable 2.2 series.</p><p>Users on the architectures that just gained JIT support are especially
encouraged to report experiences (good or bad) to <code>[email protected]</code>.
If you know you found a bug, please do send a note to
<code>[email protected]</code>. Happy hacking!</p></content>
<author>
<name>Andy Wingo</name>
<email>[email protected]</email>
</author>
<source>
<title type="html">GNU's programming and extension language</title>
<subtitle type="html">Recent Posts</subtitle>
<link rel="self" href="https://www.gnu.org/software/guile/news/feed.xml"/>
<id>https://www.gnu.org/software/guile</id>
</source>
</entry>
<entry xml:lang="en">
<title type="html" xml:lang="en">bigint shipping in firefox!</title>
<link href="http://wingolog.org/archives/2019/05/23/bigint-shipping-in-firefox"/>
<id>http://wingolog.org/2019/05/23/bigint-shipping-in-firefox</id>
<updated>2019-05-23T12:13:59+00:00</updated>
<summary type="html" xml:lang="en"></summary>
<content type="html" xml:lang="en"><div><p>I am delighted to share with folks the results of a project I have been helping out on for the last few months: implementation of "BigInt" in Firefox, which is finally shipping in Firefox 68 (beta).</p><p><b>what's a bigint?</b></p><p>BigInts are a new kind of JavaScript primitive value, like numbers or strings. A BigInt is a true integer: it can take on the value of any finite integer (subject to some arbitrarily large implementation-defined limits, such as the amount of memory in your machine). This contrasts with JavaScript number values, which have the well-known property of <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/MAX_SAFE_INTEGER">only being able to precisely represent integers between -2<sup>53</sup> and 2<sup>53</sup></a>.</p><p>BigInts are written like "normal" integers, but with an <tt>n</tt> suffix:</p><pre>var a = 1n;
var b = a + 42n;
b &lt;&lt; 64n
// result: 793209995169510719488n
</pre><p>With the bigint proposal, the usual mathematical operations (<tt>+</tt>, <tt>-</tt>, <tt>*</tt>, <tt>/</tt>, <tt>%</tt>, <tt>&lt;&lt;</tt>, <tt>&gt;&gt;</tt>, <tt>**</tt>, and the comparison operators) are extended to operate on bigint values. As a new kind of primitive value, bigint values have their own <tt>typeof</tt>:</p><pre>typeof 1n
// result: 'bigint'
</pre><p>Besides allowing for more kinds of math to be easily and efficiently expressed, BigInt also allows for better interoperability with systems that use 64-bit numbers, such as <a href="https://github.com/nodejs/node/pull/20220">"inodes" in file systems</a>, <a href="https://sauleau.com/notes/wasm-bigint.html">WebAssembly i64 values</a>, <a href="https://nodejs.org/api/process.html#process_process_hrtime_bigint">high-precision timers</a>, and so on.</p><p>You can <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt">read more about the BigInt feature over on MDN</a>, as usual. You might also like this <a href="https://developers.google.com/web/updates/2018/05/bigint">short article on BigInt basics</a> that V8 engineer Mathias Bynens wrote when Chrome shipped support for BigInt last year. There is an accompanying <a href="https://v8.dev/blog/bigint">language implementation</a> article as well, for those of y'all that enjoy the nitties and the gritties. </p><p><b>can i ship it?</b></p><p>To try out BigInt in Firefox, simply download a copy of <a href="https://www.mozilla.org/en-US/firefox/channel/desktop/">Firefox Beta</a>. This version of Firefox will be fully released to the public in a few weeks, on July 9th. If you're reading this in the future, I'm talking about Firefox 68.</p><p>BigInt is also shipping already in V8 and Chrome, and my colleague Caio Lima has an project in progress to implement it in JavaScriptCore / WebKit / Safari. Depending on your target audience, BigInt might be deployable already!</p><p><b>thanks</b></p><p>I must mention that my role in the BigInt work was relatively small; my Igalia colleague Robin Templeton did the bulk of the BigInt implementation work in Firefox, so large ups to them. Hearty thanks also to Mozilla's Jan de Mooij and Jeff Walden for their patient and detailed code reviews.</p><p>Thanks as well to the V8 engineers for their open source implementation of BigInt fundamental algorithms, as we used many of them in Firefox.</p><p>Finally, I need to make one big thank-you, and I hope that you will join me in expressing it. The road to ship anything in a web browser is long; besides the "simple matter of programming" that it is to implement a feature, you need a <a href="https://github.com/tc39/proposal-bigint/blob/master/README.md">specification with buy-in from implementors and web standards people</a>, you need a good working relationship with a browser vendor, you need willing technical reviewers, you need to follow up on the inevitable security bugs that any browser change causes, and all of this takes time. It's all predicated on having the backing of an organization that's foresighted enough to invest in this kind of long-term, high-reward platform engineering.</p><p>In that regard I think all people that work on the web platform should send a big shout-out to <a href="https://techatbloomberg.com">Tech at Bloomberg</a> for making BigInt possible by underwriting all of <a href="https://igalia.com/">Igalia</a>'s work in this area. Thank you, Bloomberg, and happy hacking!</p></div></content>
<author>
<name>Andy Wingo</name>
<uri>http://wingolog.org/</uri>
</author>
<source>
<title type="html">wingolog</title>
<subtitle type="html">A mostly dorky weblog by Andy Wingo</subtitle>
<link rel="self" href="http://wingolog.org/feed/atom"/>
<id>http://wingolog.org/feed/atom</id>
</source>
</entry>
<entry xml:lang="en">
<title type="html" xml:lang="en">GNU Parallel 20190522 ('Akihito') released</title>
<link href="http://savannah.gnu.org/forum/forum.php?forum_id=9434"/>
<id>http://savannah.gnu.org/forum/forum.php?forum_id=9434</id>
<updated>2019-05-22T20:29:50+00:00</updated>
<summary type="html" xml:lang="en"></summary>
<content type="html" xml:lang="en"><p>GNU Parallel 20190522 ('Akihito') has been released. It is available for download at: <a href="http://ftpmirror.gnu.org/parallel/">http://ftpmirror.gnu.org/parallel/</a>
<br />
</p>
<p>GNU Parallel is 10 years old in a year on 2020-04-22. You are here by invited to a reception on Friday 2020-04-17.
<br />
</p>
<p>See <a href="https://www.gnu.org/software/parallel/10-years-anniversary.html">https://www.gnu.org/software/parallel/10-years-anniversary.html</a>
<br />
</p>
<p>Quote of the month:
<br />
</p>
<p> Amazingly useful script!
<br />
-- <a href="mailto:[email protected]">[email protected]</a>
<br />
</p>
<p>New in this release:
<br />
</p>
<ul>
<li>--group-by groups lines depending on value of a column. The value can be computed.
</li>
</ul>
<ul>
<li>How to compress (bzip/gzip) a very large text quickly? <a href="https://medium.com/">https://medium.com/</a>@gchandra/how-to-compress-bzip-gzip-a-very-large-text-quickly-27c11f4c6681
</li>
</ul>
<ul>
<li>Simple tutorial to install &amp; use GNU Parallel <a href="https://medium.com/">https://medium.com/</a>@gchandra/simple-tutorial-to-install-use-gnu-parallel-79251120d618
</li>
</ul>
<ul>
<li>Introducing Parallel into Shell <a href="https://petelawson.com/post/parallel-in-shell/">https://petelawson.com/post/parallel-in-shell/</a>
</li>
</ul>
<ul>
<li>Bug fixes and man page updates.
</li>
</ul>
<p>Get the book: GNU Parallel 2018 <a href="http://www.lulu.com/shop/ole-tange/gnu-parallel-2018/paperback/product-23558902.html">http://www.lulu.com/shop/ole-tange/gnu-parallel-2018/paperback/product-23558902.html</a>
<br />
</p>
<p>GNU Parallel - For people who live life in the parallel lane.
<br />
</p>
<h2>About GNU Parallel</h2>
<p>GNU Parallel is a shell tool for executing jobs in parallel using one or more computers. A job can be a single command or a small script that has to be run for each of the lines in the input. The typical input is a list of files, a list of hosts, a list of users, a list of URLs, or a list of tables. A job can also be a command that reads from a pipe. GNU Parallel can then split the input and pipe it into commands in parallel.
<br />
</p>
<p>If you use xargs and tee today you will find GNU Parallel very easy to use as GNU Parallel is written to have the same options as xargs. If you write loops in shell, you will find GNU Parallel may be able to replace most of the loops and make them run faster by running several jobs in parallel. GNU Parallel can even replace nested loops.
<br />
</p>
<p>GNU Parallel makes sure output from the commands is the same output as you would get had you run the commands sequentially. This makes it possible to use output from GNU Parallel as input for other programs.
<br />
</p>
<p>You can find more about GNU Parallel at: <a href="http://www.gnu.org/s/parallel/">http://www.gnu.org/s/parallel/</a>
<br />
</p>
<p>You can install GNU Parallel in just 10 seconds with:
<br />
(wget -O - pi.dk/3 || curl pi.dk/3/ || fetch -o - <a href="http://pi.dk/3">http://pi.dk/3</a>) | bash
<br />
</p>
<p>Watch the intro video on <a href="http://www.youtube.com/playlist?list=PL284C9FF2488BC6D1">http://www.youtube.com/playlist?list=PL284C9FF2488BC6D1</a>
<br />
</p>
<p>Walk through the tutorial (man parallel_tutorial). Your command line will love you for it.
<br />
</p>
<p>When using programs that use GNU Parallel to process data for publication please cite:
<br />
</p>
<p>O. Tange (2018): GNU Parallel 2018, March 2018, <a href="https://doi.org/10.5281/zenodo.1146014">https://doi.org/10.5281/zenodo.1146014</a>.
<br />
</p>
<p>If you like GNU Parallel:
<br />
</p>
<ul>
<li>Give a demo at your local user group/team/colleagues
</li>
<li>Post the intro videos on Reddit/Diaspora*/forums/blogs/ Identi.ca/Google+/Twitter/Facebook/Linkedin/mailing lists
</li>
<li>Get the merchandise <a href="https://gnuparallel.threadless.com/designs/gnu-parallel">https://gnuparallel.threadless.com/designs/gnu-parallel</a>
</li>
<li>Request or write a review for your favourite blog or magazine
</li>
<li>Request or build a package for your favourite distribution (if it is not already there)
</li>
<li>Invite me for your next conference
</li>
</ul>
<p>If you use programs that use GNU Parallel for research:
<br />
</p>
<ul>
<li>Please cite GNU Parallel in you publications (use --citation)
</li>
</ul>
<p>If GNU Parallel saves you money:
<br />
</p>
<ul>
<li>(Have your company) donate to FSF <a href="https://my.fsf.org/donate/">https://my.fsf.org/donate/</a>
</li>
</ul>
<h2>About GNU SQL</h2>
<p>GNU sql aims to give a simple, unified interface for accessing databases through all the different databases' command line clients. So far the focus has been on giving a common way to specify login information (protocol, username, password, hostname, and port number), size (database and table size), and running queries.
<br />
</p>
<p>The database is addressed using a DBURL. If commands are left out you will get that database's interactive shell.
<br />
</p>
<p>When using GNU SQL for a publication please cite:
<br />
</p>
<p>O. Tange (2011): GNU SQL - A Command Line Tool for Accessing Different Databases Using DBURLs, ;login: The USENIX Magazine, April 2011:29-32.
<br />
</p>
<h2>About GNU Niceload</h2>
<p>GNU niceload slows down a program when the computer load average (or other system activity) is above a certain limit. When the limit is reached the program will be suspended for some time. If the limit is a soft limit the program will be allowed to run for short amounts of time before being suspended again. If the limit is a hard limit the program will only be allowed to run when the system is below the limit.<br />
</p></content>
<author>
<name>Ole Tange</name>
<uri>http://savannah.gnu.org/news/atom.php?group=parallel</uri>
</author>
<source>
<title type="html">GNU Parallel - build and execute command lines from standard input in parallel - News</title>
<link rel="self" href="http://savannah.gnu.org/news/atom.php?group=parallel"/>
<id>http://savannah.gnu.org/news/atom.php?group=parallel</id>
</source>
</entry>
<entry xml:lang="en">
<title type="html" xml:lang="en">Creating and using a custom Linux kernel on Guix System</title>
<link href="https://gnu.org/software/guix/blog/2019/creating-and-using-a-custom-linux-kernel-on-guix-system/"/>
<id>https://gnu.org/software/guix/blog/2019/creating-and-using-a-custom-linux-kernel-on-guix-system/</id>
<updated>2019-05-21T10:00:00+00:00</updated>
<summary type="html" xml:lang="en"></summary>
<content type="html" xml:lang="en"><p>Guix is, at its core, a source based distribution with
<a href="https://www.gnu.org/software/guix/manual/en/html_node/Substitutes.html">substitutes</a>,
and as such building packages from their source code is an expected part
of regular package installations and upgrades. Given this starting
point, it makes sense that efforts are made to reduce the amount of time
spent compiling packages, and recent changes and upgrades to the
building and distribution of substitutes continues to be a topic of
discussion within Guix.</p><p>One of the packages which I prefer to not build myself is the
Linux-Libre kernel. The kernel, while not requiring an overabundance of
RAM to build, does take a very long time on my build machine (which my
children argue is actually their Kodi computer), and I will often delay
reconfiguring my laptop while I want for a substitute to be prepared by
the official build farm. The official kernel configuration, as is the
case with many GNU/Linux distributions, errs on the side of
inclusiveness, and this is really what causes the build to take such a
long time when I build the package for myself.</p><p>The Linux kernel, however, can also just be described as a package
installed on my machine, and as such can be customized just like any
other package. The procedure is a little bit different, although this
is primarily due to the nature of how the package definition is written.</p><p>The
<a href="https://git.savannah.gnu.org/cgit/guix.git/tree/gnu/packages/linux.scm#n294"><code>linux-libre</code></a>
kernel package definition is actually a procedure
which creates a package.</p><pre><code class="language-scheme">(define* (make-linux-libre version hash supported-systems
#:key
;; A function that takes an arch and a variant.
;; See kernel-config for an example.
(extra-version #f)
(configuration-file #f)
(defconfig "defconfig")
(extra-options %default-extra-linux-options)
(patches (list %boot-logo-patch)))
...)</code></pre><p>The current <code>linux-libre</code> package is for the 5.1.x series, and is
declared like this:</p><pre><code class="language-scheme">(define-public linux-libre
(make-linux-libre %linux-libre-version
%linux-libre-hash
'("x86_64-linux" "i686-linux" "armhf-linux" "aarch64-linux")
#:patches %linux-libre-5.1-patches
#:configuration-file kernel-config))</code></pre><p>Any keys which are not assigned values inherit their default value from
the <code>make-linux-libre</code> definition. When comparing the two snippets above,
you may notice that the code comment in the first doesn't actually refer
to the <code>#:extra-version</code> keyword; it is actually for <code>#:configuration-file</code>.
Because of this, it is not actually easy to include a custom kernel
configuration from the definition, but don't worry, there are other ways
to work with what we do have.</p><p>There are two ways to create a kernel with a custom kernel configuration.
The first is to provide a standard <code>.config</code> file during the build
process by including an actual <code>.config</code> file as a native input to our
custom kernel. The
<a href="https://git.savannah.gnu.org/cgit/guix.git/tree/gnu/packages/linux.scm#n379">following</a>
is a snippet from the custom 'configure phase of the <code>make-linux-libre</code>
package definition:</p><pre><code class="language-scheme">(let ((build (assoc-ref %standard-phases 'build))
(config (assoc-ref (or native-inputs inputs) "kconfig")))
;; Use a custom kernel configuration file or a default
;; configuration file.
(if config
(begin
(copy-file config ".config")
(chmod ".config" #o666))
(invoke "make" ,defconfig))</code></pre><p>Below is a sample kernel package for one of my computers. Linux-Libre
is just like other regular packages and can be inherited and overridden
like any other:</p><pre><code class="language-scheme">(define-public linux-libre/E2140
(package
(inherit linux-libre)
(native-inputs
`(("kconfig" ,(local-file "E2140.config"))
,@(alist-delete "kconfig"
(package-native-inputs linux-libre))))))</code></pre><p>In the same directory as the file defining <code>linux-libre-E2140</code> is a file
named <code>E2140.config</code>, which is an actual kernel configuration file. I
left the defconfig keyword of <code>make-linux-libre</code> blank, so the only
kernel configuration in the package is the one which I included as a
native-input.</p><p>The second way to create a custom kernel is to pass a new value to the
extra-options keyword of the <code>make-linux-libre</code> procedure. The
extra-options keyword works with another function defined right below it:</p><pre><code class="language-scheme">(define %default-extra-linux-options
`(;; https://lists.gnu.org/archive/html/guix-devel/2014-04/msg00039.html
("CONFIG_DEVPTS_MULTIPLE_INSTANCES" . #t)
;; Modules required for initrd:
("CONFIG_NET_9P" . m)
("CONFIG_NET_9P_VIRTIO" . m)
("CONFIG_VIRTIO_BLK" . m)
("CONFIG_VIRTIO_NET" . m)
("CONFIG_VIRTIO_PCI" . m)
("CONFIG_VIRTIO_BALLOON" . m)
("CONFIG_VIRTIO_MMIO" . m)
("CONFIG_FUSE_FS" . m)
("CONFIG_CIFS" . m)
("CONFIG_9P_FS" . m)))
(define (config-&gt;string options)
(string-join (map (match-lambda
((option . 'm)
(string-append option "=m"))
((option . #t)
(string-append option "=y"))
((option . #f)
(string-append option "=n")))
options)
"\n"))</code></pre><p>And in the custom configure script from the <code>make-linux-libre</code> package:</p><pre><code class="language-scheme">;; Appending works even when the option wasn't in the
;; file. The last one prevails if duplicated.
(let ((port (open-file ".config" "a"))
(extra-configuration ,(config-&gt;string extra-options)))
(display extra-configuration port)
(close-port port))
(invoke "make" "oldconfig"))))</code></pre><p>So by not providing a configuration-file the <code>.config</code> starts blank, and
then we write into it the collection of flags that we want. Here's
another custom kernel which I have:</p><pre><code class="language-scheme">(define %macbook41-full-config
(append %macbook41-config-options
%filesystems
%efi-support
%emulation
(@@ (gnu packages linux) %default-extra-linux-options)))
(define-public linux-libre-macbook41
;; XXX: Access the internal 'make-linux-libre' procedure, which is
;; private and unexported, and is liable to change in the future.
((@@ (gnu packages linux) make-linux-libre) (@@ (gnu packages linux) %linux-libre-version)
(@@ (gnu packages linux) %linux-libre-hash)
'("x86_64-linux")
#:extra-version "macbook41"
#:patches (@@ (gnu packages linux) %linux-libre-5.1-patches)
#:extra-options %macbook41-config-options))</code></pre><p>From the above example <code>%filesystems</code> is a collection of flags I
compiled enabling different filesystem support, <code>%efi-support</code> enables
EFI support and <code>%emulation</code> enables my x86_64-linux machine to act in
32-bit mode also. <code>%default-extra-linux-options</code> are the ones quoted
above, which had to be added in since I replaced them in the
extra-options keyword.</p><p>This all sounds like it should be doable, but how does one even know
which modules are required for their system? The two places I found
most helpful to try to answer this question were the <a href="https://wiki.gentoo.org/wiki/Handbook:AMD64/Installation/Kernel">Gentoo
Handbook</a>,
and the
<a href="https://www.kernel.org/doc/html/latest/admin-guide/README.html?highlight=localmodconfig">documentation</a>
from the kernel itself. From the kernel documentation, it seems that
<code>make localmodconfig</code> is the command we want.</p><p>In order to actually run <code>make localmodconfig</code> we first need to get and
unpack the kernel source code:</p><pre><code class="language-shell">tar xf $(guix build linux-libre --source)</code></pre><p>Once inside the directory containing the source code run <code>touch .config</code>
to create an initial, empty <code>.config</code> to start with. <code>make localmodconfig</code> works by seeing what you already have in <code>.config</code> and
letting you know what you're missing. If the file is blank then you're
missing everything. The next step is to run:</p><pre><code class="language-shell">guix environment linux-libre -- make localmodconfig</code></pre><p>and note the output. Do note that the <code>.config</code> file is still empty.
The output generally contains two types of warnings. The first start
with "WARNING" and can actually be ignored in our case. The second read:</p><pre><code class="language-shell">module pcspkr did not have configs CONFIG_INPUT_PCSPKR</code></pre><p>For each of these lines, copy the <code>CONFIG_XXXX_XXXX</code> portion into the
<code>.config</code> in the directory, and append <code>=m</code>, so in the end it looks
like this:</p><pre><code class="language-shell">CONFIG_INPUT_PCSPKR=m
CONFIG_VIRTIO=m</code></pre><p>After copying all the configuration options, run <code>make localmodconfig</code>
again to make sure that you don't have any output starting with
"module". After all of these machine specific modules there are a
couple more left that are also needed. <code>CONFIG_MODULES</code> is necessary so
that you can build and load modules separately and not have everything
built into the kernel. <code>CONFIG_BLK_DEV_SD</code> is required for reading from
hard drives. It is possible that there are other modules which you
will need.</p><p>This post does not aim to be a guide to configuring your own kernel
however, so if you do decide to build a custom kernel you'll have to
seek out other guides to create a kernel which is just right for your
needs.</p><p>The second way to setup the kernel configuration makes more use of
Guix's features and allows you to share configuration segments between
different kernels. For example, all machines using EFI to boot have a
number of EFI configuration flags that they need. It is likely that all
the kernels will share a list of filesystems to support. By using
variables it is easier to see at a glance what features are enabled and
to make sure you don't have features in one kernel but missing in another.</p><p>Left undiscussed however, is Guix's initrd and its customization. It is
likely that you'll need to modify the initrd on a machine using a custom
kernel, since certain modules which are expected to be built may not be
available for inclusion into the initrd.</p><p>Suggestions and contributions toward working toward a satisfactory
custom initrd and kernel are welcome!</p><h4>About GNU Guix</h4><p><a href="https://www.gnu.org/software/guix">GNU Guix</a> is a transactional package
manager and an advanced distribution of the GNU system that <a href="https://www.gnu.org/distros/free-system-distribution-guidelines.html">respects
user
freedom</a>.
Guix can be used on top of any system running the kernel Linux, or it
can be used as a standalone operating system distribution for i686,
x86_64, ARMv7, and AArch64 machines.</p><p>In addition to standard package management features, Guix supports
transactional upgrades and roll-backs, unprivileged package management,
per-user profiles, and garbage collection. When used as a standalone
GNU/Linux distribution, Guix offers a declarative, stateless approach to
operating system configuration management. Guix is highly customizable
and hackable through <a href="https://www.gnu.org/software/guile">Guile</a>
programming interfaces and extensions to the
<a href="http://schemers.org">Scheme</a> language.</p></content>
<author>
<name>Efraim Flashner</name>
<uri>https://gnu.org/software/guix/blog/</uri>
</author>
<source>
<title type="html">GNU Guix — Blog</title>
<link rel="self" href="https://www.gnu.org/software/guix/news/feed.xml"/>
<id>https://gnu.org/software/guix/feeds/blog.atom</id>
</source>
</entry>
<entry xml:lang="en">
<title type="html" xml:lang="en">GNU Guix 1.0.1 released</title>
<link href="https://gnu.org/software/guix/blog/2019/gnu-guix-1.0.1-released/"/>
<id>https://gnu.org/software/guix/blog/2019/gnu-guix-1.0.1-released/</id>
<updated>2019-05-19T21:30:00+00:00</updated>
<summary type="html" xml:lang="en"></summary>
<content type="html" xml:lang="en"><p>We are pleased to announce the release of GNU Guix version 1.0.1. This
new version fixes bugs in the <a href="https://www.gnu.org/software/guix/manual/en/html_node/Guided-Graphical-Installation.html">graphical
installer</a>
for the standalone Guix System.</p><p>The release comes with <a href="https://www.gnu.org/software/guix/manual/en/html_node/System-Installation.html">ISO-9660 installation
images</a>,
a <a href="https://www.gnu.org/software/guix/manual/en/html_node/Running-Guix-in-a-VM.html">virtual machine
image</a>,
and with tarballs to install the package manager on top of your
GNU/Linux distro, either <a href="https://www.gnu.org/software/guix/manual/en/html_node/Requirements.html">from
source</a>
or <a href="https://www.gnu.org/software/guix/manual/en/html_node/Binary-Installation.html">from
binaries</a>.
Guix users can update by running <code>guix pull</code>.</p><p>It’s been just over two weeks since we <a href="https://www.gnu.org/software/guix/blog/2019/gnu-guix-1.0.0-released/">announced
1.0.0</a>—two
weeks and 706 commits by 40 people already!</p><p>This is primarily a bug-fix release, specifically focusing on issues in
the graphical installer for the standalone system:</p><ul><li>The most <a href="https://issues.guix.gnu.org/issue/35541">embarrassing bug</a>
would lead the graphical installer to produce a configuration where
<a href="https://www.gnu.org/software/guix/manual/en/html_node/Using-the-Configuration-System.html#index-_0025base_002dpackages"><code>%base-packages</code></a>
was omitted from the <code>packages</code> field. Consequently, the freshly
installed system would not have the usual commands in <code>$PATH</code>—<code>ls</code>,
<code>ps</code>, etc.—and Xfce would fail to start for that reason. See below
for a “post-mortem” analysis.</li><li>The <code>wpa-supplicant</code> service would <a href="https://issues.guix.gnu.org/issue/35550">sometimes fail to
start</a> in the installation
image, thereby breaking network access; this is now fixed.</li><li>The installer <a href="https://issues.guix.gnu.org/issue/35540">now</a> allows
you to toggle the visibility of passwords and passphrases, and it <a href="https://issues.guix.gnu.org/issue/35716">no
longer</a> restricts their
length.</li><li>The installer <a href="https://issues.guix.gnu.org/issue/35657">can now
create</a> Btrfs file
systems.</li><li><code>network-manager-applet</code> is <a href="https://issues.guix.gnu.org/35554">now</a>
part of
<a href="https://www.gnu.org/software/guix/manual/en/html_node/Desktop-Services.html#index-_0025desktop_002dservices"><code>%desktop-services</code></a>,
and thus readily usable not just from GNOME but also from Xfce.</li><li>The
<a href="https://git.savannah.gnu.org/cgit/guix.git/tree/NEWS?h=version-1.0.1"><code>NEWS</code></a>
file has more details, but there were also minor bug fixes for
<a href="https://issues.guix.gnu.org/issue/35618"><code>guix environment</code></a>, <a href="https://issues.guix.gnu.org/issue/35588"><code>guix search</code></a>, and <a href="https://issues.guix.gnu.org/issue/35684"><code>guix refresh</code></a>.</li></ul><p>A couple of new features were reviewed in time to make it into 1.0.1:</p><ul><li><a href="https://www.gnu.org/software/guix/manual/en/html_node/Invoking-guix-system.html"><code>guix system docker-image</code></a>
now produces an OS image with an “entry point”, which makes it
easier to use than before.</li><li><a href="https://www.gnu.org/software/guix/manual/en/html_node/Invoking-guix-system.html"><code>guix system container</code></a>
has a new <code>--network</code> option, allowing the container to share
networking access with the host.</li><li>70 new packages were added and 483 packages were updated.</li><li>Translations were updated as usual and we are glad to announce a
20%-complete <a href="https://www.gnu.org/software/guix/manual/ru/html_node">Russian translation of the
manual</a>.</li></ul><h1>Recap of <a href="https://issues.guix.gnu.org/issue/35541">bug #35541</a></h1><p>The 1.0.1 release was primarily motivated by <a href="https://issues.guix.gnu.org/issue/35541">bug
#35541</a>, which was reported
shortly after the 1.0.0 release. If you installed Guix System with the
<a href="https://www.gnu.org/software/guix/manual/en/html_node/Guided-Graphical-Installation.html">graphical
installer</a>,
chances are that, because of this bug, you ended up with a system where
all the usual GNU/Linux commands—<code>ls</code>, <code>grep</code>, <code>ps</code>, etc.—were <em>not</em> in
<code>$PATH</code>. That in turn would also prevent Xfce from starting, if you
chose that desktop environment for your system.</p><p>We quickly published a note in the <a href="https://www.gnu.org/software/guix/manual/en/html_node/Guided-Graphical-Installation.html">system installation
instructions</a>
explaining how to work around the issue:</p><ul><li><p>First, install packages that provide those commands, along with the
text editor of your choice (for example, <code>emacs</code> or <code>vim</code>):</p><pre><code>guix install coreutils findutils grep procps sed emacs vim</code></pre></li><li><p>At this point, the essential commands you would expect are
available. Open your configuration file with your editor of choice,
for example <code>emacs</code>, running as root:</p><pre><code>sudo emacs /etc/config.scm</code></pre></li><li><p>Change the <code>packages</code> field to add the “base packages” to the list of
globally-installed packages, such that your configuration looks like
this:</p><pre><code class="language-scheme">(operating-system
;; … snip …
(packages (append (list (specification-&gt;package "nss-certs"))
%base-packages))
;; … snip …
)</code></pre></li><li><p>Reconfigure the system so that your new configuration is in effect:</p><pre><code>guix pull &amp;&amp; sudo guix system reconfigure /etc/config.scm</code></pre></li></ul><p>If you already installed 1.0.0, you can perform the steps above to get
all these core commands back.</p><p>Guix is <em>purely declarative</em>: if you give it <a href="https://www.gnu.org/software/guix/manual/en/html_node/Using-the-Configuration-System.html">an operating system
definition</a>
where the “base packages” are not <a href="https://www.gnu.org/software/guix/manual/en/html_node/Using-the-Configuration-System.html#Globally_002dVisible-Packages">available
system-wide</a>,
then it goes ahead and installs precisely that. That’s exactly what
happened with this bug: the installer generated such a configuration and
passed it to <code>guix system init</code> as part of the installation process.</p><h1>Lessons learned</h1><p>Technically, this is a “trivial” bug: it’s fixed by adding one line to
your operating system configuration and reconfiguring, and the fix for
the installer itself <a href="https://git.savannah.gnu.org/cgit/guix.git/commit/?id=ecb0df6817eb3767e6b4dcf1945f3c2dfbe3b44f">is also a
one-liner</a>.
Nevertheless, it’s obviously a serious bug for the impression it
gives—this is <em>not</em> the user experience we want to offer. So how did such
a serious bug go through unnoticed?</p><p>For several years now, Guix has had a number of automated <a href="https://www.gnu.org/software/guix/blog/2016/guixsd-system-tests/"><em>system
tests</em></a>
running in virtual machines (VMs). These tests primarily ensure that
<a href="https://www.gnu.org/software/guix/manual/en/html_node/Services.html">system
services</a>
work as expected, but some of them <a href="https://git.savannah.gnu.org/cgit/guix.git/tree/gnu/tests/install.scm">specifically test system
installation</a>:
installing to a RAID or encrypted device, with a separate <code>/home</code>, using
Btrfs, etc. These tests even run on our <a href="https://ci.guix.gnu.org/jobset/guix-master">continuous integration
service</a> (search for the
“tests.*” jobs there).</p><p>Unfortunately, those installation tests target the so-called <a href="https://www.gnu.org/software/guix/manual/en/html_node/Manual-Installation.html">“manual”
installation
process</a>,
which is scriptable. They do <em>not</em> test the installer’s graphical user
interface. Consequently, testing the user interface (UI) itself was a
manual process. Our attention was, presumably, focusing more on UI
aspects since—so we thought—the actual installation tests were already
taken care of by the system tests. That the generated system
configuration could be syntactically correct but definitely wrong from a
usability viewpoint perhaps didn’t occur to us. The end result is that
the issue went unnoticed.</p><p>The lesson here is that: manual testing should <em>also</em> look for issues in
“unexpected places”, and more importantly, we need automated tests for
the graphical UI. The Debian and Guix installer UIs are similar—both
using the <a href="https://pagure.io/newt">Newt</a> toolkit. Debian tests its
installer using
<a href="https://wiki.debian.org/DebianInstaller/Preseed">“pre-seeds”</a>
(<a href="https://salsa.debian.org/installer-team/preseed">code</a>), which are
essentially answers to all the questions and choices the UI would
present. We could adopt a similar approach, or we could test the UI
itself at a lower level—reading the screen, and simulating key strokes.
UI testing is notoriously tricky so we’ll have to figure out how to get
there.</p><h1>Conclusion</h1><p>Our 1.0 party was a bit spoiled by this bug, and we are sorry that
installation was disappointing to those of you who tried 1.0. We hope
1.0.1 will allow you to try and see what declarative and programmable
system configuration management is like, because that’s where the real
value of Guix System is—the graphical installer is icing on the cake.</p><p>Join us <a href="https://www.gnu.org/software/guix/contact/">on <code>#guix</code> and on the mailing
lists</a>!</p><h4>About GNU Guix</h4><p><a href="https://www.gnu.org/software/guix">GNU Guix</a> is a transactional package
manager and an advanced distribution of the GNU system that <a href="https://www.gnu.org/distros/free-system-distribution-guidelines.html">respects
user
freedom</a>.
Guix can be used on top of any system running the kernel Linux, or it
can be used as a standalone operating system distribution for i686,
x86_64, ARMv7, and AArch64 machines.</p><p>In addition to standard package management features, Guix supports
transactional upgrades and roll-backs, unprivileged package management,
per-user profiles, and garbage collection. When used as a standalone
GNU/Linux distribution, Guix offers a declarative, stateless approach to
operating system configuration management. Guix is highly customizable
and hackable through <a href="https://www.gnu.org/software/guile">Guile</a>
programming interfaces and extensions to the
<a href="http://schemers.org">Scheme</a> language.</p></content>
<author>
<name>Ludovic Courtès</name>
<uri>https://gnu.org/software/guix/blog/</uri>
</author>
<source>
<title type="html">GNU Guix — Blog</title>
<link rel="self" href="https://www.gnu.org/software/guix/news/feed.xml"/>
<id>https://gnu.org/software/guix/feeds/blog.atom</id>
</source>
</entry>
<entry xml:lang="en">
<title type="html" xml:lang="en">Bison 3.4 released [stable]</title>
<link href="http://savannah.gnu.org/forum/forum.php?forum_id=9433"/>
<id>http://savannah.gnu.org/forum/forum.php?forum_id=9433</id>
<updated>2019-05-19T10:01:36+00:00</updated>
<summary type="html" xml:lang="en"></summary>
<content type="html" xml:lang="en"><p>We are happy to announce the release of Bison 3.4.
<br />
</p>
<p>A particular focus was put on improving the diagnostics, which are now
<br />
colored by default, and accurate with multibyte input. Their format was
<br />
also changed, and is now similar to GCC 9's diagnostics.
<br />
</p>
<p>Users of the default backend (yacc.c) can use the new %define variable
<br />
api.header.include to avoid duplicating the content of the generated header
<br />
in the generated parser. There are two new examples installed, including a
<br />
reentrant calculator which supports recursive calls to the parser and
<br />
Flex-generated scanner.
<br />
</p>
<p>See below for more details.
<br />
</p>
<p>==================================================================
<br />
</p>
<p>Bison is a general-purpose parser generator that converts an annotated
<br />
context-free grammar into a deterministic LR or generalized LR (GLR) parser
<br />
employing LALR(1) parser tables. Bison can also generate IELR(1) or
<br />
canonical LR(1) parser tables. Once you are proficient with Bison, you can
<br />
use it to develop a wide range of language parsers, from those used in
<br />
simple desk calculators to complex programming languages.
<br />
</p>
<p>Bison is upward compatible with Yacc: all properly-written Yacc grammars
<br />
work with Bison with no change. Anyone familiar with Yacc should be able to
<br />
use Bison with little trouble. You need to be fluent in C, C++ or Java
<br />
programming in order to use Bison.
<br />
</p>
<p>Here is the GNU Bison home page:
<br />
<a href="https://gnu.org/software/bison/">https://gnu.org/software/bison/</a>
<br />
</p>
<p>==================================================================
<br />
</p>
<p>Here are the compressed sources:
<br />
<a href="https://ftp.gnu.org/gnu/bison/bison-3.4.tar.gz">https://ftp.gnu.org/gnu/bison/bison-3.4.tar.gz</a> (4.1MB)
<br />
<a href="https://ftp.gnu.org/gnu/bison/bison-3.4.tar.xz">https://ftp.gnu.org/gnu/bison/bison-3.4.tar.xz</a> (3.1MB)
<br />
</p>
<p>Here are the GPG detached signatures[*]:
<br />
<a href="https://ftp.gnu.org/gnu/bison/bison-3.4.tar.gz.sig">https://ftp.gnu.org/gnu/bison/bison-3.4.tar.gz.sig</a>
<br />
<a href="https://ftp.gnu.org/gnu/bison/bison-3.4.tar.xz.sig">https://ftp.gnu.org/gnu/bison/bison-3.4.tar.xz.sig</a>
<br />
</p>
<p>Use a mirror for higher download bandwidth:
<br />
<a href="https://www.gnu.org/order/ftp.html">https://www.gnu.org/order/ftp.html</a>
<br />
</p>
<p>[*] Use a .sig file to verify that the corresponding file (without the
<br />
.sig suffix) is intact. First, be sure to download both the .sig file
<br />
and the corresponding tarball. Then, run a command like this:
<br />
</p>
<p> gpg --verify bison-3.4.tar.gz.sig
<br />
</p>
<p>If that command fails because you don't have the required public key,
<br />
then run this command to import it:
<br />
</p>
<p> gpg --keyserver keys.gnupg.net --recv-keys 0DDCAA3278D5264E
<br />
</p>
<p>and rerun the 'gpg --verify' command.
<br />
</p>
<p>This release was bootstrapped with the following tools:
<br />
Autoconf 2.69
<br />
Automake 1.16.1
<br />
Flex 2.6.4
<br />
Gettext 0.19.8.1
<br />
Gnulib v0.1-2563-gd654989d8
<br />
</p>
<p>==================================================================
<br />
</p>
<p>NEWS
<br />
</p>
<textarea class="verbatim" cols="80" readonly="readonly" rows="20">* Noteworthy changes in release 3.4 (2019-05-19) [stable]
** Deprecated features
The %pure-parser directive is deprecated in favor of '%define api.pure'
since Bison 2.3b (2008-05-27), but no warning was issued; there is one
now. Note that since Bison 2.7 you are strongly encouraged to use
'%define api.pure full' instead of '%define api.pure'.
** New features
*** Colored diagnostics
As an experimental feature, diagnostics are now colored, controlled by the
new options --color and --style.
To use them, install the libtextstyle library before configuring Bison.
It is available from
https://alpha.gnu.org/gnu/gettext/
for instance
https://alpha.gnu.org/gnu/gettext/libtextstyle-0.8.tar.gz
The option --color supports the following arguments:
- always, yes: Enable colors.
- never, no: Disable colors.
- auto, tty (default): Enable colors if the output device is a tty.
To customize the styles, create a CSS file similar to
/* bison-bw.css */
.warning { }
.error { font-weight: 800; text-decoration: underline; }
.note { }
then invoke bison with --style=bison-bw.css, or set the BISON_STYLE
environment variable to "bison-bw.css".
*** Disabling output
When given -fsyntax-only, the diagnostics are reported, but no output is
generated.
The name of this option is somewhat misleading as bison does more than
just checking the syntax: every stage is run (including checking for
conflicts for instance), except the generation of the output files.
*** Include the generated header (yacc.c)
Before, when --defines is used, bison generated a header, and pasted an
exact copy of it into the generated parser implementation file. If the
header name is not "y.tab.h", it is now #included instead of being
duplicated.
To use an '#include' even if the header name is "y.tab.h" (which is what
happens with --yacc, or when using the Autotools' ylwrap), define
api.header.include to the exact argument to pass to #include. For
instance:
%define api.header.include {"parse.h"}
or
%define api.header.include {&lt;parser/parse.h&gt;}
*** api.location.type is now supported in C (yacc.c, glr.c)
The %define variable api.location.type defines the name of the type to use
for locations. When defined, Bison no longer defines YYLTYPE.
This can be used in programs with several parsers to factor their
definition of locations: let one of them generate them, and the others
just use them.
** Changes
*** Graphviz output
In conformance with the recommendations of the Graphviz team, if %require
"3.4" (or better) is specified, the option --graph generates a *.gv file
by default, instead of *.dot.
*** Diagnostics overhaul
Column numbers were wrong with multibyte characters, which would also
result in skewed diagnostics with carets. Beside, because we were
indenting the quoted source with a single space, lines with tab characters
were incorrectly underlined.
To address these issues, and to be clearer, Bison now issues diagnostics
as GCC9 does. For instance it used to display (there's a tab before the
opening brace):
foo.y:3.37-38: error: $2 of ‘expr’ has no declared type
expr: expr '+' "number" { $$ = $1 + $2; }
^~
It now reports
foo.y:3.37-38: error: $2 of ‘expr’ has no declared type
3 | expr: expr '+' "number" { $$ = $1 + $2; }
| ^~
Other constructs now also have better locations, resulting in more precise
diagnostics.
*** Fix-it hints for %empty
Running Bison with -Wempty-rules and --update will remove incorrect %empty
annotations, and add the missing ones.
*** Generated reports
The format of the reports (parse.output) was improved for readability.
*** Better support for --no-line.
When --no-line is used, the generated files are now cleaner: no lines are
generated instead of empty lines. Together with using api.header.include,
that should help people saving the generated files into version control
systems get smaller diffs.
** Documentation
A new example in C shows an simple infix calculator with a hand-written
scanner (examples/c/calc).
A new example in C shows a reentrant parser (capable of recursive calls)
built with Flex and Bison (examples/c/reccalc).
There is a new section about the history of Yaccs and Bison.
** Bug fixes
A few obscure bugs were fixed, including the second oldest (known) bug in
Bison: it was there when Bison was entered in the RCS version control
system, in December 1987. See the NEWS of Bison 3.3 for the previous
oldest bug.
</textarea></content>
<author>
<name>Akim Demaille</name>
<uri>http://savannah.gnu.org/news/atom.php?group=bison</uri>
</author>
<source>
<title type="html">Bison - News</title>
<link rel="self" href="http://savannah.gnu.org/news/atom.php?group=bison"/>
<id>http://savannah.gnu.org/news/atom.php?group=bison</id>
</source>
</entry>
<entry xml:lang="en">
<title type="html" xml:lang="en">Six more devices from ThinkPenguin, Inc. now FSF-certified to Respect Your Freedom</title>
<link href="http://www.fsf.org/news/six-more-devices-from-thinkpenguin-inc-now-fsf-certified-to-respect-your-freedom"/>
<id>http://www.fsf.org/news/six-more-devices-from-thinkpenguin-inc-now-fsf-certified-to-respect-your-freedom</id>
<updated>2019-05-16T17:44:36+00:00</updated>
<summary type="html" xml:lang="en"></summary>
<content type="html" xml:lang="en"><p>This is ThinkPenguin's second batch of devices to receive <a href="https://www.fsf.org/ryf">RYF
certification</a> this spring. The <a href="https://www.fsf.org/news/seven-new-devices-from-thinkpenguin-inc-now-fsf-certified-to-respect-your-freedom">FSF announced certification</a> of
seven other devices from ThinkPenguin on March 21st. This latest
collection of devices makes ThinkPenguin the retailer with the largest
catalog of RYF-certified devices.</p>
<p>"It's unfortunate that so many of even the simplest devices out there
have surprise proprietary software requirements. RYF is an antidote
for that. It connects ethical shoppers concerned about their freedom
with companies offering options respecting that freedom," said the
FSF's executive director, John Sullivan.</p>
<p>Today's certifications expands the availability of RYF-certified
peripheral devices. The <a href="https://www.thinkpenguin.com/gnu-linux/penguin-usb-20-external-stereo-sound-adapter-gnu-linux-tpe-usbsound">Penguin USB 2.0 External USB Stereo Sound
Adapter</a> and the <a href="https://www.thinkpenguin.com/gnu-linux/51-channels-24-bit-96khz-pci-express-audio-sound-card-w-full-low-profile-bracket-tpe-pcies">5.1 Channels 24-bit 96KHz PCI Express Audio Sound
Card</a> help users get the most of their computers in terms of sound
quality. For wireless connectivity, ThinkPenguin offers the <a href="https://www.thinkpenguin.com/gnu-linux/wireless-n-pci-express-dual-band-mini-half-height-card-w-full-height-bracket-option-tpe-nh">Wireless
N PCI Express Dual-Band Mini Half-Height Card</a> and <a href="https://www.thinkpenguin.com/gnu-linux/penguin-wireless-n-mini-pcie">Penguin
Wireless N Mini PCIe Card</a>. For users with an older printer, the
<a href="https://www.thinkpenguin.com/gnu-linux/usb-parallel-printer-cable-tpe-usbparal">USB to Parallel Printer Cable</a> can let them continue to use it
with their more current hardware. Finally, the <a href="https://www.thinkpenguin.com/gnu-linux/pcie-esata-sata-6gbps-controller-card-w-full-lowprofile-brackets-tpe-pciesata">PCIe eSATA / SATA
6Gbps Controller Card</a> help users to connect to external eSATA
devices as well as internal SATA.</p>
<p>"I've spent the last 14 years working on projects aimed at making free
software adoption easy for everyone, but the single greatest obstacle
over the past 20 years has not been software. It's been hardware. The
RYF program helps solve this problem by linking users to trustworthy
sources where they can get hardware guaranteed to work on GNU/Linux,
and be properly supported using free software," said Christopher Waid,
founder and CEO of ThinkPenguin.</p>
<p>While ThinkPenguin has consistently sought certification since the
inception of the RYF program -- gaining their <a href="https://www.fsf.org/news/ryf-certification-thinkpenguin-usb-with-atheros-chip">first</a> certification
in 2013, and adding several more over the years since -- the pace at
which they are gaining certifications now eclipses all past efforts.</p>
<p>"ThinkPenguin continues to impress with the rapid expansion of their
catalog of RYF-certified devices. Adding 14 new devices in a little
over a month shows their dedication to the RYF certification program
and the protection of users it represents," said the FSF's licensing
and compliance manager, Donald Robertson, III.</p>
<p>To learn more about the Respects Your Freedom certification program,
including details on the certification of these ThinkPenguin devices,
please visit <a href="https://fsf.org/ryf">https://fsf.org/ryf</a>.</p>
<p>Retailers interested in applying for certification can consult
<a href="https://www.fsf.org/resources/hw/endorsement/criteria">https://www.fsf.org/resources/hw/endorsement/criteria</a>.</p>
<h3>About the Free Software Foundation</h3>
<p>The <a href="https://fsf.org">Free Software Foundation</a>, founded in 1985, is dedicated to
promoting computer users' right to use, study, copy, modify, and
redistribute computer programs. The FSF promotes the development and
use of free (as in freedom) software -- particularly the GNU operating
system and its GNU/Linux variants -- and free documentation for free
software. The FSF also helps to spread awareness of the ethical and
political issues of freedom in the use of software, and its Web sites,
located at <a href="https://fsf.org">https://fsf.org</a> and <a href="https://gnu.org">https://gnu.org</a>, are an important
source of information about GNU/Linux. Donations to support the FSF's
work can be made at <a href="https://donate.fsf.org">https://donate.fsf.org</a>. Its headquarters are in
Boston, MA, USA.</p>
<p>More information about the FSF, as well as important information for
journalists and publishers, is at <a href="https://www.fsf.org/press">https://www.fsf.org/press</a>.</p>
<h3>About ThinkPenguin, Inc.</h3>
<p>Started by Christopher Waid, founder and CEO, ThinkPenguin, Inc., is a
consumer-driven company with a mission to bring free software to the
masses. At the core of the company is a catalog of computers and
accessories with broad support for GNU/Linux. The company provides
technical support for end-users and works with the community,
distributions, and upstream projects to make GNU/Linux all that it can
be.</p>
<h3>Media Contacts</h3>
<p>Donald Robertson, III <br />
Licensing and Compliance Manager <br />
Free Software Foundation<br />
+1 (617) 542 5942<br />
<a href="mailto:[email protected]">[email protected]</a><br />
</p>
<p>ThinkPenguin, Inc. <br />
+1 (888) 39 THINK (84465) x703 <br />
<a href="mailto:[email protected]">[email protected]</a> <br />
</p></content>
<author>
<name>FSF News</name>
<uri>http://www.fsf.org/news/aggregator</uri>
</author>
<source>
<title type="html">FSF News</title>
<link rel="self" href="http://static.fsf.org/fsforg/rss/news.xml"/>
<id>http://www.fsf.org/news/aggregator</id>
</source>
</entry>
<entry xml:lang="en">
<title type="html" xml:lang="en">2019-05-12: GNUnet 0.11.4 released</title>
<link href="https://gnunet.org/#gnunet-0.11.4-release"/>
<id>https://gnunet.org/#gnunet-0.11.4-release</id>
<updated>2019-05-12T17:40:00+00:00</updated>
<summary type="html" xml:lang="en"></summary>
<content type="html" xml:lang="en"><h3>
<a name="gnunet-0.11.4-release">2019-05-12: GNUnet 0.11.4 released</a>
</h3>
<p>
We are pleased to announce the release of GNUnet 0.11.4.
</p>
<p>
This is a bugfix release for 0.11.3, mostly fixing minor bugs,
improving documentation and fixing various build issues. In
terms of usability, users should be aware that there are still a large
number of known open issues in particular with respect to ease of use,
but also some critical privacy issues especially for mobile users.
Also, the nascent network is tiny (about 200 peers) and thus unlikely to
provide good anonymity or extensive amounts of interesting
information. As a result, the 0.11.4 release is still only suitable
for early adopters with some reasonable pain tolerance.
</p>
<h4>Download links</h4>
<ul>
<li><a href="http://ftpmirror.gnu.org/gnunet/gnunet-0.11.4.tar.gz">http://ftpmirror.gnu.org/gnunet/gnunet-0.11.4.tar.gz</a></li>
<li><a href="http://ftpmirror.gnu.org/gnunet/gnunet-0.11.4.tar.gz.sig">http://ftpmirror.gnu.org/gnunet/gnunet-0.11.4.tar.gz.sig</a></li>
<li><a href="http://ftpmirror.gnu.org/gnunet/gnunet-gtk-0.11.0.tar.gz">http://ftpmirror.gnu.org/gnunet/gnunet-gtk-0.11.0.tar.gz</a></li>
<li><a href="http://ftpmirror.gnu.org/gnunet/gnunet-gtk-0.11.0.tar.gz.sig">http://ftpmirror.gnu.org/gnunet/gnunet-gtk-0.11.0.tar.gz.sig</a></li>
<li><a href="http://ftpmirror.gnu.org/gnunet/gnunet-fuse-0.11.0.tar.gz">http://ftpmirror.gnu.org/gnunet/gnunet-fuse-0.11.0.tar.gz</a></li>
<li><a href="http://ftpmirror.gnu.org/gnunet/gnunet-fuse-0.11.0.tar.gz.sig">http://ftpmirror.gnu.org/gnunet/gnunet-fuse-0.11.0.tar.gz.sig</a></li>
</ul>
<p>
(gnunet-gtk and gnunet-fuse were not released again, as there were no
changes and the 0.11.0 versions are expected to continue to work fine
with gnunet-0.11.4.)
</p>
<p>
Note that due to mirror synchronization, not all links might be functional
early after the release. For direct access try <a href="http://ftp.gnu.org/gnu/gnunet/">http://ftp.gnu.org/gnu/gnunet/</a>
</p>
<p>
Note that GNUnet is now started using <tt>gnunet-arm -s</tt>. GNUnet should be
stopped using <tt>gnunet-arm -e</tt>.
</p>
<h4>Noteworthy changes in 0.11.4</h4>
<ul>
<li>gnunet-arm -s no longer logs into the console by default and
instead into a logfile (in $GNUNET_HOME). </li>
<li>The reclaim subsystem is no longer experimental.
Further, the internal encryption scheme moved from ABE to GNS-style
encryption. </li>
<li>GNUnet now depends on a more recent version of libmicrohttpd. </li>
<li>The REST API now includes read-only access to the configuration. </li>
<li>All manpages are now in mdoc format. </li>
<li>gnunet-download-manager.scm removed. </li>
</ul>
<h4>Known Issues</h4>
<ul>
<li>There are known major design issues in the TRANSPORT, ATS and CORE subsystems
which will need to be addressed in the future to achieve acceptable usability,
performance and security.</li>
<li>There are known moderate implementation limitations in CADET that
negatively impact performance. Also CADET may unexpectedly deliver messages out-of-order.</li>
<li>There are known moderate design issues in FS that also impact
usability and performance.</li>
<li>There are minor implementation limitations in SET that create
unnecessary attack surface for availability.</li>
<li>The RPS subsystem remains experimental.</li>
<li>Some high-level tests in the test-suite fail non-deterministically due to
the low-level TRANSPORT issues.</li>
</ul>
<p>
In addition to this list, you may also want to consult our bug tracker
at <a href="https://bugs.gnunet.org/">bugs.gnunet.org</a> which lists
about 190 more specific issues.
</p>
<h4>Thanks</h4>
<p>
This release was the work of many people. The following people
contributed code and were thus easily identified:
ng0, Christian Grothoff, Hartmut Goebel, Martin Schanzenbach, Devan Carpenter, Naomi Phillips and Julius Bünger.
</p></content>
<author>
<name>GNUnet News</name>
<uri>https://gnunet.org</uri>
</author>
<source>
<title type="html">GNUnet.org</title>
<subtitle type="html">News from GNUnet</subtitle>
<link rel="self" href="https://gnunet.org/rss.xml"/>
<id>https://gnunet.org</id>
</source>
</entry>
<entry xml:lang="en">
<title type="html" xml:lang="en">Unifont 12.1.01 Released</title>
<link href="http://savannah.gnu.org/forum/forum.php?forum_id=9432"/>
<id>http://savannah.gnu.org/forum/forum.php?forum_id=9432</id>
<updated>2019-05-11T20:59:48+00:00</updated>
<summary type="html" xml:lang="en"></summary>
<content type="html" xml:lang="en"><p><strong>11 May 2019</strong> Unifont 12.1.01 is now available. Significant changes in this version include the <strong>Reiwa Japanese era glyph</strong> (U+32FF), which was the only addition made in the Unicode 12.1.0 release of 7 May 2019; Rebecca Bettencourt has contributed many Under ConScript Uniocde Registry (UCSUR) scripts; and David Corbett and Johnnie Weaver modified glyphs in two Plane 1 scripts. Full details are in the ChangeLog file.
<br />
</p>
<p>Download this release at:
<br />
</p>
<p><a href="https://ftpmirror.gnu.org/unifont/unifont-12.1.01/">https://ftpmirror.gnu.org/unifont/unifont-12.1.01/</a>
<br />
</p>
<p>or if that fails,
<br />
</p>
<p><a href="https://ftp.gnu.org/gnu/unifont/unifont-12.1.01/">https://ftp.gnu.org/gnu/unifont/unifont-12.1.01/</a>
<br />
</p>
<p>or, as a last resort,
<br />
</p>
<p><a href="ftp://ftp.gnu.org/gnu/unifont/unifont-12.1.01/">ftp://ftp.gnu.org/gnu/unifont/unifont-12.1.01/</a><br />
</p></content>
<author>
<name>Paul Hardy</name>
<uri>http://savannah.gnu.org/news/atom.php?group=unifont</uri>
</author>
<source>
<title type="html">Unifont - News</title>
<link rel="self" href="http://savannah.gnu.org/news/atom.php?group=unifont"/>
<id>http://savannah.gnu.org/news/atom.php?group=unifont</id>
</source>
</entry>
<entry xml:lang="en">
<title type="html" xml:lang="en">Nest, the company, died at Google I/O 2019</title>
<link href="http://savannah.gnu.org/forum/forum.php?forum_id=9431"/>
<id>http://savannah.gnu.org/forum/forum.php?forum_id=9431</id>
<updated>2019-05-11T11:39:18+00:00</updated>
<summary type="html" xml:lang="en"></summary>
<content type="html" xml:lang="en"><p><a href="https://arstechnica.com/gadgets/2019/05/nest-the-company-died-at-google-io-2019/">https://arstechnica.com/gadgets/2019/05/nest-the-company-died-at-google-io-2019/</a><br />
</p></content>
<author>
<name>Stephen H. Dawson DSL</name>
<uri>http://savannah.gnu.org/news/atom.php?group=remotecontrol</uri>
</author>
<source>
<title type="html">GNU remotecontrol - News</title>
<link rel="self" href="http://savannah.gnu.org/news/atom.php?group=remotecontrol"/>
<id>http://savannah.gnu.org/news/atom.php?group=remotecontrol</id>
</source>
</entry>
<entry xml:lang="en">
<title type="html" xml:lang="en">GNU gettext 0.20 released</title>
<link href="http://savannah.gnu.org/forum/forum.php?forum_id=9430"/>
<id>http://savannah.gnu.org/forum/forum.php?forum_id=9430</id>
<updated>2019-05-09T02:15:21+00:00</updated>
<summary type="html" xml:lang="en"></summary>
<content type="html" xml:lang="en"><p>Download from <a href="https://ftp.gnu.org/pub/gnu/gettext/gettext-0.20.tar.gz">https://ftp.gnu.org/pub/gnu/gettext/gettext-0.20.tar.gz</a>
<br />
</p>
<p>New in this release:
<br />
</p>
<ul>
<li>Support for reproducible builds:
</li>
</ul><p> - msgfmt now eliminates the POT-Creation-Date header field from .mo files.
<br />
</p>
<ul>
<li>Improvements for translators:
</li>
</ul><p> - update-po target in Makefile.in.in now uses msgmerge --previous.
<br />
</p>
<ul>
<li>Improvements for maintainers:
</li>
</ul><p> - msgmerge now has an option --for-msgfmt, that produces a PO file meant for use by msgfmt only. This option saves processing time, in particular by omitting fuzzy matching that is not useful in this situation.
<br />
- The .pot file in a 'po' directory is now erased by "make maintainer-clean".
<br />
- It is now possible to override xgettext options from the po/Makefile.in.in through options in XGETTEXT_OPTIONS (declared in po/Makevars).
<br />
- The --intl option of the gettextize program (deprecated since 2010) is no longer available. Instead of including the intl sources in your package, we suggest making the libintl library an optional prerequisite of your package. This will simplify the build system of your package.
<br />
- Accordingly, the Autoconf macro AM_GNU_GETTEXT_INTL_SUBDIR is gone as well.
<br />
</p>
<ul>
<li>Programming languages support:
</li>
</ul><p> - C, C++:
<br />
xgettext now supports strings in u8"..." syntax, as specified in C11 and C++11.
<br />
- C, C++:
<br />
xgettext now supports 'p'/'P' exponent markers in number tokens, as specified in C99 and C++17.
<br />
- C++:
<br />
xgettext now supports underscores in number tokens.
<br />
- C++:
<br />
xgettext now supports single-quotes in number tokens, as specified in C++14.
<br />
- Shell:
<br />
o The programs 'gettext', 'ngettext' now support a --context argument.
<br />
o gettext.sh contains new function eval_pgettext and eval_npgettext for producing translations of messages with context.
<br />
- Java:
<br />
o xgettext now supports UTF-8 encoded .properties files (a new feature of Java 9).
<br />
o The build system and tools now support Java 9, 10, and 11. On the other hand, support for old versions of Java (Java 5 and older, GCJ 4.2.x and older) has been dropped.
<br />
- Perl:
<br />
o Native support for context functions (pgettext, dpgettext, dcpgettext, npgettext, dnpgettext, dcnpgettext).
<br />
o better detection of question mark and slash as operators (as opposed to regular expression delimiters).
<br />
- Scheme:
<br />
xgettext now parses the syntax for specialized byte vectors (#u8(...), #vu8(...), etc.) correctly.
<br />
- Pascal:
<br />
xgettext can now extract strings from .rsj files, produced by the Free Pascal compiler version 3.0.0 or newer.
<br />
- Vala:
<br />
xgettext now parses escape sequences in strings more accurately.
<br />
- JavaScript:
<br />
xgettext now parses template literals correctly.
<br />
</p>
<ul>
<li>Runtime behaviour:
</li>
</ul><p> - The interpretation of the language preferences on macOS has been fixed.
<br />
- Per-thread locales are now also supported on Solaris 11.4.
<br />
- The replacements for the printf()/fprintf()/... functions that are provided through &lt;libintl.h&gt; on native Windows and NetBSD are now POSIX compliant. There is no conflict any more between these replacements and other possible replacements provided by gnulib or mingw.
<br />
</p>
<ul>
<li>Libtextstyle:
</li>
</ul><p> - This package installs a new library 'libtextstyle', together with a new header file &lt;textstyle.h&gt;. It is a library for styling text output sent to a console or terminal emulator. Packagers: please see the suggested packaging hints in the file PACKAGING.<br />
</p></content>
<author>
<name>Bruno Haible</name>
<uri>http://savannah.gnu.org/news/atom.php?group=gettext</uri>
</author>
<source>
<title type="html">GNU gettext - News</title>
<link rel="self" href="http://savannah.gnu.org/news/atom.php?group=gettext"/>
<id>http://savannah.gnu.org/news/atom.php?group=gettext</id>
</source>
</entry>
<entry xml:lang="en">
<title type="html" xml:lang="en">CSSC-1.4.1 released</title>
<link href="http://savannah.gnu.org/forum/forum.php?forum_id=9429"/>
<id>http://savannah.gnu.org/forum/forum.php?forum_id=9429</id>
<updated>2019-05-07T20:27:17+00:00</updated>
<summary type="html" xml:lang="en"></summary>
<content type="html" xml:lang="en"><textarea class="verbatim" cols="80" readonly="readonly" rows="20">I'm pleased to announce the release of GNU CSSC, version
1.4.1. This is a stable release. The previous stable
release was 1.4.0.
Stable releases of CSSC are available from
https://ftp.gnu.org/gnu/cssc/. Development releases and
release candidates are available from
https://alpha.gnu.org/gnu/cssc/.
CSSC ("Compatibly Stupid Source Control") is the GNU
project's replacement for the traditional Unix SCCS suite.
It aims for full compatibility, including precise nuances
of behaviour, support for all command-line options, and in
most cases bug-for-bug compatibility. CSSC comes with an
extensive automated test suite.
If you are currently using SCCS to do version control of
software, you should be able to just drop in CSSC, even for
example if you have a large number of shell scripts which
are layered on top of SCCS and depend on it. This should
allow you to develop on and for the GNU/Linux platform if
your source code exists only in an SCCS repository. CSSC
also allows you to migrate to a more modern version control
system (such as git).
There is a mailing list for users of the CSSC suite. To
join it, please send email to &lt;[email protected]&gt;
or visit the URL
http://lists.gnu.org/mailman/listinfo/cssc-users.
There is also a mailing list for (usually automated) mails
about bugs and changes to CSSC. This is
http://lists.gnu.org/mailman/listinfo/bug-cssc.
For more information about CSSC, please see
http://www.gnu.org/software/cssc/.
These people have contributed to the development of CSSC :-
James Youngman, Ross Ridge, Eric Allman, Lars Hecking,
Larry McVoy, Dave Bodenstab, Malcolm Boff, Richard Polton,
Fila Kolodny, Peter Kjellerstedt, John Interrante, Marko
Rauhamaa, Achim Hoffann, Dick Streefland, Greg A. Woods,
Aron Griffis, Michael Sterrett, William W. Austin, Hyman
Rosen, Mark Reynolds, Sergey Ostashenko, Frank van
Maarseveen, Jeff Sheinberg, Thomas Duffy, Yann Dirson,
Martin Wilck
Many thanks to all the above people.
Changes since the previous release stable are:
New in CSSC-1.4.1, 2019-05-07
* This release - and future releases - of CSSC must be
compiled with a C++ compiler that supports the 2011
C++ standard.
* When the history file is updated (with admin or delta for
example) the history file is not made executable simply
because the 'x' flag is set. Instead, preserve the
executable-ness from the history file we are replacing.
* This release is based on updated versions of gnulib and of
the googletest unit test framework.
Checksums for the release file are:
$ for sum in sha1sum md5sum ; do $sum CSSC-1.4.1.tar.gz; done
bfb99cbd6255c7035e99455de7241d4753746fe1 CSSC-1.4.1.tar.gz
c9aaae7602e39b7a5d438b0cc48fcaa3 CSSC-1.4.1.tar.gz
Please report any bugs via this software to the CSSC bug
reporting page, http://savannah.gnu.org/bugs/?group=cssc
</textarea></content>
<author>
<name>James Youngman</name>
<uri>http://savannah.gnu.org/news/atom.php?group=cssc</uri>
</author>
<source>
<title type="html">GNU CSSC - News</title>
<link rel="self" href="http://savannah.gnu.org/news/atom.php?group=cssc"/>
<id>http://savannah.gnu.org/news/atom.php?group=cssc</id>
</source>
</entry>
<entry xml:lang="en">
<title type="html" xml:lang="en">GNU Guix 1.0.0 released</title>
<link href="https://gnu.org/software/guix/blog/2019/gnu-guix-1.0.0-released/"/>
<id>https://gnu.org/software/guix/blog/2019/gnu-guix-1.0.0-released/</id>
<updated>2019-05-02T14:00:00+00:00</updated>
<summary type="html" xml:lang="en"></summary>
<content type="html" xml:lang="en"><p>We are excited to announce the release of GNU Guix version 1.0.0!</p><p>The release comes with <a href="https://www.gnu.org/software/guix/manual/en/html_node/System-Installation.html">ISO-9660 installation
images</a>,
a <a href="https://www.gnu.org/software/guix/manual/en/html_node/Running-Guix-in-a-VM.html">virtual machine
image</a>,
and with tarballs to install the package manager on top of your
GNU/Linux distro, either <a href="https://www.gnu.org/software/guix/manual/en/html_node/Requirements.html">from
source</a>
or <a href="https://www.gnu.org/software/guix/manual/en/html_node/Binary-Installation.html">from
binaries</a>.
Guix users can update by running <code>guix pull</code>.</p><p><img alt="Guix 1.0!" src="https://www.gnu.org/software/guix/static/blog/img/guix-1.0.png" /></p><p>One-point-oh always means a lot for free software releases. For Guix,
1.0 is the result of seven years of development, with code, packaging,
and documentation contributions made by 260 people, translation work
carried out by a dozen of people, and artwork and web site development
by a couple of individuals, to name some of the activities that have
been happening. During those years we published no less than <a href="https://www.gnu.org/software/guix/blog/tags/releases/">19 “0.x”
releases</a>.</p><h1>The journey to 1.0</h1><p>We took our time to get there, which is quite unusual in an era where
free software moves so fast. Why did we take this much time? First, it
takes time to build a community around a GNU/Linux distribution, and a
distribution wouldn’t really exist without it. Second, we feel like
we’re contributing an important piece to <a href="https://www.gnu.org/gnu/about-gnu.html">the GNU operating
system</a>, and that is surely
intimidating and humbling.</p><p>Last, we’ve been building something new. Of course we stand on the
shoulders of giants, and in particular <a href="https://nixos.org/nix/">Nix</a>,
which brought the functional software deployment paradigm that Guix
implements. But developing Guix has been—and still is!—a challenge in
many ways: it’s a <a href="https://arxiv.org/abs/1305.4584">programming</a>
<a href="https://www.gnu.org/software/guix/blog/2017/back-from-gpce/">language</a>
design challenge, an
<a href="https://www.gnu.org/software/guix/blog/2015/service-composition-in-guixsd/">operating</a>
<a href="https://www.gnu.org/software/guix/blog/2017/running-system-services-in-containers/">system</a>
design challenge, a challenge for
<a href="https://www.gnu.org/software/guix/blog/2016/timely-delivery-of-security-updates/">security</a>,
<a href="https://www.gnu.org/software/guix/blog/tags/reproducibility/">reproducibility</a>,
<a href="https://www.gnu.org/software/guix/blog/tags/bootstrapping/">bootstrapping</a>,
usability, and more. In other words, it’s been a long but insightful
journey! :-)</p><h1>What GNU Guix can do for you</h1><p>Presumably some of the readers are discovering Guix today, so let’s recap
what Guix can do for you as a user. Guix is a complete toolbox for
software deployment in general, which makes it different from most of
the tools you may be familiar with.</p><p><img alt="Guix manages packages, environments, containers, and systems." src="https://www.gnu.org/software/guix/static/blog/img/guix-scope.png" /></p><p>This may sound a little abstract so let’s look at concrete use cases:</p><ul><li><p><em>As a user</em>, Guix allows you to <a href="https://www.gnu.org/software/guix/manual/en/html_node/Invoking-guix-package.html">install applications and to keep
them
up-to-date</a>:
search for software with <code>guix search</code>, install it with <code>guix install</code>, and maintain it up-to-date by regularly running <code>guix pull</code> and <code>guix upgrade</code>. Guix follows a so-called “rolling
release” model, so you can run <code>guix pull</code> at any time to get the
latest and greatest bits of free software.</p><p>This certainly sounds familiar, but a distinguishing property here
is <em>dependability</em>: Guix is transactional, meaning that you can at
any time roll back to a previous “generation” of your package set
with <code>guix package --roll-back</code>, inspect differences with <code>guix package -l</code>, and so on.</p><p>Another useful property is <em>reproducibility</em>: Guix allows you to
deploy the <em>exact same software environment</em> on different machines
or at different points in time thanks to <a href="https://www.gnu.org/software/guix/manual/en/html_node/Invoking-guix-describe.html"><code>guix describe</code></a>
and <a href="https://www.gnu.org/software/guix/manual/en/html_node/Invoking-guix-pull.html"><code>guix pull</code></a>.</p><p>This, coupled with the fact that package management operations do
not require root access, is invaluable notably in the context of
high-performance computing (HPC) and reproducible science, which the
<a href="https://guix-hpc.bordeaux.inria.fr/">Guix-HPC effort</a> has been
focusing on.</p></li><li><p><em>As a developer</em>, we hope you’ll enjoy <a href="https://www.gnu.org/software/guix/manual/en/html_node/Invoking-guix-environment.html"><code>guix environment</code></a>,
which allows you to spawn one-off software environments. Suppose
you’re a GIMP developer: running <code>guix environment gimp</code> spawns a
shell with everything you need to hack on GIMP—much quicker than
manually installing its many dependencies.</p><p>Developers often struggle to push their work to users so they get
quick feedback. The <a href="https://www.gnu.org/software/guix/blog/2017/creating-bundles-with-guix-pack/"><code>guix pack</code></a>
provides an easy way to create <em>container images</em> for use by Docker
&amp; co., or even <a href="https://www.gnu.org/software/guix/blog/2018/tarballs-the-ultimate-container-image-format/">standalone relocatable
tarballs</a>
that anyone can run, regardless of the GNU/Linux distribution they
use.</p><p>Oh, and you may also like <a href="https://www.gnu.org/software/guix/manual/en/html_node/Package-Transformation-Options.html">package transformation
options</a>,
which allow you define package variants from the command line.</p></li><li><p><em>As a system administrator</em>—and actually, we’re all system
administrators of sorts on our laptops!—, Guix’s declarative and
unified approach to configuration management should be handy. It
surely is a departure from what most people are used to, but it is
so reassuring: one configuration file is enough to specify <a href="https://www.gnu.org/software/guix/manual/en/html_node/Using-the-Configuration-System.html">all the
aspects of the system
config</a>—services,
file systems, locale, accounts—all in the same language.</p><p>That makes it surprisingly easy to deploy otherwise complex services
such as applications that depend on Web services. For instance,
setting up
<a href="https://www.gnu.org/software/guix/manual/en/html_node/Version-Control-Services.html#Cgit-Service">CGit</a>
or
<a href="https://www.gnu.org/software/guix/manual/en/html_node/Monitoring-Services.html#Zabbix-front_002dend">Zabbix</a>
is a one-liner, even though behind the scenes that involves setting
up nginx, fcgiwrap, etc. We’d love to see to what extent this helps
people self-host services—sort of similar to what
<a href="https://freedombox.org/">FreedomBox</a> and
<a href="https://yunohost.org/">YunoHost</a> have been focusing on.</p><p>With <a href="https://www.gnu.org/software/guix/manual/en/html_node/Invoking-guix-system.html"><code>guix system</code></a>
you can instantiate a configuration on your machine, or in a virtual
machine (VM) where you can test it, or in a container. You can also
provision ISO images, VM images, or container images with a complete
OS, from the same config, all with <code>guix system</code>.</p></li></ul><p>The <a href="https://www.gnu.org/software/guix/guix-refcard.pdf">quick reference
card</a> shows the
important commands. As you start diving deeper into Guix, you’ll
discover that many aspects of the system are exposed using consistent
<a href="https://www.gnu.org/software/guile/">Guile</a> programming interfaces:
<a href="https://www.gnu.org/software/guix/manual/en/html_node/Defining-Packages.html">package
definitions</a>,
<a href="https://www.gnu.org/software/guix/manual/en/html_node/Services.html">system
services</a>,
the <a href="https://www.gnu.org/software/shepherd/">“init” system</a>, and a whole
bunch of system-level libraries. We believe that makes the system very
<em>hackable</em>, and we hope you’ll find it as much fun to play with as we do.</p><p>So much for the overview!</p><h1>What’s new since 0.16.0</h1><p>For those who’ve been following along, a great many things have changed
over the last 5 months since the <a href="https://www.gnu.org/software/guix/blog/2018/gnu-guix-and-guixsd-0.16.0-released/">0.16.0
release</a>—99
people contributed over 5,700 commits during that time! Here are the
highlights:</p><ul><li>The ISO installation image now runs a cute <a href="https://www.gnu.org/software/guix/manual/en/html_node/Guided-Graphical-Installation.html">text-mode graphical
installer</a>—big
thanks to Mathieu Othacehe for writing it and to everyone who
tested it and improved it! It is similar in spirit to the Debian
installer. Whether you’re a die-hard GNU/Linux hacker or a novice
user, you’ll certainly find that this makes system installation
much less tedious than it was! The installer is fully translated
to French, German, and Spanish.</li><li>The new <a href="https://www.gnu.org/software/guix/manual/en/html_node/Running-GuixSD-in-a-VM.html">VM
image</a>
better matches user expectations: whether you want to tinker with
Guix System and see what it’s like, or whether you want to use it
as a development environment, this VM image should be more directly
useful.</li><li>The user interface was improved: aliases for common operations
<a href="https://www.gnu.org/software/guix/manual/en/html_node/Invoking-guix-package.html">such as <code>guix search</code> and <code>guix install</code></a>
are now available, diagnostics are now colorized, more operations
show a progress bar, there’s a new <code>--verbosity</code> option recognized
by all commands, and most commands are now “quiet” by default.</li><li>There’s a new <code>--with-git-url</code> <a href="https://www.gnu.org/software/guix/manual/en/html_node/Package-Transformation-Options.html">package transformation
option</a>,
that goes with <code>--with-branch</code> and <code>--with-commit</code>.</li><li>Guix now has a first-class, uniform mechanism to configure
<a href="https://www.gnu.org/software/guix/manual/en/html_node/Keyboard-Layout.html">keyboard
layout</a>—a
long overdue addition. Related to that, <a href="https://www.gnu.org/software/guix/manual/en/html_node/X-Window.html">Xorg
configuration</a>
has been streamlined with the new <code>xorg-configuration</code> record.</li><li>We introduced <code>guix pack -R</code> <a href="https://www.gnu.org/software/guix/blog/2018/tarballs-the-ultimate-container-image-format/">a while
back</a>:
it creates tarballs containing <em>relocatable</em> application bundles
that rely on user namespaces. Starting from 1.0, <code>guix pack -RR</code>
(like “reliably relocatable”?) generates relocatable binaries that
fall back to <a href="https://proot-me.github.io/">PRoot</a> on systems where
<a href="http://man7.org/linux/man-pages/man7/user_namespaces.7.html">user
namespaces</a>
are not supported.</li><li>More than 1,100 packages were added, leading to <a href="https://www.gnu.org/software/guix/packages">close to 10,000
packages</a>, 2,104
packages were updated, and several system services were
contributed.</li><li>The manual has been fully translated to
<a href="https://www.gnu.org/software/guix/manual/fr/html_node/">French</a>,
the
<a href="https://www.gnu.org/software/guix/manual/de/html_node/">German</a>
and <a href="https://www.gnu.org/software/guix/manual/es/html_node/">Spanish</a>
translations are nearing completion, and work has begun on a
<a href="https://www.gnu.org/software/guix/manual/zh-cn/html_node/">Simplified
Chinese</a>
translation. You can help <a href="https://translationproject.org/domain/guix-manual.html">translate the manual into your
language</a>
by <a href="https://translationproject.org/html/translators.html">joining the Translation
Project</a>.</li></ul><p>That’s a long list already, but you can find more details in the
<a href="https://git.savannah.gnu.org/cgit/guix.git/tree/NEWS?h=version-1.0.0"><code>NEWS</code></a>
file.</p><h1>What’s next?</h1><p>One-point-oh is a major milestone, especially for those of us who’ve
been on board for several years. But with the wealth of ideas we’ve
been collecting, it’s definitely not the end of the road!</p><p>If you’re interested in “devops” and distributed deployment, you will
certainly be happy to help in that area, those interested in OS
development might want to make <a href="https://www.gnu.org/software/shepherd/">the
Shepherd</a> more flexible and
snappy, furthering integration with <a href="https://www.gnu.org/software/guix/blog/2019/connecting-reproducible-deployment-to-a-long-term-source-code-archive/">Software
Heritage</a>
will probably be #1 on the to-do list of scientists concerned with
long-term reproducibility, programming language tinkerers may want to
push
<a href="https://www.gnu.org/software/guix/manual/en/html_node/G_002dExpressions.html#G_002dExpressions">G-expressions</a>
further, etc. Guix 1.0 is a tool that’s both serviceable for one’s
day-to-day computer usage and a great playground for the tinkerers among
us.</p><p>Whether you want to help on design, coding, maintenance, system
administration, translation, testing, artwork, web services, funding,
organizing a Guix install party… <a href="https://www.gnu.org/software/guix/contribute/">your contributions are
welcome</a>!</p><p>We’re humans—don’t hesitate to <a href="https://www.gnu.org/software/guix/contact/">get in touch with
us</a>, and enjoy Guix 1.0!</p><h4>About GNU Guix</h4><p><a href="https://www.gnu.org/software/guix">GNU Guix</a> is a transactional package
manager and an advanced distribution of the GNU system that <a href="https://www.gnu.org/distros/free-system-distribution-guidelines.html">respects
user
freedom</a>.
Guix can be used on top of any system running the kernel Linux, or it
can be used as a standalone operating system distribution for i686,
x86_64, ARMv7, and AArch64 machines.</p><p>In addition to standard package management features, Guix supports
transactional upgrades and roll-backs, unprivileged package management,
per-user profiles, and garbage collection. When used as a standalone
GNU/Linux distribution, Guix offers a declarative, stateless approach to
operating system configuration management. Guix is highly customizable
and hackable through <a href="https://www.gnu.org/software/guile">Guile</a>
programming interfaces and extensions to the
<a href="http://schemers.org">Scheme</a> language.</p></content>
<author>
<name>Ludovic Courtès</name>
<uri>https://gnu.org/software/guix/blog/</uri>
</author>
<source>
<title type="html">GNU Guix — Blog</title>
<link rel="self" href="https://www.gnu.org/software/guix/news/feed.xml"/>
<id>https://gnu.org/software/guix/feeds/blog.atom</id>
</source>
</entry>
<entry xml:lang="en">
<title type="html" xml:lang="en">Version 2.9</title>
<link href="http://savannah.gnu.org/forum/forum.php?forum_id=9426"/>
<id>http://savannah.gnu.org/forum/forum.php?forum_id=9426</id>
<updated>2019-04-24T06:57:18+00:00</updated>
<summary type="html" xml:lang="en"></summary>
<content type="html" xml:lang="en"><p>Version 2.9 of GNU dico is available from download from <a href="https://ftp.gnu.org/gnu/dico/dico-2.9.tar.xz">the GNU archive</a> and from <a href="https://download.gnu.org.ua/release/dico/dico-2.9.tar.xz">its main archive</a> site.
<br />
</p>
<p>This version fixes compilation on 32-bit systems.<br />
</p></content>
<author>
<name>Sergey Poznyakoff</name>
<uri>http://savannah.gnu.org/news/atom.php?group=dico</uri>
</author>
<source>
<title type="html">GNU dico - News</title>
<link rel="self" href="http://savannah.gnu.org/news/atom.php?group=dico"/>
<id>http://savannah.gnu.org/news/atom.php?group=dico</id>
</source>
</entry>
<entry xml:lang="en">
<title type="html" xml:lang="en">Version 1.9</title>
<link href="http://savannah.gnu.org/forum/forum.php?forum_id=9425"/>
<id>http://savannah.gnu.org/forum/forum.php?forum_id=9425</id>
<updated>2019-04-24T06:02:12+00:00</updated>
<summary type="html" xml:lang="en"></summary>
<content type="html" xml:lang="en"><p>Version 1.9 is available for download from <a href="https://ftp.gnu.org/gnu/rush/rush-1.9.tar.xz">GNU</a> and <a href="http://download.gnu.org.ua/release/rush/rush-1.9.tar.xz">Puszcza</a> archives. It should soon become available in the mirrors too.
<br />
</p>
<p>New in this version:
<br />
</p>
<h4>Backreference expansion</h4>
<p>Arguments to tranformations, chroot and chdir statements can contain references to parenthesized groups in the recent regular expression match. Such references are replaced with the strings that matched the corresponding groups. Syntactically, a backreference expansion is a percent sign followed by one-digit number of the subexpression (1-based, %0 refers to entire matched line). For example
<br />
</p>
<blockquote class="verbatim"><p> rule X<br />
command ^cd (.+) &amp;&amp; (.+)<br />
chdir %1<br />
set %2<br />
</p></blockquote>
<h4>User-defined variables</h4>
<p>The configuration file can define new variables or redefine the built-in ones using the <strong>setvar</strong> statement:
<br />
</p>
<blockquote class="verbatim"><p> setvar[VAR] PATTERN<br />
</p></blockquote>
<p>Here, VAR is the variable name, and PATTERN is its new value. The PATTERN is subject to variable and backreference expansion.
<br />
</p>
<p>User-defined variables can be unset using the "unsetvar" statement:
<br />
</p>
<blockquote class="verbatim"><p> unsetvar[VAR]<br />
</p></blockquote>
<p>Unsetting a built-in variable, previously redefined using the <strong>setvar</strong> statement causes the user-supplied definition to be forgotten and the built-in one restored.
<br />
</p>
<h4>Shell-like variable expansion</h4>
<p>The following shell-like notations are supported:
<br />
</p>
<blockquote class="verbatim"><p> ${VAR:-WORD} Use Default Values<br />
${VAR:=WORD} Assign Default Values<br />
${VAR:?WORD} Display Error if Null or Unset<br />
${VAR:+WORD} Use Alternate Value<br />
</p></blockquote>
<h4>New script rush-po for extracting translatable strings from the configuration</h4>
<p>The script rush-po.awk that was used in prior versions has been withdrawn.<br />
</p></content>
<author>
<name>Sergey Poznyakoff</name>
<uri>http://savannah.gnu.org/news/atom.php?group=rush</uri>
</author>
<source>
<title type="html">GNU Rush - News</title>
<link rel="self" href="http://savannah.gnu.org/news/atom.php?group=rush"/>
<id>http://savannah.gnu.org/news/atom.php?group=rush</id>
</source>
</entry>
<entry xml:lang="en">
<title type="html" xml:lang="en">How hacking threats spurred secret U.S. blacklist</title>
<link href="http://savannah.gnu.org/forum/forum.php?forum_id=9424"/>
<id>http://savannah.gnu.org/forum/forum.php?forum_id=9424</id>
<updated>2019-04-23T21:38:53+00:00</updated>
<summary type="html" xml:lang="en"></summary>
<content type="html" xml:lang="en"><p>U.S. energy regulators are pursuing a risky plan to share with electric utilities a secret "don't buy" list of foreign technology suppliers, according to multiple sources.
<br />
</p>
<p><a href="https://www.eenews.net/stories/1060176111">https://www.eenews.net/stories/1060176111</a><br />
</p></content>
<author>
<name>Stephen H. Dawson DSL</name>
<uri>http://savannah.gnu.org/news/atom.php?group=remotecontrol</uri>
</author>
<source>
<title type="html">GNU remotecontrol - News</title>
<link rel="self" href="http://savannah.gnu.org/news/atom.php?group=remotecontrol"/>
<id>http://savannah.gnu.org/news/atom.php?group=remotecontrol</id>
</source>
</entry>
<entry xml:lang="en">
<title type="html" xml:lang="en">Main development is located at http://github.com/gnustep</title>
<link href="http://savannah.gnu.org/forum/forum.php?forum_id=9423"/>
<id>http://savannah.gnu.org/forum/forum.php?forum_id=9423</id>
<updated>2019-04-23T14:25:45+00:00</updated>
<summary type="html" xml:lang="en"></summary>
<content type="html" xml:lang="en"><p>Main development is located at <a href="http://github.com/gnustep">http://github.com/gnustep</a><br />
</p></content>
<author>
<name>Gregory John Casamento</name>
<uri>http://savannah.gnu.org/news/atom.php?group=gnustep</uri>
</author>
<source>
<title type="html">GNUstep - News</title>
<link rel="self" href="http://savannah.gnu.org/news/atom.php?group=gnustep"/>
<id>http://savannah.gnu.org/news/atom.php?group=gnustep</id>
</source>
</entry>
<entry xml:lang="en">
<title type="html" xml:lang="en">GNU Parallel 20190422 ('Invitation') released [stable]</title>
<link href="http://savannah.gnu.org/forum/forum.php?forum_id=9422"/>
<id>http://savannah.gnu.org/forum/forum.php?forum_id=9422</id>
<updated>2019-04-21T18:20:53+00:00</updated>
<summary type="html" xml:lang="en"></summary>
<content type="html" xml:lang="en"><p>GNU Parallel 20190422 ('Invitation') [stable] has been released. It is available for download at: <a href="http://ftpmirror.gnu.org/parallel/">http://ftpmirror.gnu.org/parallel/</a>
<br />
</p>
<p>No new functionality was introduced so this is a good candidate for a stable release.
<br />
</p>
<h2>Invitation to 10 year reception</h2>
<p>GNU Parallel is 10 years old in a year on 2020-04-22. You are here by invited to a reception on Friday 2020-04-17.
<br />
</p>
<p>The primary reception will be held in Copenhagen, DK. Please reserve the date and email <a href="mailto:[email protected]">[email protected]</a> if you want to join.
<br />
</p>
<p>If you cannot make it, you are encouraged to host a parallel party.
<br />
</p>
<p>So far we hope to have parallel parties at:
<br />
</p>
<blockquote class="verbatim"><p> PROSA<br />
Vester Farimagsgade 37A<br />
DK-1606 København V<br />
RSVP: [email protected]<br />
<br />
PROSA<br />
Søren Frichs Vej 38 K th<br />
DK-8230 Åbyhøj<br />
RSVP: To be determined<br />
<br />
PROSA<br />
Overgade 54<br />
DK-5000 Odense C<br />
RSVP: To be determined<br />
</p></blockquote>
<p>If you want to host a party held in parallel (either in this or in a parallel universe), please let me know, so it can be announced.
<br />
</p>
<p>If you have parallel ideas for how to celebrate GNU Parallel, please post on the email list [email protected]. So far we have the following ideas:
<br />
</p>
<ul>
<li>Use GNU Parallel logo (the café wall illusion) as decoration everywhere - preferably in a moving version where the bars slide. Maybe we can borrow this <a href="https://www.youtube.com/watch?v=_XFDnFLqRFE">https://www.youtube.com/watch?v=_XFDnFLqRFE</a> or make an animation in javascript based on <a href="https://bl.ocks.org/Fil/13177d3c911fb8943cb0013086469b87">https://bl.ocks.org/Fil/13177d3c911fb8943cb0013086469b87</a>? Other illusions might be fun, too.
</li>
<li>Only serve beverages in parallel (2 or more), which may or may not be the same kind of beverage, and may or may not be served to the same person, and may or may not be served by multiple waiters in parallel
</li>
<li>Let people drink in parallel with straws (2 or more straws)
</li>
<li>Serve popcorn as snack (funny because cores and kernels are the same word in Danish, and GNU Parallel keeps cores hot)
</li>
<li>Serve saltstænger and similar parallel snacks.
</li>
<li>Serve (snack friendly) cereal ("serial") in parallel bowls.
</li>
<li>Live parallel streaming from parallel parties
</li>
<li>Play songs in parallel that use the same 4 chords: <a href="https://www.youtube.com/watch?v=5pidokakU4I">https://www.youtube.com/watch?v=5pidokakU4I</a>
</li>
<li>Play songs named parallel, serial, mutex, race condition and similar
</li>
<li>Have RC racing cars to demonstrate race condition
</li>
<li>Put a counting semaphore on the toilets
</li>
<li>Only let people leave one at a time to simulate serialized output - UNLESS they swap some clothing (to simulate half line mixing)
</li>
</ul>
<p>If you have interesting stories about or uses of GNU Parallel, please post them, so can be part of the anniversary update.
<br />
</p>
<p>Quote of the month:
<br />
</p>
<p> Y'all need some GNU parallel in your lives
<br />
-- ChaKu @ChaiLovesChai@twitter
<br />
</p>
<p>New in this release:
<br />
</p>
<ul>
<li>Invitation to the 10 years anniversary next year.
</li>
</ul>
<ul>
<li>The Austin Linux Meetup: KVM as Hypervisor and GNU Parallel <a href="https://www.meetup.com/linuxaustin/events/jbxcnqyzgbpb/">https://www.meetup.com/linuxaustin/events/jbxcnqyzgbpb/</a>
</li>
</ul>
<ul>
<li>Bug fixes and man page updates.
</li>
</ul>
<p>Get the book: GNU Parallel 2018 <a href="http://www.lulu.com/shop/ole-tange/gnu-parallel-2018/paperback/product-23558902.html">http://www.lulu.com/shop/ole-tange/gnu-parallel-2018/paperback/product-23558902.html</a>
<br />
</p>
<p>GNU Parallel - For people who live life in the parallel lane.
<br />
</p>
<h2>About GNU Parallel</h2>
<p>GNU Parallel is a shell tool for executing jobs in parallel using one or more computers. A job can be a single command or a small script that has to be run for each of the lines in the input. The typical input is a list of files, a list of hosts, a list of users, a list of URLs, or a list of tables. A job can also be a command that reads from a pipe. GNU Parallel can then split the input and pipe it into commands in parallel.
<br />
</p>
<p>If you use xargs and tee today you will find GNU Parallel very easy to use as GNU Parallel is written to have the same options as xargs. If you write loops in shell, you will find GNU Parallel may be able to replace most of the loops and make them run faster by running several jobs in parallel. GNU Parallel can even replace nested loops.
<br />
</p>
<p>GNU Parallel makes sure output from the commands is the same output as you would get had you run the commands sequentially. This makes it possible to use output from GNU Parallel as input for other programs.
<br />
</p>
<p>You can find more about GNU Parallel at: <a href="http://www.gnu.org/s/parallel/">http://www.gnu.org/s/parallel/</a>
<br />
</p>
<p>You can install GNU Parallel in just 10 seconds with:
<br />
(wget -O - pi.dk/3 || curl pi.dk/3/ || fetch -o - <a href="http://pi.dk/3">http://pi.dk/3</a>) | bash
<br />
</p>
<p>Watch the intro video on <a href="http://www.youtube.com/playlist?list=PL284C9FF2488BC6D1">http://www.youtube.com/playlist?list=PL284C9FF2488BC6D1</a>
<br />
</p>
<p>Walk through the tutorial (man parallel_tutorial). Your command line will love you for it.
<br />
</p>
<p>When using programs that use GNU Parallel to process data for publication please cite:
<br />
</p>
<p>O. Tange (2018): GNU Parallel 2018, March 2018, <a href="https://doi.org/10.5281/zenodo.1146014">https://doi.org/10.5281/zenodo.1146014</a>.
<br />
</p>
<p>If you like GNU Parallel:
<br />
</p>
<ul>
<li>Give a demo at your local user group/team/colleagues
</li>
<li>Post the intro videos on Reddit/Diaspora*/forums/blogs/ Identi.ca/Google+/Twitter/Facebook/Linkedin/mailing lists
</li>
<li>Get the merchandise <a href="https://gnuparallel.threadless.com/designs/gnu-parallel">https://gnuparallel.threadless.com/designs/gnu-parallel</a>
</li>
<li>Request or write a review for your favourite blog or magazine
</li>
<li>Request or build a package for your favourite distribution (if it is not already there)
</li>
<li>Invite me for your next conference
</li>
</ul>
<p>If you use programs that use GNU Parallel for research:
<br />
</p>
<ul>
<li>Please cite GNU Parallel in you publications (use --citation)
</li>
</ul>
<p>If GNU Parallel saves you money:
<br />
</p>
<ul>
<li>(Have your company) donate to FSF <a href="https://my.fsf.org/donate/">https://my.fsf.org/donate/</a>
</li>
</ul>
<h2>About GNU SQL</h2>
<p>GNU sql aims to give a simple, unified interface for accessing databases through all the different databases' command line clients. So far the focus has been on giving a common way to specify login information (protocol, username, password, hostname, and port number), size (database and table size), and running queries.
<br />
</p>
<p>The database is addressed using a DBURL. If commands are left out you will get that database's interactive shell.
<br />
</p>
<p>When using GNU SQL for a publication please cite:
<br />
</p>
<p>O. Tange (2011): GNU SQL - A Command Line Tool for Accessing Different Databases Using DBURLs, ;login: The USENIX Magazine, April 2011:29-32.
<br />
</p>
<h2>About GNU Niceload</h2>
<p>GNU niceload slows down a program when the computer load average (or other system activity) is above a certain limit. When the limit is reached the program will be suspended for some time. If the limit is a soft limit the program will be allowed to run for short amounts of time before being suspended again. If the limit is a hard limit the program will only be allowed to run when the system is below the limit.<br />
</p></content>
<author>
<name>Ole Tange</name>
<uri>http://savannah.gnu.org/news/atom.php?group=parallel</uri>
</author>
<source>
<title type="html">GNU Parallel - build and execute command lines from standard input in parallel - News</title>
<link rel="self" href="http://savannah.gnu.org/news/atom.php?group=parallel"/>
<id>http://savannah.gnu.org/news/atom.php?group=parallel</id>
</source>
</entry>
<entry xml:lang="en">
<title type="html" xml:lang="en">Gnuastro 0.9 released</title>
<link href="http://savannah.gnu.org/forum/forum.php?forum_id=9419"/>
<id>http://savannah.gnu.org/forum/forum.php?forum_id=9419</id>
<updated>2019-04-17T17:54:52+00:00</updated>
<summary type="html" xml:lang="en"></summary>
<content type="html" xml:lang="en"><p>The 9th release of GNU Astronomy Utilities (Gnuastro) is now available for download. Please see <a href="http://lists.gnu.org/archive/html/info-gnuastro/2019-04/msg00001.html">the announcement</a> for details.<br />
</p></content>
<author>
<name>Mohammad Akhlaghi</name>
<uri>http://savannah.gnu.org/news/atom.php?group=gnuastro</uri>
</author>
<source>
<title type="html">GNU Astronomy Utilities - News</title>
<link rel="self" href="http://savannah.gnu.org/news/atom.php?group=gnuastro"/>
<id>http://savannah.gnu.org/news/atom.php?group=gnuastro</id>
</source>
</entry>
<entry xml:lang="en">
<title type="html" xml:lang="en">Malfunction in ghm-planning (at) gnu.org</title>
<link href="http://savannah.gnu.org/forum/forum.php?forum_id=9417"/>
<id>http://savannah.gnu.org/forum/forum.php?forum_id=9417</id>
<updated>2019-04-14T07:56:27+00:00</updated>
<summary type="html" xml:lang="en"></summary>
<content type="html" xml:lang="en"><p>Due to a problem in the alias configuration, mails sent to ghm-planning before Sun Apr 14 8:00 CEST have been silently dropped.
<br />
</p>
<p>If you sent a registration email and/or a talk proposal for the GHM 2019, please resend it.
<br />
</p>
<p>Sorry for the inconvenience!<br />
</p></content>
<author>
<name>Jose E. Marchesi</name>
<uri>http://savannah.gnu.org/news/atom.php?group=ghm</uri>
</author>
<source>
<title type="html">GNU Hackers Meetings - News</title>
<link rel="self" href="http://savannah.gnu.org/news/atom.php?group=ghm"/>
<id>http://savannah.gnu.org/news/atom.php?group=ghm</id>
</source>
</entry>
<entry xml:lang="en">
<title type="html" xml:lang="en">GNU Hackers' Meeting 2019 in Madrid</title>
<link href="http://savannah.gnu.org/forum/forum.php?forum_id=9415"/>
<id>http://savannah.gnu.org/forum/forum.php?forum_id=9415</id>
<updated>2019-04-12T20:03:26+00:00</updated>
<summary type="html" xml:lang="en"></summary>
<content type="html" xml:lang="en"><p>Twelve years after it's first edition in Orense, the GHM is back to Spain! This time, we will be gathering in the nice city of Madrid for hacking, learning and meeting each other.
<br />
</p>
<p>The event will have place from Wednesday 4 September to Friday 6
<br />
September, 2019.
<br />
</p>
<p>Please visit <a href="http://www.gnu.org/ghm/2019">http://www.gnu.org/ghm/2019</a> for more information on the venue and instructions on how to register and propose talks.
<br />
</p>
<p>The website will be updated as we complete the schedule and the organizational details, so stay tuned!<br />
</p></content>
<author>
<name>Jose E. Marchesi</name>
<uri>http://savannah.gnu.org/news/atom.php?group=ghm</uri>
</author>
<source>
<title type="html">GNU Hackers Meetings - News</title>
<link rel="self" href="http://savannah.gnu.org/news/atom.php?group=ghm"/>
<id>http://savannah.gnu.org/news/atom.php?group=ghm</id>
</source>
</entry>
<entry xml:lang="en">
<title type="html" xml:lang="en">2019-04-04: GNUnet 0.11.2 released</title>
<link href="https://gnunet.org/#gnunet-0.11.2-release"/>
<id>https://gnunet.org/#gnunet-0.11.2-release</id>
<updated>2019-04-04T13:00:00+00:00</updated>
<summary type="html" xml:lang="en"></summary>
<content type="html" xml:lang="en"><h3>
<a name="gnunet-0.11.2-release">2019-04-04: GNUnet 0.11.2 released</a>
</h3>
<p>
We are pleased to announce the release of GNUnet 0.11.2.
</p>
<p>
This is a bugfix release for 0.11.0, mostly fixing minor bugs,
improving documentation and fixing various build issues. In
terms of usability, users should be aware that there are still a large
number of known open issues in particular with respect to ease of use,
but also some critical privacy issues especially for mobile users.
Also, the nascent network is tiny (about 200 peers) and thus unlikely to
provide good anonymity or extensive amounts of interesting
information. As a result, the 0.11.2 release is still only suitable
for early adopters with some reasonable pain tolerance.
</p>
<h4>Download links</h4>
<ul>
<li><a href="http://ftpmirror.gnu.org/gnunet/gnunet-0.11.2.tar.gz">http://ftpmirror.gnu.org/gnunet/gnunet-0.11.2.tar.gz</a></li>
<li><a href="http://ftpmirror.gnu.org/gnunet/gnunet-0.11.2.tar.gz.sig">http://ftpmirror.gnu.org/gnunet/gnunet-0.11.2.tar.gz.sig</a></li>
<li><a href="http://ftpmirror.gnu.org/gnunet/gnunet-gtk-0.11.0.tar.gz">http://ftpmirror.gnu.org/gnunet/gnunet-gtk-0.11.0.tar.gz</a></li>
<li><a href="http://ftpmirror.gnu.org/gnunet/gnunet-gtk-0.11.0.tar.gz.sig">http://ftpmirror.gnu.org/gnunet/gnunet-gtk-0.11.0.tar.gz.sig</a></li>
<li><a href="http://ftpmirror.gnu.org/gnunet/gnunet-fuse-0.11.0.tar.gz">http://ftpmirror.gnu.org/gnunet/gnunet-fuse-0.11.0.tar.gz</a></li>
<li><a href="http://ftpmirror.gnu.org/gnunet/gnunet-fuse-0.11.0.tar.gz.sig">http://ftpmirror.gnu.org/gnunet/gnunet-fuse-0.11.0.tar.gz.sig</a></li>
</ul>
<p>
(gnunet-gtk and gnunet-fuse were not released again, as there were no
changes and the 0.11.0 versions are expected to continue to work fine
with gnunet-0.11.2.)
</p>
<p>
Note that due to mirror synchronization, not all links might be functional
early after the release. For direct access try <a href="http://ftp.gnu.org/gnu/gnunet/">http://ftp.gnu.org/gnu/gnunet/</a>
</p>
<p>
Note that GNUnet is now started using <tt>gnunet-arm -s</tt>. GNUnet should be
stopped using <tt>gnunet-arm -e</tt>.
</p>
<h4>Noteworthy changes in 0.11.2</h4>
<ul>
<li>gnunet-qr was rewritten in C, removing our last dependency on Python 2.x</li>
<li>REST and GNS proxy configuration options for address binding were added</li>
<li>gnunet-publish by default no longer includes creation time</li>
<li>Unreliable message ordering logic in CADET was fixed</li>
<li>Various improvements to build system and documentation</li>
</ul>
<p>
The above is just the short list, our bugtracker lists
<a href="https://bugs.gnunet.org/changelog_page.php?version_id=312">
14 individual issues</a> that were resolved since 0.11.0.
</p>
<h4>Known Issues</h4>
<ul>
<li>There are known major design issues in the TRANSPORT, ATS and CORE subsystems
which will need to be addressed in the future to achieve acceptable usability,
performance and security.</li>
<li>There are known moderate implementation limitations in CADET that
negatively impact performance. Also CADET may unexpectedly deliver messages out-of-order.</li>
<li>There are known moderate design issues in FS that also impact
usability and performance.</li>
<li>There are minor implementation limitations in SET that create
unnecessary attack surface for availability.</li>
<li>The RPS subsystem remains experimental.</li>
<li>Some high-level tests in the test-suite fail non-deterministically due to
the low-level TRANSPORT issues.</li>
</ul>
<p>
In addition to this list, you may also want to consult our bug tracker
at <a href="https://bugs.gnunet.org/">bugs.gnunet.org</a> which lists
about 190 more specific issues.
</p>
<h4>Thanks</h4>
<p>
This release was the work of many people. The following people
contributed code and were thus easily identified:
ng0, Christian Grothoff, Hartmut Goebel, Martin Schanzenbach, Devan Carpenter, Naomi Phillips and Julius Bünger.
</p></content>
<author>
<name>GNUnet News</name>
<uri>https://gnunet.org</uri>
</author>
<source>
<title type="html">GNUnet.org</title>
<subtitle type="html">News from GNUnet</subtitle>
<link rel="self" href="https://gnunet.org/rss.xml"/>
<id>https://gnunet.org</id>
</source>
</entry>
<entry xml:lang="en">
<title type="html" xml:lang="en">2019-04-03: GNUnet 0.11.1 released</title>
<link href="https://gnunet.org/#gnunet-0.11.1-release"/>
<id>https://gnunet.org/#gnunet-0.11.1-release</id>
<updated>2019-04-03T16:00:00+00:00</updated>
<summary type="html" xml:lang="en"></summary>
<content type="html" xml:lang="en"><h3>
<a name="gnunet-0.11.1-release">2019-04-03: GNUnet 0.11.1 released</a>
</h3>
<p>
We are pleased to announce the release of GNUnet 0.11.1.
</p>
<p>
This is a bugfix release for 0.11.0, mostly fixing minor bugs,
improving documentation and fixing various build issues. In
terms of usability, users should be aware that there are still a large
number of known open issues in particular with respect to ease of use,
but also some critical privacy issues especially for mobile users.
Also, the nascent network is tiny (about 200 peers) and thus unlikely to
provide good anonymity or extensive amounts of interesting
information. As a result, the 0.11.1 release is still only suitable
for early adopters with some reasonable pain tolerance.
</p>
<h4>Download links</h4>
<ul>
<li><a href="http://ftpmirror.gnu.org/gnunet/gnunet-0.11.1.tar.gz">http://ftpmirror.gnu.org/gnunet/gnunet-0.11.1.tar.gz</a></li>
<li><a href="http://ftpmirror.gnu.org/gnunet/gnunet-0.11.1.tar.gz.sig">http://ftpmirror.gnu.org/gnunet/gnunet-0.11.1.tar.gz.sig</a></li>
<li><a href="http://ftpmirror.gnu.org/gnunet/gnunet-gtk-0.11.0.tar.gz">http://ftpmirror.gnu.org/gnunet/gnunet-gtk-0.11.0.tar.gz</a></li>
<li><a href="http://ftpmirror.gnu.org/gnunet/gnunet-gtk-0.11.0.tar.gz.sig">http://ftpmirror.gnu.org/gnunet/gnunet-gtk-0.11.0.tar.gz.sig</a></li>
<li><a href="http://ftpmirror.gnu.org/gnunet/gnunet-fuse-0.11.0.tar.gz">http://ftpmirror.gnu.org/gnunet/gnunet-fuse-0.11.0.tar.gz</a></li>
<li><a href="http://ftpmirror.gnu.org/gnunet/gnunet-fuse-0.11.0.tar.gz.sig">http://ftpmirror.gnu.org/gnunet/gnunet-fuse-0.11.0.tar.gz.sig</a></li>
</ul>
<p>
(gnunet-gtk and gnunet-fuse were not released again, as there were no
changes and the 0.11.0 versions are expected to continue to work fine
with gnunet-0.11.1.)
</p>
<p>
Note that due to mirror synchronization, not all links might be functional
early after the release. For direct access try <a href="http://ftp.gnu.org/gnu/gnunet/">http://ftp.gnu.org/gnu/gnunet/</a>
</p>
<p>
Note that GNUnet is now started using <tt>gnunet-arm -s</tt>. GNUnet should be
stopped using <tt>gnunet-arm -e</tt>.
</p>
<h4>Noteworthy changes in 0.11.1</h4>
<ul>
<li>gnunet-qr was rewritten in C, removing our last dependency on Python 2.x</li>
<li>REST and GNS proxy configuration options for address binding were added</li>
<li>gnunet-publish by default no longer includes creation time</li>
<li>Unreliable message ordering logic in CADET was fixed</li>
<li>Various improvements to build system and documentation</li>
</ul>
<p>
The above is just the short list, our bugtracker lists
<a href="https://bugs.gnunet.org/changelog_page.php?version_id=312">
14 individual issues</a> that were resolved since 0.11.0.
</p>
<h4>Known Issues</h4>
<ul>
<li>There are known major design issues in the TRANSPORT, ATS and CORE subsystems
which will need to be addressed in the future to achieve acceptable usability,
performance and security.</li>
<li>There are known moderate implementation limitations in CADET that
negatively impact performance. Also CADET may unexpectedly deliver messages out-of-order.</li>
<li>There are known moderate design issues in FS that also impact
usability and performance.</li>
<li>There are minor implementation limitations in SET that create
unnecessary attack surface for availability.</li>
<li>The RPS subsystem remains experimental.</li>
<li>Some high-level tests in the test-suite fail non-deterministically due to
the low-level TRANSPORT issues.</li>
</ul>
<p>
In addition to this list, you may also want to consult our bug tracker
at <a href="https://bugs.gnunet.org/">bugs.gnunet.org</a> which lists
about 190 more specific issues.
</p>
<h4>Thanks</h4>
<p>
This release was the work of many people. The following people
contributed code and were thus easily identified:
ng0, Christian Grothoff, Hartmut Goebel, Martin Schanzenbach, Devan Carpenter, Naomi Phillips and Julius Bünger.
</p></content>
<author>
<name>GNUnet News</name>
<uri>https://gnunet.org</uri>
</author>
<source>
<title type="html">GNUnet.org</title>
<subtitle type="html">News from GNUnet</subtitle>
<link rel="self" href="https://gnunet.org/rss.xml"/>
<id>https://gnunet.org</id>
</source>
</entry>
<entry xml:lang="en">
<title type="html" xml:lang="en">Connecting reproducible deployment to a long-term source code archive</title>
<link href="https://gnu.org/software/guix/blog/2019/connecting-reproducible-deployment-to-a-long-term-source-code-archive/"/>
<id>https://gnu.org/software/guix/blog/2019/connecting-reproducible-deployment-to-a-long-term-source-code-archive/</id>
<updated>2019-03-29T14:50:00+00:00</updated>
<summary type="html" xml:lang="en"></summary>
<content type="html" xml:lang="en"><p>GNU Guix can be used as a “package manager” to install and upgrade
software packages as is familiar to GNU/Linux users, or as an
environment manager, but it can also provision containers or virtual
machines, and manage the operating system running on your machine.</p><p>One foundation that sets it apart from other tools in these areas is
<em>reproducibility</em>. From a high-level view, Guix allows users to
<em>declare</em> complete software environments and instantiate them. They can
share those environments with others, who can replicate them or adapt
them to their needs. This aspect is key to reproducible computational
experiments: scientists need to reproduce software environments before
they can reproduce experimental results, and this is one of the things
we are focusing on in the context of the
<a href="https://guix-hpc.bordeaux.inria.fr">Guix-HPC</a> effort. At a lower
level, the project, along with others in the <a href="https://reproducible-builds.org">Reproducible
Builds</a> community, is working to ensure
that software build outputs are <a href="https://reproducible-builds.org/docs/definition/">reproducible,
bit for bit</a>.</p><p>Work on reproducibility at all levels has been making great progress.
Guix, for instance, allows you to <a href="https://www.gnu.org/software/guix/blog/2018/multi-dimensional-transactions-and-rollbacks-oh-my/">travel back in
time</a>.
That Guix can travel back in time <em>and</em> build software reproducibly is a
great step forward. But there’s still an important piece that’s missing
to make this viable: a stable source code archive. This is where
<a href="https://www.softwareheritage.org">Software Heritage</a> (SWH for short)
comes in.</p><h1>When source code vanishes</h1><p>Guix contains thousands of package definitions. Each <a href="https://www.gnu.org/software/guix/manual/en/html_node/Defining-Packages.html">package
definition</a>
specifies the package’s source code URL and hash, the package’s
dependencies, and its build procedure. Most of the time, the package’s
source code is an archive (a “tarball”) fetched from a web site, but
more and more frequently the source code is a specific revision checked
out directly from a version control system.</p><p>The obvious question, then, is: what happens if the source code URL
becomes unreachable? The whole reproducibility endeavor collapses when
source code disappears. And source code <em>does</em> disappear, or, even
worse, it can be modified in place. At GNU we’re doing a good job of
having stable hosting that keeps releases around “forever”, unchanged
(modulo rare exceptions). But a lot of free software out there is
hosted on personal web pages with a short lifetime and on commercial
hosting services that come and go.</p><p>By default Guix would look up source code by hash in the caches of our
build farms. This comes for free: the <a href="https://www.gnu.org/software/guix/manual/en/html_node/Substitutes.html">“substitute”
mechanism</a>
extends to all “build artifacts”, including downloads. However, with
limited capacity, our build farms do not keep all the source code of all
the packages for a long time. Thus, one could very well find oneself
unable to rebuild a package months or years later, simply because its
source code disappeared or moved to a different location.</p><h1>Connecting to the archive</h1><p>It quickly became clear that reproducible builds had “reproducible
source code downloads”, so to speak, as a prerequisite. The Software
Heritage archive is the missing piece that would finally allow us to
reproduce software environments years later in spite of the volatility
of code hosting sites. Software Heritage’s mission is to archive
essentially “all” the source code ever published, including version
control history. Its archive already periodically ingests release
tarballs from the GNU servers, repositories from GitHub, packages from
PyPI, and much more.</p><p><img alt="Software Heritage logo" src="https://www.gnu.org/software/guix/static/blog/img/software-heritage-logo-title.svg" /></p><p>We quickly settled on a scheme where Guix would fall back to the
Software Heritage archive whenever it fails to download source code from
its original location. That way, package definitions don’t need to be
modified: they still refer to the original source code URL, but the
downloading machinery transparently goes to Software Heritage when
needed.</p><p>There are two types of source code downloads in Guix: tarball downloads,
and version control checkouts. In the former case, resorting to
Software Heritage is easy: Guix knows the SHA256 hash of the tarball so
it can look it up by hash using <a href="https://archive.softwareheritage.org/api/1/content/raw/">the <code>/content</code> endpoint of the
archive’s
interface</a>.</p><p>Fetching version control checkouts is more involved. In this case, the
downloader would first resolve the commit identifier to obtain a
<a href="https://archive.softwareheritage.org/api/1/revision/">Software Heritage
revision</a>. The
actual code for that revision is then fetched through the
<a href="https://docs.softwareheritage.org/devel/swh-vault/api.html"><em>vault</em></a>.</p><p>The vault conveniently allows users to fetch the tarball corresponding
to a revision. However, not all revisions are readily available as
tarballs (understandably), so the vault has an interface that allows you
to request the “<em>cooking</em>” of a specific revision. Cooking is
asynchronous and can take some time. Currently, if a revision hasn’t
been cooked yet, the Guix download machinery will request it and wait
until it is available. The process can take some time but will
eventually succeed.</p><p>Success! At this point, we have essentially bridged the gap between the
stable archive that Software Heritage provides and the reproducible
software deployment pipeline of Guix. This code <a href="https://issues.guix.info/issue/33432">was
integrated</a> in November 2018,
making it the first free software distribution backed by a stable
archive.</p><h1>The challenges ahead</h1><p>This milestone was encouraging: we had seemingly achieved our goal, but
we also knew of several shortcomings. First, even though the software
we package is still primarily distributed as tarballs, Software Heritage
keeps relatively few of these tarballs. Software Heritage does ingest
tarballs, notably those found on <a href="https://ftp.gnu.org/gnu/">the GNU
servers</a>, but the primary focus is on
preserving complete version control repositories rather than release
tarballs.</p><p>It is not yet clear to us what to do with plain old tarballs. On one
hand, they are here and cannot be ignored. Furthermore, some provide
artifacts that are not in version control, such as <code>configure</code> scripts,
and often enough they are accompanied by a cryptographic signature from
the developers that allows recipients to <em>authenticate</em> the code—an
important piece of information that’s often missing from version control
history. On the other hand, version control tags are increasingly
becoming the mechanism of choice to distribute software releases. It
may be that tags will become the primary mechanism for software release
distribution soon enough.</p><p>Version control tags turn out not to be ideal either, because they’re
mutable and per-repository. Conversely, Git commit identifiers are
unambiguous and repository-independent because they’re essentially
content-addressed, but our package definitions often refer to tags, not
commits, because that makes it clearer that we’re providing an actual
release and not an arbitrary revision (this is another illustration of
<a href="https://en.wikipedia.org/wiki/Zooko's_triangle">Zooko’s triangle</a>).</p><p>This leads to another limitation that stems from the mismatch between
the way Guix and Software Heritage compute hashes over version control
checkouts: both compute a hash over a serialized representation of the
directory, but they serialize the directory in a different way (SWH
serializes directories as Git trees, while Guix uses “normalized
archives” or Nars, the format the build daemon manipulates, which is
inherited from Nix.) That prevents Guix from looking up revisions by
content hash. The solution will probably involve changing Guix to
support the same method as Software Heritage, and/or adding Guix’s method
to Software Heritage.</p><p>Having to wait for “cooking” completion can also be problematic. The
Software Heritage team is investigating the possibility to
<a href="https://forge.softwareheritage.org/T1350">automatically cook all version control
tags</a>. That way, relevant
revisions would almost always be readily available through the vault.</p><p>Similarly, we have no guarantee that software provided by Guix is
available in the archive. Our plan is to <a href="https://forge.softwareheritage.org/T1352">extend Software
Heritage</a> such that it would
periodically archive the source code of software packaged by Guix.</p><h1>Going further</h1><p>In the process of adding support for Software Heritage, Guix <a href="https://issues.guix.info/issue/33432">gained
Guile bindings to the Software Heritage HTTP
interface</a>. Here’s a couple of
things we can do:</p><pre><code class="language-scheme">(use-modules (guix swh))
;; Check whether SWH has ever crawled our repository.
(define o (lookup-origin "https://git.savannah.gnu.org/git/guix.git"))
⇒ #&lt;&lt;origin&gt; id: 86312956 …&gt;
;; It did! When was its last visit?
(define last-visit
(first (origin-visits o)))
(date-&gt;string (visit-date last-visit))
⇒ "Fri Mar 29 10:07:45Z 2019"
;; Does it have our “v0.15.0” Git tag?
(lookup-origin-revision "https://git.savannah.gnu.org/git/guix.git" "v0.15.0")
⇒ #&lt;&lt;revision&gt; id: "359fdda40f754bbf1b5dc261e7427b75463b59be" …&gt;</code></pre><p>Guix itself is a Guile library so when we combine the two, there are
interesting things we can do:</p><pre><code class="language-scheme">(use-modules (guix) (guix swh)
(gnu packages base)
(gnu packages golang))
;; This is our GNU Coreutils package.
coreutils
⇒ #&lt;package [email protected] gnu/packages/base.scm:342 1c67b40&gt;
;; Does SWH have its tarball?
(lookup-content (origin-sha256 (package-source coreutils))
"sha256")
⇒ #&lt;&lt;content&gt; checksums: (("sha1" …)) data-url: …&gt;
;; Our package for HashiCorp’s Configuration Language (HCL) is
;; built from a Git commit.
(define commit
(git-reference-commit
(origin-uri (package-source go-github-com-hashicorp-hcl))))
;; Is this particular commit available in the archive?
(lookup-revision commit)
⇒ #&lt;&lt;revision&gt; id: "23c074d0eceb2b8a5bfdbb271ab780cde70f05a8" …&gt;</code></pre><p>We’re currently using a subset of this interface, but there’s certainly
more we could do. For example, we can compute archive coverage of the
Guix packages; we can also request the archival of each package’s source
code <em>via</em> the <a href="https://archive.softwareheritage.org/api/1/origin/save/">“save code”
interface</a>—though
all this is subject to <a href="https://archive.softwareheritage.org/api/#rate-limiting">rate
limiting</a>.</p><h1>Wrap-up</h1><p>Software Heritage support in Guix creates a bridge from the stable
source code archive to reproducible software deployment with complete
provenance tracking. For the first time it gives us a software package
distribution that can be rebuilt months or years later. This is
particularly beneficial in the context of reproducible science: finally
we can describe reproducible software environments, a prerequisite for
reproducible computational experiments.</p><p>Going further, we can provide a complete software supply tool chain with
provenance tracking that links revisions in the archive to
bit-reproducible build artifacts produced by Guix. Oh and Guix itself
<a href="https://archive.softwareheritage.org/api/1/origin/git/url/https://git.savannah.gnu.org/git/guix.git/">is
archived</a>,
so we have this meta-level where we could link Guix revisions to the
revisions of packages it provides… There are still technical challenges
to overcome, but that vision is shaping up.</p><h4>About GNU Guix</h4><p><a href="https://www.gnu.org/software/guix">GNU Guix</a> is a transactional package
manager and an advanced distribution of the GNU system that <a href="https://www.gnu.org/distros/free-system-distribution-guidelines.html">respects
user
freedom</a>.
Guix can be used on top of any system running the kernel Linux, or it
can be used as a standalone operating system distribution for i686,
x86_64, ARMv7, and AArch64 machines.</p><p>In addition to standard package management features, Guix supports
transactional upgrades and roll-backs, unprivileged package management,
per-user profiles, and garbage collection. When used as a standalone
GNU/Linux distribution, Guix offers a declarative, stateless approach to
operating system configuration management. Guix is highly customizable
and hackable through <a href="https://www.gnu.org/software/guile">Guile</a>
programming interfaces and extensions to the
<a href="http://schemers.org">Scheme</a> language.</p></content>
<author>
<name>Ludovic Courtès</name>
<uri>https://gnu.org/software/guix/blog/</uri>
</author>
<source>
<title type="html">GNU Guix — Blog</title>
<link rel="self" href="https://www.gnu.org/software/guix/news/feed.xml"/>
<id>https://gnu.org/software/guix/feeds/blog.atom</id>
</source>
</entry>
<entry xml:lang="en">
<title type="html" xml:lang="en">osip2 [5.1.0] &amp; exosip2 [5.1.0]</title>
<link href="http://savannah.gnu.org/forum/forum.php?forum_id=9405"/>
<id>http://savannah.gnu.org/forum/forum.php?forum_id=9405</id>
<updated>2019-03-28T19:50:43+00:00</updated>
<summary type="html" xml:lang="en"></summary>
<content type="html" xml:lang="en"><p>I have released today newer versions for both osip2 &amp; exosip2.
<br />
</p>
<p>osip is very mature. There was only one tiny feature change to allow more flexible NAPTR request (such as ENUM). A very few bugs were discovered and fixed.
<br />
</p>
<p>eXosip is also mature. However a few bugs around PRACK and retransmissions were reported and fixed. openssl support has also been updated to support more features, be more flexible and support all openssl versions. ENUM support has been introduced this year. See the ChangeLog for more!
<br />
</p>
<p>In all case, upgrading is <strong>strongly</strong> recommanded. API changes are documented in the ChangeLog: there is not much!<br />
</p></content>
<author>
<name>Aymeric MOIZARD</name>
<uri>http://savannah.gnu.org/news/atom.php?group=osip</uri>
</author>
<source>
<title type="html">The oSIP library - News</title>
<link rel="self" href="http://savannah.gnu.org/news/atom.php?group=osip"/>
<id>http://savannah.gnu.org/news/atom.php?group=osip</id>
</source>
</entry>
<entry xml:lang="en">
<title type="html" xml:lang="en">GNU nano 4.0 was released</title>
<link href="http://savannah.gnu.org/forum/forum.php?forum_id=9404"/>
<id>http://savannah.gnu.org/forum/forum.php?forum_id=9404</id>
<updated>2019-03-27T18:36:29+00:00</updated>
<summary type="html" xml:lang="en"></summary>
<content type="html" xml:lang="en"><p>This version breaks with the close compatibility with Pico: nano no longer hard-wraps the current line by default when it becomes overlong, and uses smooth scrolling by default, plus two other minor changes. Further, in 3.0 indenting and unindenting became undoable, and now, with 4.0, also justifications have become undoable (to any depth), making that all of the user's actions are now undoable and redoable (with the M-U and M-E keystrokes).<br />
</p></content>
<author>
<name>Benno Schulenberg</name>
<uri>http://savannah.gnu.org/news/atom.php?group=nano</uri>
</author>
<source>
<title type="html">GNU nano - News</title>
<link rel="self" href="http://savannah.gnu.org/news/atom.php?group=nano"/>
<id>http://savannah.gnu.org/news/atom.php?group=nano</id>
</source>
</entry>
<entry xml:lang="en">
<title type="html" xml:lang="en">FSF job opportunity: campaigns manager</title>
<link href="http://www.fsf.org/news/fsf-job-opportunity-campaigns-manager-1"/>
<id>http://www.fsf.org/news/fsf-job-opportunity-campaigns-manager-1</id>
<updated>2019-03-25T20:15:00+00:00</updated>
<summary type="html" xml:lang="en"></summary>
<content type="html" xml:lang="en"><p>The Free Software Foundation (FSF), a Massachusetts 501(c)(3) charity with a worldwide mission to protect computer user freedom, seeks a motivated and talented Boston-based individual to be our full-time campaigns manager.</p>
<p>Reporting to the executive director, the campaigns manager works on our campaigns team to lead, plan, carry out, evaluate, and improve the FSF's advocacy and education campaigns. The team also works closely with other FSF departments, including licensing, operations, and tech. The position will start by taking responsibility for existing campaigns in support of the GNU Project, free software adoption, free media formats, and freedom on the network; and against Digital Restrictions Management (DRM), software patents, and proprietary software.</p>
<p>Examples of job responsibilities include, but are not limited to:</p>
<ul>
<li>Planning and participating in online and physical actions to
achieve our campaign goals;<br />
</li>
<li>Setting specific goals for each action and then measuring our
success in achieving them;<br />
</li>
<li>Doing the writing and messaging work needed to effectively explain
our campaigns and motivate people to support them;<br />
</li>
<li>Overseeing or doing the graphic design work to make our campaigns
and their Web sites attractive;<br />
</li>
<li>Supporting and attending special events, including
community-building activities and our annual LibrePlanet conference;<br />
</li>
<li>Assisting with annual online and mail fundraising efforts;<br />
</li>
<li>Working with our tech team on the technology choices and
deployments -- especially of Web publication systems like Drupal
and Plone -- for our campaign sites; and</li>
<li>Being an approachable, humble, and friendly representative of the
FSF to our worldwide community of existing supporters and the
broader public, both in person and online.<br />
</li>
</ul>
<p>Ideal candidates have at least three to five years of work experience in online issue advocacy and free software; proficiency and comfort with professional writing and publications preferred. Because the FSF works globally and seeks to have our materials distributed in as many languages as possible, multilingual candidates will have an advantage. With our small staff of fourteen, each person makes a clear contribution. We work hard, but offer a humane and fun work environment at an office located in the heart of downtown Boston. The FSF is a mature but growing organization that provides great potential for advancement; existing staff get the first chance at any new job openings.</p>
<h2>Benefits and salary</h2>
<p>This job is a union position that must be worked on-site at the FSF's downtown Boston office. The salary is fixed at $63,253/year and is non-negotiable. Other benefits include:</p>
<ul>
<li>Full individual or family health coverage through Blue Cross/Blue Shield's HMO Blue program;<br />
</li>
<li>Subsidized dental plan;<br />
</li>
<li>Four weeks of paid vacation annually;<br />
</li>
<li>Seventeen paid holidays annually;<br />
</li>
<li>Weekly remote work allowance;<br />
</li>
<li>Public transit commuting cost reimbursement;<br />
</li>
<li>403(b) program through TIAA with employer match;<br />
</li>
<li>Yearly cost-of-living pay increases (based on government guidelines);<br />
</li>
<li>Healthcare expense reimbursement budget;<br />
</li>
<li>Ergonomic budget;<br />
</li>
<li>Relocation (to Boston area) expense reimbursement;<br />
</li>
<li>Conference travel and professional development opportunities; and</li>
<li>Potential for an annual performance bonus.</li>
</ul>
<h2>Application instructions</h2>
<p>Applications must be submitted via email to <a href="mailto:[email protected]">[email protected]</a>. The email must contain the subject line "Campaigns manager". A complete application should include:</p>
<ul>
<li>Cover letter, including a brief example of a time you motivated and organized others to take action on an issue important to you;<br />
</li>
<li>Resume;<br />
</li>
<li>Two recent writing samples;<br />
</li>
<li>Links to any talks you have given (optional); and<br />
</li>
<li>Graphic design samples (optional).</li>
</ul>
<p>All materials must be in a free format (such as plain text, PDF, or OpenDocument). Email submissions that do not follow these instructions will probably be overlooked. No phone calls, please.</p>
<p><strong>Applications will be reviewed on a rolling basis until the position is filled. To guarantee consideration, submit your application by Sunday, April 28th.</strong><br />
</p>
<p>The FSF is an equal opportunity employer and will not discriminate against any employee or application for employment on the basis of race, color, marital status, religion, age, sex, sexual orientation, national origin, handicap, or any other legally protected status recognized by federal, state or local law. We value diversity in our workplace. </p>
<h3>About the Free Software Foundation</h3>
<p>The Free Software Foundation, founded in 1985, is dedicated to promoting computer users' right to use, study, copy, modify, and redistribute computer programs. The FSF promotes the development and use of free (as in freedom) software -- particularly the GNU operating system and its GNU/Linux variants -- and free documentation for free software. The FSF also helps to spread awareness of the ethical and political issues of freedom in the use of software, and its Web sites, located at fsf.org and gnu.org, are an important source of information about GNU/Linux. Donations to support the FSF's work can be made at <a href="https://donate.fsf.org">https://donate.fsf.org</a>. We are based in Boston, MA, USA.</p></content>
<author>
<name>FSF News</name>
<uri>http://www.fsf.org/news/aggregator</uri>
</author>
<source>
<title type="html">FSF News</title>
<link rel="self" href="http://static.fsf.org/fsforg/rss/news.xml"/>
<id>http://www.fsf.org/news/aggregator</id>
</source>
</entry>
<entry xml:lang="en">
<title type="html" xml:lang="en">OpenStreetMap and Deborah Nicholson win 2018 FSF Awards</title>
<link href="http://www.fsf.org/news/openstreetmap-and-deborah-nicholson-win-2018-fsf-awards"/>
<id>http://www.fsf.org/news/openstreetmap-and-deborah-nicholson-win-2018-fsf-awards</id>
<updated>2019-03-23T23:30:00+00:00</updated>
<summary type="html" xml:lang="en"></summary>
<content type="html" xml:lang="en"><p><em>BOSTON, Massachusetts, USA -- Saturday, March 23, 2019 -- The Free
Software Foundation (FSF) recognizes <a href="https://www.openstreetmap.org/">OpenStreetMap</a> with the 2018
Free Software Award for Projects of Social Benefit and Deborah
Nicholson with the Award for the Advancement of Free Software. FSF
president Richard M. Stallman presented the awards today in a yearly
ceremony during the LibrePlanet 2019 conference at the Massachusetts
Institute of Technology (MIT).</em></p>
<p>The <a href="https://www.fsf.org/awards/sb-award/">Award for Projects of Social Benefit</a> is presented to a
project or team responsible for applying free software, or the ideas
of the free software movement, to intentionally and significantly
benefit society. This award stresses the use of free software in
service to humanity.</p>
<p><img alt="Richard Stallman with Free Software Awards winners Deborah Nicholson and Kate Chapman" src="https://static.fsf.org/nosvn/libreplanet/2019/photos/free-software-awards/both.jpg" style="float: right; width: 250px; margin: 10px 0px 10px 10px;" /> </p>
<p>This year the FSF awarded OpenStreetMap and the award was accepted by
Kate Chapman, chairperson of the OpenStreetMap Foundation and
co-founder of the Humanitarian OpenStreetMap Team (HOT).</p>
<p>OpenStreetMap is a collaborative project to create a free editable map
of the world. Founded by Steve Coast in the UK in 2004, OpenStreetMap
is built by a community of over one million community members and has
found its application on thousands of Web sites, mobile apps, and
hardware devices. OpenStreetMap is the only truly global service
without restrictions on use or availability of map information.</p>
<p>Stallman emphasized the importance of OpenStreetMap in a time where
geotech and geo-thinking are highly prevalent. "It has been clear for
decades that map data are important. Therefore we need a free
collection of map data. The name OpenStreetMap doesn't say so
explicitly, but its map data is free. It is the free replacement that
the Free World needs."</p>
<p>Kate thanked the Free Software Foundation and the large community of
contributors of OpenStreetMap. "In 2004, much of the geospatial data
was either extraordinarily expensive or unavailable. Our strong
community of people committed to free and open map information has
changed that. Without the leadership before us from groups such as the
Free Software Foundation, we would not have been able to grow and
develop to the resource we are today."</p>
<p>The <a href="https://www.fsf.org/awards/fs-award">Award for the Advancement of Free Software</a> goes to an
individual who has made a great contribution to the progress and
development of free software through activities that accord with the
spirit of free software.</p>
<p><img alt="Richard Stallman presenting Free Software Award to Deborah Nicholson" src="https://static.fsf.org/nosvn/libreplanet/2019/photos/free-software-awards/deb.jpg" style="float: right; width: 250px; margin: 10px 0px 10px 10px;" /> </p>
<p>This year it was presented to Deborah Nicholson, who, motivated by the
intersection of technology and social justice, advocates access to
political information, unfettered freedom of speech and assembly, and
civil liberties in our increasingly digital world. She joined the free
software movement in 2006 after years of local organizing for free
speech, marriage equality, government transparency and access to the
political process. The Free Software Foundation recognizes her as an
exceptional opinion leader, activist and community advocate.</p>
<p>Deborah is the director of community operations at the <a href="https://sfconservancy.org">Software
Freedom Conservancy</a>, where she supports the work of its member
organizations and facilitates collaboration with the wider free
software community. She has served as the membership coordinator for
the <a href="https://www.fsf.org">Free Software Foundation</a>, where she created the Women's
Caucus to increase recruitment and retention of women in the free
software community. She has been widely recognized for her volunteer
work with <a href="https://mediagoblin.org/">GNU MediaGoblin</a>, a federated media-publishing platform,
and <a href="https://blog.openhatch.org/2017/celebrating-our-successes-and-winding-down-as-an-organization/">OpenHatch</a>, free software's welcoming committee. She continues
her work as a founding organizer of the <a href="http://seagl.org/">Seattle GNU/Linux
Conference</a>, an annual event dedicated to surfacing new voices and
welcoming new people to the free software community.</p>
<p>Stallman praised her body of work and her unremitting and widespread
contributions to the free software community. "Deborah continuously
reaches out to, and engages, new audiences with her message on the
need for free software in any version of the future."</p>
<p>Deborah continued: "Free software is critically important for
autonomy, privacy and a healthy democracy -- but it can't achieve that
if it is only accessible for some, or if it is alienating for large
swathes of people. That's why it's so important that we continue
surfacing new voices, making room for non-coders and welcoming new
contributors into the free software community. I also find that in
addition to helping us build a better, bigger movement, the work of
welcoming is extremely rewarding."</p>
<p>Nominations for both awards are submitted by members of the public,
then evaluated by an award committee composed of previous winners and
FSF founder and president Richard Stallman.</p>
<p>More information about both awards, including the full list of
previous winners, can be found at <a href="https://www.fsf.org/awards">https://www.fsf.org/awards</a>.</p>
<h1><em>About the Free Software Foundation</em></h1>
<p>The Free Software Foundation, founded in 1985, is dedicated to
promoting computer users' right to use, study, copy, modify, and
redistribute computer programs. The FSF promotes the development and
use of free (as in freedom) software -- particularly the GNU operating
system and its GNU/Linux variants -- and free documentation for free
software. The FSF also helps to spread awareness of the ethical and
political issues of freedom in the use of software, and its Web sites,
located at <a href="https://fsf.org">https://fsf.org</a> and <a href="https://gnu.org">https://gnu.org</a>, are an important
source of information about GNU/Linux. Donations to support the FSF's
work can be made at <a href="https://my.fsf.org/donate">https://my.fsf.org/donate</a>. Its headquarters are
in Boston, MA, USA.</p>
<p>More information about the FSF, as well as important information for
journalists and publishers, is at <a href="https://www.fsf.org/press">https://www.fsf.org/press</a>.</p>
<h1><em>Media Contacts</em></h1>
<p>John Sullivan <br />
Executive Director <br />
Free Software Foundation <br />
+1 (617) 542 5942 <br />
<a href="mailto:[email protected]">[email protected]</a></p>
<p><em>Photo credits: Copyright Š 2019 Madi Muhlberg, photos licensed under CC-BY 4.0.</em></p></content>
<author>
<name>FSF News</name>
<uri>http://www.fsf.org/news/aggregator</uri>
</author>
<source>
<title type="html">FSF News</title>
<link rel="self" href="http://static.fsf.org/fsforg/rss/news.xml"/>
<id>http://www.fsf.org/news/aggregator</id>
</source>
</entry>
<entry xml:lang="en">
<title type="html" xml:lang="en">OpenStreetMap and Deborah Nicholson win 2019 FSF Awards</title>
<link href="http://www.fsf.org/news/openstreetmap-and-deborah-nicholson-win-2019-fsf-awards"/>
<id>http://www.fsf.org/news/openstreetmap-and-deborah-nicholson-win-2019-fsf-awards</id>
<updated>2019-03-23T22:59:48+00:00</updated>
<summary type="html" xml:lang="en"></summary>
<content type="html" xml:lang="en"><p><em>BOSTON, Massachusetts, USA -- Saturday, March 23, 2019-- The Free
Software Foundation (FSF) recognizes <a href="https://www.openstreetmap.org/">OpenStreetMap</a> with the 2018
Free Software Award for Projects of Social Benefit and Deborah
Nicholson with the Award for the Advancement of Free Software. FSF
president Richard M. Stallman presented the awards today in a yearly
ceremony during the LibrePlanet 2019 conference at the Massachusetts
Institute of Technology (MIT).</em></p>
<p>The <a href="https://www.fsf.org/awards/sb-award/">Award for Projects of Social Benefit</a> is presented to a
project or team responsible for applying free software, or the ideas
of the free software movement, to intentionally and significantly
benefit society. This award stresses the use of free software in
service to humanity.</p>
<p><img alt="Richard Stallman with Free Software Awards winners Deborah Nicholson and Kate Chapman" src="https://static.fsf.org/nosvn/libreplanet/2019/photos/free-software-awards/both.jpg" style="float: right; width: 250px; margin: 10px 0px 10px 10px;" /> </p>
<p>This year the FSF awarded OpenStreetMap and the award was accepted by
Kate Chapman, chairperson of the OpenStreetMap Foundation and
co-founder of the Humanitarian OpenStreetMap Team (HOT).</p>
<p>OpenStreetMap is a collaborative project to create a free editable map
of the world. Founded by Steve Coast in the UK in 2004, OpenStreetMap
is built by a community of over one million community members and has
found its application on thousands of Web sites, mobile apps, and
hardware devices. OpenStreetMap is the only truly global service
without restrictions on use or availability of map information.</p>
<p>Stallman emphasized the importance of OpenStreetMap in a time where
geotech and geo-thinking are highly prevalent. "It has been clear for
decades that map data are important. Therefore we need a free
collection of map data. The name OpenStreetMap doesn't say so
explicitly, but its map data is free. It is the free replacement that
the Free World needs."</p>
<p>Kate thanked the Free Software Foundation and the large community of
contributors of OpenStreetMap. "In 2004, much of the geospatial data
was either extraordinarily expensive or unavailable. Our strong
community of people committed to free and open map information has
changed that. Without the leadership before us from groups such as the
Free Software Foundation, we would not have been able to grow and
develop to the resource we are today."</p>
<p>The <a href="https://www.fsf.org/awards/fs-award">Award for the Advancement of Free Software</a> goes to an
individual who has made a great contribution to the progress and
development of free software through activities that accord with the
spirit of free software.</p>
<p><img alt="Richard Stallman presenting Free Software Award to Deborah Nicholson" src="https://static.fsf.org/nosvn/libreplanet/2019/photos/free-software-awards/deb.jpg" style="float: right; width: 250px; margin: 10px 0px 10px 10px;" /> </p>
<p>This year it was presented to Deborah Nicholson, who, motivated by the
intersection of technology and social justice, advocates access to
political information, unfettered freedom of speech and assembly, and
civil liberties in our increasingly digital world. She joined the free
software movement in 2006 after years of local organizing of free
speech, marriage equality, government transparency and access to the
political process. The Free Software Foundation recognizes her as an
exceptional opinion leader, activist and community advocate.</p>
<p>Deborah is the director of community operations at the <a href="https://sfconservancy.org">Software
Freedom Conservancy</a>, where she supports the work of its member
organizations and facilitates collaboration with the wider free
software community. She has served as the membership coordinator for
the <a href="https://www.fsf.org">Free Software Foundation</a>, where she created the Women's
Caucus to increase recruitment and retention of women in the free
software community. She has been widely recognized for her volunteer
work with <a href="https://mediagoblin.org/">GNU MediaGoblin</a>, a federated media-publishing platform,
and <a href="https://blog.openhatch.org/2017/celebrating-our-successes-and-winding-down-as-an-organization/">OpenHatch</a>, free software's welcoming committee. She continues
her work as a founding organizer of the <a href="http://seagl.org/">Seattle GNU/Linux
Conference</a>, an annual event dedicated to surfacing new voices and
welcoming new people to the free software community.</p>
<p>Stallman praised her body of work and her unremitting and widespread
contributions to the free software community. "Deborah continuously
reaches out to, and engages, new audiences with her message on the
need for free software in any version of the future."</p>
<p>Deborah continued: "Free software is critically important for
autonomy, privacy and a healthy democracy -- but it can't achieve that
if it is only accessible for some, or if it is alienating for large
swathes of people. That's why it's so important that we continue
surfacing new voices, making room for non-coders and welcoming new
contributors into the free software community. I also find that in
addition to helping us build a better, bigger movement, the work of
welcoming is extremely rewarding."</p>
<p>Nominations for both awards are submitted by members of the public,
then evaluated by an award committee composed of previous winners and
FSF founder and president Richard Stallman.</p>
<p>More information about both awards, including the full list of
previous winners, can be found at <a href="https://www.fsf.org/awards">https://www.fsf.org/awards</a>.</p>
<h1><em>About the Free Software Foundation</em></h1>
<p>The Free Software Foundation, founded in 1985, is dedicated to
promoting computer users' right to use, study, copy, modify, and
redistribute computer programs. The FSF promotes the development and
use of free (as in freedom) software -- particularly the GNU operating
system and its GNU/Linux variants -- and free documentation for free
software. The FSF also helps to spread awareness of the ethical and
political issues of freedom in the use of software, and its Web sites,
located at <a href="https://fsf.org">https://fsf.org</a> and <a href="https://gnu.org">https://gnu.org</a>, are an important
source of information about GNU/Linux. Donations to support the FSF's
work can be made at <a href="https://my.fsf.org/donate">https://my.fsf.org/donate</a>. Its headquarters are
in Boston, MA, USA.</p>
<p>More information about the FSF, as well as important information for
journalists and publishers, is at <a href="https://www.fsf.org/press">https://www.fsf.org/press</a>.</p>
<h1><em>Media Contacts</em></h1>
<p>John Sullivan <br />
Executive Director <br />
Free Software Foundation <br />
+1 (617) 542 5942 <br />
<a href="mailto:[email protected]">[email protected]</a></p>
<p><em>Photo credits: Copyright Š 2019 Madi Muhlberg, photos licensed under CC-BY 4.0.</em></p></content>
<author>
<name>FSF News</name>
<uri>http://www.fsf.org/news/aggregator</uri>
</author>
<source>
<title type="html">FSF News</title>
<link rel="self" href="http://static.fsf.org/fsforg/rss/news.xml"/>
<id>http://www.fsf.org/news/aggregator</id>
</source>
</entry>
</feed>
| 337,202 | Common Lisp | .l | 4,428 | 73.271454 | 8,381 | 0.739183 | JadedCtrl/rsss | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:31 AM (Europe/Amsterdam) | aaaa46e1b2dbeb6e73897edd852b0b5b3388952f5f482f6834bfce94dda18ff0 | 38,884 | [
-1
] |
38,885 | rss2.xml | JadedCtrl_rsss/t/rss2.xml | <?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0"
xmlns:content="http://purl.org/rss/1.0/modules/content/"
xmlns:dc="http://purl.org/dc/elements/1.1/"
xmlns:itunes="http://www.itunes.com/dtds/podcast-1.0.dtd"
xmlns:trackback="http://madskills.com/public/xml/rss/module/trackback/">
<channel>
<title>Esperanto-USA member blogs</title>
<link>http://esperanto-usa.org/eusa/blogs/member-blogs.rss</link>
<description>Recent posts from Esperanto-USA members / Lastaj blogeroj fare de membroj de Esperanto-USA</description>
<pubDate>Tue, 09 Jul 2019 00:00:39 -0700</pubDate>
<item>
<title>Semajna kunveno por 2019-07-02</title>
<link>http://www.ekoci.org/2019/07/02/semajna-kunveno-por-2019-07-02/</link>
<description>Ekoci</description>
<pubDate>Tue, 02 Jul 2019 14:00:44 +0000</pubDate>
<dc:date>2019-07-02T14:00:44+00:00</dc:date>
</item>
<item>
<title>Ĉirkaŭ la mondon post okdek tagoj 26</title>
<link>http://eo1a.blogspot.com/2019/06/cirkau-la-mondon-post-okdek-tagoj-26.html</link>
<description>Esperanto Unua</description>
<pubDate>Sat, 29 Jun 2019 00:47:00 +0000</pubDate>
<dc:date>2019-06-29T00:47:00+00:00</dc:date>
</item>
<item>
<title>Maja bulteno</title>
<link>http://esperanto-chicago.org/maja-bulteno-2019/</link>
<description>La Esperanto-Societo de Ŝikago</description>
<pubDate>Fri, 14 Jun 2019 14:09:22 +0000</pubDate>
<dc:date>2019-06-14T14:09:22+00:00</dc:date>
</item>
<item>
<title>Aprila bulteno</title>
<link>http://esperanto-chicago.org/aprila-bulteno-2019/</link>
<description>La Esperanto-Societo de Ŝikago</description>
<pubDate>Fri, 14 Jun 2019 14:07:09 +0000</pubDate>
<dc:date>2019-06-14T14:07:09+00:00</dc:date>
</item>
<item>
<title>Marta bulteno</title>
<link>http://esperanto-chicago.org/marta-bulteno-2019/</link>
<description>La Esperanto-Societo de Ŝikago</description>
<pubDate>Fri, 14 Jun 2019 14:03:20 +0000</pubDate>
<dc:date>2019-06-14T14:03:20+00:00</dc:date>
</item>
<item>
<title>Februara bulteno</title>
<link>http://esperanto-chicago.org/februara-bulteno-2019/</link>
<description>La Esperanto-Societo de Ŝikago</description>
<pubDate>Fri, 14 Jun 2019 13:58:17 +0000</pubDate>
<dc:date>2019-06-14T13:58:17+00:00</dc:date>
</item>
<item>
<title>Propaganda Komitato / Propaganda Committee</title>
<link>https://esperantoslv.wordpress.com/2019/06/13/propaganda-komitato-propaganda-committee/</link>
<description>Esperanto SLV</description>
<pubDate>Thu, 13 Jun 2019 15:37:13 +0000</pubDate>
<dc:date>2019-06-13T15:37:13+00:00</dc:date>
</item>
<item>
<title>Ĉirkaŭ la mondon post okdek tagoj 25</title>
<link>http://eo1a.blogspot.com/2019/06/cirkau-la-mondon-post-okdek-tagoj-25.html</link>
<description>Esperanto Unua</description>
<pubDate>Sat, 08 Jun 2019 13:43:00 +0000</pubDate>
<dc:date>2019-06-08T13:43:00+00:00</dc:date>
</item>
<item>
<title>Semajna kunveno por 2019-06-04</title>
<link>http://www.ekoci.org/2019/06/04/semajna-kunveno-por-2019-06-04/</link>
<description>Ekoci</description>
<pubDate>Tue, 04 Jun 2019 14:47:07 +0000</pubDate>
<dc:date>2019-06-04T14:47:07+00:00</dc:date>
</item>
<item>
<title>Norda Karolino Printempa Esperanto-Renkontiĝo 2019</title>
<link>https://esperanto-nc.org/2019/06/02/norda-karolino-printempa-esperanto-renkontigo-2019/</link>
<description>Esperanto in North Carolina</description>
<pubDate>Sun, 02 Jun 2019 00:13:29 +0000</pubDate>
<dc:date>2019-06-02T00:13:29+00:00</dc:date>
</item>
<item>
<title>Semajna kunveno por 2019-05-28</title>
<link>http://www.ekoci.org/2019/05/27/semajna-kunveno-por-2019-05-28/</link>
<description>Ekoci</description>
<pubDate>Mon, 27 May 2019 20:31:56 +0000</pubDate>
<dc:date>2019-05-27T20:31:56+00:00</dc:date>
</item>
<item>
<title>Ĉirkaŭ la mondon post okdek tagoj 24</title>
<link>http://eo1a.blogspot.com/2019/05/cirkau-la-mondon-post-okdek-tagoj-24.html</link>
<description>Esperanto Unua</description>
<pubDate>Mon, 27 May 2019 13:11:00 +0000</pubDate>
<dc:date>2019-05-27T13:11:00+00:00</dc:date>
</item>
<item>
<title>Esther Schor’s TED Talk</title>
<link>https://esperanto-nc.org/2019/05/24/esther-schors-ted-talk/</link>
<description>Esperanto in North Carolina</description>
<pubDate>Fri, 24 May 2019 20:17:55 +0000</pubDate>
<dc:date>2019-05-24T20:17:55+00:00</dc:date>
</item>
<item>
<title>Ĉirkaŭ la mondon post okdek tagoj 23</title>
<link>http://eo1a.blogspot.com/2019/05/cirkau-la-mondon-post-okdek-tagoj-23.html</link>
<description>Esperanto Unua</description>
<pubDate>Sat, 11 May 2019 14:02:00 +0000</pubDate>
<dc:date>2019-05-11T14:02:00+00:00</dc:date>
</item>
<item>
<title>Semajna kunveno por 2019-05-07</title>
<link>http://www.ekoci.org/2019/05/07/semajna-kunveno-por-2019-05-07/</link>
<description>Ekoci</description>
<pubDate>Tue, 07 May 2019 13:57:55 +0000</pubDate>
<dc:date>2019-05-07T13:57:55+00:00</dc:date>
</item>
<item>
<title>Ni Desegnis Bestojn/We Drew Animals</title>
<link>https://esperantoslv.wordpress.com/2019/05/06/ni-desegnas-bestojn/</link>
<description>Esperanto SLV</description>
<pubDate>Mon, 06 May 2019 13:30:44 +0000</pubDate>
<dc:date>2019-05-06T13:30:44+00:00</dc:date>
</item>
<item>
<title>Ĉirkaŭ la mondon post okdek tagoj 22</title>
<link>http://eo1a.blogspot.com/2019/05/cirkau-la-mondon-post-okdek-tagoj-22.html</link>
<description>Esperanto Unua</description>
<pubDate>Sat, 04 May 2019 17:31:00 +0000</pubDate>
<dc:date>2019-05-04T17:31:00+00:00</dc:date>
</item>
<item>
<title>NULIGITA! Semajna kunveno por 2019-04-30</title>
<link>http://www.ekoci.org/2019/04/30/semajna-kunveno-por-2019-04-30/</link>
<description>Ekoci</description>
<pubDate>Tue, 30 Apr 2019 14:05:51 +0000</pubDate>
<dc:date>2019-04-30T14:05:51+00:00</dc:date>
</item>
<item>
<title>Ĉu vi Ĉeestos NASK?/Will you be at NASK?</title>
<link>https://esperantoslv.wordpress.com/2019/04/27/cu-vi-ceestos-nask-will-you-be-at-nask/</link>
<description>Esperanto SLV</description>
<pubDate>Sat, 27 Apr 2019 16:31:34 +0000</pubDate>
<dc:date>2019-04-27T16:31:34+00:00</dc:date>
</item>
<item>
<title>Bonvenon al nia Nova Retpaĝo/Welcome to Our New Webpage</title>
<link>https://esperantoslv.wordpress.com/2019/04/26/bonevenon-al-nia-nova-retpagxo-welcome-to-our-new-webpage/</link>
<description>Esperanto SLV</description>
<pubDate>Fri, 26 Apr 2019 00:41:16 +0000</pubDate>
<dc:date>2019-04-26T00:41:16+00:00</dc:date>
</item>
<item>
<title>Tomaso Alexander Does A Video Promoting the 2019 Spring Esperanto Gathering in North Carolina</title>
<link>https://esperanto-nc.org/2019/02/16/tomaso-alexander-does-a-video-promoting-the-spring-esperanto-gathering/</link>
<description>Esperanto in North Carolina</description>
<pubDate>Sat, 16 Feb 2019 20:42:05 +0000</pubDate>
<dc:date>2019-02-16T20:42:05+00:00</dc:date>
</item>
<dc:date>2019-07-09T00:00:39-07:00</dc:date>
</channel>
</rss>
| 7,595 | Common Lisp | .l | 161 | 40.89441 | 126 | 0.67467 | JadedCtrl/rsss | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:31 AM (Europe/Amsterdam) | 8711c5d9a066b3ccef1b049725d0bbbaef76febf962c576d4280bd7947d97f7c | 38,885 | [
-1
] |
38,900 | memoize.lisp | davd33_simple-cv-with-lisp/src/memoize.lisp | (in-package #:memoize)
(defun memo (fn name key test)
"Return a memo-function of fn."
(let ((table (make-hash-table :test test)))
;; to be able to clear
(setf (get name 'memo) table)
#'(lambda (&rest args)
(let ((k (funcall key args)))
(multiple-value-bind (val found-p)
(gethash k table)
(if found-p
val
(setf (gethash k table) (apply fn args))))))))
(defun memoize (fn-name &key (key #'first) (test #'eql))
"Replace fn-name's global definition with a memoized version."
(setf (symbol-function fn-name)
(memo (symbol-function fn-name) fn-name key test)))
(defun clear-memoize (fn-name)
"Clear the hash table from a memo funcion."
(let ((table (get fn-name 'memo)))
(when table (clrhash table))))
(defmacro defmemo (fn args &body body)
"Define a memoized function."
`(memoize (defun ,fn ,args . ,body)))
| 924 | Common Lisp | .lisp | 24 | 32.5 | 64 | 0.618304 | davd33/simple-cv-with-lisp | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:39 AM (Europe/Amsterdam) | 348701573e9ab5a0bc261af25e13f0fe718ada1e16eaab305be8d9c40ac7d76b | 38,900 | [
-1
] |
38,901 | hm.lisp | davd33_simple-cv-with-lisp/src/hm.lisp | (in-package #:hm)
;; Hash table utils
(defun print-elt (k v &key (stream t))
"Prints one element with K key and V value."
(format stream "~&~a -> ~a" k v))
(defun print-all (ht)
"Use PRINT-ELT and MAPHASH to print all the k/v pairs of HT."
(maphash #'print-elt ht))
(defmacro put (hash-table key value)
"Adds a key/value pair in hash-table."
`(setf (gethash ,key ,hash-table) ,value))
(defmacro get (hash-table key)
"Get value in hash-table for key."
`(gethash ,key ,hash-table))
(defmethod one ((ht hash-table))
"Get first key/value pair of HASHTABLE using MAPHASH.
The value is returned first and then the key (use multiple-value-bind to bind it)."
(block htmap
(maphash #'(lambda (k v)
(return-from htmap (values v k)))
ht)))
(defun reduce (fn hashmap initial-value)
"Do a reduce on a hashmap providing key and value in FN.
FN should take the following arguments:
- ACCUMULATOR: the built result
- KEY: the current key
- VALUE: the current value
The initial value must be provided."
(let ((result initial-value))
(maphash #'(lambda (k v)
(setf result (funcall fn result k v)))
hashmap)
result))
| 1,206 | Common Lisp | .lisp | 33 | 32.272727 | 83 | 0.670962 | davd33/simple-cv-with-lisp | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:39 AM (Europe/Amsterdam) | e8831a84768ed36a860cd34b0ab29aef42c673bc6391b7e80e28cc9a40b29d6a | 38,901 | [
-1
] |
38,902 | be-it.lisp | davd33_simple-cv-with-lisp/src/be-it.lisp | (in-package :be-it)
;; DEFINE COMMAND ARGUMENTS
(opts:define-opts
(:name :help
:description "Some help here needed." ; TODO manage program arguments.
:short #\h
:long "help"))
;; TODO
;; The parameters that we'd be interested for are the following:
;; - the language of the page... although we could as well generate as many html files that
;; we have from languages
;; - the path of the output directory to which the html files should be created
;; SETUP LOCALIZATION
(eval-when
(:compile-toplevel
:load-toplevel
:execute)
(defun read-lang-lisp (file-path)
(with-open-file (in file-path)
(with-standard-io-syntax
(read in)))))
(eval-when
(:compile-toplevel
:load-toplevel
:execute)
(defparameter *lang* (read-lang-lisp "/home/davd/clisp/be-it/src/lang.en.lisp")))
(eval-when
(:compile-toplevel
:load-toplevel
:execute)
(defun lang-get (key)
"Get the translation for the given key."
(getf *lang* key)))
;; DEFINE WEB PAGE COMPONENTS
(defparameter *page-title* "Davd Rueda")
(defmacro css (&body styles)
"Takes 1..n CSS instructions as 2-elements lists, then returns a css formatted string.
A CSS instruction list looks like this: (:font-size <string>)"
`(str:concat
,@(loop for style in styles
collect `(format nil "~a: ~a;~%" ,(string (first style)) ,(second style)))))
(defmacro with-page ((&key title) &body body)
`(spinneret:with-html
(:doctype)
(:html
(:head
(:link :href "/css/cv.css" :rel "stylesheet" :type "text/css")
(:link :href "/css/font-awesome.css" :rel "stylesheet" :type "text/css")
(:title ,title))
(:body
,@body))))
(deftag link (text attrs &key href class)
`(:a.contact-link
:class ,class
:href ,href
,@attrs
,@text))
(deftag reading (body attrs &key reading)
"Displays a DTO:READING-DTO."
`(with-slots ((title dto:title)
(image-path dto:image)
(external-url dto:external-url)) ,reading
(:a.book-card
:style (css
(:width "200px")
(:margin "10px")
(:text-align :center)
(:color "#222")
(:text-decoration :none))
:href (or external-url "#")
:title title
(:img :width 130
:style (css
(:margin "0 auto")
(:background :darkblue))
:src (str:concat "/images/" image-path)))))
(deftag paragraph (body attrs &key paragraph-dto black-mode)
"Displays a DTO:PARAGRAPH-DTO."
`(with-slots ((pels dto:elements)) ,paragraph-dto
(reduce
#'(lambda (a pel)
(let ((content (handler-case (json:decode-json-from-string (dto:content pel))
(json:json-syntax-error () (dto:content pel)))))
(cons (if (listp content)
(cond
((equalp :link (first content)) (link
:style (css (:margin "0"))
:href (third content)
(second content))))
(:span content))
a)))
(sort pels #'< :key #'dto:order)
:initial-value (:p))))
(deftag work-experience (body attrs &key work-experience)
"Displays a work experience."
`(with-slots ((title dto:title)
;; (company dto:company)
(desc dto:description)
;; (duration dto:duration)
;; (remote? dto:remote?)
;; (ref dto:reference)
(technologies dto:technologies)) ,work-experience
(let ((technologies (str:split "," technologies)))
(:div.card
;; (when remote? (:i :style (css (:float :right))
;; :title "remote position"
;; :class "fal fa-wifi"))
(:h1 title
;; (when ,ref (link :class "work-reference" :href ref "SEE REFERENCE"))
)
;; (when company (:h4 company))
;; (:em duration)
(:p desc)
(:div.card-tags
(loop for tech in technologies
collect (:div.card-tag tech)))
,@body))))
(deftag repeat (template attrs &key for)
"This is a tag that repeats a given template using the key
for a translation split into a list of several strings.
- for: lang-binding-form: 2 elements list with var name and translation key
- template: a single form (one list of potentially embedded tags)"
`(reduce #'(lambda (acc elt)
(append
acc
(let ((,(caadr for) elt))
,@template)))
,@(cdadr for)
:initial-value `(progn)))
(defun cv->html (cv-title cv)
"Converts a DTO:CV-DTO to html."
(with-page (:title cv-title)
(labels ((paragraphs-by-section-title (sections title)
"Find a DTO:SECTION-DTO in a list of sections by DTO:TITLE."
(dto:paragraphs (find title sections
:key #'dto:title :test #'string=))))
;; TOP BAND INFORMATION
(with-slots ((co-mail dto:mail)
(co-github dto:github)
(co-linkedin dto:linkedin)) (dto:contact cv)
(:section.contact
(link :href (str:concat "mailto:" co-mail) co-mail)
(link :href co-github "Github")
(link :href co-linkedin "Linkedin")
(link :href "https://github.com/davd33/simple-cv-with-lisp" "(fork-me!)")
(:span :class "pdf-download-link"
(link :href "/pdf/cv.david-rueda.pdf" "PDF"))
(:section.lang-flags
(:em "Speaks: Fr / En / Sp / De"))))
;; CV TITLE - IMAGE - INTRODUCTION
(:header.centered
(:img
:class "cv-img"
:src "/images/my.jpg"
:alt (dto:image-description cv))
(:h1 cv-title)
(:h2 (dto:sub-title cv))
(:section
(repeat
:for (about-me (paragraphs-by-section-title (dto:sections cv) "about.me.txt.p"))
(paragraph :paragraph-dto about-me))))
;; WORK EXPERIENCE
(:h1.centered.dark-title "Work Experiences")
(:section.work-exp-cards
(repeat
:for (we (dto:work-experiences cv))
(work-experience :work-experience we)))
;; BOOKS THAT I READ
(:h1.centered "Reading")
(:section.books :id "books-section"
(:div.books
:style (css
(:display :flex)
(:margin-bottom "50px")
(:flex-wrap :wrap)
(:justify-content :center)
(:align-items :baseline))
(repeat :for (reading (dto:readings cv))
(reading :reading reading))))
;; LISP EXPERIENCE
(:h1.centered.dark-title "When I discovered Lisp")
(:section.lisp-experience
(repeat :for (lisp (paragraphs-by-section-title (dto:sections cv)
"my-experience-with-lisp"))
(paragraph :paragraph-dto lisp))))))
| 7,301 | Common Lisp | .lisp | 185 | 28.783784 | 92 | 0.539633 | davd33/simple-cv-with-lisp | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:39 AM (Europe/Amsterdam) | 0f5de1965629679eca9b151b939549ffd8cd495af974377d404a07ac48ddc667 | 38,902 | [
-1
] |
38,903 | api.lisp | davd33_simple-cv-with-lisp/src/api.lisp | (in-package #:api)
(defroute api-doc
(:get :text/html)
"<p>Helloworld</p>")
(setf snooze:*catch-errors* :verbose)
(defun cv-handler (payload-as-string)
(let* ((json (handler-case
(json:decode-json-from-string payload-as-string)
(error (e)
(http-condition 400 "Malformed JSON (~A)!" e)))))
(services:store-cv (get-in json :contact)
(get-in json :reading-list)
(get-in json :work-experience-list)
(get-in json :section-list)
json)))
(defroute cv
(:post "application/json")
(cv-handler (payload-as-string)))
;;; UTILITY
(defun app-root ()
(fad:pathname-as-directory
(make-pathname :name nil
:type nil
:defaults #.(or *compile-file-truename* *load-truename*))))
;; START HTTP SERVER
(defclass snooze-acceptor (hunchentoot:easy-acceptor) ())
(defparameter *lispdoc-dispatch-table*
(list
(hunchentoot:create-folder-dispatcher-and-handler
"/images/" (fad:pathname-as-directory #P"./resources/images"))
(hunchentoot:create-folder-dispatcher-and-handler
"/css/" (fad:pathname-as-directory #P"./resources/css"))
(hunchentoot:create-folder-dispatcher-and-handler
"/docs/" (fad:pathname-as-directory #P"./resources/docs"))
(hunchentoot:create-folder-dispatcher-and-handler
"/webfonts/" (fad:pathname-as-directory #P"./resources/webfonts"))
(make-hunchentoot-app '((*home-resource* . web-site:home)))))
(defmethod hunchentoot:acceptor-dispatch-request :around ((a snooze-acceptor) request)
(let ((hunchentoot:*dispatch-table* *lispdoc-dispatch-table*))
(call-next-method)))
(defvar *server* nil)
(defun stop ()
(when *server* (hunchentoot:stop *server*) (setq *server* nil)))
(defun start (&key (port 5000))
(stop)
(setq *server*
(hunchentoot:start (make-instance 'snooze-acceptor :port port))))
| 1,952 | Common Lisp | .lisp | 47 | 34.808511 | 86 | 0.648863 | davd33/simple-cv-with-lisp | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:39 AM (Europe/Amsterdam) | 82be00553ef1dada4e88196d2492db0411e16434360d1f2cb26e7fa5fd70e33e | 38,903 | [
-1
] |
38,904 | web-site.lisp | davd33_simple-cv-with-lisp/src/web-site.lisp | (in-package #:web-site)
(defun start-all ()
(dao:connect)
(api:start))
(defun stop-all ()
(api:stop))
(defmacro build-spinneret-html-response (&body body)
`(with-output-to-string (out)
(let ((spinneret:*html* out))
,@body)))
(defroute home
(:get "text/html")
"It works!")
(defroute wcv
(:get "text/html" cv-id)
(build-spinneret-html-response (let ((cv (services:get-cv cv-id)))
(be-it:cv->html (dto:title cv)
cv))))
| 535 | Common Lisp | .lisp | 18 | 22.111111 | 68 | 0.542969 | davd33/simple-cv-with-lisp | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:45:39 AM (Europe/Amsterdam) | 8a97a111222ad216e816f7ec843742506af2ab857cef594fc56ae5a1b93bdf5e | 38,904 | [
-1
] |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.