n2o

To cache the layer containing the dependencies from your Clojure project, you can execute a command without starting a REPL. This downloads all common dependencies, which are then be cached.

For example:

FROM clojure:openjdk-14-tools-deps-alpine

# Cache and install Clojure dependencies
COPY deps.edn .

yogthos

Introductory resources

• High level overview https://yogthos.github.io/ClojureDistilled.html
• An Animated Introduction to Clojure https://markm208.github.io/cljbook/
• Interactive tutorial in a browser https://tryclojure.org/
• Interactive exercises http://clojurescriptkoans.com/
• Clerk notebooks with introductory examples https://github.clerk.garden/anthonygalea/notes-on-clojure
• More interactive exercises https://4clojure.oxal.org/
• Lambda Island tutorials https://lambdaisland.com/
• Functional Programming with Clojure resources https://practicalli.github.io/

YellowApple

/* Ripped from https://www.tutorialspoint.com/sqlite/sqlite_c_cpp.htm */
#include <stdio.h>
#include <sqlite3.h>

int main(int argc, char* argv[]) {
        sqlite3 *db;
        char *zErrMsg = 0;
        int rc;

        rc = sqlite3_open(":memory:", &db);

tclementdev

libdispatch efficiency tips

The libdispatch is one of the most misused API due to the way it was presented to us when it was introduced and for many years after that, and due to the confusing documentation and API. This page is a compilation of important things to know if you're going to use this library. Many references are available at the end of this document pointing to comments from Apple's very own libdispatch maintainer (Pierre Habouzit).

My take-aways are:

• You should create very few, long-lived, well-defined queues. These queues should be seen as execution contexts in your program (gui, background work, ...) that benefit from executing in parallel. An important thing to note is that if these queues are all active at once, you will get as many threads running. In most apps, you probably do not need to create more than 3 or 4 queues.

• Go serial first, and as you find performance bottle necks, measure why, and if concurrency helps, apply with care, always validating under system pressure. Reuse

kubek2k

Top picks from StrangeLoop 2016

These are the presentations, which I did like most (and had a chance to watch). Order matters:

• Idealized commit logs - the best talk IMO. Andrew Shreve shows his approach to better understanding of programs by using technique called program slicing - the idea is to decompose program and its tests in way that every 'commit' contains the smallest part of the code that makes included test pass. This way you get a history of program, which aims at incremental development of understanding. Awesome stuff. https://www.youtube.com/watch?v=dSqLt8BgbRQ&index=4&list=PLcGKfGEEONaDvuLDFFKRfzbsaBuVVXdYa

• Clojure spec - the technique that is built into the language, allowing you to express the constraints over values as a part of function signature definition. Having those, you are able to validate, auto-document and auto-test (genertively) code. While its not a super innovative idea - it's interesting to see something like this to be implemented as a part of the language (i

jkstill

Decoding the data in /proc/net/tcp:

Linux 5.x  /proc/net/tcp
Linux 6.x  /proc/PID/net/tcp

Given a socket:

$ ls -l  /proc/24784/fd/11
lrwx------ 1 jkstill dba 64 Dec  4 16:22 /proc/24784/fd/11 -> socket:[15907701]

rgov

(* Converts hex digits in big endian to an integer. *)
on fromHex(theDigits)
	set theValue to 0
	repeat with theDigit in theDigits
		set theValue to (theValue * 16) + (offset of theDigit in "0123456789ABCDEF") - 1
	end repeat
	return theValue
end fromHex

(* Does a record have a certain key? (Hack.) *)