Alexis Purslane alexispurslane

title

1. Types of Verilog

There are two basic ways that you can write a Verilog program:

Structural Verilog: this is where you specify the logic gates and connections between them of your circuit directly, as if you were doing a textual version of drawing logic gate circuits. This is very low level and nitty-gritty. Here's an example of what that looks like:

CLIME

CLIME is an Emacs/SLIME backend for McCLIM. It lets you call CLIM drawing routines at the SLIME REPL and see rendered images inline in Emacs. It also supports Presentations so that you can (accept TYPE) and click in Emacs to choose an object.

Quick overview

Scroll down to see screenshots!

Tweetstream: https://twitter.com/lukego/status/1387747747864973312
Demo of ACCEPT: https://www.youtube.com/watch?v=ZTO4fwba4i0

Developer experience, libraries, performance… (2021/11)

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

SBCL Is by far the most common of the CL implementations in 2021. It will be the easiest to find help for, easiest to find videos about, and many major open source CL projects are written using SBCL
Download a binary directly from the website http://www.sbcl.org/platform-table.html (even for M1 macs) to get up and running (easy to get started)
Great video for setting up Emacs + Slime + Quick Lisp https://www.youtube.com/watch?v=VnWVu8VVDbI

Now as to why Common Lisp over Scheme

Testimonies

CL's compiler

The thing in CL I miss most doing Clojure as my day job? CL's compiler. I like having a compiler tell me at compile time about the mistakes I've made. Bogus arguments. Unreachable code because of unhandled exceptions, and so on. CL saves me round after round of bugs that in clojure aren't found until you run the code. If you test well, it's found when testing, if you don't it's found in production. "Clojure compiler" almost demands air quotes.

CL's optional but oh-so-useful model of type declarations is also infinitely more useful (to me) than Clojure's use of "spec", and instrumentation that happens only at test time because of the cost. Depending on the OPTIMIZE declarations, other type defs are a floor wax and dessert topping. Want checks for argument types? Lower optimizations. Want most efficient machine code? High optimizations.

/u/Decweb, March 2023 https://www.reddit.com/r/lisp/comments/11ttnxk/the_rise_fall_of_lisp_too_good_for_the_rest_of/jczpysp/

	import collections.abc as ABC
	from itertools import islice, tee

	class MutableIterator(ABC.Iterator):
	def __init__(self, nexts=()):
	self.nexts = list(nexts)

	def __next__(self):
	if self.nexts:
	return self.nexts.pop()

	#define let(name,value) const __typeof__ (value) name = value;
	#define var(name,value) __typeof__ (value) name = value;

	int main(int argc, char *argv[]) {
	let(x,3); // const int x = 3;
	var(y,5); // int y = 5;

	printf("x:%i y:%i",x,y); // -> x:3 y:5
	}

	#!/bin/sh -e
	##!! PLEASE USE THIS SCRIPT WITH CAUTION - AND AT YOUR OWN RISK !!##
	##!! IT HAS BEEN KNOWN TO CAUSE RESETS AND WIPE DATA ON SOME CHROMEBOXES !!##

	APPLICATION="${0##*/}"
	ANSWER=''
	SUDO=''

	USAGE="
	$APPLICATION [no options]

	var empty_list = function(selector) {
	return selector(undefined, undefined, true);
	};

	var prepend = function(el, list) {
	return function(selector) {
	return selector(el, list, false);
	};
	};
	var head = function(list) {