Lisp dir

From elisp manual:-- Function: file-directory-p filename. This function returns ‘t’ if FILENAME is the name of an existing directory, ‘nil’ otherwise. (copy-directory '/home/joe/stuff' '/home/joe/stuff-backup') ;; delete a whole dir. new in emacs 23 (delete-directory '/home/joe/stuff' t) (info '(elisp) Files') Example: (defun make-backup () 'Make a backup copy of current buffer's file. Create a backup of current buffer's file. Is there a way to create a directory using common lisp. I want to first create a folder and then put my .txt .png files in that. I know that first I can create the folder externally and then using with-open-file and so on create my files inside the directory. What I want is a common lisp solution for this. Lisp is the second-oldest high-level programming language after Fortran and has changed a great deal since its early days, and a number of dialects have existed over its history. Today, the most widely known general-purpose Lisp dialects are Common Lisp and Scheme. Lisp was invented by John McCarthy ... MS-DOS and MS-Windows systems usually lack the standard Unix program ls, so this function emulates the standard Unix program ls with Lisp code. As a technical detail, when switches contains the long ‘--dired ’ option, insert-directory treats it specially, for the sake of dired. Lisp definition is - to pronounce the sibilants \s\ and \z\ imperfectly especially by turning them into \th\ and \t͟h\. How to use lisp in a sentence. site-lisp is intended for making libraries available to all users on a given system, and so would be managed on a per-system basis.. If you are just trying to manage your own config consistently across servers, don't put things in site-lisp; put them under a sub-directory of your user directory, such as ~/.emacs.d/lisp/ and then use: (add-to-list 'load-path (expand-file-name '~/.emacs.d/lisp ... — Constant: dir-locals-file This constant is the name of the file where Emacs expects to find the directory-local variables. The name of the file is .dir-locals.el 1.A file by that name in a directory causes Emacs to apply its settings to any file in that directory or any of its subdirectories (optionally, you can exclude subdirectories; see below). The 'DIR' command is a DOS (remember that dark place) command that displays a list of a directories files and subdirectories. But did you know that you can use the 'DIR' command from within AutoLisp? This is a great function for obtaining a list of files in a directory, especially useful for Batch Processing Routines. Let's have a look at it. \-B lisp\-lib\-dir Specifies the installation directory\. This is the directory containing the linking sets and other data files\. This option is normally not necessary, because the installation directory is already built\-in into the clisp executable\.

How to use spacemacs in terminal?

2020.08.22 19:22 codekutz How to use spacemacs in terminal?

I've been unable to find a good guide for running spacemacs in the terminal and have not been able to yet. I use the emacs-macport (https://github.com/railwaycat/homebrew-emacsmacport). I've heard that you should be able to run emacs -nw but this gives me a bunch of what look like dependency errors:
Warning: arch-dependent data dir '/Users/travis/build/railwaycat/homebrew-emacsmacport/build-scripts/emacs-source/tmproot/Emacs.app/Contents/MacOS/libexec/': No such file or directory
Warning: arch-independent data dir '/Users/travis/build/railwaycat/homebrew-emacsmacport/build-scripts/emacs-source/tmproot/Emacs.app/Contents/Resources/etc/': No such file or directory
Warning: Lisp directory '/Users/travis/build/railwaycat/homebrew-emacsmacport/build-scripts/emacs-source/tmproot/Emacs.app/Contents/Resources/lisp': No such file or directory
Error: charsets directory not found:
/Users/travis/build/railwaycat/homebrew-emacsmacport/build-scripts/emacs-source/tmproot/Emacs.app/Contents/Resources/etc/charsets
Emacs will not function correctly without the character map files.
Please check your installation!
Any suggestions / ideas or links to a good theoretical guide, would be a great help.
submitted by codekutz to spacemacs [link] [comments]


2020.08.16 01:42 emacsomancer Repairing asdf package storage?

Something silly that I've done that I don't quite understand how to resolve.
I ended up with some project under ~/common-lisp which have their own quicklisp configs tied to them (to locally pull and compile quicklisp packages). In retrospect, they shouldn't have been located in that directory.
But now these seem to be "embedded" in my system, and if I remove the quicklisp dirs from these, or delete/move the directories themselves, then various lisp applications (e.g. stumpwm) end up complaining that they can't find various packages (swank &c.)
What's the best way of repairing this?
submitted by emacsomancer to lisp [link] [comments]


2020.08.13 00:20 jamJam20 generated-autoload-file error: file-missing "Cannot open load file"

Hay everyone, I have the following code in my init to generate autoloads. However it stopped working and I'm not sure why?
 (defun t-generate-autoload-define (loaddef &rest DIRS) (let ((generated-autoload-file loaddef)) (when (not (file-exists-p loaddef)) (with-current-buffer (find-file-noselect generated-autoload-file) (insert ";; generated by function: `t-generate-autoload-define'.") (save-buffer))) (apply 'update-directory-autoloads DIRS))) (defun t-reload-core-autoloads () "Reload autoload function from `core/lib' and save in `t-autoload-file'." (interactive) (when (file-exists-p t-autoload-file) (delete-file t-autoload-file t) (message "delete old autoload file: %s" t-autoload-file)) (t-generate-autoload-define t-autoload-file (concat t-emacs-dir "config/core/lib/")) (load t-autoload-file nil 'nomessage) (message "reload core autoload file: %s done." t-autoload-file)) (defun t-load-core-autoload () (when (not (file-exists-p t-autoload-file)) (t-generate-autoload-define t-autoload-file (concat t-emacs-dir "config/core/lib/")) (byte-compile-file t-autoload-file) (message "generate autoload file: %s done." t-autoload-file)) (load t-autoload-file nil 'nomessage)) (add-hook 'after-init-hook #'t-load-core-autoload) 
It generates okay
 ;; generated by function: `t-generate-autoload-define'. ;;;### (autoloads nil "../config/core/lib/lib-debug" "../config/core/lib/lib-debug.el" ;;;;;; (0 0 0 0)) ;;; Generated autoloads from ../config/core/lib/lib-debug.el 
but when I open emacs I get
Debugger entered--Lisp error: (file-missing "Cannot open load file" "No such file or directory" "../config/core/lib/lib-debug.el") 
submitted by jamJam20 to emacs [link] [comments]


2020.07.23 00:38 jherrlin Permissions on file from code block with :file header argument

Looking for a way to set execute permission on a file that comes from source code block result.
Guess some substitute for :tangle-mode but for a :file .
This tangles a file with execute permissions. #+BEGIN_SRC shell :tangle /tmp/tangled-script.sh :tangle-mode (identity #o755) #!/bin/bash echo Hello World #+END_SRC This writes a file to tmp with 644 permissions that I can change. #+BEGIN_SRC shell :results file :file script-results.sh :output-dir /tmp echo "#!/bin/bash" echo "echo Hello World" #+END_SRC I am looking for something like this. After writing the file to the file system, change permissions with a header argument. #+BEGIN_SRC shell :results file :file script-results.sh :output-dir /tmp :file-mode (identity #o755) echo "#!/bin/bash" echo "echo Hello World" #+END_SRC 
In =./lisp/ob-core.el:636:(defun org-babel-execute-src-block (&optional arg info params)= I find the place where writing to the file system happens when a source block have :file header argument. But from what I understand it doesn't support file permissions changes. Are there any workaround or other way to accomplish this?
submitted by jherrlin to orgmode [link] [comments]


2020.06.25 12:49 yousufinternet magit is not available in package-install

I have to warn everyone that I am a beginner (and not a native English speaker) so it might just be a silly issue, I also tried searching but can't find a working solution.
I have magit installed, but yesterday after upgrading some packages (I use arch BTW, but not sure if emacs was upgraded or not) I started getting this in the warnings buffer:
Error (use-package): Cannot load magit 
I ran package-refresh-contents repositories done refreshing, then I ran : (I use evil BTW) package-install RET magit but magit is not available in the repos, I only get magithub and few other suggestions.
This is how I load magit:
(use-package magit :ensure t) 
and this is my package-archives variable in init.el:
(setq package-archives '(("org" . "http://orgmode.org/elpa/") ("gnu" . "http://elpa.gnu.org/packages/") ("melpa" . "https://melpa.org/packages/") ("marmalade" . "http://marmalade-repo.org/packages/"))) 
Also, emacs --debug-init output:
Debugger entered--Lisp error: (invalid-read-syntax ")") read(#) eval-buffer(# nil "/home/yusuf/.emacs.d/elpa/imenu-list-20190115.2130/imenu-list-autoloads.el" nil t) ; Reading at buffer position 901 load-with-code-conversion("/home/yusuf/.emacs.d/elpa/imenu-list-20190115.2130/imenu-list-autoloads.el" "/home/yusuf/.emacs.d/elpa/imenu-list-20190115.2130/imenu-list-autoloads.el" nil t) load("/home/yusuf/.emacs.d/elpa/imenu-list-20190115.2130/imenu-list-autoloads" nil t) package--activate-autoloads-and-load-path(#s(package-desc :name imenu-list :version (20190115 2130) :summary "Show imenu entries in a separate buffer" :reqs ((cl-lib (0 5))) :kind nil :archive nil :dir "/home/yusuf/.emacs.d/elpa/imenu-list-20190115.2130" :extras ((:url . "https://github.com/bmag/imenu-list") (:maintainer "Bar Magal (2015)") (:authors ("Bar Magal (2015)")) (:commit . "46008738f8fef578a763c308cf6695e5b4d4aa77")) :signed nil)) package--load-files-for-activation(#s(package-desc :name imenu-list :version (20190115 2130) :summary "Show imenu entries in a separate buffer" :reqs ((cl-lib (0 5))) :kind nil :archive nil :dir "/home/yusuf/.emacs.d/elpa/imenu-list-20190115.2130" :extras ((:url . "https://github.com/bmag/imenu-list") (:maintainer "Bar Magal (2015)") (:authors ("Bar Magal (2015)")) (:commit . "46008738f8fef578a763c308cf6695e5b4d4aa77")) :signed nil) nil) package-activate-1(#s(package-desc :name imenu-list :version (20190115 2130) :summary "Show imenu entries in a separate buffer" :reqs ((cl-lib (0 5))) :kind nil :archive nil :dir "/home/yusuf/.emacs.d/elpa/imenu-list-20190115.2130" :extras ((:url . "https://github.com/bmag/imenu-list") (:maintainer "Bar Magal (2015)") (:authors ("Bar Magal (2015)")) (:commit . "46008738f8fef578a763c308cf6695e5b4d4aa77")) :signed nil) nil deps) package-activate(imenu-list) package-initialize() eval-buffer(# nil "/home/yusuf/.emacs.d/init.el" nil t) ; Reading at buffer position 1104 load-with-code-conversion("/home/yusuf/.emacs.d/init.el" "/home/yusuf/.emacs.d/init.el" t t) load("/home/yusuf/.emacs.d/init" t t) #f(compiled-function () #)() command-line() normal-top-level() 
I think it is saying that there is something wrong with imenu-list but I don't know what it is or how to fix it.
Help is appreciated
submitted by yousufinternet to emacs [link] [comments]


2020.06.16 00:22 Maggyero A review of Concepts and Confusions of Prefix, Infix, Postfix and Lisp Notations

Here is my review of u/xah’s interesting Concepts and Confusions of Prefix, Infix, Postfix and Lisp Notations article.
In it he states that the functional and Lisp notations are not prefix notations:
There is a wide misunderstanding that this notation being “prefix notation”. In this article, i'll give some general overview of the meanings of Algebraic Notation and prefix, infix, postfix notations, and explain how LISP notation is a Functional Notation and calling it “prefix notation” is misleading and misconception at a fundamental level.
It seems to me incorrect because in these notations, operators are still written before their operands. They just happen to use a different application operator than SPACE or AT @ (which are non-delimiting): they use the opening and closing PARENTHESES () (which are delimiting, and thus create explicit nested structures and therefore readability issues). In other words, the application operator is orthogonal to the position of applied operators which determines if the notation is prefix, postfix or infix:
Prefix notation
f(g(x,y),h(z)) (functional notation) f [g x,y],[h z] f @ [g @ x,y],[h @ z] (Mathematica-like prefix notation)
Postfix notation
((x,y)g,(z)h)f [x,y g],[z h] f [x,y @ g],[z @ h] @ f (Mathematica-like and Bash-like postfix notation)
Infix notation
[x(g)y](f)[(h)z] [x g y] f [h z] NOT APPLICABLE
Note. — The opening and closing BRACKETS [] subexpression delimiter and the COMMA , operand separator above are not applied operators like f, g and h.
We can notice that if the language allows variadic operators (operators that accept a varying number of operands), using a non-delimiting application operator (SPACE or AT @) above compels us to use subexpression delimiters (opening and closing BRACKETS []), unless the applied operators are unary (that is actually the restriction imposed by the AT @ prefix notation and the double SLASHES // postfix notation in Mathematica, as well as the PIPE postfix notation in Bash). So to get a readability benefit (implicit nested structure) when using a non-delimiting application operator, we should transform the applied operators to unary operators. For instance, in prefix notation:
f @ [g @ x,y],[h @ z]
should be transformed to:
u -> f(u, h(z)) @ v -> g(v, y) @ x
In postfix notation:
[x,y @ g],[z @ h] @ f
should be transformed to:
x @ v -> g(v, y) @ u -> f(u, h(z))
Now that we have made a distinction between the application operator and applied operators, we can further notice that while the applied operators above are used in prefix, postfix and infix notations, the application operator is used in infix notation in every case. We could imagine an application operator used in prefix or postfix notation too (the SPACE application operator is omitted here since non-infix SPACE application operators are impractical):
Prefix notation (prefix applied operators, prefix application operator)
(f (g x,y),(h z)) (Lisp-like notation) @ f [@ g x,y],[@ h z]
Prefix notation (prefix applied operators, postfix application operator)
(f (g x,y),(h z)) (Lisp-like notation) f [g x,y @],[h z @] @
Postfix notation (postfix applied operators, prefix application operator)
((x,y g),(z h) f) @ [@ x,y g],[@ z h] f
Postfix notation (postfix applied operators, postfix application operator)
((x,y g),(z h) f) [x,y g @],[z h @] f @
Infix notation (infix applied operators, prefix application operator)
((x g y) f (z h)) @ [@ x g y] f [@ z h]
Infix notation (infix applied operators, postfix application operator)
((x g y) f (z h)) [x g y @] f [z h @] @
So while I agree with the consequence given in the article, which is that the functional and Lisp notations create explicit nested structures and therefore harm readability, I disagree with the cause given in the article, which is that the functional and Lisp notations are not prefix notations. To me they also are prefix notations and the real cause of these explicit nested structures is that the functional and Lisp notations use a delimiting application operator (opening and closing PARENTHESES ()), as opposed to a non-delimiting application operator (such as SPACE, AT @ or double SLASHES // in Mathematica and PIPE in Bash). But that delimiting is actually necessary (except for unary operators, like illustrated by Mathematica and Bash) and not specific to the functional or Lisp notations, since most languages allow variadic operators (operators that accept a varying number of operands).
submitted by Maggyero to compsci [link] [comments]


2020.06.15 22:52 Skeleton237 Org mode init file problems

I am new to org mode, and I was trying to create a org file with my emacs configuration and use org-babel-load-file in my init.el to load it into emacs.
My init file only has: (org-babel-load-file "~/emacs.d/settings.org"), and it loads my configuration, but when I open emacs using -debug-init it gives me the following error:
Debugger entered--Lisp error: (void-function org-dynamic-block-define) (org-dynamic-block-define "columnview" (function org-columns-insert-dblock)) (progn (org-dynamic-block-define "columnview" (function org-columns-insert-dblock))) (lambda nil (progn (org-dynamic-block-define "columnview" (function org-columns-insert-dblock))))() eval-after-load(org (lambda nil (progn (org-dynamic-block-define "columnview" (function org-columns-insert-dblock))))) eval-buffer(# nil "/home/renqa.emacs.d/elpa/org-20200615/org-autoloads.el" nil t) ; Reading at buffer position 43203 load-with-code-conversion("/home/renqa.emacs.d/elpa/org-20200615/org-autoloads.el" "/home/renqa.emacs.d/elpa/org-20200615/org-autoloads.el" nil t) load("/home/renqa.emacs.d/elpa/org-20200615/org-autoloads" nil t) package--activate-autoloads-and-load-path(#s(package-desc :name org :version (20200615) :summary "Outline-based notes management and organizer" :reqs nil :kind nil :archive nil :dir "/home/renqa.emacs.d/elpa/org-20200615" :extras nil :signed nil)) package--load-files-for-activation(#s(package-desc :name org :version (20200615) :summary "Outline-based notes management and organizer" :reqs nil :kind nil :archive nil :dir "/home/renqa.emacs.d/elpa/org-20200615" :extras nil :signed nil) nil) package-activate-1(#s(package-desc :name org :version (20200615) :summary "Outline-based notes management and organizer" :reqs nil :kind nil :archive nil :dir "/home/renqa.emacs.d/elpa/org-20200615" :extras nil :signed nil) nil deps) package-activate(org) package-initialize() eval-buffer(# nil "/home/renqa.emacs.d/settings.el" nil t) ; Reading at buffer position 21 load-with-code-conversion("/home/renqa.emacs.d/settings.el" "/home/renqa.emacs.d/settings.el" nil nil) load("/home/renqa.emacs.d/settings.el" nil nil t) load-file("/home/renqa.emacs.d/settings.el") org-babel-load-file("~/.emacs.d/settings.org") eval-buffer(# nil "/home/renqa.emacs.d/init.el" nil t) ; Reading at buffer position 48 load-with-code-conversion("/home/renqa.emacs.d/init.el" "/home/renqa.emacs.d/init.el" t t) load("/home/renqa.emacs.d/init" t t) #f(compiled-function () #)() command-line() normal-top-level() 
Besides this, if I get the settings.el created when i open emacs, rename it to init.el and open emacs again, it works fine with no erros on debug.

EDIT: I got it to work by putting require-package and package-initialize in the init.el, thanks for everyone's response!
submitted by Skeleton237 to emacs [link] [comments]


2020.06.12 19:23 Imagi007 How does TAB completion work in emacs (elisp question)

Apologies in advance for the long question, but I could not figure out how to explain my issue succinctly (English not my native language).
How does this code work? I could only understand parts of it as described below:
(defun load-library (library) "Load the Emacs Lisp library named LIBRARY. LIBRARY should be a string. This is an interface to the function `load'. LIBRARY is searched for in `load-path', both with and without `load-suffixes' (as well as `load-file-rep-suffixes'). See Info node `(emacs)Lisp Libraries' for more details. See `load-file' for a different interface to `load'." (interactive (let (completion-ignored-extensions) (list (completing-read "Load library: " (apply-partially 'locate-file-completion-table load-path (get-load-suffixes)))))) (load library)) 
I mean I understand most of it, except for this specific part:
(completing-read "Load library: " (apply-partially 'locate-file-completion-table load-path (get-load-suffixes)) 
I know that completing-read will display the "Load library: " prompt and whatever I type will be returned as a string for the argument 'library' for the load-library function.
At the same time, this part ...
(apply-partially 'locate-file-completion-table load-path (get-load-suffixes)) 
... creates a partial function that should be able to do the completion itself (as per documentation for completing-read function).
But at this point, my understanding falls apart, and I don't know HOW does this partial function do the completion itself?? I believe this partial function gets called somehow when I press TAB after typing a few characters for the library name. But I don't understand what exactly is happening here. The documentation for locate-file-completion-table shows:
(locate-file-completion-table DIRS SUFFIXES STRING PRED ACTION) 
So that means the partial function still needs the three arguments STRING, PRED, ACTION. How does it get those arguments once I press TAB??
Any explanation or pointers is very much appreciated.
submitted by Imagi007 to emacs [link] [comments]


2020.06.11 16:00 vp275 Unable to run Emacs - Help

Hi guys,
I wanted to install 'Doom-emacs' on my ubuntu system. However, after installing the doom part, the program would only load vanilla emacs. So I deleted emacs from my system.
Now I'm not able to install emacs no matter what I try.
I get the following error when I try to run 'emacs' through terminal:
Warning: arch-independent data dir '/usshare/emacs/26.3/etc/': No such file or directory Warning: Lisp directory '/usshare/emacs/26.3/lisp': No such file or directory Error: charsets directory not found: /usshare/emacs/26.3/etc/charsets Emacs will not function correctly without the character map files. Please check your installation! 
The emacs icon is still present in the app list, but doesn't load anything.
How do I install plain emacs on my system?
OS: Ubuntu 20.04 LTS
Update: Resolved the issue by uninstalling emacs from Ubuntu Store and reinstalling it.
submitted by vp275 to emacs [link] [comments]


2020.06.02 02:14 negativeoilprice [NEWS] * lisp/progmodes/project.el (project-vc-dir, project-shell): New comm…

[NEWS] * lisp/progmodes/project.el (project-vc-dir, project-shell): New comm… submitted by negativeoilprice to planetemacs [link] [comments]


2020.05.14 21:52 SquidLord [Dev] Dynamic Templating and the Uses Thereof

From the Discord, a discussion about templating.

SquidLordToday at 3:30 PM

You know -- maybe the whole possibility of a parsing language should be a plug-in, then we just need API hooks to connect to your choice of Python, Lua, Prolog, Lisp, or JavaScript. 📷📷

Sam BaronToday at 3:31 PM

Ah, that would be nice📷

SquidLordToday at 3:31 PM

I'm just imagining some of the wonderfully unholy mash-up possibilities.***[3:32 PM]***Hmmm. Wouldn't even be hard, just the addition of a very basic bit of non-standard template markup.📷

Sam BaronToday at 3:38 PM

Hmmm. Wouldn't even be hard, just the addition of a very basic bit of non-standard template markup.
u/SquidLord In the markdown files or in the UI component?📷

SquidLordToday at 3:39 PM

In the Markdown files themselves. Just like any web template system. Editable, human readable text intended to be a significator to the system to do something on render.📷

Sam BaronToday at 3:40 PM

Ah yes, there's been several spirited discussions about enhancing markdown files. I'm all for it although isn't that what html is for?📷

SquidLordToday at 3:40 PM

Nope, that's what template languages are for, expressing things not intended for the HTML-level renderer.***[3:41 PM]***For example, let's say I wanted to include a list of all files in a given directory as a set of links. And I'm just making this syntax up off the top of my head: <: list titles= :>📷

Sam BaronToday at 3:43 PM

Ah sure, so for complex views, not necessarily single notes***[3:43 PM]***I wasn't following, but I am now📷

SquidLordToday at 3:44 PM

No, that could be the sum total of a single note. Or it might have other text around it:

My Journal Stuff

<: list titles= :>

Footnotes:

<: list :>
submitted by SquidLord to ObsidianMD [link] [comments]


2020.04.26 17:14 swnjyx From Go to Multiplayer and Beyond: A Journey in Game Design

From Go to Multiplayer and Beyond: A Journey in Game Design
Long post warning...
TL;DR: Game design can be full of twists and turns and if you’re designing a game based on a classic, at some point you’ll have to choose between the classic and the new. That won’t be an easy choice!
Off we go...
In late 2013 I was struck with a strange obsession. I’d been running a startup company for nearly 6 years already. Earlier that year we’d raised some significant funding and things were going really well, but it was an incredibly challenging time. Managing growth, funding, and the team are all good things, but the pressure was still intense.
Whether it was a reaction to this pressure cooker or some other outside influence, I started to try to solve a different problem during my rare free time: how would you make a game of Go multiplayer? Doing so started as an interesting abstract thought experiment but it also seemed like a gateway to make it a tabletop favorite for more people. There had been quite a few attempts in the past (like Multicolor Go, RenGo/PairGo, TriPlan (In German) and a range of others). There are also a whole range of Go variants and even blends of Chess and Go, but none of these seemed very satisfying and hadn’t gotten much traction.
Throughout the startup time, I regularly came back to my original challenge of Multiplayer Go and started to indoctrinate some friends in play-testing, experimenting, and theorizing! The second goal of accessibility definitely seemed worthwhile: how to make the resulting game more accessible to casual players than Go can be?
Friends a colleagues helped tested the game on random game nights over a period of several years and two of them became regular contributors to it which created another source of motivation to keep going back to it.
Working on and off on the game provided a great outlet at times over the past few years and it’s a testament to how having a side obsession can be a help through challenging times! Taking a break from work is one thing, but when things are on fire “taking a rest” is hard. Having a set of hard problems to think about, design choices to make or things to test is another level of immersive. In many ways, the game design process turned out to be almost as hard as the company building process!
I decided to write this now because as improbable as it would have seemed to us way back at the beginning, the game design journey kept going! This week we actually just crossed the Kickstarter funding line for the game Mitropia which is the outcome of all this design. While this isn’t the end of the journey it feels like a significant milestone at least!
This post isn’t about the campaign no more to come on that topic, but hopefully the content will be interesting and encourage a few more people to jump into game design (and keep going at it!).

Why Go?

I was first introduced to Go in the late 90s whilst working on a Master’s thesis in AI (admitting to some age there - AI was already a thing back then!). The result of the work was an AI Go system that used Adversarial planning and could play out and win many of the problems in the first few books of the famous Beginner Go Problems series.
At the time computers were woeful at playing go and Gobi was pretty good for its time (some of the original papers are still online like this one). Compared to today’s Go programs and especially Alpha Go, of course, this now looks like a set of cave paintings (a set of cave paintings in Lisp at least!).
In any case, one of the great things about the period was learning the game of Go itself with friends working on other subjects, some of which spent many hours playing and learning (shout out to Neil especially if you are out there!).
I never became a very strong player but really enjoyed playing and the interplay between strategy and tactics in the came is rare and fascinating.

Attempting Multiplayer Go

The powerful thing about Go is that the rules really are very simple, yet they lead to endless complexity and interaction on the board. In essence, Go boils down to:
  • Placing pieces (called stones) on the board turn by turn (always on the intersections of grid lines).
  • The concept of liberties which are “free spaces” next to played stones and the fact at stone or group of stones which has its last liberty taken is “surrounded” and captured.
  • Not being allowed to place a stone somewhere where it would already have no liberties.
  • Scoring based on the number of the board locations occupied or surrounded.
There are a few other rules such as what happens when moves might repeat (they cannot replicate the same board state), but that is essentially everything. Strategically the game is about the growing (and later cementing) influence over the board. Tactically it is about understanding the interplay between groups of stones on the board.
Our first attempt at multiplayer Go was almost laughably simple and huge. The boards were large and small grids drawn on paper and stones were Go stones colored with Sharpie Ink. (Pro tip: grind the sharpie interior up, put it in water and marinade the Go stones!). There were even gold and silver player stones (with the minor downside that you got to take some of the gold and silver home on your hands!).

A giant Go board with lots of multicolored stones - what could go wrong?!
The big games took several hours to complete (and the first one in fact didn't complete). The core rules remained though. Captures, liberties, placement rules, and so forth were all part of the game. What was added were rules for group captures when the stones of multiple players touched the same group. There was also a complex alliance system to allow for players to align (and not have their own stones kill each other) which we later dropped again.

Smaller boards, cards and lighter components

One of the biggest challenges of the initial games (apart from their epic length!) was that it did not really address the accessible and easy on-ramp criteria we were aiming for. Skilled Go players still had a significant advantage over other players. This could partly be dealt with by the use of handicap stones as Go itself does. This worked by giving less familiar players a “head start” on the board. Still, this left the problem of a large board being so daunting to play one and once a strong player got in a good position they could rip through defenses with ease.
We had also realized that obtaining large quantities of Go stones and coloring them would be very difficult. They also weighed a considerable amount.
As a result, we made a printed prototype that had a smaller board, light plastic marker token, a set of dice to determine how “far” a player could move on their turn, and a set of cards that allowed special moves such as playing two pieces together at once.

Smaller boards and lighter pieces solved some problems.
The cards and dice essentially added two forms of randomness to the game: controlling how far people could move and allowing for surprise moves. Both of these were a nod to leveling the playing field for less-skilled players. Sometimes an unusual move could very much derail a careful attack.
Of these innovations, the cards turned out to be a great idea, and the dice a terrible idea. The cards created a hidden information element that added a new edge to the game without disturbing the underlying mechanics . The dice, however, slowed down gameplay and more often than not created frustration. When a player had looked forward to making a key move all turn and the rolled low, that “table-flipping” look flashed in their eyes! The dice got cut; the cards stayed and evolved significantly.
There was also another piece of folly in this early prototype. Seeing people hesitate on their turns, we decided to add a 1 minute hourglass sand timer to the box. Flipping it set the clock running down to make a move. However, it was immediately obvious that this would not work. Instead of giving people a minute, whenever the timer was flipped the next person got simply what the person before had let run through the timer. This created its own dynamic: move very quickly so the next person has no time… pretty quickly someone has zero seconds to move in…
This should have been obvious immediately, the only way to do this is to either use a digital timer which resets to zero or give everyone their own sand timer. Suffice it to say, the timer did not make it in the next round of prototypes.

Enter Hexes and Pattern Cards...

The game was fun to play but still felt abstract and complex to get into. At this point, several insights came together:
  • New players found it confusing to play on intersections rather than inside the squares of the grid board.
  • The dice didn’t work well in restricting moves, but no restrictions left people lost in a sea of options.
  • Go rules actually work well on boards that are not the classic grid shape.
Looking back, this was perhaps the most important mindset shift of the design process. We let go of the idea of trying to “create a multiplayer version of Go” and shifted to “building a strategy game which is fun to play and uses the underlying mechanism of Go”.
This might seem like a narrow distinction, but it actually completely changed our approach to game design and opened up a whole host of new options! I’ll be the first to admit that it was a hard shift for me especially since I’d been the one who was most invested in the multiplayer Go idea and still had all the preconceptions that came with it. The end result was very liberating, however, and we immediately started talking about adding themes, other mechanisms, and also other board structures.
The two biggest changes happened very quickly. The first was to change from a drawn grid-based structure to one based on hexagons(!) and the second was to have players play into the center of the hexagons, not on the intersections (!!).
From a Go perspective, this is sacrilege! But it turns out though that the logic of Go can just as easily be played “in the squares” as it can on the intersections.
The shift to hexagons seems crazy as well, yet it is similarly easy to map to Go. A stone played away from the edge of the board now has 6 liberties rather than four, but everything else remains the same.
In fact, the difference is even smaller for groups. A group of 2 stones on a Go board has 6 liberties, on a hex board it is 8. A group of 3 stones on a Go board has 8 liberties, on a hex board it’s 10. In other words, the hex board only adds two extra liberties no matter how large a group is.
What the hex did, however, is that it made it much easier to dream up a randomly constructed board that looked like maps and had obstacles painted on the tiles. Hex boards could be easily constructed and turned out to be intuitive to play on.

Hexagons for Go, Paper pattern cards to restrict movement.
The first board was made using Memoir 44 tiles and allowed us to experiment with the size of tiles, obstacles and other objectives on the board.
The move to hexagons also allowed us to tie in with another big piece of the design puzzle: how to elegantly constrain movements on the board without using dice. This took the form of creating what we called “pattern” cards. These cards can be seen in paper form in the photo below. The concentric hexes which are marked in color represent legal moves from an “origin” stone which is any stone already placed on the board.

Movement pattern: any piece a player has on the board can form the anchor point in the center and all blue points are legal moves from there.
These patterns were inspired by the patterns in Onitama. A hand of cards allows the player to play different moves on different turns and adds randomness without dice (drawing from the card deck does this instead).
The key difference is that you know your hand for the entire turn and can plot your move. There is no dice roll to wait for before you can start thinking.
Of course, pattern cards could have been introduced without the hexagonal board shapes, but somehow the changes felt right together. Hexagonal pattern cards are a lot more interesting to look at than grids.
In retrospect this set of decisions feels natural now, but at the time it was an existential back and forth battle between the two design principles of the game: the purity of an abstract form of multiplayer Go and the need to find a way to make it more accessible. At times it felt like we might be making the wrong decision, but in the long run it definitely turned out to be the right one for us.

To theme or not to theme?

At the same time as debating the pros and cons of hex boards, a lengthy discussion raged around whether or not a story theme would benefit the game or distract from gameplay. At this point, we knew we had fun gameplay dynamics but it was neither a pure abstract came nor a thematic game. Would adding 5 distinct tribes add to the gameplay experience?
The tipping point came and we decided to just go for it and see if it worked. The early artwork led to a new prototype. It took time to really connect the tribes to gameplay in a meaningful way, and it’s been coming together over the past couple of years. The tribes certainly needed to have a role in the game. The first role was to have special moves and scoring patterns per tribe. As these evolved and the art-work evolved, each tribe started to gain its own personality. (More on this below.)

The first prototype with real artwork
This is also when we gave the game a new name (Mitropia) in order to separate it from Go. We hadn’t settle on a name before so this wasn’t a wrench but it did cement the decisions around themes, hexagonal boards and the other significant changes we’d pulled in.

GenCon, Spiel Essen + Highs and Lows

By 2019, the core mechanics had really come together, and Mitropia got its first large-scale public showing at GenCon and Spiel Essen, where the team did hundreds of playtests in just a few days (and many since!). The enthusiasm made it clear the game was worth launching, and the comments led to a wide range of refinements (detailed below).
The artwork came together for five tribes. I would recommend any game designer to try to make sketches of the artwork and work with some artists for sketches if you can. It’s so eye-opening to see a story to come to life. It generates new ideas for gameplay well beyond being just decorative. By the time we got to Spiel Essen in 2019, we knew we had a game which was fun and people enjoyed playing -- the huge number of playtests at the show confirmed this. It was amazing to see after a long journey. The core game seemed to be in a great place.
It wasn’t all sunshine and roses. We also realized we still had more work to do. Feedback from players and game-designers at the show highlighted some things that were confusing and the theme didn’t always come through as we’d hoped. More important, the experience players had was not always free-flowing. In some cases, it was hard for players to envisage the end-state and the feeling of the game remained too abstract. Thank you especially to Jakob Jaskov of Fog of Love here for some amazing insights!
This feedback led us to work hard and playtest a number of changes that are now already in or about to be added to the Kickstarter edition. Specific examples:
  1. A range of small adjustments like merging two card decks into one, removing an unnecessary setup phase early in the game, and more.
  2. A set of rules for short blitz games for two players (something we had not thought would be exciting to people before Spiel Essen).
  3. The addition of terrain types to the board which Tribes have different affinities for (and yield more points at the end of the game). This a stretch goal but we’ll certainly include a basic form of it in the game.
  4. Closer ties between the look and feel of the pieces and the tribes (this is one of the stretch goals).
There are also a number of other game modes in the stretch goals. It would have been hard to imagine these without the amazing feedback we’ve had over time. A testament to those who provided it -- thanks everyone!

Tabletopia and Tabletop Simulator

Being able to play games online is now even more useful given the various social distancing rules in place around the globe. However, it also turned out to be invaluable for us in game design. Changing a digital setup and trying new rules with new people is much easier in Tabletopia or Tabletop Simulator than waiting weeks for physical prototypes.
We started doing this in around 2016 with Tabletopia first and more recently with Tabletop Simulator. Without these test sessions we really could not have gotten enough early games in to feel like we were making progress.

One of the early Tabletopia test environments with dice still included....
Having physical prototypes really helps at events like GenCon and Spiel, but for quick iteration in your team, you can’t beat the online platforms!

Go Rules in Depth

I didn’t want to end this post without coming back around to the Go rules and how they are used. If you’re not familiar with Go you might want to skip this section.
Some of the decisions that need to be made in the making Multiplayer Go really include:
  • How do you determine group life and death?
  • What happens when groups are captured and more than one opponent is taking liberties?
  • Do Ko rules apply (Can repeated board states arise?).
  • Is it better to use Chinese or Japanese scoring? Does it matter?
  • Will people gang up on each other? Does that matter?
  • If you do have “special” moves, do they break Go rules?
  • Will Go strategy still apply?
Our solutions to the above problems explored a lot of options but in the end, we landed on a pretty simple set of rules:
  • All the basic Go rules apply (placing pieces, not moving them, liberties, life, and death, no suicide allowed).
  • Ko rules apply in theory (you cannot return the board to some previous state). However, in practice, these very very rarely occur in 3 or more player games (in fact one would need to explicitly engineer them even if they are possible).
  • When groups are captured the number of prisoners is shared evenly between all players who have at least one piece touching the group. If there is a piece left over it goes to the player playing the killing move. One could imagine variants here, but this is simple and intuitive.
  • We banned any move (special or otherwise) which took more than one liberty from an opponent group in a single move.
  • We also explicitly avoided any move which removed a piece from the board after it had been played. (there are special moves which “intercept” plays).
Together, these moves have proven pretty robust in allowing the underlying Go dynamics to remain intact. Life and Death still works in a similar way, eyes are still of value, creating two eyes still makes a group safe (baring stupid moved).
The area of most complexity was the scoring question. The most logical system to use would be Chinese style area scoring where the score for a player is determined by the number of stones that player has on the board added to the empty area surrounded by that player's stones. Prisoners are ignored. The utility of this is that players can play on at the end of the game in their own territory without reducing their score. We observed this often happened with players less familiar with Go.
On the other hand, Japanese scoring has the merit that prisoners feel meaningful. Again from a game experience, players, again and again, expressed the sense that they felt prisoners should be meaningful. Capturing something and not having it count was too “abstract”.
For a considerable time we oscillated between these different approaches and there seemed to be no good solution (and in the way there is not). Our ultimate solution was to violate the balance of go to some extent and combine scoring methods. In Mitropia, therefore, the final score is the sum of players’ alive stones on the board, the territory surrounded, and the prisoners held.
Doing this changes the balance of the game and creates an extra incentive for capturing pieces (since it often means getting prisoners and territory in one move). Ultimately this seemed a sacrifice worth making in order to keep the gameplay more intuitive.

Multiplayer Go?

So here comes the million dollar question: Did we succeed in creating a multiplayer Go? The answer to this is probably “no”, the game that evolved is not truly multiplayer Go.
Creating a truer form multiplayer Go is still a great endeavor and in fact there have been some recent attempts, but although we’ve stayed quite true to the Go underpinnings in Mitropia, the game has also gathered a range of other things which means it has strayed from this path.
But did we succeed in creating a fun strategy game that uses the underlying mechanics of Go? We think so! From all our playtests, it certainly stood out that Mitropia is more immediately accessible than Go is (especially for casual players), and it meets the requirement of being multiplayer. The themes and special moves have also added their own fun dynamics as well.
The balance we struck was more about keeping the core of the Go mechanics intact while adding a different play experience on top than trying to preserve the feeling of Go underneath. We’re hoping people really enjoy playing and that a few of them will also get introduced back to Go this way!
As pointed out in the comments to, there are also other games which have threads of Go and multiplayer Go in them in then (Through the Desert and Hacienda for example) and while they turned out differently, it's interesting to see the common mechanisms there.

If you're playing games and have an urge to design - give it a shot, and if you’re designing a game: Don’t stop!

This post ended up being a lot longer than intended! Still, hopefully, it’s an interesting insight into a game design journey that might inspire one or two others. We’re looking forward to getting Mitropia to people and then building more beyond that.
The game design journey has in many ways been as hard as building a company, with what feels like just as many hard decisions. It’s exciting to see the game funded and we’re working to unlock more stretch goals to truly get everything into the box that we want there!
So if you’ve been working on a game “forever”... don’t give up. When you look back it’ll probably be true that it’s given you a refuge from the world from time to time and, even better, there’s no reason why it might not one day see the light of day!
We’re deeply thankful to everyone who has contributed along the way. Thanks for reading!
Links:
submitted by swnjyx to boardgames [link] [comments]


2020.04.24 04:27 keepitsalty Running external program on many different threads?

I have a problem that I can't quite figure out. I'm porting one of my bash scripts over to common-lisp.
In my bash script, I find all the files in a directory matching a wildcard and then pass those paths into a program and parse the output. Since the external program is a little slow, I use gnu parallel to launch all these processes to speed things up.
My problem, is that I can't quite figure out why my code works for one case, but not all the cases.
I will show you my code and then an example of what I'm talking about:
(defparameter *file-dir* "~/Documents/projects/file-dir") (defparameter *file-assessment* (uiop:strcat *file-dir* "/assessment")) (defparameter *file-opt* (uiop:strcat *file-dir* "/file-opt")) ;; external software executable (defparameter *obj-db* nil) ;; database to store output (defun get-input-files (&optional (dir *file-assessment*)) (let (files) (cl-fad:walk-directory dir #'(lambda (x) (when (cl:pathname-match-p x #P"*.i") (push (namestring x) files))) :directories t) files)) (defun construct-command (inputfile) (uiop:strcat *file-opt* " -i " inputfile " --list-constructed-objects" " --no-gdb-backtrace")) ;; store input-file path and list of object (defun create-assessment (name objects) (list :name name :objects objects)) (defun add-assessment-to-db (assessment) (push assessment *obj-db*)) ;; closure to parse specific lines of output (defun make-pre-processor () (let ((proc-lines nil) (ret-str nil)) #'(lambda (str) (when proc-lines (setf ret-str str)) (when (string= str "**START OBJECT DATA**") (setf proc-lines t)) (when (string= str "**END OBJECT DATA**") (setf proc-lines nil) (setf ret-str nil)) ret-str))) ;; closure to pass into bt:make-thread ;; bt:make-thread needs a function with no arguments, ;; so a function with the correct command needs to be 'built-in' per se. (defun run-file-opt (input) `#'(lambda () (let* ((command (construct-command ,input)) (file-opt (uiop:launch-program command :output :stream)) (stream (uiop:process-info-output file-opt)) (is-line-object (make-pre-processor))) (loop for line = (read-line stream nil nil) while line when (funcall is-line-object line) collect it into objects finally (bt:with-lock-held (bt:make-lock) (add-assessment-to-db (create-assessment ,input objects))))))) ;; I end up with a list of about 200 input-files that I need to run through the program ;; and store in *obj-db* (defun update-object-database (lst) (loop for input-file in lst do (bt:make-thread (run-file-opt input-file) :name input-file))) ;; single test case (defparameter single-input (first (get-input-files)) (defparameter test-file-opt (run-file-opt single-input)) (bt:make-thread test-file-opt :name "test-file-opt") *obj-db* ;;; ((:NAME ;;; "~/Documents/projects/file-diassessment/input_01.i" ;;; :OBJECTS ;;; ("CSV" "CavityPressurePostprocessor" "CompositeFunction" ;;; "ComputeAxisymmetricRZFiniteStrain" "ComputeIsotropicElasticityTensor" ;;; "ComputeMultipleInelasticStress" "ComputeThermalExpansionEigenstrain"))) ;; Which works as expected, but now trying my update function (setf *obj-db* nil) (update-object-database (get-input-files)) *obj-db* ;; NIL 
Why would this work for one input-file, but when trying to loop across all input files, I doesn't do anything?
submitted by keepitsalty to lisp [link] [comments]


2020.04.14 17:48 Sewing31 org-mode use output of source block in other source block header

Is it possible to use the result of one source code block not within another code block but actually within another source blocks header argument? I know this piece of functinality
#+name: block-1 #+BEGIN_SRC emacs-lisp (current-time-string) #+END_SRC #+BEGIN_SRC emacs-lisp :var input=block-1 (format "We got %S in block-1" input) #+END_SRC 
but what I want is something like this, i.e. to reuse the result to e.g. form a path for the dir header argument

#+name: block-1 #+BEGIN_SRC emacs-lisp (current-time-string) #+END_SRC #+BEGIN_SRC emacs-lisp :var input=block-1 :dir path/input (format "We got %S in block-1" input) #+END_SRC 
submitted by Sewing31 to emacs [link] [comments]


2020.04.10 17:31 snicksn First elisp, print files in directories + string

For another project (typescript) I need name of all files in a directory, insert string before and after the name. I thought I would try (e)lisp for the first time. So far I have
(setq dir "/path/to/di") (setq files (directory-files dir)) 
which seems to work, it shows the filenames when I do C-M-x in emacs-lisp-mode. Then I try mapcar to add string before and after the filename, but getting nowhere with that. How can I add string before and after each filename?
Thanks
submitted by snicksn to emacs [link] [comments]


2020.03.10 03:51 xunius org-ctags failed to create TAGS

Hi all, I'm trying out the "org-ctags" functions and I noticed that it won't create the TAGS file when I run M-x org-ctags-create-tags or evaluate (org-ctags-create-tags "/path/to/my/org/folder").
I looked into the "org-ctags.el" definition and copied and pasted the relevant lines into scratch and tested it, it seems that the placement of the * char is giving me the issue. Specifically, if I run this command in my terminal:
ctags --langdef=orgmode --langmap=orgmode:.org --regex-orgmode="/<<([^>]+)>>/\1/d,definition/" -f /path/to/org/TAGS -e -R "/path/to/org/*" 
I got this error from ctags:
ctags: Warning: cannot open input file "/path/to/org/*" : No such file or directory 
If I instead put the * outside double quote:
ctags --langdef=orgmode --langmap=orgmode:.org --regex-orgmode="/<<([^>]+)>>/\1/d,definition/" -f /path/to/org/TAGS -e -R "/path/to/org/"* 
It runs successfully. So this implies that the elisp function in the above link should be changed to:
(shell-command (format (concat "%s --langdef=orgmode --langmap=orgmode:.org " "--regex-orgmode=\"%s\" -f \"%s\" -e -R \"%s\"*") org-ctags-path-to-ctags org-ctags-tag-regexp (expand-file-name (concat dir-name "/TAGS")) (expand-file-name (concat dir-name "/"))))) 
I'm not entirely sure it is my shell or what, I tried both bash and sh and both behaved like that. I also pasted that shell command to shellcheck which didn't report any issue regarding the placement of the wild card char * inside or outside double quotes. So, is this a bug of "org-ctags"?
PS My org-ctags-path-to-ctags is the default value ctags, and the ctags --version is:
Universal Ctags 0.0.0(3fdf28bc), Copyright (C) 2015 Universal Ctags Team Universal Ctags is derived from Exuberant Ctags. Exuberant Ctags 5.8, Copyright (C) 1996-2009 Darren Hiebert Compiled: May 22 2019, 21:51:22 URL: https://ctags.io/ Optional compiled features: +wildcards, +regex, +iconv, +option-directory, +xpath, +json, +interactive, +sandbox, +yaml, +packcc 
submitted by xunius to emacs [link] [comments]


2020.02.23 16:50 pauljewell Mixed installation of org-mode

Good afternoon!
I am working in a gentoo system, with emacs version 26.3-r1. I have used orgmode for some time, with a configuration file similar in content to that from Bernt Hansen. This version of emacs comes with org-mode 9.1.9. I had previously run with the git version of orgmode installed in my user directory tree, apparently without problems. Anyway, I have been working to update my configuration, but I am running into problems with mixed installation. What I have done is this:

(package-initialize) (add-to-list 'load-path (expand-file-name "~/git/org-mode/lisp")) (add-to-list 'load-path (expand-file-name "~/git/org-mode/contrib/lisp")) (add-to-list 'auto-mode-alist '("\\.\\(org\\org_archive\\txt\\)$" . org-mode)) (use-package org :ensure t) ;; Also tried (require 'org) with same result (defvar init-dir) ;; Initial directory for emacs configuration (setq init-dir (file-name-directory (or load-file-name (buffer-file-name)))) ;; Save emacs customisations in this file: (setq custom-file "~/.emacs.d/emacs-custom.el") (load custom-file) (org-babel-load-file (expand-file-name "emacs-init.org" user-emacs-directory)) 
This is to ensure org-mode is loaded directly from the git tree, and not from the built in directory under /usshare/emacs/26.3/lisp. I am getting errors on startup which are related to a mixed installation, despite my best efforts to avoid this as shown above.
I believe the init.el is the first configuration file loaded; I know I cannot do anything with org files before loading the correct org version.
Can any of you give me some hints what to try next? Note: the org-mode package is not loaded via the emacs package manager, nor via the Gentoo package manager.
Many thanks! Paul
submitted by pauljewell to orgmode [link] [comments]


2020.01.20 14:38 skouakskouek [Doom-Emacs] Can not make org-super-agenda work.

Hi, I'm a heavy user of org-mode, but a total beginner with Lisp.
Basically, I just copy and paste some piece of codes, and was lucky to had everything work so far. However, I am not able to make the org-super-agenda work.
After I run emacs, I type the org-super-agenda command, and it seems to be correctly enabled, but nothing happen after this.
What I tried:
Am I missing something?
Many thanks in advance for your help, and please find my config file below:
;;; .doom.d/config.el -*- lexical-binding: t; -*- ;; Place your private configuration here (setq user-full-name "John") (setq user-mail-address "[email protected]") (setq package-archives '(("gnu" . "http://elpa.gnu.org/packages/") ("org" . "http://orgmode.org/elpa/") ("melpa" . "http://melpa.org/packages/"))) (defun ht-daadvice-unadvice (sym) "Remove all advices from symbol SYM." (interactive "aFunction symbol: ") (advice-mapc (lambda (advice _props) (advice-remove sym advice)) sym)) (load-theme 'doom-spacegrey t) (after! org (use-package! org-expiry ; Created timestamps in task :config ;; Configure timestamp property (setq org-expiry-created-property-name "CREATED" ; Name of property when an item is created org-expiry-inactive-timestamps t ; Don't have everything in the agenda view ) (defun mrb/insert-created-timestamp() "Insert a CREATED property using org-expiry.el for TODO entries" (org-expiry-insert-created) (org-back-to-heading) (org-end-of-line) ) ;; Whenever a TODO entry is created, I want a timestamp ;; Advice org-insert-todo-heading to insert a created timestamp using org-expiry (defadvice org-insert-todo-heading (after mrb/created-timestamp-advice activate) "Insert a CREATED property using org-expiry.el for TODO entries" (mrb/insert-created-timestamp) ) ;; Make it active (ad-activate 'org-insert-todo-heading))) ; old fn ;(progn ; (setq org-expiry-inactive-timestamps 't) ; Inactive to prevent unintended inclusion in other filters ; (org-expiry-insinuate))) (after! org (setq org-todo-keyword-faces (quote (("TODO" :background "coral4" :foreground "coral1" :weight bold :box 1 ) ("NEXT" :background "SpringGreen4" :foreground "SpringGreen1" :weight bold :box 1) ("WAITING" :background "orange4" :foreground "orange1" :weight bold :box 1) ("HOLD" :background "LightGoldenrod4" :foreground "LightGoldenrod1" :weight bold :box 1) ; DONE keywords ("DONE" :background "PaleGreen4" :foreground "PaleGreen1" :weight bold :box 1) ("CANCELLED" :background "PaleGreen4" :foreground "PaleGreen1" :weight bold :box 1) ("DELEGATED" :background "PaleGreen4" :foreground "PaleGreen1" :weight bold :box 1) ("PREP" :background "coral4" :foreground "coral1" :weight bold :box 1) ("MEETING" :background "SteelBlue4" :foreground "SteelBlue1" :weight bold :box 1) ("PHONE" :background "SteelBlue4" :foreground "SteelBlue1" :weight bold :box 1))))) (add-hook 'doom-init-ui-hook #'doom-init-theme-h) (remove-hook 'after-make-frame-functions #'doom-init-theme-h) (setq frame-title-format "%b λI") (add-to-list 'default-frame-alist '(font . "SF Mono 11")) (setq +doom-dashboard-name "λI:home") (setq +doom-dashboard-banner-dir "~/../other") (setq +doom-dashboard-banner-file "ai-splash-small.png") ;; remove footer & 'loaded' information (setq +doom-dashboard-functions '(doom-dashboard-widget-banner doom-dashboard-widget-shortmenu)) (let ((org-super-agenda-groups '(;; Each group has an implicit boolean OR operator between its selectors. (:name "Today" ; Optionally specify section name :time-grid t ; Items that appear on the time grid :todo "WAITING") ; Items that have this TODO keyword (:name "Important" ;; Single arguments given alone :tag "bills" :priority "A") ;; Set order of multiple groups at once (:order-multi (2 (:name "Shopping in town" ;; Boolean AND group matches items that match all subgroups :and (:tag "shopping" :tag "@town")) (:name "Food-related" ;; Multiple args given in list with implicit OR :tag ("food" "dinner")) (:name "Personal" :habit t :tag "personal") (:name "Space-related (non-moon-or-planet-related)" ;; Regexps match case-insensitively on the entire entry :and (:regexp ("space" "NASA") ;; Boolean NOT also has implicit OR between selectors :not (:regexp "moon" :tag "planet"))))) ;; Groups supply their own section names when none are given (:todo "WAITING" :order 8) ; Set order of this section (:todo ("SOMEDAY" "TO-READ" "CHECK" "TO-WATCH" "WATCHING") ;; Show this group at the end of the agenda (since it has the ;; highest number). If you specified this group last, items ;; with these todo keywords that e.g. have priority A would be ;; displayed in that group instead, because items are grouped ;; out in the order the groups are listed. :order 9) (:priority<= "B" ;; Show this section after "Today" and "Important", because ;; their order is unspecified, defaulting to 0. Sections ;; are displayed lowest-number-first. :order 1) ;; After the last group, the agenda will display items that didn't ;; match any of these groups, with the default order position of 99 ))) (org-agenda nil "a")) (after! org (use-package! org-expiry ; Created timestamps in task :config ;; Configure timestamp property (setq org-expiry-created-property-name "CREATED" ; Name of property when an item is created org-expiry-inactive-timestamps t ; Don't have everything in the agenda view ) (defun mrb/insert-created-timestamp() "Insert a CREATED property using org-expiry.el for TODO entries" (org-expiry-insert-created) (org-back-to-heading) (org-end-of-line) ) ;; Whenever a TODO entry is created, I want a timestamp ;; Advice org-insert-todo-heading to insert a created timestamp using org-expiry (defadvice org-insert-todo-heading (after mrb/created-timestamp-advice activate) "Insert a CREATED property using org-expiry.el for TODO entries" (mrb/insert-created-timestamp) ) ;; Make it active (ad-activate 'org-insert-todo-heading))) ; old fn ;(progn ; (setq org-expiry-inactive-timestamps 't) ; Inactive to prevent unintended inclusion in other filters ; (org-expiry-insinuate))) 
submitted by skouakskouek to orgmode [link] [comments]


2019.12.18 04:34 ckoneru counsel-locate does not work with regex or fuzzy match.

I was trying to implement counsel-locate but I cannot get it to work like in the article https://oremacs.com/2015/07/02/counsel-locate/ .
Say I want locate org files in a directory called github. According to the article I can query github org$ to achieve that but this does not give me any results. I do get results of all the org files in the computer if i query org though, but I want to filter the results down.
Do I have to configure some sort of code to achieve this?
Update - Work around for Mac OS as locate command in BSD/Mac does not support regex.
Thanks to @ u/walseb package I am able to use locate with ellocate.
make sure you tweak the stack memory(max-lisp-eval-depth) substantially if you are running for a large directory(default seems to be 500)
(setq max-specpdl-size 1300000) (setq max-lisp-eval-depth 100000) (use-package ellocate :ensure t :config (setq ellocate-scan-dirs '(("~/" "~/ellocate-home-db"))) :commands (ellocate)) 

If anyone wants to use mdfind command with counsel please follow the instructions in - http://pragmaticemacs.com/emacs/super-spotlight-search-with-counsel/
submitted by ckoneru to emacs [link] [comments]


2019.11.18 19:17 Waffle2006 34 // The Lobster [Discussion]

34 // The Lobster [Discussion]
What is the A24 Marathon?
Discussion Archive
Released May 13, 2016. Runtime: 118 minutes.
  • Synopsis
    • In a dystopian society, single people must find a mate within 45 days or be transformed into an animal of their choice.
  • Cast
    • Colin Farrell as David
    • Rachel Weisz as Shortsighted Woman
    • Léa Seydoux as Loner Leader
    • Ariane Labed as the Maid
    • Ben Whishaw as Limping Man
    • Angeliki Papoulia as Heartless Woman
    • John C. Reilly as Lisping Man
    • Olivia Colman as Hotel Manager
  • Crew
    • Yorgos Lanthimos (directoco-writer)
    • Efthimis Filippou (co-writer)
    • Thimios Bakatakis (cinematographer)
    • Yorgos Mavropsaridis (editor)
  • Where to Watch
    • Netflix
    • Kanopy (check if your university or library gives you access!)
    • Rent on Amazon Prime, iTunes, etc.

Feel free to use the comment thread below for discussion, and/or join our Discord server. As always, BEWARE SPOILERS!
NEXT WEEK: De Palma dir. Noah Baumbach, Jake Paltrow
submitted by Waffle2006 to A24 [link] [comments]


2019.11.07 19:55 AliiiB2512 Error HectorSLAM on catkin_make command using RPLIDAR A2 on pi

For a robotic project i'm working on. We're building a rc car that is autonomous. so we're using ROS to manage all of it on a raspberryPi 3B+ with the RPLIDAR SDK and HECTOR SLAM.
the catkin_make command was successful for just the RPLIDAR and when cloning the hector slam into the same src folder, (src/hector_slam and src/rplidar_ros) when running catkin_make now that HECTOR_SLAM is introduced i get these errors and i'm not sure how to solve

catkin_make Base path: /home/bres/rplidar_ws Source space: /home/bres/rplidar_ws/src Build space: /home/bres/rplidar_ws/build Devel space: /home/bres/rplidar_ws/devel Install space: /home/bres/rplidar_ws/install #### #### Running command: "make cmake_check_build_system" in "/home/bres/rplidar_ws/build" #### #### #### Running command: "make -j4 -l4" in "/home/bres/rplidar_ws/build" #### [ 0%] Built target nav_msgs_generate_messages_nodejs [ 0%] Built target std_msgs_generate_messages_nodejs [ 0%] Built target _hector_nav_msgs_generate_messages_check_deps_GetRecoveryInfo [ 0%] Built target _hector_nav_msgs_generate_messages_check_deps_GetSearchPosition [ 0%] Built target _hector_nav_msgs_generate_messages_check_deps_GetNormal [ 0%] Built target _hector_nav_msgs_generate_messages_check_deps_GetDistanceToObstacle [ 0%] Built target nav_msgs_generate_messages_py [ 0%] Built target nav_msgs_generate_messages_lisp [ 0%] Built target std_msgs_generate_messages_py [ 0%] Built target std_msgs_generate_messages_lisp [ 0%] Built target _hector_nav_msgs_generate_messages_check_deps_GetRobotTrajectory [ 0%] Built target std_msgs_generate_messages_cpp [ 0%] Built target nav_msgs_generate_messages_cpp [ 0%] Built target nav_msgs_generate_messages_eus [ 0%] Built target std_msgs_generate_messages_eus [ 0%] Built target rosgraph_msgs_generate_messages_cpp [ 0%] Built target _catkin_empty_exported_target [ 0%] Built target actionlib_msgs_generate_messages_py [ 0%] Built target actionlib_msgs_generate_messages_eus [ 0%] Built target actionlib_msgs_generate_messages_lisp [ 0%] Built target geometry_msgs_generate_messages_cpp [ 0%] Built target actionlib_msgs_generate_messages_cpp [ 0%] Built target geometry_msgs_generate_messages_eus [ 0%] Built target actionlib_msgs_generate_messages_nodejs [ 0%] Built target geometry_msgs_generate_messages_lisp [ 0%] Built target geometry_msgs_generate_messages_nodejs [ 0%] Built target roscpp_generate_messages_py [ 0%] Built target geometry_msgs_generate_messages_py [ 0%] Built target roscpp_generate_messages_nodejs [ 0%] Built target roscpp_generate_messages_eus [ 0%] Built target rosgraph_msgs_generate_messages_eus [ 0%] Built target roscpp_generate_messages_cpp [ 0%] Built target rosgraph_msgs_generate_messages_lisp [ 0%] Built target rosgraph_msgs_generate_messages_nodejs [ 0%] Built target roscpp_generate_messages_lisp [ 0%] Built target rosgraph_msgs_generate_messages_py [ 1%] Building CXX object hector_slam/hector_compressed_map_transport/CMakeFiles/map_to_image_node.disrc/map_to_image_node.cpp.o [ 4%] Built target rplidarNodeClient [ 14%] Built target rplidarNode [ 17%] Built target imu_attitude_to_tf_node [ 17%] Built target visualization_msgs_generate_messages_eus [ 17%] Built target visualization_msgs_generate_messages_cpp [ 20%] Built target pose_and_orientation_to_imu_node [ 20%] Built target visualization_msgs_generate_messages_lisp [ 20%] Built target visualization_msgs_generate_messages_py [ 20%] Built target visualization_msgs_generate_messages_nodejs [ 20%] Built target sensor_msgs_generate_messages_eus [ 20%] Built target sensor_msgs_generate_messages_lisp [ 20%] Built target sensor_msgs_generate_messages_nodejs [ 20%] Built target sensor_msgs_generate_messages_cpp [ 20%] Built target sensor_msgs_generate_messages_py [ 20%] Built target tf_generate_messages_py [ 20%] Built target tf_generate_messages_cpp [ 20%] Built target actionlib_generate_messages_cpp [ 20%] Built target tf_generate_messages_eus [ 20%] Built target actionlib_generate_messages_eus [ 20%] Built target actionlib_generate_messages_lisp [ 20%] Built target actionlib_generate_messages_nodejs [ 20%] Built target tf_generate_messages_lisp [ 20%] Built target tf2_msgs_generate_messages_eus [ 20%] Built target tf_generate_messages_nodejs [ 20%] Built target tf2_msgs_generate_messages_nodejs [ 20%] Built target actionlib_generate_messages_py [ 20%] Built target tf2_msgs_generate_messages_lisp [ 20%] Built target tf2_msgs_generate_messages_py [ 20%] Built target tf2_msgs_generate_messages_cpp [ 20%] Built target _hector_mapping_generate_messages_check_deps_HectorDebugInfo [ 20%] Built target _hector_mapping_generate_messages_check_deps_HectorIterData [ 35%] Built target hector_nav_msgs_generate_messages_nodejs [ 35%] Built target hector_nav_msgs_generate_messages_py [ 42%] Built target hector_nav_msgs_generate_messages_lisp [ 50%] Built target hector_nav_msgs_generate_messages_cpp [ 58%] Built target hector_nav_msgs_generate_messages_eus [ 61%] Built target hector_mapping_generate_messages_cpp [ 65%] Built target hector_mapping_generate_messages_py [ 70%] Built target hector_mapping_generate_messages_eus [ 72%] Built target hector_mapping_generate_messages_lisp [ 75%] Built target hector_mapping_generate_messages_nodejs [ 75%] Built target hector_nav_msgs_generate_messages [ 77%] Building CXX object hector_slam/hector_trajectory_serveCMakeFiles/hector_trajectory_server.disrc/hector_trajectory_server.cpp.o [ 78%] Building CXX object hector_slam/hector_map_serveCMakeFiles/hector_map_server.disrc/hector_map_server.cpp.o [ 81%] Built target geotiff_writer [ 82%] Building CXX object hector_slam/hector_mapping/CMakeFiles/hector_mapping.disrc/HectorMappingRos.cpp.o virtual memory exhausted: Cannot allocate memory hector_slam/hector_map_serveCMakeFiles/hector_map_server.dibuild.make:62: recipe for target 'hector_slam/hector_map_serveCMakeFiles/hector_map_server.disrc/hector_map_server.cpp.o' failed make[2]: *** [hector_slam/hector_map_serveCMakeFiles/hector_map_server.disrc/hector_map_server.cpp.o] Error 1 CMakeFiles/Makefile2:3580: recipe for target 'hector_slam/hector_map_serveCMakeFiles/hector_map_server.diall' failed make[1]: *** [hector_slam/hector_map_serveCMakeFiles/hector_map_server.diall] Error 2 make[1]: *** Waiting for unfinished jobs.... c++: internal compiler error: Killed (program cc1plus) Please submit a full bug report, with preprocessed source if appropriate. See  for instructions. hector_slam/hector_mapping/CMakeFiles/hector_mapping.dibuild.make:62: recipe for target 'hector_slam/hector_mapping/CMakeFiles/hector_mapping.disrc/HectorMappingRos.cpp.o' failed make[2]: *** [hector_slam/hector_mapping/CMakeFiles/hector_mapping.disrc/HectorMappingRos.cpp.o] Error 4 make[2]: *** Waiting for unfinished jobs.... [ 84%] Building CXX object hector_slam/hector_mapping/CMakeFiles/hector_mapping.disrc/main.cpp.o c++: internal compiler error: Killed (program cc1plus) Please submit a full bug report, with preprocessed source if appropriate. See  for instructions. hector_slam/hector_trajectory_serveCMakeFiles/hector_trajectory_server.dibuild.make:62: recipe for target 'hector_slam/hector_trajectory_serveCMakeFiles/hector_trajectory_server.disrc/hector_trajectory_server.cpp.o' failed make[2]: *** [hector_slam/hector_trajectory_serveCMakeFiles/hector_trajectory_server.disrc/hector_trajectory_server.cpp.o] Error 4 CMakeFiles/Makefile2:3689: recipe for target 'hector_slam/hector_trajectory_serveCMakeFiles/hector_trajectory_server.diall' failed make[1]: *** [hector_slam/hector_trajectory_serveCMakeFiles/hector_trajectory_server.diall] Error 2 c++: internal compiler error: Killed (program cc1plus) Please submit a full bug report, with preprocessed source if appropriate. See  for instructions. hector_slam/hector_compressed_map_transport/CMakeFiles/map_to_image_node.dibuild.make:62: recipe for target 'hector_slam/hector_compressed_map_transport/CMakeFiles/map_to_image_node.disrc/map_to_image_node.cpp.o' failed make[2]: *** [hector_slam/hector_compressed_map_transport/CMakeFiles/map_to_image_node.disrc/map_to_image_node.cpp.o] Error 4 CMakeFiles/Makefile2:2767: recipe for target 'hector_slam/hector_compressed_map_transport/CMakeFiles/map_to_image_node.diall' failed make[1]: *** [hector_slam/hector_compressed_map_transport/CMakeFiles/map_to_image_node.diall] Error 2 c++: internal compiler error: Killed (program cc1plus) Please submit a full bug report, with preprocessed source if appropriate. See  for instructions. hector_slam/hector_mapping/CMakeFiles/hector_mapping.dibuild.make:86: recipe for target 'hector_slam/hector_mapping/CMakeFiles/hector_mapping.disrc/main.cpp.o' failed make[2]: *** [hector_slam/hector_mapping/CMakeFiles/hector_mapping.disrc/main.cpp.o] Error 4 CMakeFiles/Makefile2:3758: recipe for target 'hector_slam/hector_mapping/CMakeFiles/hector_mapping.diall' failed make[1]: *** [hector_slam/hector_mapping/CMakeFiles/hector_mapping.diall] Error 2 Makefile:140: recipe for target 'all' failed make: *** [all] Error 2 Invoking "make -j4 -l4" failed 
and quite confused as to what any of it means? or where to even start tackling
submitted by AliiiB2512 to ROS [link] [comments]


2019.11.02 04:43 arichiardi Starting sbcl REPL with current system

Hi there,
Coming from Clojure to learn Common Lisp, very newbie at the moment but went through the asdf/quicklisp intro.
Say I have a project with a subdir src and lisp files in it and a .asd file in the project root.
Is there a way for me to load sbcl with the system from the root .asd already loaded into memory?
I have been told load-asd does the magic but it requires an absolute path to the asd, so, for instance, I cannot really use truename unless I always launch sbcl from the project root.
Probably I am missing a better way though.
EDIT: I solved by adding the following to my .dir-locals.el:
((lisp-mode . ((eval . (setenv "CL_SOURCE_REGISTRY" (projectile-project-root))))))
Thank you for all the suggestions (especially qlot looks good!).
submitted by arichiardi to lisp [link] [comments]


AutoCAD Autolisp Collection - Setting Out in Land Survey Bigkaybeezy - YouTube Lisp - Recompiling a game as it runs - YouTube You Sshunk My Battlesship EARRAPE (lisp) - The Addams Family AutoCAD Autolisp Collection - Land Survey Utilities Basics of the Emacs file manager (dired == directory editor) Bulk Plotting Multiple Cross Section in AutoCAD (Quick ... YouTube

directories - How to check if a directory exists in elisp ...

  1. AutoCAD Autolisp Collection - Setting Out in Land Survey
  2. Bigkaybeezy - YouTube
  3. Lisp - Recompiling a game as it runs - YouTube
  4. You Sshunk My Battlesship EARRAPE (lisp) - The Addams Family
  5. AutoCAD Autolisp Collection - Land Survey Utilities
  6. Basics of the Emacs file manager (dired == directory editor)
  7. Bulk Plotting Multiple Cross Section in AutoCAD (Quick ...
  8. YouTube
  9. The Lisp Test
  10. lisp family. Common Lisp, Scheme, Elisp, Clojure. macOS SpotLight, Tulsi Gabbard, Andrew Young

Skip navigation Sign in. Search I had a comment on another video asking how to recompile functions as a program is running. This is the answer. The code follows: (defun update-swank 'Cal... You Sshunk My Battlesship EARRAPE (lisp) - The Addams Family. Collection of AutoLisp for Bulk Printing. Useful for printing Multiple Cross Sections present in Single Drawing File. Bulk Plot is handy for printing multipl... topic talked: • modern lisp family. Common Lisp, Scheme, Elisp, Clojure. • 〈Proliferation of Computing Languages〉 [ http://xahlee.info/UnixResource_dir/writ/... A Csv file by name ES.CSV gets created in a temporary directory. Vertex Export Using VID command you can export, easting and northing of each Vertex of any alignment represented by a polyline. Using ‘DTC’ command you can delete the content in Temporary directory. Thank you, in the next section you will learn Lisp functions related Survey Utility Category Here I demonstrate some of the basic actions we can perform inside a DIRED buffer. I also show how we can enable a writable buffer that we can then manipulate using regular expressions, multiple ... How to Play 8 Ball Pool Game in iMessage in iOS 12, Cheats, Shots, Game Settings and Tips (2019) by HowToiSolve vanessa testing to see if she has a lisp. Woah! Simon Cowell Has Ashley Marina Sing 3 Times! She Stuns The Judges - America's Got Talent 2020 - Duration: 9:53. America's Got Talent Recommended for ...