Monday, August 31, 2009

ERUNT Freeware download and review - registry backup tool from SnapFiles

ERUNT Freeware download and review - registry backup tool from SnapFiles: "ERUNT
registry backup tool"

ERUNT (Emergency Recovery Utility NT) allows you to keep a complete backup of your registry and restore it when needed. The standard registry backup options that come with Windows back up most of the registry but not all of it. ERUNT however creates a complete backup set, including the Security hive and user related sections. ERUNT is easy to use and since it creates a full backup, there are no options or choices other than to select the location of the backup files. The backup set includes a small executable that will launch the registry restore if needed.

Emsa Disk Check: CD/DVD/HDD Disk Diagnostics Utility

Emsa Disk Check: CD/DVD/HDD Disk Diagnostics Utility: "Emsa Disk Check"

Emsa Disk Check is a dual-purpose utility, for disk checking (prescan and full disk reading) and also benchmarking. What it does, is scanning/reading the entire contents of a disk (CD, DVD or hard drive; or even floppy) and show any read errors that may appear, but also show drive speed information, progress statistics etc. It was designed with simplicity in mind, but usefulness for the user.

Create a free forum

Create a free forum

Everyone can create his free forum, in a few seconds, without any technical knowledge, and begin to discuss immediately! The interface of the forum is easy to use and to personalize. How to create a free forum?
Simply begin with this first step by choosing a style for your forum.
Don't worry, you can always easily change to a different version anytime you want.

Freeware Replacements For Common Commercial Apps

Freeware Replacements For Common Commercial Apps: "Freeware Replacements For Common Commercial Apps"

Cable management

Cable management

IKEA's selection of cable tidying products.

Saturday, August 29, 2009

Lock the Desktop from the Taskbar - Windows 7

Lock the Desktop from the Taskbar - Windows 7: "Lock the Desktop from the Taskbar"

Many people lock their Windows desktop while they are away from their computer for a few minutes. In Windows 7 you can do this by pressing Windows Key + L. However, what if you frequently lock the desktop and would like a one-click shortcut directly from the taskbar?

Thursday, August 20, 2009



Collection of legal torrents covering many areas.



Wikibooks is a Wikimedia community for creating a free library of educational textbooks that anyone can edit.

Saturday, August 15, 2009

Unison File Synchronizer

Unison File Synchronizer: "Unison is a file-synchronization tool for Unix and Windows. It allows two replicas of a collection of files and directories to be stored on different hosts (or different disks on the same host), modified separately, and then brought up to date by propagating the changes in each replica to the other."

Thursday, August 13, 2009

Loads of Linux Links: Top

Loads of Linux Links: Top: "Loads of Linux Links"

Categorised list of Linux software.

4DOS.INFO - Klaus Meinhard's Homepage: DOS Programs and Applications

4DOS.INFO - Klaus Meinhard's Homepage: DOS Programs and Applications: "old DOS programs"


FREE SOFTWARE FOR DOS — Front Page: "Free Software for DOS"

Antivirus | Archivers, Compressors, EXE Packers & related (3)
Batch Processing (2) | Boot Managers & Utils
Calculators, Converters, Stats, Math | Calendars, Clocks & PIMs
Communication & Internet (2) | Database & Spreadsheet Programs
Desktops, Shells, GUIs | Directory Utils | Disk Utils (2)
Encryption & Encoding | File Managers (2) | File Utils (3)
Graphics | HTML Utils | Information, Reference, Research
Keyboard & Mouse Utils | Menus & Program Executers
Miscellaneous Utils | Operating Systems | Printing Helpers
Programming Languages & Tools | Screen & Video
Sound Progs & CD Players | System Utils | Text Editors (2)
Text Utils (5) | Unix >> DOS | Windows & OS/2 Utils for DOS Users
Secondary List

Return of the ’70s Weirdos | Newsweek Technology |

Return of the ’70s Weirdos | Newsweek Technology | "Return of the ’70s Weirdos"

That photo of 11 weirdos in '70s clothes you may have seen on the Internet really is the original Microsoft team, snapped Dec. 7, 1978, on the eve of the company's move from Albuquerque, N.M., to Seattle. Almost 30 years later, a few weeks before Bill Gates's departure from Microsoft, the group (looking better) reconvened.

Wednesday, August 12, 2009

Monday, August 10, 2009

Bhante Vimalaramsi - 6Rs

One thing that many people have a problem understanding is that the
6R's is not a process to make things be the way we want them to be!
The 6R's are not a stick used to beat and "make" things change
"NOOOOO" The 6R's are for showing us how to allow the tightness and
pain to be there without getting involved with making it change.
Change will come when we allow the space for it to arise by itself.
The problems most people have is their expectations that they want
things to happen in their own time. And they become disenchanted with
the 6R's when things don't occur in the way we want them to. But the
6R's are not a control but an education device to show us how craving
and clinging actually works and it teaches us patience. WHich by the
way leads to nibbana! Hahaha! Anyway I hope this helps somewhat. As
always if it is not clear please don't hesitate to ask again. Smiles
and happiness to you always!

bash tip - Tracking down disk space hogs

du -h ~ | sort -nr | less

bash tip

Throw this in your .bashrc: alias s="screen -RAad" . This makes multiple screen session management
really easy. When I want to IRC, I just type "s irc". When I'm checking out how my torrent is going, "s
tor". The beauty is, you don't have to do anything different for a new session. If you forget which
sessions you have going, just type "s" and you'll be provided with a list of existing screen sessions.

More useful tips available:

xterm colour schemes

xterms suggested colour schemes:

green on black
black on wheat
white on navy
cyan on black
orange on black

He uses white on navy for emacs.

In a series of experiments, proofreading performance was consistently
better with positive polarity (dark text on light background) than
with negative polarity displays (light text on dark background). This
positive polarity advantage was independent of ambient lighting
(darkness vs. typical office illumination) and of chromaticity (black
and white vs. blue and yellow). A final experiment showed that colour
contrast (red text on green background) could not compensate for a
lack of luminance contrast. Physiological measures of effort and
strain (breathing rate, heart rate, heart rate variability and skin
conductance level) and self-reported mood, fatigue, arousal,
eyestrain, headache, muscle strain and back pain did not vary as a
function of any of the independent variables, suggesting that
participants worked equally hard in all experimental conditions, so
that the interpretation of the primary performance measure was
unlikely to be contaminated by a performance-effort trade-off.

Lisp notes

Sun Aug 17 11:17:43 BST 2008

In article <48a7480f$0$26084$>,
Mark Carter wrote:

> > Hi, Lisp n00b here. I have written a little accounts package in Python,
> > and I was experimenting with converting it to Lisp. I'm using SBCL on OS X.
> >
> > I know almost jack about Forth and APL, but it was occuring to me that
> > it would be a very interesting style to try in Lisp. I think it would
> > make my programs shorter, and would also be useful for making ad-hoc
> > queries.
> >
> > To set the stage, the app that I am writing from the ground up has two
> > classes: account and entry. A ledger is composed of a list of accounts,
> > and accounts have a list of entries in them.
> >
> > I have defined a couple of macros/functions:

Well, you are basically reinventing already existing
Lisp functionality. ;-)

> >
> > (defun foreach-lambda (list func)
> > (loop for el in list do (funcall func el)))

This is called MAP. mapping is a basic concept in Lisp.

(map nil (lambda (item) (do-something item)) list)

There are some other map functions (mapcar, ...).

> >
> > (defmacro foreach (list arg &rest body)
> > "Process each argument in a list"
> > `(foreach-lambda ,list (lambda (,arg) ,@body)))

This is called DOLIST.

(dolist (item list)
(do-something item))

Btw., if you write a macro like above, you should make a small

(defmacro foreach (list arg &body body)
"Process each argument in a list"
`(foreach-lambda ,list (lambda (,arg) ,@body)))

&body informs the Lisp system that body is a sequence
of expressions. It will usually use this information
to format code that uses this macro a little bit better.
You should compare the two. The &rest version
will be indented as if the body were normal arguments.
For the &body version the Lisp system use a different indentation.

> > (defun find-account (code)
> > (find-if (lambda (x) (eq code (account-code x)))
> > *accounts*))

Instead of FIND-IF use FIND - that's shorter.

CL-USER 68 > (find 3 '((a 1) (b 2) (c 3)) :key #'second)
(C 3)

Don't compare numbers with EQ. Use EQL or =.

(find code *accounts* :key #'account-code)

Above will use EQL , but you can tell it to use another:

(find code *accounts* :key #'account-code :test #'account-number-equal)
You might not need it in your case. But this nice
flexibility is there in Common Lisp via various keyword arguments.

> >
> > (defun accounts (func)
> > (foreach *accounts* a (funcall func a)))

(dolist (a *accounts*) (funcall func a))

or shorter

(map nil func *accounts*)

> >
> > (defun account (code func) (funcall func (find-account code)))
> >
> >
> > There's other bits in it too, but this is all I want to demonstrate just
> > now.
> >
> > Well, the nice thing is, if I want to debug or just do an ad-hoc query
> > in the REPL, I can do something like
> > (accounts #'print-balance)

I would rename this function to do-all-accounts or map-accounts.

> > to print the balances of all the accounts. If I am only interested in
> > one account, I can do
> > (account :bank #'print-balance)
> > Or, I can do other things like
> > (account :bank #'describe)

That makes little sense.

(describe (find-account :bank))

is just as good.

> >That's pretty neat, and I'm getting quite enthusiastic about this
> > mysterious beast called Lisp, as it is not an approach I have tried in
> > Python.
> >
> > Although it's quite nice, the way I have done it is not quite right,
> > because if I want descriptions for the entries in an account, the call
> > gets muddles with lambdas. My current definition for showing entries is
> >
> > (defun show-entries (code)
> > "Show the entries for an account code"
> > (foreach (account-entries (find-account code)) e
> > (describe e)))

(map nil #'describe
(account-entries (find-account code)))
> >
> > Now, I'm thinking if I had a stack-based approach, I could define it as
> > something like
> > (-account code) (-entries) (-describe)
> > If you wanted to describe all the entries in all the accounts, then you'd do
> > (-accounts) (-entries) (-describe)
> > where the prefix of '-' denotes a convention that there is a global
> > stack that is being twiddled with. And things like -account would work
> > differently depending on whether the stack was a list of classes or just
> > a class. It also looks really cool; there's no apparent looping
> > construct, and it's very convenient and intuitive for the user.
> >
> > I'm wondering if anyone has adopted a similar or better approach, and
> > what came of it.
> >
> > I'm finding that I can twiddle and fiddle with ideas in Lisp which I
> > probably wouldn't have tried to do in Python. Having said that, I
> > probably would have produced a finished result more quickly.

I think the Lisp-based functional approach is fine. You just
need to use some of the built in stuff. Check the chapters
about lists, vectors, arrays and sequences in the CLHS to get
an overview about the language. Recently here was posted
a pointer to the Common Lisp Quick Reference, which also
gives a nice overview about existing functionality.


Emacs: run-forth.el

;Article: 50575 of comp.lang.forth
;From: (Bob Pepin)
;Newsgroups: comp.lang.forth
;Subject: Re: Basicly a basic BASIC
;Date: 06 Dec 1999 03:50:35 +0100
;Organization: Entreprise des P&T
;Lines: 193
;Message-ID: <86ogc46av8.fsf@homer.localnet>
;References: <81rct3$> <81u1h0$207f$> <> <> <> <384558b0$0$> <827d20$6j7$> <82dhap$gp$>
;X-Trace: 944448945 13997 (6 Dec 1999 02:55:45 GMT)
;NNTP-Posting-Date: 6 Dec 1999 02:55:45 GMT
;X-Newsreader: Gnus v5.7/Emacs 20.4
;Xref: comp.lang.forth:50575

; (Anton Ertl) writes:

;> In article <827d20$6j7$>,
;> Wil Baden writes:
;> Goran Rydquist's forth.el (and, by inheritance, gforth.el) also has a
;> feature that supports running a Forth system interactively in an emacs
;> window and copying lines or regions with a few keystrokes from an
;> edited file to the Forth window, passing the text to the Forth system,
;> and displaying the output in the Forth window. No bouncing either.
;> However, I don't use or maintain this stuff, and IIRC it does not work
;> well with current versions of emacs and Gforth.

;I've attached a small .el that interfaces to forth via comint, works fine
;with the new emacsen, hope someone finds it useful..

;;;; run-forth.el
;;;; mostly stolen from cmuscheme.el

(provide 'run-forth)
;(require 'gforth)
(require 'comint)
;(require 'string)

(defvar inferior-forth-mode-hook nil
"*Hook for customising inferior-forth mode.")
(defvar inferior-forth-mode-map nil)

(cond ((not inferior-forth-mode-map)
(setq inferior-forth-mode-map
(copy-keymap comint-mode-map))
(define-key inferior-forth-mode-map "\M-\C-x" ;gnu convention
(define-key inferior-forth-mode-map "\C-x\C-e" 'forth-send-line)))

;; Install the process communication commands in the forth-mode keymap.
(define-key forth-mode-map "\M-\C-x" 'forth-send-definition);gnu convention
(define-key forth-mode-map "\C-x\C-e" 'forth-send-line);gnu convention
(define-key forth-mode-map "\C-ce" 'forth-send-definition)
(define-key forth-mode-map "\C-c\C-e" 'forth-send-definition-and-go)
(define-key forth-mode-map "\C-cr" 'forth-send-region)
(define-key forth-mode-map "\C-c\C-r" 'forth-send-region-and-go)
(define-key forth-mode-map "\C-cb" 'forth-send-buffer)
(define-key forth-mode-map "\C-c\C-b" 'forth-send-buffer-and-go)
(define-key forth-mode-map "\C-cz" 'switch-to-forth)

(defun inferior-forth-mode ()
"Major mode for interacting with an inferior Forth process.

The following commands are available:

A Forth process can be fired up with M-x run-forth.

Customisation: Entry to this mode runs the hooks on comint-mode-hook and
inferior-forth-mode-hook (in that order).

You can send text to the inferior Forth process from other buffers containing
Forth source.
switch-to-forth switches the current buffer to the Forth process buffer.
forth-send-definition sends the current definition to the Forth process.
forth-compile-definition compiles the current definition.
forth-send-region sends the current region to the Forth process.
forth-compile-region compiles the current region.

forth-send-definition-and-go, forth-compile-definition-and-go,
forth-send-region-and-go, and forth-compile-region-and-go
switch to the Forth process buffer after sending their text.
For information on running multiple processes in multiple buffers, see
documentation for variable forth-buffer."
;; Customise in inferior-forth-mode-hook
(setq comint-prompt-regexp "")
; (forth-mode-variables)
(setq major-mode 'inferior-forth-mode)
(setq mode-name "Inferior Forth")
(setq mode-line-process '(": %s"))
(use-local-map inferior-forth-mode-map)
(run-hooks 'inferior-forth-mode-hook))

(defvar forth-program-name "forth"
"*Program invoked be the run-forth command")

(defun run-forth (cmd)
"Run an inferior Forth process, input and output via buffer *forth*.
If there is a process already running in *forth*, just switch to that buffer.
With argument, allows you to edit the command line (default is value
of forth-program-name). Runs the hooks from inferior-forth-mode-hook
\(after the comint-mode-hook is run).
\(Type \\[describe-mode] in the process buffer for a list of commands.)"

(interactive (list (if current-prefix-arg
(read-string "Run Forth: " forth-program-name)
(if (not (comint-check-proc "*forth*"))
(let ((cmdlist (split-string cmd "[\t ]")))
(set-buffer (apply 'make-comint "forth" (car cmdlist)
nil (cdr cmdlist)))
(setq forth-buffer "*forth*")
(switch-to-buffer "*forth*"))

(defun forth-send-region (start end)
"Send the current region to the inferior Forth process."
(interactive "r")
(comint-send-region (forth-proc) start end)
(comint-send-string (forth-proc) "\n"))

(defun forth-send-definition ()
"Send the current definition to the inferior Forth process."
(let ((end (point)))
(forth-send-region (point) end))))

(defun forth-send-line ()
"Send the current line to the inferior Forth process."
(let ((end (point)))
(forth-send-region (point) end))))

(defun forth-send-buffer ()
"Send the current buffer to the inferior Forth process."
(forth-send-region (point-min) (point-max)))

(defun forth-send-region-and-go (start end)
"Send the current region to the inferior Forth process,
and switch to the process buffer."
(interactive "r")
(forth-send-region start end)
(switch-to-forth t))

(defun forth-send-definition-and-go ()
"Send the current definition to the inferior Forth,
and switch to the process buffer."
(switch-to-forth t))

(defun forth-send-line-and-go ()
"Send the current line to the inferior Forth,
and switch to the process buffer."
(switch-to-forth t))

(defun forth-send-buffer-and-go ()
"Send the current buffer to the inferior Forth,
and switch to the process buffer."
(switch-to-forth t))

(defun beginning-of-definition ()
(search-backward-regexp "\\<:\\>"))

(defun end-of-definition ()
(search-forward-regexp "\\<;\\>"))

(defun switch-to-forth (eob-p)
"Switch to the forth process buffer.
With argument, positions cursor at end of buffer."
(interactive "P")
(if (get-buffer forth-buffer)
(pop-to-buffer forth-buffer)
(error "No current process buffer. See variable forth-buffer."))
(cond (eob-p
(goto-char (point-max)))))

(defvar forth-buffer nil "*The current forth process buffer.")

(defun forth-proc ()
"Returns the current forth process. See variable forth-buffer."
(let ((proc (get-buffer-process (if (eq major-mode 'inferior-forth-mode)
(or proc
(error "No current process. See variable forth-buffer"))))

(run-hooks 'run-forth-load-hook)

; sell me shitty software once, shame on you.
; sell me shitty software twice, shame on me.

Forth - inlined data

\ Created 20-Apr-2009
\ Example of how to create custom commands that read data from
\ the source file itself

: line# ( n -- ) ." line " . ." : " ;
: line ( n -- ) line#
refill drop
source type
cr ;

: scanit 1 line 2 line refill drop ;


this is the first line
this is the second line

." Finished" cr

Allegro Common Lisp - buttons

Button function which sets the value of a static text widget to the contents of an editable text widget:

(defun form1-default-button-2-on-click (dialog widget)
(declare (ignorable dialog widget))
(let* ((text (find-component :editable-text-1 dialog))
(label (find-component :static-text-1 dialog)))
(setf (value label) (value text))

Saturday, August 8, 2009

The Underground History of American Education

The Underground History of American Education

The shocking possibility that dumb people don’t exist in sufficient numbers to warrant the millions of careers devoted to tending them will seem incredible to you. Yet that is my central proposition: the mass dumbness which justifies official schooling first had to be dreamed of; it isn’t real.

Download The Catacomb Abyss | DOS Games Archive

Download The Catacomb Abyss | DOS Games Archive: "The Catacomb Abyss"

Bry likes this game. Seems to be shareware, though.



It has many other flavors:

Cannot delete file: Access is denied
There has been a sharing violation.
The source or destination file may be in use.
The file is in use by another program or user.


Windows Live Skydrive & 3 Alternative Online Storage Services

Windows Live Skydrive & 3 Alternative Online Storage Services: "Windows Live Skydrive & 3 Alternative Online Storage Services"

Well, I must say I am coming to the conclusion that the Windows Live Initiative is becoming one of the best things to come out of Microsoft in years.

In a series of articles, I hope to cover Windows Live in a greater amount of detail then you may have seen before. I am aware that Make Use Of has previously covered several services (such as Live Writer and SkyDrive), so I am going to avoid simply giving a run-down of features. You already know it.

No what I hope to do is really give you a great deal more detail on fully integrating Windows Live and maximising your experience. These articles will include tips, hacks, reviews and most importantly the comparisons between Live Services and its competitors.

Free Office Suite to Download

Free Office Suite to Download: "SoftMaker Office 2006 for Windows"

A free office suite

Play Ogg! - Free Software Foundation

Play Ogg! - Free Software Foundation: "Ogg"

Increasingly proprietary software companies like Microsoft, Apple, and Adobe are pushing video and audio formats that restrict access and restrict software developers, but there is an alternative that can be played on all computers without restriction — Ogg. Ogg provides professional grade multimedia formats. Ogg is used extensively by free software projects, artists and a growing number of music and video distributors.

Saturday, August 1, 2009

FreeBASIC compiler (a free BASIC compiler) - official page - About [en]

FreeBASIC compiler (a free BASIC compiler) - official page - About [en]: "FreeBASIC is a completely free, open-source, 32-bit BASIC compiler, with syntax similar to MS-QuickBASIC, that adds new features such as pointers, unsigned data types, inline assembly, object orientation, and many others."

Available for DOS, Windows and Linux.