swannodette

Code Splitting

NOTE: This gist uses the master branch of ClojureScript. Clone ClojureScript and from the checkout run ./script/bootstrap and ./script/uberjar. This will produce target/cljs.jar which you can use to follow this guide.

As client applications become larger it becomes desirable to load only the code actually required to run a particular logical screen. Previously ClojureScript :modules compiler option permitted such code splitting, but this feature only worked under :advanced compilation and users would still have to manage loading these splits. :modules also required manual

BusFactor1Inc

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; nock.lisp - The Interpretation and Compilation of Nock Programs.
;;
;; Nock is the Maxwell's Equations of Software. It is a language that
;; powers the Urbit virtual machine; its specification can fit on a 
;; t-shirt[1].  
;;
;; In this set of Common Lisp functions below are 'tar', 
;; a Nock interpreter, 'dao', a Nock compiler and 'phi',
;; a Nock compiler driver.

rduplain

From the Archives: Code Quarterly's 2011 Q&A with Rich Hickey

Rich Hickey is frequently quoted as saying:

You can reach a point with Lisp where, between the conceptual simplicity, the large libraries, and the customization of macros, you are able to write only code that matters. And, once there, you are able to achieve a very high degree of focus, such as you would when playing Go, or playing a musical instrument, or meditating. And then, as with those activities, there can be a feeling of elation that accompanies that mental state of focus.

RockyRoad29

After upgrade, org-meta-return doesn’t work any more

After Spacemacs upgrade to 0.200.7, org-mode 9. falls back to built-in 8.x and causes multiple issues.

The first issue I detected was xhen pressing M-RETURN to insert a new heading, nothing happens but a message:

org-element–set-regexps: Symbol’s function definition is void: org-link-types

rofrol

Elm best practices

Style guide

• http://package.elm-lang.org/help/design-guidelines
• http://elm-lang.org/docs/style-guide
• https://github.com/NoRedInk/elm-style-guide
• https://gist.github.com/laszlopandy/c3bf56b6f87f71303c9f
• https://github.com/ohanhi/elm-style-guide

swannodette

Externs Inference

Integrating third party JavaScript libraries not written with Google Closure Compiler in mind continues to both be a source of error for users when going to production, and significant vigilance and effort for the the broader community (CLJSJS libraries must provide up-to-date and accurate externs).

In truth writing externs is far simpler than most users imagine. You only need externs for the parts of the library you actually intend to use from ClojureScript. However this isn't so easy to determine from Closure's own documentation. Still in the process of writing your code it's easy to miss a case. In production you will see the much dreaded error that some mangled name does not exist. Fortunately it's possible to enable some compiler flags :pretty-print true :pseudo-names true to generate an advanced build with human readable names. However debugging missing externs means compiling your production build for each missed case. So much time wasted for such simple mistakes damages our sen

matthieubulte

(* Good morning everyone, I'm currently learning ocaml for one of my CS class and needed to implement
   an avl tree using ocaml. I thought that it would be interesting to go a step further and try
   to verify the balance property of the avl tree using the type system. Here's the resulting code
   annotated for people new to the ideas of type level programming :)
*)

(* the property we are going to try to verify is that at each node of our tree, the height difference between
   the left and the right sub-trees is at most of 1. *)

halgari

The question was asked why I (as a programmer who prefers dynamic languages) don't consider static types "worth it". Here
is a short list of what I would need from a type system for it to be truely useful to me: 

1) Full type inference. I would really prefer to be able to write: 

(defn concat-names [person]
  (assoc person :full-name (str (:first-name person)
                                (:second-name person))))

And have the compiler know that whatever type required and produced from this function was acceptible as long as the 

malisper

(defun multiple (a b)
  "Is A a multiple of B?"
  (= (mod a b) 0))

(defun next-fraction (n fractions)
  "Returns the next value of F in the Fractran program."
  (find-if (lambda (f)
             (integerp (* n f)))
           fractions))

rygorous

Why do compilers even bother with exploiting undefinedness signed overflow? And what are those
mysterious cases where it helps?

A lot of people (myself included) are against transforms that aggressively exploit undefined behavior, but
I think it's useful to know what compiler writers are accomplishing by this.

TL;DR: C doesn't work very well if int!=register width, but (for backwards compat) int is 32-bit on all
major 64-bit targets, and this causes quite hairy problems for code generation and optimization in some
fairly common cases. The signed overflow UB exploitation is an attempt to work around this.