~lucasemmoreira/first-emacs

first-emacs/configuration.org -rw-r--r-- 4.9 KiB
b47220d3Lucas Moreira minor organization changes 10 months ago
                                                                                
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
#+Title: FirstEmacs
#+Author: Lucas E M Moreira
#+mail: me@lucasemmoreira.xyz

* What is this?
  I created this config to make emacs a more smooth first experience for my girlfriend. I do not think this setup is meant to be used always, but it does break a few first annoying barriers. Mainly the ~C-c~ and the ~C-x~ hotkeys.

* How to use it?
  Well, you can use it as an org file. To do so, create the ~\~/.emacs~ file like this:
  #+begin_src elisp
   
    (org-babel-load-file "~/path/to/this/file/name-of-this-file.org")
  #+end_src
  A note of caution: in my config, my emacs only converts to the configuration what is with ~emacs-lisp~. If you fell the need, just erase the ~elisp~ to be extra safe.

* Make it simpler please!
  Ok, so this is the main dish. [[https://github.com/darkstego/wakib-keys][This]] repository contains the configuration that breaks those first barriers I mentioned earlier. I was not able to download it through ~use-package~. So you will have to do it yourself. But it is very simple. All you have to do is put the main file ~wakib-keys.el~ inside the emacs configuration folder ~\~/.emacs.d/~. Done! Good to go!
  #+begin_src emacs-lisp
    ;; https://github.com/darkstego/wakib-keys
    (require 'wakib-keys "~/.emacs.d/wakib-keys.el")
    (wakib-keys 1)
  #+end_src
  I will not elongate on what the lib does (you can read it the original repo =]) but the idea is that ~Ctrl + c~ and ~Ctrl + x~ (or in emacs notation ~C-c~ and ~C-x~) are used as expected in most guis applications, i.e., for copying and cutting.

* Some basic stuff (in my opinion!)
  Well here we can divide in a few parts.

** Packages please!
   This setup is for you to be able to install packages more easily.
   #+begin_src emacs-lisp
    ;; Configure package.el to include MELPA.
    (require 'package)
    (add-to-list 'package-archives '("gnu" . "https://elpa.gnu.org/packages/") t)
    (add-to-list 'package-archives '("melpa" . "https://melpa.org/packages/") t)
    (add-to-list 'package-archives '("org" . "http://orgmode.org/elpa/") t)
    (package-initialize)
    
    ;; Ensure that use-package is installed.
    ;;
    ;; If use-package isn't already installed, it's extremely likely that this is a
    ;; fresh installation! So we'll want to update the package repository and
    ;; install use-package before loading the literate configuration.
    (when (not (package-installed-p 'use-package))
      (package-refresh-contents)
      (package-install 'use-package))
   #+end_src

** Some keybindings (shortcuts)
   These are some keybindings that I find very useful. They are very similar to web browsers (except for the last three).
   #+begin_src emacs-lisp
     (global-set-key (kbd "<C-tab>") 'other-window)
     (global-set-key (kbd "<C-f4>") 'delete-window)
     (global-set-key (kbd "C-t") 'split-window-right)
     (global-set-key (kbd "C-<") 'previous-buffer)
     (global-set-key (kbd "C->") 'next-buffer)
   #+end_src
   
** A more friendly interface for the next step =]
   This part I put because it not so trivial to create a first version, and it is useful if you want to be a more "emacs user". Also, this code creates a good search in the buffer with ~Ctrl + s~ (or ~C-s~).
   #+begin_src emacs-lisp
     (use-package ivy
       :diminish
       :bind (("C-s" . swiper)
	      :map ivy-minibuffer-map
	      ("TAB" . ivy-alt-done)
	      ("C-f" . ivy-alt-done)
	      ("C-l" . ivy-alt-done)
	      ("C-j" . ivy-next-line)
	      ("C-k" . ivy-previous-line)
	      :map ivy-switch-buffer-map
	      ("C-k" . ivy-previous-line)
	      ("C-l" . ivy-done)
	      ("C-d" . ivy-switch-buffer-kill)
	      :map ivy-reverse-i-search-map
	      ("C-k" . ivy-previous-line)
	      ("C-d" . ivy-reverse-i-search-kill))
       :config
       (ivy-mode 1))
    
     (use-package counsel
       :demand t
       :bind (("M-x" . counsel-M-x)
	      ("C-x b" . counsel-ibuffer)
	      ("C-x C-f" . counsel-find-file)
	      ("C-M-l" . counsel-imenu)
	      :map minibuffer-local-map
	      ("C-r" . 'counsel-minibuffer-history))
       :custom
       (counsel-linux-app-format-function #'counsel-linux-app-format-function-name-only)
       :config
       (setq ivy-initial-inputs-alist nil)) ;; Don't start searches with ^
    #+end_src
   
** Help me with the chords!
   Emacs is widely know for its chords, and it can be intimidating. This package helps you see what is that you /chording/ for.
   #+begin_src emacs-lisp
      (use-package which-key
	:config (which-key-mode))
   #+end_src
   
  
* Add more!
  Well, here it is important for me to say that, the ~wakib-keys~ package may have some impact but fell free to add more stuff! The nice thing of emacs is to that is very modular and you can try a bunch of [[https://www.emacswiki.org/emacs/InstallingPackages][packages]]! For example the very nice [[https://elpy.readthedocs.io/en/latest/][elpy]] package for python development:
  #+begin_src emacs-lisp
    (use-package elpy
      :ensure t
      :init
      (elpy-enable))
  #+end_src