This project is a tiny compiler for a very simple language consisting of boolean expression.
The language has two constants: 1 for true and 0 for false, and 4 logic gates:
! (not), & (and), | (or), and ^ (xor).
It can also use parentheses to manage priorities.
Here is its grammar in BNF format:
expr ::= "0" | "1"
I'll preface this with three things. 1. I prefer schemes over Common Lisps, and I prefer Racket of the Schemes. 2. There is more to it than the points I raise here. 3. I assume you have no previous experience with Lisp, and don't have a preference for Schemes over Common Lisp. With all that out of the way... I would say Common Lisp/SBCL. Let me explain
Now as to why Common Lisp over Scheme
| #!/bin/bash | |
| #no PATH, no way to accidently run any programs | |
| PATH='' | |
| #useful variables | |
| term_height=0 | |
| term_width=0 | |
| term_scroll_height=0 | |
| status_line_row=0 |
| .vimrc | |
| " Map leader to comma | |
| let maplocalleader="," | |
| " Toggle this for vim-sexp to not go into insert mode after wrapping something | |
| let g:sexp_insert_after_wrap = 0 | |
| " Toggle this to disable automatically creating closing brackets and quotes | |
| let g:sexp_enable_insert_mode_mappings = 1 | |
| Vocab |
Cython has two major benefits:
Cython gains most of it's benefit from statically typing arguments. However, statically typing is not required, in fact, regular python code is valid cython (but don't expect much of a speed up). By incrementally adding more type information, the code can speed up by several factors. This gist just provides a very basic usage of cython.
As of version 3.3, python includes the very promising concurrent.futures module, with elegant context managers for running tasks concurrently. Thanks to the simple and consistent interface you can use both threads and processes with minimal effort.
For most CPU bound tasks - anything that is heavy number crunching - you want your program to use all the CPUs in your PC. The simplest way to get a CPU bound task to run in parallel is to use the ProcessPoolExecutor, which will create enough sub-processes to keep all your CPUs busy.
We use the context manager thusly:
with concurrent.futures.ProcessPoolExecutor() as executor:
I found understanding Rust types really confusing, so I wrote up a small tutorial for myself in an attempt to understand some of them. This is by no means exhaustive. There is a types section in the manual, but it has nowhere near enough examples.
I'm not talking about managed pointers (@) at all. A lot of the difficulty with Rust types is that the language is constantly changing, so this will likely be out of date soon.
First, a few preliminaries: it's easier to play with types if you have a REPL and can interactively check the types of objects. This isn't really possible in Rust, but there are workarounds.
| import os | |
| import requests | |
| CONFIG_PATTERN = 'http://api.themoviedb.org/3/configuration?api_key={key}' | |
| IMG_PATTERN = 'http://api.themoviedb.org/3/movie/{imdbid}/images?api_key={key}' | |
| KEY = '<your_api_key>' | |
| def _get_json(url): | |
| r = requests.get(url) | |
| return r.json() |
| (ns prime-sieve | |
| (:require [clojure.core.async :as async :refer [chan go <! >!]])) | |
| ;;; concurrent prime sieve in Clojure using core.async | |
| ;; inspired by a similar implementation in Go | |
| ;; http://golang.org/doc/play/sieve.go | |
| (defmacro go-forever | |
| "An infinite loop that runs in a go block." |