parsonsmatt

timestamp :: String -> Q a -> Q a
timestamp name action = do
  start <- runIO getCurrentTime
  runIO $ putStrLn $ "Starting " <> name <> ": " <> show start
  a <- action
  end <- runIO getCurrentTime
  runIO $ do
    putStrLn $ "Ending " <> name <> ": " <> show end
    putStrLn $ "Elapased " <> name <> ": " <> show (diffUTCTime end start)
  pure a

taktoa

I started writing this polemic to answer your question, but I ended up touching on most of my gripes with Haskell in general, not just in a corporate context.

GHC

GHC is a modern compiler with an amazing RTS and tons of features, but I have some issues with it.

Monolithic and Hard to Contribute To

DusanMadar

A step-by-step guide how to use Python with Tor and Privoxy

Latest revision: 2021-12-05.

Tested on Ubuntu 18.04 Docker container. The Dockerfile is a single line FROM ubuntu:18.04. Alternatively, you can simply run docker run -it ubuntu:18.04 bash.

NOTE: stopping services didn't work for me for some reason. That's why there is kill $(pidof <service name>) after each failed service <service name> stop to kill it.

References

parsonsmatt

The question of "How do I design my application in Haskell?" comes up a lot. There's a bunch of perspectives and choices, so it makes sense that it's difficult to choose just one. Do I use plain monad transformers, mtl, just pass the parameters manually and use IO for everything, the ReaderT design pattern, free monads, freer monads, some other kind of algebraic effect system?!

The answer is: why not both/all?

Lately, I've been centering on a n application design architecture with roughly three layers:

Layer 1:

newtype AppT m a = AppT { unAppT :: ReaderT YourStuff m a } deriving ............ The ReaderT Design Pattern, essentially. This is what everything gets boiled down to, and what everything eventually gets interpreted in. This type is the backbone of your app. For some components, you carry around some info/state (consider [MonadMetrics](https://hackage

evancz

A vision for data interchange in Elm

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.

Literature Review

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.

natefaubion

module Grammar where

import Prelude

import Control.Applicative.Free (FreeAp, liftFreeAp, foldFreeAp)
import Control.Alt (class Alt, (<|>))
import Control.Alternative (class Alternative)
import Control.Monad.Eff (Eff)
import Control.Monad.Eff.Console (log, CONSOLE)
import Control.Plus (class Plus, empty)

regilero

# Change YOUR_TOKEN to your prerender token and uncomment that line if you want to cache urls and view crawl stats
# Change example.com (server_name) to your website url
# Change /path/to/your/root to the correct value

# Generate $prerender_ua bool value based on user agent
# indexation bots will get this as 1, 
# prerender user agent will always get 0 (avoid loops)
map $http_user_agent $prerender_ua {

    default 0;

darnir

# for background in 16 color terminal, valid background colors include:
# base03, bg, black, any of the non brights

# style notes:
# when bg=235, that's a highlighted message
# normal bg=233

# basic colors ---------------------------------------------------------
# color normal        brightyellow    default
color error         color196        color235                        # message line error text

dantman

'use strict';
import Promise from 'bluebird';
import { map, clone } from 'lodash';
import Client_SQLite3 from 'knex/lib/dialects/sqlite3';

export default class Client_ReactNativeSqliteStorage extends Client_SQLite3 {
	dialect: 'sqlite';
	driverName = 'react-native-sqlite-storage';

	_driver() {

schmengler

<?php
trait Memoize
{
    /**
     * @var array [method][parameters]
     */
    private $memoizedResults = [];
 
    protected function memoizedCall($methodName, $args)
    {