Freie Software

Created: 2013-08-12 Mo 01:28 · tmp

(defun strikethrough (start end)
  (interactive "r") 
  (goto-char (min start end))
  (while (< (point) (+ (max start end) (abs (- start end))))
    (forward-char)
    (insert "̶")))

; email
(setq user-full-name "Arne Babenhauserheide"
       mail-from-style 'angles
       user-mail-address "EMAIL"
       mail-default-reply-to user-mail-address)
(setq user-mail-address "EMAIL")
(setq smtpmail-default-smtp-server 
       "smtp.web.de")
(setq smtpmail-local-domain nil)
; disable “we now use message mode” warning.
(setq compose-mail-user-agent-warning nil)
(setq compose-mail-user-agent-warnings nil)
(setq message-default-headers "BCC: EMAIL
")

(require 'smtpmail)

; MailMode
(setq send-mail-function 
    'smtpmail-send-it)
; MessageMode
(setq message-send-mail-function 
    'message-smtpmail-send-it)

(setq starttls-extra-arguments 
    '("--insecure" "--verbose"))
(setq smtpmail-auth-credentials 
   '(("smtp.web.de" 25 
   "NAME" "PASSWORT"))) 
(setq smtpmail-default-smtp-server 
    "smtp.web.de") 
(setq smtpmail-smtp-server "smtp.web.de") 
(setq smtpmail-smtp-service 25) 

tagebuch

alias tagebuch='/usr/bin/emacs \
-nw --no-init-file --no-site-file \
--load ~/.emacs-init-tagebuch \
~/pfad/zum/Tagebuch.txt.gpg'

alias tagebuch='/usr/bin/emacs \
-nw --no-init-file --no-site-file \
--load ~/.emacs-init-tagebuch \
~/pfad/zum/Tagebuch.txt.gpg'

(setq load-path (cons "~/.emacs.d/libs/markdown-mode" load-path))
(autoload 'markdown-mode "markdown-mode.el"
   "Major mode for editing Markdown files" t)

(setq auto-mode-alist
      (cons '("\\.txt\\.gpg" . markdown-mode)
    auto-mode-alist))

(global-visual-line-mode)

(require 'epa-file)
(epa-file-enable)

(defun datum ()
  "print the current time in iso-format"
  (interactive)
  (insert (format-time-string "%Y-%m-%d %H:%M:%S") "\n-------------------\n\n"))

(custom-set-variables
 '(current-language-environment "UTF-8")
 '(default-input-method "rfc1345")
 '(inhibit-startup-screen t)
 '(save-place t nil (saveplace)))

M-x customize-variable calendar-holidays

(holiday-fixed 3 19 "Dia del Padre")
(holiday-float 5 0 2 "Muttertag")
(holiday-float 5 0 1 "Dia de la Madre")
(holiday-easter-etc 39 "Vatertag")

(defmacro namespace (prefix &rest sexps)
  (let* ((naive-dfs-map
          (lambda (fun tree)
            (mapcar (lambda (n) (if (listp n) (funcall naive-dfs-map fun n)
                                  (funcall fun n))) tree)))
         (to-rewrite (loop for sexp in sexps
                           when (member (car sexp)
                                        '(defvar defmacro defun))
                           collect (cadr sexp)))
         (fixed-sexps (funcall naive-dfs-map
                               (lambda (n) (if (member n to-rewrite)
                                               (intern
                                                (format "%s-%s" prefix n)) n))
                               sexps)))
    `(progn ,@fixed-sexps)))

(provide 'namespace)

(require 'namespace)
(namespace foo
           (defun bar ()
             "bar")
           (defun foo (s)
               "foo"))

(foo-foo (foo-bar))

(defun foo-bar ()
  "bar")
(defun foo-baz ()
  (foo-bar))
(defun foo-isastring (s)
  (stringp s))
(defun foo-foo (s)
  (if (foo-isastring s)
      "foo"))

(foo-foo (foo-bar))

(require 'namespace)
(namespace foo
           (defun bar ()
             "bar")
           (defun baz ()
             (bar))
           (defun isastring (s)
             (stringp s))
           (defun foo (s)
             (if (isastring s)
                 "foo")))

(foo-foo (foo-bar))

(require-namespaced 'feature)

\#+source: python-listdir
\#+begin_src python
import os
return len(os.listdir('.'))
\#+end_src

| number of files |
|-----------------|
|              28 |
\#+TBLFM: @2$1='(sbe python-listdir)

import os
return len(os.listdir('.'))

USK@nwa8lHa271k2QvJ8aa0Ov7IHAV-DFOCFgmDt3X6BpCI,DuQSUZiI~agF8c-6tjsFFGuZ8eICrzWCILB60nT8KKo,AQACAAE/sone/-1/sone-current.jar

USK@6~ZDYdvAgMoUfG6M5Kwi7SQqyS-gTcyFeaNN1Pf3FvY,OSOT4OEeg4xyYnwcGECZUX6~lnmYrZsz05Km7G7bvOQ,AQACAAE/WoT/74

http://127.0.0.1:8888/Sone/viewSone.html?sone=6~ZDYdvAgMoUfG6M5Kwi7SQqyS-gTcyFeaNN1Pf3FvY

identity=XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX  
lastGoodVersion==XXXXXXXXXXXXXXXXXXXXXXX  
location==XXXXXXXXXXXXXXXXXXXXXXXXXX  
myName=ArneBab  
opennet=false  
sigP256=XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX  
version==XXXXXXXXXXXXXXXXXXXXXXX  
ark.number=XXXX  
ark.pubURI=XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX  
auth.negTypes=10  
ecdsa.P256.pub=XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX  
physical.udp==XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX  
End

Freenet ermöglicht es uns, unsichtbare Nachrichten zu
schreiben. Es ist zwar sichtbar, dass eine Verbindung
zwischen uns besteht, aber nicht wie, wann und wofür sie
genutzt wird.

Zusätzlich kannst du darüber mit Pseudonym
schreiben. Warum das wichtig ist habe ich in einer
Präsentation zum SUMA-award festgehalten:
http://www.draketo.de/proj/freenet-funding/suma-slides.pdf (ab
Folie 4 - ab Folie 7 praktische Lösungen)

Um dich mit mir zu verbinden:

1. Lade auf https://freenetproject.org Freenet herunter
  und installiere es,
2. wähle im Wizard, der dann aufgeht, „nur Freunde“¹ und
3. kopiere unter http://127.0.0.1:8888/addfriend/ den
  Textblock am Ende meiner E-Mail² in das Textfeld.
4. Schick mir dann den Text, den Freenet auf dieser Seite hier
  zeigt: http://127.0.0.1:8888/friends/myref.txt (häng die Datei an
  eine E-Mail an oder kopier’ den Ihnalt einfach in den Text der
  E-Mail)

Sobald ich den Text dann auch bei mir eingetragen habe, sind wir
verbunden. Wir können uns von da an einfach über die
Freundesseite schreiben:

* Schreiben: http://127.0.0.1:8888/friends/
* Lesen: http://127.0.0.1:8888/alerts/

Diese Nachrichten sind echt vertraulich: Niemand kann sehen
was, wann oder ob wir uns geschrieben haben, weil der normale
Datenaustausch von Freenet unsere Nachrichten maskiert.

¹: Wenn du willst, dass Freenet schneller ist, kannst du
   stattdessen "(auch) mit Fremden verbinden" wählen. Das ist
   nicht so sicher wie nur Verbindungen zu Freunden aber viel
   praktischer :) - und unsere Nachrichten sind immernoch
   wirklich vertraulich.

²: Hier ist der Textblock für das Textfeld auf
   http://127.0.0.1:8888/addfriend/ :

identity=XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX  
lastGoodVersion==XXXXXXXXXXXXXXXXXXXXXXX  
location==XXXXXXXXXXXXXXXXXXXXXXXXXX  
myName=ArneBab  
opennet=false  
sigP256=XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX  
version==XXXXXXXXXXXXXXXXXXXXXXX  
ark.number=XXXX  
ark.pubURI=XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX  
auth.negTypes=10  
ecdsa.P256.pub=XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX  
physical.udp==XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX  
End

Liebe Grüße,

pmerge @glsa

\#! /bin/sh

\### Update the portage tree and the glsa packages via pkgcore

\# spew a status message
echo $(date) "start to update GLSA" >> /tmp/cron-update.log

\# Sync only portage
pmaint sync /usr/portage

\# security relevant programs
pmerge -uDN @glsa > /tmp/cron-update-pkgcore-last.log || cat \
    /tmp/cron-update-pkgcore-last.log >> /tmp/cron-update.log  

\# And keep everything working
revdep-rebuild

\# Finally update all configs which can be updated automatically
cfg-update -au

echo $(date) "finished updating GLSA" >> /tmp/cron-update.log

\#!/bin/sh                                                     

\### Update my computer using pgkcore, 
\### since that also works if some dependencies couldn't be resolved.

\# Sync all overlays
eix-sync

\## First use pkgcore
\# security relevant programs (with build-time dependencies (-B))
pmerge -BuD @glsa

\# system, world and all the rest
pmerge -BuD @system
pmerge -BuD @world
pmerge -BuD @installed

\# Then use portage for packages pkgcore misses (inlcuding overlays) 
\# and for *EMERGE_DEFAULT_OPTS="--keep-going"* in make.conf 
emerge -uD @security
emerge -uD @system
emerge -uD @world
emerge -uD @installed

\# And keep everything working
emerge @preserved-rebuild
revdep-rebuild

\# Finally update all configs which can be updated automatically
cfg-update -au

sudo cp /usr/share/hal/fdi/policy/10osvendor/10-keymap.fdi \
/etc/hal/fdi/policy/

<merge key="input.xkb.layout" type="string">de</merge>
<merge key="input.xkb.variant" type="string" />

<merge key="input.xkb.layout" type="string">de</merge>
<merge key="input.xkb.variant" type="string">neo</merge>

define : fib n
    let rek : (i 0) (u 1) (v 1)
        if : >= i : - n 2
            . v
            rek (+ i 1) v (+ u v) ; else

def fib(n):
   if n in (1, 2):
      return 1
   u = 1
   v = 1
   for i in range(n-2):
      tmp = v
      v = u+v
      u = tmp
   return v

def fibrek(n, i=0, u=1, v=1):
    if i >= n-2:
        return v
    return fibrek(n, i+1, v, u+v)

def _rek(n, i, u, v):
    if i >= n-2:
        return v
    return _rek(n, i+1, v, u+v)

def fibrek2(n):
    return _rek(n, 0, 1,1)

def fibrek3(n):
    def rek(i=0, u=1, v=1):
        if i >= n-2:
            return v
        return rek(i+1, v, u+v)
    return rek()

define : fib n
    let rek : (i 0) (u 1) (v 1)
        if : >= i : - n 2
            . v
            rek (+ i 1) v (+ u v)

define : skipindent inport
    let skipper
        : inunderbars #t
          indent 0
          nextchar : read-char inport
        ; when the file ends, do not do anything else
        when : not : eof-object? nextchar 
            ; skip underbars
            if inunderbars
                if : char=? nextchar #\_ ; still in underbars?
                    skipper 
                        . #t ; still in underbars?
                        + indent 1
                        read-char inport
                    ; else, reevaluate without inunderbars
                    skipper #f indent nextchar
                ; else: skip remaining spaces
                if : char=? nextchar #\space
                    skipper
                        . #f
                        + indent 1
                        read-char inport
                    begin
                        unread-char nextchar inport
                        . indent

(suchen, suchen, 
 am Kopf kratzen, 
 weitersuchen) 

(`top`)

(`pkill java`) 

(`hostname`) 

(`ssh …`; nochmal…) 

python3 -c "import antigravity;print(antigravity.__doc__)"

def summieren(liste): 
	"""Summiere alle Zahlen der Liste manuell."""
	# erst brauchen wir einen Zähler, 
	# auf den wir alle Zahlen aufsummieren.
	gesamt = 0
	# Dann summieren wir 
	# alle Zahlen der Liste zu dem Zähler. 
	for x in liste: 
		# Das heißt, wir erhöhen ihn
		# für jede Zahl in der Liste um die Zahl. 
		gesamt += x
	# und geben ihn dann zurück. 
	return gesamt

def summieren(liste): 
	"""Summiere alle Zahlen der Liste mit sum()."""
	return sum(liste) 

for i in liste_von_tuples: 
   res.append(i[1])

for i, j in liste_von_tuples: 
   res.append(j)

for i, j in liste_von_tuples: 
   res.append(j)

#!/bin/env python
# encoding: utf-8

#######################################################
#                                                     #
# Hallo Welt!                                         #
# - Mein Erstes PyQt-Programm mit Kommentaren         #
#                                                     #
#   Copyright (C) 2007, Arne Babenhauserheide, GPL    #
#                                                     #
#   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 2 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,     #
# write to the Free Software Foundation, Inc., 51     #
# Franklin Street, Fifth Floor, Boston, MA 02110-1301 #
# USA.                                                #
#                                                     #
#######################################################

# Erst holen wir das System-Framework. "sys"
# Qt Programme brauchen von ihm die 
# Kommandozeilenparameter. 

import sys

# Dann die benötigten Qt-Klassen. 
# Erstens das grundlegende Widget für Programme
# QApplication

from qt import QApplication

# und Zweitens einen Knopf, den wir beschriften wollen
# QPushButton

from qt import QPushButton

# und dann noch Signal und Slot, 
# damit ein Druck auf den Knopf
# das Programm beenden kann. 

from qt import SIGNAL, SLOT

# Jetzt können wir uns das Programm app definieren 
# und ihm die Kommandozeilenparameter übergeben: 

app=QApplication(sys.argv)

# Der Knopf ist ähnlich schnell geschrieben. 
# Er erhält den Text "Hallo Welt!\nIch kann 
# (ein bisschen) PyQt!"
# Das \n erzeugt einen Zeilenumbruch. 
# Einfallsreicherweise nennen wir ihn "button". 

button=QPushButton("Hallo Welt!\nIch kann (ein bisschen) PyQt!", None)
# button=QPushButton(u"Hallo traumrose!\nIch liebe Dich!\nKüsst du mich?", None)

# Jetzt machen wir ihn zum Haupt-Widget 
# des Programmes "app", 
# so dass er auf der obersten Ebene liegt: 

app.setMainWidget(button)

# Dann sagen wir ihm, dass er angezeigt werden soll. 

button.show()

# Kurz vor dem Abschluss fügen wir noch 
# als kleine Spielerei 
# etwas Interaktivität hinzu: 
# Das Programm soll sich beenden, 
# wenn der Knopf gedrückt wird. 

# Dafür verbinden wir das Signal "pressed()" 
# des Knopfes "button" 
# mit dem Slot "quit()" des Programmes app. 

app.connect(button, SIGNAL("pressed()"), 
		app, SLOT("quit()"))

# Als letztes führen wir das GUI-Programm aus. 
# Erst hier wird der Knopf wirklich sichtbar. 

app.exec_loop()

# Um das zu testen kannst du das Programm einfach 
# Schritt für Schritt in der Python-Shell ausführen. 

# Das beendet mein erste Programm. 
# Ich hoffe, Du hattest Spaß beim Lesen!

def naivefilter(filepath, name):
    """Get only the relevant values."""
    values = []
    with open(filepath) as f:
        for line in f:
            if line.startswith(name):
                values.append(line)
    return values

def allvalues(filepath):
    """Get all values from the file."""
    with open(filepath) as f:
        for line in f:
            yield line

def valuesforstation(filepath, name):
    """Get all the values from a file 
    which come from the given station."""
    return tuple(line for line in allvalues(filepath) 
                 if line.startswith(name))

def valueswithoutX(filepath, X):
    """Get all the values from a file 
    which do not contain the value X."""
    return tuple(line for line in allvalues(filepath) 
                 if not X in line)

#!/usr/bin/env python
# encoding: utf-8

"""This file tests the memory purging of python by creating an instance of a
class over and over again.

It shows, that the instance is created at only one of two places over and over
again, so the maximum additional memory consumed when replacing an
instance is the size of the instance 

The reason seems to be that the instance is first created and then assigned
to the variable. Only after that, the previous object gets deleted. 

This seems easy to understand, because this behaviour is necessary to allow
for recursive functions where the new value of the variable depends on its
previous value. 

"""

# We want random, so that no optimizing of same objects can be done. 

from random import random

# Now we create a memory hungry class. 

class MemoryHungry(object): 
    """MemoryHungry is a class which just has many attributes which consume 
memory.

For me one instance of MemoryHungry takes about 140Mib with 
number_of_atts=3,000,000 - bab.

When I use a dict where I assign keys with random names to the value None 
(all the same object), this takes about 250MiB per instance. - bab
"""
    def __init__(self, number_of_atts=3000000, mode="list"): 
        if mode == "list": 
            self.liste = [] #: list of random numbers
        elif mode == "dict": 
            self.liste = {} #: dict with random numbers as keys

        # We add random numbers to teh list to make sure, that no memory 
        # usage can be optimized by grouping same objects or similar. 
        for i in range(number_of_atts): 
            self.blah = random() #: temporary random number
            # append self.blah to the list attribute of the class, so it consumes 
            # memory (as object of the list reassigning self.blah doesn't delete the 
            # value/instance of float): 
            if mode == "list": 
                self.liste.append(self.blah)
            if mode == "dict": 
                self.liste[self.blah] = None 
                # None is only one object, so what takes space here are the keys.

# Also we create a class thirsty, which creates a float with the same content 
# over and over again. 

class MemoryThirsty(object): 
    """MemoryThirsty is a class which just has many attributes which consume 
memory.

For me one instance of MemoryThirsty only takes about 70Mib with 
number_of_atts=3,000,000, which is half the amount taken by the same 
number of random numbers -bab.
"""
    def __init__(self, number_of_atts=3000000): 
        self.liste = [] #: List of random numbers

        # We add random numbers to the list to make sure, that no memory 
        # usage can be optimized by grouping same objects or similar. 
        for i in range(number_of_atts): 
            self.blah = 0.111111111111111111111111111111111 #: just a floating point number
            # append self.blah to the list attribute of the class, so it consumes 
            # memory (as object of the list reassigning self.blah doesn't delete the 
            # value/instance of float): 
            self.liste.append(self.blah)

### Self-Test ###

if __name__ == "__main__": 
    # Create a MemoryHungry instance and give it to a variable over and over again.
    print "hunger"
    for i in range(10): 
        # assign an instance of MemoryHungry to the variable hunger
        hunger = MemoryHungry(mode="dict")
        # And print the instance. 
	print hunger, i
        pass
    print "hunger done"
    del hunger
    print "thirst"
    for i in range(10): 
        # assign an instance of MemoryHungry to the variable hunger
        thirsty = MemoryThirsty()
        # And print the instance. 
	print thirsty, i
    del thirsty
    # We're done. Say so. 
    print "done"

def foo():
    print "bla"

\>>> import bla
\>>> bla.foo()
bla
\>>> def fu():
...   print "fu"
...
\>>> fu()
fu
\>>> from bla import foo
\>>> foo()
bla
\>>> bla.foo = fu
\>>> bla.foo()
fu
\>>> foo()
bla

\>>> import bla
\>>> bla.foo()
bla
\>>> def fu():
...   print "fu"
...
\>>> fu()
fu
\>>> bla.foo = fu
\>>> bla.foo()
fu
\>>> from bla import foo
\>>> foo()
fu

Character devices  --->
   /dev/agpgart (AGP Support) 
   Direct Rendering Manager (XFree86 4.1.0 and higher DRI support)

# babcode: ATI drivers
nvidia-agp
agpart
radeonhd

emerge -C ati-drivers
echo  "x11-drivers/xf86-video-radeonhd" >> portage-keywords/hardware
emerge x11-drivers/xf86-video-radeonhd
# record via pulseaudio, usage: `babrecord file.wav`  
alias babrecord='parecord -r --format=float32le --file-format'

./bigramm_statistik.py --svg --svg-output neo2.svg -l "xvlcw khgfqß´
uiaeo snrtdy
üöäpz bm,.j"

Anhang	Größe
freenet_graphs-2010-11-17-network_size-associated-google-trend.png [110]	22.56 KB
freenet_graphs-2010-11-16-with_trend.png [103]	321.32 KB
freenet_graphs-2010-11-17-network_size.png [111]	28.75 KB
freenet_graphs-2010-11-16-with_trend_small.png [112]	124.08 KB
freenet_graphs-2010-12-15-network_size.png [106]	29.34 KB
freenet_graphs-2010-12-15-network_size_small.png [113]	9.59 KB

Anhang	Größe
2011-04-06-freenet-sone.png [119]	116.3 KB
2011-04-06-freenet-sone_small.png [129]	49.03 KB

Anhang	Größe
2014-11-01-ueber-freenet-verbinden-mail.txt [155]	13.53 KB
2014-11-01-ueber-freenet-verbinden-mail.html [148]	14.06 KB

Anhang	Größe
2008-06-24-desktop.png [184]	559.04 KB
2008-06-24-desktop-small.png [186]	109.65 KB

Anhang	Größe
2010-06-30-plasma-drak.png [205]	879.52 KB
2010-06-30-KDE-4.5-rc1-plasma-drak.png [196]	879.52 KB
2010-06-30-KDE-4.5-rc1-plasma-drak-small.png [206]	144.16 KB

Anhang	Größe
2013-08-11-So-let-rekursion.org [218]	6.87 KB
2013-08-11-So-let-rekursion-fib.w [219]	124 Bytes
2013-08-11-So-let-rekursion-fib.scm [220]	130 Bytes
2013-08-11-So-let-rekursion-fibloop.py_.txt [221]	143 Bytes
2013-08-11-So-let-rekursion-fibrek.py_.txt [222]	99 Bytes
2013-08-11-So-let-rekursion-fibrek2.py_.txt [223]	133 Bytes
2013-08-11-So-let-rekursion-fibrek3.py_.txt [224]	136 Bytes
2013-08-11-So-let-rekursion-skipindent.w [225]	937 Bytes
2013-08-11-So-let-rekursion-skipindent.scm [226]	972 Bytes

Anhang	Größe
neo-tastatur-mit-gnu-plussy-und-infinite-hands-0.JPG [248]	26.38 KB
neo-tastatur-mit-gnu-plussy-und-infinite-hands-1.JPG [245]	75.8 KB
neo-tastatur-mit-gnu-plussy-und-infinite-hands-2.JPG [246]	129.51 KB
neo-tastatur-mit-gnu-plussy-und-infinite-hands-3.JPG [247]	104 KB
neo-tastatur-mit-gnu-plussy-und-infinite-hands-1-thumb.JPG [249]	42.36 KB
neo-tastatur-mit-gnu-plussy-und-infinite-hands-2-thumb.JPG [250]	37.49 KB
neo-tastatur-mit-gnu-plussy-und-infinite-hands-3-thumb.JPG [251]	28.82 KB

Anhang	Größe
tortoisehg-clone.png [264]	29.84 KB
tortoisehg-commit.png [265]	41.75 KB
tortoisehg-synchronize.png [266]	47.43 KB
tortoisehg-synchronize-pull.png [267]	39.09 KB
tortoisehg-update.png [268]	18.84 KB
tortoisehg-update-result.png [269]	23.33 KB

Test	Mercurial	Bazaar	Result
Initial clone	1m23.699s	8m52.962s	Mercurial is about 6 times faster
Repository size	111M	214M	Mercurial needs roughly half the space
full log	0m12.907s	0m29.207s	Mercurial is about 2.2 times faster
local clone	00m37.642s	4m14.102s	Mercurial is about 6.7 times faster
local clone with hot buffers	0m32.744s	3m44.461	Mercurial is about 6.8 times faster
local clone with hot buffers and shared repository and hardlinks (bzr)	0m32.744s	0m4.546s	Bazaar is about 7.2 times faster (but you must create your clones in the shared repository)

Anhang	Größe
blob_swarm-0.2.tar.gz [302]	556.85 KB
blob_swarm-0.3.tar.gz [301]	855.62 KB

Anhang	Größe
blob_valentine-0.3.tar.gz [304]	255 KB
blob_valentine_screenshot-2008-02-15.png [305]	209.4 KB

Anhang	Größe
summieren_sum.py.txt [315]	476 Bytes
summieren_selbst.py.txt [316]	749 Bytes
summe.cpp_.txt [314]	767 Bytes
summe.f90__.txt [317]	221 Bytes
summen.py_.txt [313]	301 Bytes
summen.f90 [312]	307 Bytes

Anhang	Größe
dvorak_klein.png [371]	37.4 KB
haeik_klein.png [372]	38.43 KB
neo2_klein.png [373]	38.19 KB
qwertz_klein.png [374]	40.05 KB
tnrs_klein.png [375]	37.7 KB

Anhang	Größe
video-done-right-generic.html [385]	1.65 KB
htaccess [386]	51 Bytes

Freie Software

Alternative Geschäftsmodelle im Netz: Eine Million Dollar mit dem Humble Indie Bundle

Codeswarm

CreativeCommons Lizenzen sind riskant für echt freie Werke (seit 2015-10-08 dank GPL-Kompatibilität von BY-SA nicht mehr!)

Emacs

(strikethrough start end): Durchstreichen in plain text mit Unicode

Darum Emacs: Markdown mode

E-Mail mit Emacs: web.de

Emacs als Tagebuch

Einrichtung

Das Alias erklärt

Die ~/.emacs-init-tagebuch erklärt

Muttertag und Vatertag für Emacs Org-Agenda, Deutsch und Spanisch

Namespaces in Emacs Lisp - ohne den Interpreter zu ändern

Paper zu Org-Mode für „reproducible research“

Freenet

Was du damit machen kannst

Wie du es nutzen kannst

Der schnelle Weg: Opennet

Der sicherere Weg: Darknet

Bitte aktiviert eure Freenet-Knoten

Bitte installiert Freenet, Deutschland hat seit 2015 Vorratsdatenspeicherung

Freenet-Project als Sicherheit für Informanten

Korrelation zwischen Freenet Nutzerzahlen und Google Trends zu Zensur

Mit Freenet sicher kommunizieren

Sone: Pseudonymes Microblogging über Freenet

Unfug zu Freenet auf golem.de

Verwendet Freenet (Programm)! Es ist zensurfrei, anonym und frei lizensiert

Vortrag: SUMA-Award für das Freenet-Projekt (Video)

Transkript / Untertitel

„Lasst uns über Freenet kommunizieren, dann kann ich wieder frei sprechen“ — Mail an Freunde

Was das bringt

Freenet Installieren

Mit mir verbinden

Versteckt kommunizieren

An eure Freunde schicken

Über Freenet verbinden (E-Mail-Vorlage)

Freie Schriften

Freie Software kann Geld bringen

GNU Hurd

Gegen DRM - Computer werden geblockt

Gentoo

Automatische Aktualisierungen in Gentoo GNU/Linux

Daily Cron

Gentoo auf iMac Flat-Screen 1,25Ghz

KDM (Login) Tastaturlayout auf Neo umstellen

Identitätsdiebstal verhindern mit GnuPG

KDE

KDE 4

KDE 4.1

KDE 4.3.3

KDE 4.5 rc1 Bildschirmfoto mit Infos zum Selbermachen

KDE in Gentoo

Let-Rekursion ist toll!

Inhaltsverzeichnis

Let-Rekursion erklärt

Mein Augenöffner (Code)

Fußnoten:

Lizenzen

Bedeutung der Lizenzen

Warum Lizenzen wichtig sind

Warum Werke unter freien Lizenzen die einzig vertretbaren Werke sind(*)

BSD und GPL in einfachen Worten

Meine Neo-Tastatur - Mit GNU, Plussy und Infinite Hands

Mercurial

Kurze Einführung in Mercurial mit TortoiseHG (GNU/Linux und Windows)

Das Repository herunterladen

Arbeitsfluss mit TortoiseHG

Leistungstests und Vergleiche, DVCS: Mercurial (hg) vs. Git vs. Bazaar(bzr), ...

Vergleiche | Comparisions

Englisch

Deutsch

Warum Mercurial | Why Mercurial

Mercurial vs. Bazaar speedtest clone and log (unscientific)

Mercurial vs. Bazaar speedtest clone and log - update: hg 1.1 vs. bzr 1.10

Results

Data

Notes

Result

Mercurial vs. Bazaar speedtest clone and log - update: 4 runs with different versions