cothrun + programming   713

the Fennel programming language
Fennel is a programming language that brings together the speed, simplicity, and reach of Lua with the flexibility of a lisp syntax and macro system.

Full Lua compatibilty: Easily call any Lua function or library from Fennel and vice-versa.
Zero overhead: Compiled code should be just as or more efficient than hand-written Lua.
Compile-time macros: Ship compiled code with no runtime dependency on Fennel.
Embeddable: Fennel is a one-file library as well as an executable. Embed it in other programs to support runtime extensibility and interactive development.
Anywhere you can run Lua code, you can run Fennel code.
lisp  lua  programming 
11 weeks ago by cothrun
combinatorylogic/mbase: Metaprogramming framework for .net
MBase is a metaprogramming framework built on top of .NET. It is designed for rapid prototyping and high quality implementation of custom programming language compilers, but can also serve as a robust and flexible embeddable scripting engine. Applications are not limited to .NET platform, since MBase can be used to implement compilers targeting other platforms - JVM, LLVM, C, etc.

MBase consists of a core language and a library of micro-DSLs.

The core of MBase is built on top of a Lisp-like language. Its main applications include:

DSL compilers and interpreters implementation;
Intermediate target language for higher level DSL compilers;
Efficient embedded scripting platform.
MBase includes the following micro-DSLs and libraries:

advanced pattern matching;
abstract syntax trees support;
recursive descent parsing;
Lexing and parsing (LL(*));
PEG and Pratt parsing;
embedded Prolog interpreter and compiler;
extensible syntax frontend;
list comprehensions;
XML querying and transforms language;
embedded .NET IL assembler;
.NET bindings builder;
.NET class builder.
Not.NET low level imperative embedded language;
Compiler construction modules:
Generic register allocation
Generic SSA transform and loop analysis
Tarjan algorithm implementation
Embedded ML compiler
framework  programming 
october 2018 by cothrun
Kit Programming Language | A magical, high performance programming language for game development.
Kit is a programming language designed for creating concise, high performance cross-platform applications. Kit compiles to C, so it’s highly portable; it can be used in addition to or as an alternative to C, and was designed with game development in mind.
programming  gamedev 
september 2018 by cothrun
Laurence Tratt: Why Aren’t More Users More Happy With Our VMs? Part 1
Programming language performance is something that nearly everyone cares about at some point, whether they realise it or not. If you’re a programmer, you sometimes have to make your programs run fast; if you’re a user, you might be frustrated at a program that runs slowly, without knowing that it’s caused by a poor programming language implementation. Those of us who work on, or around, programming language Virtual Machines (VMs) tell a good story about performance, but a surprising number of users seem unhappy with the performance of their programs. Sometimes, yes, they’re unrealistic, but are they always so? In this first blog post (based on this paper) of two, I’m going to show that programs running on VMs often don’t follow the simple performance patterns that nearly all of us expected. Perhaps that’s why users aren’t as happy as VM developers think they should be?
benchmarking  programming  language  vm 
september 2018 by cothrun
Introduction -
This book digs into all the awful details that are necessary to understand in order to write correct Unsafe Rust programs. Due to the nature of this problem, it may lead to unleashing untold horrors that shatter your psyche into a billion infinitesimal fragments of despair.
rust  bestpractices  reference  programming  book 
august 2018 by cothrun
The subject of this book sometimes goes by the name “programming methodology”, “science of
programming”, “logic of programming”, “theory of programming”, “formal methods of
program development”, or “verification”. It concerns those aspects of programming that are
amenable to mathematical proof. A good theory helps us to write precise specifications, and to
design programs whose executions provably satisfy the specifications. We will be considering the
state of a computation, the time of a computation, the memory space required by a computation, and
the interactions with a computation. There are other important aspects of software design and
production that are not touched by this book: the management of people, the user interface,
documentation, and testing.
programming  learning  theory  computerscience 
august 2018 by cothrun
CS Unplugged
CS Unplugged is a collection of free teaching material that teaches Computer Science through engaging games and puzzles that use cards, string, crayons and lots of running around.
education  programming  computerscience 
july 2018 by cothrun
Akin's Laws of Spacecraft Design
I've been involved in spacecraft and space systems design and development for my entire career, including teaching the senior-level capstone spacecraft design course, for ten years at MIT and now at the University of Maryland for more than two decades. These are some bits of wisdom that I have gleaned during that time, some by picking up on the experience of others, but mostly by screwing up myself.
engineering  design  space  programming  development 
may 2018 by cothrun
the secret life of NaN
The floating point standard defines a special value called Not-a-Number (NaN) which is used to represent, well, values that aren’t numbers. Double precision NaNs come with a payload of 51 bits which can be used for whatever you want– one especially fun hack is using the payload to represent all other non-floating point values and their types at runtime in dynamically typed languages.
programming  math  floatingpoint 
april 2018 by cothrun
Inigo Quilez :: fractals, computer graphics, mathematics, demoscene and more
These are written articles on the techniques I develop for my computer graphics experiments, demos, shadertoys and movies. For video tutorials, code and other useful resources visit the landing page. All content here is beginner and medium level, and mostly pragmatic rather than theoretical. I have a long long queue of pending articles, I write them whenever I have a little bit of free time (mostly late at night), so stay tuned!
graphics  3d  math  tutorial  programming 
september 2017 by cothrun
The language of choice
Propositional logic was discovered by Stoics around 300 B.C., only to be abandoned in later antiquity and rebuilt in the 19th century by George Boole’s successors. One of them, Charles Peirce, saw its significance for what we now call logic circuits, yet that discovery too was forgotten until the 1930s. In the ’50s John McCarthy invented conditional expressions, casting the logic into the form we’ll study here; then in 1986 Randal Bryant repeated one of McCarthy’s constructions with a crucial tweak that made his report “for many years the most cited paper in all of computer science, because it revolutionized the data structures used to represent Boolean functions” (Knuth).1 Let’s explore and code up some of this heritage of millennia, and bring it to bear on a suitable challenge: playing tic-tac-toe.

Then we’ll tackle a task that’s a little more practical: verifying a carry-lookahead adder circuit. Supposedly logic gets used all the time for all kinds of serious work, but for such you’ll have to consult the serious authors; what I can say myself, from working out the code to follow, is that the subject offers a fun playground plus the most primitive form of the pun between meaning and mechanism.

You’re encouraged to read with this article’s code cloned and ready
programming  logic  algorithms 
july 2017 by cothrun
« earlier      
per page:    204080120160

related tags

3d  abstraction  access  ada  advice  ai  algebra  algorithm  algorithms  analysis  analytics  android  angularjs  anki  api  apl  apple  apps  architecture  arduino  art  asm  asm.js  assembler  asyncronous  atom  audio  augmentedreality  automation  bash  basic  beagleboneblack  benchmarking  bestof  bestpractices  bigquery  binary  biology  bit  bitcoin  blog  book  books  browser  business  Bézier  c  c++  calculus  canvas  career  children  class  cleanup  climate  clojure  closed  closure  cloud  cocoa  cocoatouch  code  coffeescript  collaboration  color  command-t  commandline  compatibility  compiler  complexity  computer  computerscience  computer_science  concurrency  cpp  cpu  creativity  crossplatform  crypto  cryptography  css  css3  cuda  culture  cygwin  d  d3d  data  database  datamining  datastructures  dct  debug  deduplication  design  designpatterns  development  devops  diagram  dictionary  directx  discussion  diy  django  dlang  dna  documentation  drupal  dsl  dsp  ebook  economics  ecosystem  editor  education  electronics  embedded  emoji  employment  emulation  emulator  engineering  english  environment  erlang  error  estimation  excel  exercise  exercises  f#  feeds  fft  file  filesystem  filetype:pdf  finance  fizzbuzz  flash  floatingpoint  flowchart  font  fonts  format  forth  FPGA  fractal  framework  free  functional  funny  game  gamedev  games  gamma  generator  generators  geography  git  github  go  golang  google  goto  gpu  graphics  grid  gui  habits  hacking  hamming  hardware  hash  haskell  health  hex  history  HtDP  html  html5  http  humor  ide  ideas  ie  image  images  inspiration  interview  intro  io  ios  iphone  java  javascript  jit  job  jobs  jpeg  jquery  json  julia  jvm  j_lang  kata  knuth  kotlin  language  languages  learn  learning  LESS  library  life  linearalgebra  lint  linux  lisp  lists  livestream  logic  lua  mac  make  management  maps  math  matlab  maze  memory  metaphor  minecraft  mobile  monad  monitor  mono  monospace  morrowind  motivation  msaccess  music  mvc  mysql  names  nasa  network  news  nim  node.js  objective-c  objectorientedprogramming  ocaml  octave  online  oop  opencl  opengl  opensource  operatingsystem  optimization  os  outsourcing  papers  parser  pascal  password  patterns  pdo  perceptual  performance  perl  persistence  philosophy  photography  php  physics  pid  planning  plugin  practice  presentation  probability  procedural  process  processing  procrastination  productivity  programming  projecteuler  projectmanagement  projects  prolog  psychology  puzzles  python  quality  quantummechanics  R  racket  rail  raspberrypi  reactive  reading  realtime  redis  refactor  reference  regex  religion  repl  research  resources  responsive  reverseengineering  rss  ruby  rust  SASS  scala  scale  schedule  scheme  science  scm  scrape  scripting  search  security  seismic  seismology  self-improvement  serialization  server  shader  shell  sicp  simplicity  skill-sets  smalltalk  sockets  software  sonicpi  sound  source  south  space  spreadsheet  sql  ssd  standards  startup  statemachine  statistics  storage  streaming  streamprocessing  string  structures  study  style  sublimetext  sudoku  swift  synthesizer  talk  tdd  teaching  technology  terminal  testing  theory  tips  tmux  tools  toread  tutorial  twitch  type  types  typescript  typography  unicode  unity  unix  utilities  versioncontrol  video  vim  virtualization  visual  visualbasic  visualization  vm  web  webdev  webgl  webOS  windows  wirth  work  workflow  writing  x86  x86_64  youtube 

Copy this bookmark: