- `add-load-path!' for adding directories to the `load-path', relative to
this file. Emacs searches the `load-path' when you load packages with
`require' or `use-package'.
+** Modeline
+In order to display the time in the modeline:
+#+begin_src emacs-lisp :tangle yes
+(display-time-mode 1)
+#+end_src
+To display the battery percentage:
+#+begin_src emacs-lisp :tangle yes
+(display-battery-mode 1)
+#+end_src
+** EXWM
+First we load our packages:
+#+begin_src emacs-lisp :tangle yes
+(use-package! exwm)
+(use-package! exwm-config)
+(exwm-config-example)
+#+end_src
+Now, we set our keybindings:
+#+begin_src emacs-lisp :tangle yes
+
+(setq exwm-input-global-keys
+ `(
+ ([?\s-r] . exwm-reset)
+ ([?\s-w] . exwm-workspace-switch)
+ ,@(mapcar (lambda (i)
+ `(,(kbd (format "s-%d" i)) .
+ (lambda ()
+ (interactive)
+ (exwm-workspace-switch-create ,i))))
+ (number-sequence 0 9))
+ ([?\s-&] . (lambda (command)
+ (interactive (list (read-shell-command "$ ")))
+ (start-process-shell-command command nil command)))
+
+ ([?\s-d] . (lambda ()
+ (interactive)
+ (dired default-directory)))
+
+ ([?\s-f] . (lambda ()
+ (interactive)
+ (exwm-layout-toggle-mode-line)
+ (exwm-workspace-toggle-minibuffer)))
+
+ ([?\s-b] . exwm-workspace-switch-to-buffer)
+
+
+ ([?\s-w] . (lambda ()
+ (interactive)
+ (start-process "" nil "qutebrowser")))
+ ([?\s-k] . (lambda ()
+ (interactive)
+ (start-process "" nil "krita")))
+ ([?\s-g] . (lambda ()
+ (interactive)
+ (start-process "" nil "gimp")))
+ ([?\s-b] . (lambda ()
+ (interactive)
+ (start-process "" nil "blender")))
+ ([?\s-c] . (lambda ()
+ (interactive)
+ (start-process "" nil "chromium")))
+ ([s-f2] . (lambda ()
+ (interactive)
+ (start-process "" nil "/usr/bin/slock")))))
+
+
+#+end_src
+And we also need to set up our media keys:
+#+begin_src emacs-lisp :tangle yes
+(exwm-input-set-key (kbd "<XF86AudioNext>") 'emms-next)
+(exwm-input-set-key (kbd "<XF86AudioPrev>") 'emms-previous)
+(exwm-input-set-key (kbd "<XF86AudioPlay>") 'emms-pause)
+(exwm-input-set-key
+ (kbd "<XF86AudioRaiseVolume>")
+ (lambda ()
+ (interactive) (start-process-shell-command
+ "pactl" nil "pactl set-sink-volume 0 +5% && pactl set-sink-volume 1 +5%")))
+(exwm-input-set-key
+ (kbd "<XF86AudioLowerVolume>")
+ (lambda ()
+ (interactive) (start-process-shell-command
+ "pactl" nil "pactl set-sink-volume 0 -5% && pactl set-sink-volume 1 -5%")))
+(exwm-input-set-key
+ (kbd "<XF86AudioMute>")
+ (lambda ()
+ (interactive) (start-process-shell-command
+ "pactl" nil "pactl set-sink-mute 0 toggle && pactl set-sink-mute 1 toggle")))
+;; Things to implement in exwm:
+;;Key([], 'XF86MonBrightnessUp', lazy.spawn("light -A 10")),
+;;Key([], 'XF86MonBrightnessDown', lazy.spawn("light -U 10")),
+;;Key([], "Print", lazy.spawn("scrot '%Y-%m-%d-%s_screenshot_$wx$h.jpg' -e 'mv $f ~/img/scrot")),
+#+end_src
** Font
Now we configure fonts:
#+begin_src emacs-lisp :tangle yes
(setq catppuccin-flavor 'mocha)
#+end_src
** Doom Module and Programs Configuration
+*** Agenda
+Now we add these two files to our agenda search path:
+#+begin_src emacs-lisp :tangle yes
+(setq org-agenda-files (list "~/org/agenda.org"
+ "~/org/contacts.org"
+ "~/org/notes.org"))
+(setq org-default-notes-file (concat org-directory "/notes.org"))
+#+end_src
*** IRC
Set up circe to connect to my bouncer:
#+begin_src emacs-lisp :tangle yes
#+begin_src emacs-lisp :tangle yes
(setq emms-player-mpd-music-directory "~/music/")
(setq emms-player-list '(emms-player-mpd))
+(emms-all)
(emms-player-mpd-connect)
#+end_src
*** Journal
First we set the journal to be in the website directory:
#+begin_src emacs-lisp :tangle yes
-
(setq org-journal-dir "~/org/website/journal/")
(setq org-journal-date-format "%A, %d %B %Y")
#+end_src
(setq org-journal-file-header 'org-journal-file-header-func)
(setq org-journal-file-format "%Y%m%d.org")
#+end_src
+To add everything to the agenda search path, we toggle:
+#+begin_src emacs-lisp :tangle yes
+(setq org-journal-enable-agenda-integration t)
+#+end_src
*** Brain
+I don't use this anymore, but it's good to have.
#+begin_src emacs-lisp :tangle yes
(setq org-brain-path "~/org/website/brain/")
#+end_src
*** Roam
+This is the configuration for my mindmap.
#+begin_src emacs-lisp :tangle yes
(setq org-roam-directory (file-truename "~/org/website/mindmap"))
(setq org-roam-capture-templates '(("d" "default" plain "%?"
:unnarrowed t)))
#+end_src
*** Publishing
+In order to publish my website, we need to configure emacs to publish it somewhere and with diferrent parameters:
#+begin_src emacs-lisp :tangle yes
(require 'ox-publish)
(setq org-publish-project-alist
("website" :components ("website-org" "website-static"))))
+#+end_src
+*** Contacts
+Now we configure org-contacts, which allows me to store contacts in an org mode file:
+#+begin_src emacs-lisp :tangle yes
+(setq org-contacts-files '("~/org/contacts.org"))
+#+end_src
+And then we need to add some templates with org-capture in order to add entries to the contacts easier:
+#+begin_src emacs-lisp :tangle yes
+(defvar my/org-contacts-template "* %^{name}
+:PROPERTIES:
+:ADDRESS: %^{289 Cleveland St. Brooklyn, 11206 NY, USA}
+:BIRTHDAY: %^{yyyy-mm-dd}
+:EMAIL: %^{Email}
+:NOTE: %^{NOTE}
+:END:" "Template for org-contacts.")
+
+(setq org-capture-templates
+ `(("c" "Contact" entry (file+headline "~/org/contacts.org" "Friends"), my/org-contacts-template
+ :empty-lines 1)))
#+end_src
** Keybindings
Now we set up our keybindings for our applications:
(map! :leader
:desc "Open password manager"
"p w" #'ivy-pass)
+(map! :leader
+ :desc "Open password manager"
+ "d i" #'dictionary)
#+end_src
** External Packages
we want to include some packages that don't come with doom emacs.
:init (setq epa-pinentry-mode `loopback)
(pinentry-start))
#+end_src
+*** Rainbow Mode
+#+begin_src emacs-lisp :tangle yes
+(define-globalized-minor-mode global-rainbow-mode rainbow-mode
+ (lambda ()
+ (when (not (memq major-mode
+ (list 'org-agenda-mode)))
+ (rainbow-mode 1))))
+(global-rainbow-mode 1)
+#+end_src
* packages.el Configuration
These are some external packages that I use that are not provided by doom modules.
#+begin_src emacs-lisp :tangle packages.el
:recipe (:host github
:repo "kmonad/kbd-mode"))
(package! nasm-mode)
+(package! org-contrib)
+(package! exwm)
+(package! rainbow-mode)
#+end_src
* init.el Configuration
ein
(eval +overlay)
gist
- lookup
+ (lookup +dictionary +offline)
lsp
magit
make
:app
calendar
emms
- everywhere ; *leave* Emacs!? You must be joking
- irc ; how neckbeards socialize
- (rss +org) ; emacs as an RSS reader
+ everywhere
+ irc
+ (rss +org)
;;twitter ; twitter client https://twitter.com/vnought
:config
Key([mod], "f", lazy.spawn("firefox"), desc="Run Firefox"),
Key([mod], "b", lazy.spawn("blender"), desc="Run Blender"),
Key([mod], "p", lazy.spawn("krita"), desc="Run Krita"),
+ Key([mod], "v", lazy.spawn("inkscape"), desc="Run Inkscape"),
Key([mod], "g", lazy.spawn("gimp"), desc="Run GIMP"),
Key([mod], "t", lazy.spawn("torbrowser-launcher"), desc="Run Tor Browser"),
Key([mod], "i", lazy.spawn("emacsclient --eval \"(emacs-everywhere)\""), desc="Emacs Everywhere!"),
#+begin_src python :tangle config.py
c.downloads.location.directory = "~/downloads"
#+end_src
+We also want to do this for the purpose of EXWM:
+#+begin_src python :tangle config.py
+c.tabs.tabs_are_windows = True
+#+end_src
** End of Config
#+begin_src python :tangle config.py
config.load_autoconfig()
#+end_src
#+RESULTS:
+- [[file:20230619.org][20230619.org]]
+- [[file:20230616.org][20230616.org]]
+- [[file:20230615.org][20230615.org]]
- [[file:20230614.org][20230614.org]]
- [[file:20230613.org][20230613.org]]
- [[file:20230611.org][20230611.org]]
can be explained by a bimodal or binary system. Everything, from
boolean logic to art, any system whose goal is to make a prediction.
+My hypothesis is that whenever someone believes something, the opposite
+belief is equally valid. In order to demonstrate, let me introduce:
+
** The Great Filter
No, not the one about aliens dying or something. I'm talking about the
everyday systems that you use in order to make predictions about the
Because this is indeed a system that explains everything, I must also
demonstrate why it might be impossible to explain everything. I'll
give the argument in a short set of syllogisms.
+
+1. If something must explain everything, it must also explain itself.
+2. If it explains itself, it means it is circular by definition, and therefore not objective.
+3. If it does not explain itself, then it does not explain everything, and it is therefore incomplete.
+
+So either the system we're describing is circular, in which case it is arbitrary and subjective,
+or it is incomplete. So there's no way to construct any system with both qualities. Right?
+
+*** The problem with the problem with explaining everything
+Notice that our above set of syllogisms is extrapolative. This means that it makes predictions
+about what is possible about a system. Due to this, the system results in some duality:
+either a valid system is incomplete or subjective. And there's another problem too: the system applies to itself.
+
+If either systems are subjective or incomplete, then the system we are using to describe subjective and incomplete
+systems is also subjective. Which presents a problem: we have no reason to believe that this framework is worth
+believing in at all!
+*** The problem with the problem with the problem with explaining everything
+But the fact that the system applied to itself breaks it is just a confirmation that our predictions are accurate!
+We predicted that things that explain themselves must be circular, and we were correct!
+*** etc...
+The claim is that we can do this forever, although even this statement can go on forever. What's interesting
+is that it seems like there's an inherent link between duality and [[id:654280d8-82e8-4a0e-a914-bd32181c101b][infinite]] [[id:8f265f93-e5fd-4150-a845-a60ab7063164][recursion]]; infinite self reference. But the real question is: is this
+statement about frameworks true, or is it false? Well, according to the principle of duality, both of them can
+be true.
+
+** The Filter is based on what you choose to believe
+So what you think is true or false is just what you choose to be true or false. Of course, even this statement is an infinite contradiction
+and confirmation, but what I am trying to communicate is that what you believe filters what's true and what's false, and as a result,
+leads to different prescriptions, or different actions for the same situation. In this way, frameworks act like filters. They shield us
+from the infinite opposite side of what we currently believe. Does this "filter" I am describing exist or not?
+
+** Of course it Doesn't!
+The mindmap explains everything, without a filter.
+
+* The problem and solution with duality
+The theory of duality is self deconstructing and self constructing in the same way via self reference. If the opposite stance is valid,
+that means that not believing in duality is valid, but that also is a data point that confirms our hypothesis.
+
+We're also describing duality using a dual framework here, which is another pretty interesting thought.
+
+* Logic Explains Duality
+Logic is a self affirming structure, and that might give you the clue that it is also self destructing. Nevertheless, one of the axioms
+of logic is:
+\begin{align*}
+p \neq \neg p.
+\end{align*}
+This statement filters for binary, or as I would call it, dual mode frameworks, and gets around the principle of explosion. We have an intuitive
+understanding of truth and falsehood, and we can use those general terms whenever there is a mutually exclusive divide. In short, you can view
+the logical framework as an abstraction of all other dual frameworks. I propose that you can do analysis on all dual frameworks in much the same
+way group theory does analysis on groups.
+
+* Programming Explains Duality
+Of course, there is logic in programming, but that is kind of boring. What I am going to explain here is a recursive, binary structure known
+as the binary tree. It seems like you can model a lot of things in this way as well; John Conway's surreal numbers are a manifestation of this
+phenomenon.
+#+begin_src python :exports both :results output
+class BinaryTreeNode:
+ def __init__(self, value):
+ self.left = None
+ self.right = None
+ self.value = value
+ def insert(self, value):
+ if value < self.value:
+ if self.left is None:
+ self.left = BinaryTreeNode(value)
+ else:
+ self.left.insert(value)
+ else:
+ if self.right is None:
+ self.right = BinaryTreeNode(value)
+ else:
+ self.right.insert(value)
+#+end_src
+Currently, all that this binary tree has is an insert method, but that is all that is needed in order to see the [[id:8f265f93-e5fd-4150-a845-a60ab7063164][recursion]] in the structure.
+Each node "height" is self similar, and it works of a dual-mode sorting algorithm. That is, smaller values go on the left side, and bigger
+values go on the right side.
You're ruining your own fun I guess. These are just the recommended settings
and if you want to change them then you're free to.
-That won't stop me from following you in real life, though. Teehee!
+That won't stop me from stalking you and physically threatening you, though. Teehee!
* How did you make it?
This section of the website was made with ~org-roam~, an emacs package that allows
you to make a web of notes, something close to a wiki.
projects / monorepo.git / commitdiff