| param ( | |
| [string]$Version = $( Read-Host "Input version" ), | |
| [string]$DomainName = $( Read-Host "Input domain name" ), | |
| [string]$ApplicationName = $( Read-Host "Input application name" ) | |
| ) | |
| $ApplicationURI = $("https://$DomainName/$ApplicationName") | |
| 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 |
Welcome to my blog post for #FsAdvent 2016.
If you're using a relational database, as your application grows in size, at some point you may find yourself looking for an SQL parser. This can give you lots of leverage, for example allowing you to:
| module Editable exposing (..) | |
| type Editable ofType | |
| = NotEditing { value : ofType } | |
| | Editing { originalValue : ofType, buffer : ofType } | |
| value : Editable ofType -> ofType | |
| value editable = |
| @-moz-document domain("github.com"), domain("gist.github.com"), domain("render.githubusercontent.com") { | |
| /* Hasklig https://github.com/i-tu/Hasklig */ | |
| /* Fira Code https://github.com/tonsky/FiraCode */ | |
| /* Ligaturizer https://github.com/ToxicFrog/Ligaturizer */ | |
| .branch-name, | |
| .blob-num, | |
| .blob-code-inner, | |
| .CodeMirror pre, | |
| .commit .sha, | |
| .commit-desc pre, |
Full source: https://gist.github.com/mrange/aa9e0898492b6d384dd839bc4a2f96a1
Option<_> is great for ROP (Railway Oriented Programming) but we get no info on what went wrong (the failure value is None which carries no info).
With the introduction F# 4.1 we got Result<_, _> a "smarter" Option<_> as it allows us to pass a failure value.
However, when one inspects the signature of Result.bind one sees a potential issue for ROP:
a chapter from A Mind-Body Look at the Concept of Asperger's Syndrome (pdf) by Michael Samsel, LMHC
A Hacker News discussion (2021) on this list
In humans, eye contact is the center of the attachment system. In Asperger's Syndrome there is either an avoidance of eye contact (most common) or an unvarying, relative unblinking, staring, constant eye contact (less common). Avoidant eye contact gives an impression of 'having something to hide', and also eliminates a big channel of communication and trust. Staring eye contact, because of its unchanging nature, is also uncommunicative, and is generally experienced as disturbing on the receiving end.
| -- Translation to Haskell of: | |
| -- http://ccd-school.de/2017/06/stratified-design-over-layered-design | |
| -- I've deliberately translated each method to a function, in order to show the | |
| -- similarity. Some functions, like extractWords, are redundant (already built | |
| -- in) or almost too simple to get their own function. | |
| module Main where | |
| import Data.List (partition) |
| # Description: Boxstarter Script | |
| # Author: Jess Frazelle <[email protected]> | |
| # Last Updated: 2017-09-11 | |
| # | |
| # Install boxstarter: | |
| # . { iwr -useb http://boxstarter.org/bootstrapper.ps1 } | iex; get-boxstarter -Force | |
| # | |
| # You might need to set: Set-ExecutionPolicy RemoteSigned | |
| # | |
| # Run this boxstarter by calling the following from an **elevated** command-prompt: |
How do you send information between clients and servers? What format should that information be in? What happens when the server changes the format, but the client has not been updated yet? What happens when the server changes the format, but the database cannot be updated?
These are difficult questions. It is not just about picking a format, but rather picking a format that can evolve as your application evolves.
By now there are many approaches to communicating between client and server. These approaches tend to be known within specific companies and language communities, but the techniques do not cross borders. I will outline JSON, ProtoBuf, and GraphQL here so we can learn from them all.