bhauman

Independent composable build scripts for cljs

There is a need more complex build scripts for ClojureScript. It would be nice to have a minmal interface and method for composing these scripts. Somehting like:

(-> (watch-cljs ["src"])
    (watch-sass [""])
    (compile-sass)
    (watch-css [""])
 (mark-macro-affected-source build-options)

wingo

;; Lambkin, a garbage-collected heap suitable for microcontrollers.
;; Copyright (C) 2015 Andy Wingo <[email protected]>.
;;
;; This program is free software: you can redistribute it and/or modify
;; it under the terms of the GNU General Public License as published by
;; the Free Software Foundation, either version 3 of the License, or
;; (at your option) any later version.
;;
;; This program is distributed in the hope that it will be useful,
;; but WITHOUT ANY WARRANTY; without even the implied warranty of

scttnlsn

(ns nested-routing.core
  (:require [goog.events :as events]
            [goog.history.EventType :as EventType]
            [reagent.core :as reagent]
            [reagent.ratom :refer-macros [reaction]]
            [re-frame.core :refer [dispatch dispatch-sync register-handler register-sub subscribe]]
            [secretary.core :as secretary :refer-macros [defroute]])
  (:import goog.History))

(declare route-components

robert-stuttaford

{:environment :production
 :global      {:logging-config "./logback.xml"}
 :onyx        {:job-scheduler  :onyx.job-scheduler/balanced
               :task-scheduler :onyx.task-scheduler/balanced
               :peer-config    {:onyx.messaging/impl :netty
                                :onyx.messaging/peer-port-range [40200 40220]
                                :onyx.messaging/peer-ports [40199]
                                :onyx.messaging/bind-addr "localhost"
                                :onyx.messaging/backpressure-strategy :high-restart-latency}
               :peer-count     20

jackrusher

#!/usr/bin/env boot
;; -*- mode: Clojure;-*-

(set-env! :dependencies '[[seesaw "1.4.5"]])

(use 'seesaw.core)

(import '(javafx.scene.web WebView)
        '(javafx.scene SceneBuilder)
        '(javafx.scene.layout VBoxBuilder))

geraldodev

(ns credito.core
  (:require
    [cljs.pprint :refer [pprint]]
    [datascript.core :as d]
    [goog.dom :as gdom]
    [om.dom :as dom]
    [om.next :as om :refer-macros [defui]]
    ))

(enable-console-print!)

dpritchett

Programming as Theory Building

Peter Naur, 1985

(copied from http://alistair.cockburn.us/ASD+book+extract%3A+%22Naur,+Ehn,+Musashi%22)

Introduction

The present discussion is a contribution to the understanding of what programming is. It suggests that programming properly should be regarded as an activity by which the programmers form or achieve a certain kind of insight, a theory, of the matters at hand. This suggestion is in contrast to what appears to be a more common notion, that programming should be regarded as a production of a program and certain other texts.

idibidiart

Building a Maintainable, Agile Architecture for Realtime, Transactional Apps

A maintainable application architecture requires that the UI only contain the rendering logic and execute queries and mutations against the underlying data model on the server. A maintainable architecture must not contain any logic for composing "app state" on the client as that would necessarily embed business logic in the client. App state should be persisted to the database and the client projection of it should be composed in the mid tier, and refreshed as mutations occur on the server (and after network interruption) for a highly interactive, realtime UX.

With GraphQL we are able to define an easy-to-change application-level data schema on the server that captures the types and relationships in our data, and wiring it to data sources via resolvers that leverage our db's own query language (or data-oriented, uniform service APIs) to resolve client-specified "queries" and "mutations" against the schema.

We use GraphQL to dyn

petterik

I'm trying to implement optimistic updates using om.next, datascript and datomic. Mutations should be visible instantly in the UI (the optimistic part) and synced with datomic once the mutation has been successfully transacted. Mutations should also be retryable.

I might be going about this all wrong, but here's the way I'm going about it:
Client:
0. Call om/transact with a mutation `[(my/mutation { ... }) :read/this...]
1. Transact update to datascript and save the optimistic transaction's tx number.
2. Pass the optimistic tx number in the remote's ast's :params (more on this later).
Server:
3. Transact update to datomic returning entities created in datomic and the optimistic tx number from :params, to client.
Client:

thegeez

(ns net.thegeez.advent.spec-parsing
  (:require [clojure.string :as str]
            [clojure.spec :as s]
            [clojure.spec.gen :as gen]
            [clojure.test.check.generators :as tgen]))
;; Dependencies:
;; [org.clojure/clojure "1.9.0-alpha14"]
;; [org.clojure/test.check "0.9.0"]

;; Advent of Code is a series of code challenges in the form of an advent