Return Styles: Pseud0ch, Terminal, Valhalla, NES, Geocities, Blue Moon.

Pages: 1-4041-

Shill for Haskell thread

Name: Anonymous 2015-06-05 13:39

Frederick's experiences echo that of many others who've taken the leap. All of these points echo our experience at fynder. Another couple of point to add (I'll add some more as I think of them):

You can get away with bad code at the periphery of your systems for longer. At fynder we had a pretty nasty data scraping and import utility that grew over time and became pretty unwieldy. However it still worked and was easy to change without breaking. It also fed data into a system that had a very strong guarantee of integrity so there was another line of defence. (I've seen /u/ryantrinkle say similar to this too)

You can go a long way with a small number great programmers laying out the types and the structure, with lesser able programmers "filling in the gaps" as they get up to speed. For example at fynder /u/ocharles came up with a great use of singleton types to make our socket.io communications safer [1]. Even though I could never come up with that from scratch, I was able to add to it and extend it quite happily after a 20 minute explanation (and some follow up questions).

You don't get either of those benefits with, say python, the language I use day to day at the moment. Once your python codebase loses a certain amount of cohesion, it's way harder to refactor your way out, and I think you end up staring down the barrel of a re-write a lot sooner. Equally there's no culture of common fundamental patterns (Functor, Applicative, Monad) that everyone understands so you can't really have a few rock stars implement the core of your system and people of lesser abilities code around the core. You end up having to code to the lowest common denominator whereas in Haskell you can program up to the strongest level more easily.

[1] https://ocharles.org.uk/talk.pdf

Name: Anonymous 2015-06-05 13:40

It can't be expressed enough IMO how good the refactorability of Haskell code is and how important that is for a business (especially in a startup environment). Unfortunately I think this property is a bit of "you have to see it to believe it" and it's really hard to explain to someone a) why it is that way and b) why it's important.

I do think it's something we as a community should get better at communicating though.

Name: Anonymous 2015-06-05 13:43

Lingo was developed in-house by OTAS Technologies in order to leverage the OTAS Base analytics API. The NLG engine was developed on the Haskell stack provided by FP Complete.

"We chose Haskell and the FP Complete stack because we knew the complexity of the problem required a new approach. The result was that we built better software faster than ever, and delivered it defect-free into a production environment where it has proven robust and high-performance," add Doris.

http://www.automatedtrader.net/news/at/153887/otas-launches-otas-lingo

Name: Anonymous 2015-06-05 13:45

Native Client

Our users want to query their databases without any new IT or admin setup, so users connect via their local machine with their existing credentials. Wagon handles connections through the native client, since most databases require socket-level network access that isn’t possible directly from browser.

Exploration and analysis can be a time-consuming and tedious job with existing SQL tools. Each step is an additional database query subject to queuing, slow execution, and changing data. Our users want to quickly explore results and evaluate summary statistics without executing subsequent queries. To power that experience, the client also computes statistics and caches query results on the local file system.

We built the native client in Haskell. It’s a high level language with great libraries, static compilation, a high performance ceiling, and an active community. We use MacGap to bundle the client and the frontend into a downloadable OS X application (Windows soon!).

Technology: Haskell, MacGap

Prototyping and refactoring is safe with Haskell’s type-driven development. The compiler helps us avoid bugs and edge cases as we iterate.
Haskell’s opt-in control over compiler optimizations and strictness allows for incremental optimization. GHC includes a capable profiler, and the community maintains libraries for testing and performance measurement.

Backend Services

Our backend services persists state and shared data to allow users to securely collaborate on queries, results, and charts. The backend is also written in Haskell: using the same language for the client and the server helps us stay flexible and reduce complexity. We store application state in Postgres while larger immutable data, like shared query results, live in Amazon S3.

Technology: Haskell, Postgres, Amazon S3

Haskell’s lightweight threads and the GHC runtime scale well on multi-core machines.
Postgres is powerful, flexible, and straightforward to host. We use features like TOAST and JSON support to test new features.

http://www.wagonhq.com/blog/engineering-at-wagon/

Name: del 2015-06-05 13:46

del

Name: sage 2015-06-05 16:00

unsafePerformIO . print $ "Well typed programs can't go wrong"

Name: Anonymous 2015-06-05 16:01

>>6
You don't need unsafePerformIO to misquote Milner.

Name: Anonymous 2015-06-05 16:39

>>6
"Well typed programs can't go wrong"
This is not what Haskell claims to be. Stop being a retard.

Name: Anonymous 2015-06-05 17:09

>>8
Actually, it is.

Name: Anonymous 2015-06-05 18:15

Haskell is a simple and readable language for normal people like physicists and mathematicians, cleansed of bytesodomy and rendering specially-bred computer assfuckers-programmers useless. Yes, you read this right. After this language for normal people will get widespread, the byte-Sparta of military faggots-programmers hardened by getting anally fucked with the von Neumann architecture and orally fucked with the applicative order will lose any meaning. What will remain for these pathetic subhumans, whose brains have been whitewashed of anything human for 5 years in grad school? The only thing remaining for them will be ceasing their lowly existence.

Name: Anonymous 2015-06-05 18:59

>>8
You wouldn't know it from the way people talk around here.

Name: Anonymous 2015-06-05 19:09

IF IT COMPILES, IT WORKS

Name: Anonymous 2015-06-05 20:20

>>11
You got references to back that up?

Name: Anonymous 2015-06-05 20:49

>>13
Yes, because I am autistic and wrote down every post number in my notebook.

Name: sage 2015-06-05 22:13

static types are a fucking joke, how stupid do you have to be to not know to pass and int to a function that takes and int and bool for a bool. You learn this shit at age 5, square peg square hole, round peg round hole. Even that is above the intellectual capacity of a haskell programmer.

Name: Anonymous 2015-06-05 22:20

>>14
Ok, let's see 'em. Because I don't remember any of them.

>>15
I bet you're a big fan of hungarianShitCase notation and/or can't program without Intellisense™.

Name: Anonymous 2015-06-06 14:17

Name: Anonymous 2015-06-06 17:31

>>16
I think >>14-kun-sama-chan was being sarcastic.

Name: Anonymous 2015-06-06 18:36

>>18
You missed one. But don't worry, you'll get the hang of this sarcasm thing eventually!

Name: Anonymous 2015-06-07 0:37

>>19
Stop pretending that you were being sarcastic.

Name: Anonymous 2015-06-07 1:33

>>20
Are you for real?

Name: Anonymous 2015-06-07 2:28

>>21
back to reddit you goes

Name: Anonymous 2015-06-07 2:35

>>22
Nice dubs!

Name: Anonymous 2015-06-07 7:33

>>22
quality bump℠

Name: Udder 2015-06-07 10:31

At the start of the products’ life we mostly analyzed small retirement plans with 100 to 500 plan participants. As time went on we started seeing plans with 2,000 participants and even 10,000 participants. At these numbers the execution time for the processing started going outside of acceptable bounds. Luckily, every participant could be analyzed in isolation from the others and so the problem was embarrassingly parallel.
I changed one line of code from

map outputParticipant parts

to

map outputParticipant parts `using` parListChunk 10 rdeepseq

and execution times were now about 3.7x faster on our 4-core server.

Name: Anonymous 2015-06-07 18:01

>>25
Too bad its 50 times slower than C.

Name: Anonymous 2015-06-07 22:27

>>26
Just double the cores. Are you too poor to afford 8 cores?

Name: Anonymous 2015-06-07 22:31

>>27
I think you mean 64 cores.

Name: Anonymous 2015-06-09 18:32

Bicycle Parking Guidance System in Utrecht

I'm proud to announce that the day after I came back from ZuriHac 2015 we at LumiGuide had the grand opening of our bicycle parking and guidance system that we developed for the city of Utrecht. To our knowledge it's the first system in the world that guides cyclists to available parking space on a city-wide level.

The optical sensors that detect if there's space to park your bicycle are based on a computer-vision algorithm. Haskell is used throughout the system:

- We used GHCJS for building our highly interactive web-client for calibrating the optical sensors.

- The central management server is also written in Haskell.

- Haskell was also used to implement the binary protocols used for communicating with the displays and to interface with third-party parking facilities.

-- Bas van Dijk, chief technology officer at LumiGuide in Nijmegen

https://bicycledutch.wordpress.com/2015/06/09/bicycle-parking-guidance-system-in-utrecht/

Name: Anonymous 2015-06-09 20:06

>>26
Optimized GHC Haskell is within 3x of C. It has also been known to beat C on occasion.

Name: Anonymous 2015-06-09 20:31

The Haskell ecosystem has evolved so much that open-source libraries deserve whole talks about them https://www.youtube.com/watch?v=5_fCUSOn7m0&feature=youtu.be

With Lisp, it's just a handful of retards writing interpreters. All the libraries on Cliki are either bitrotten or incomplete abandonware. That is, when then links aren't broken. Lisp is like an old dilapidated hut with a couple of autists inside screaming of their superiority. Haskell is a skyscraper in Abu Dhabi.

Name: Anonymous 2015-06-09 22:20

>>30
*And reads nothing like Haskell should.

Name: Anonymous 2015-06-09 22:29

dubs

Name: Anonymous 2015-06-10 19:15

>>31
The Haskell community is full of bullies

Name: Anonymous 2015-06-11 19:24

>>34
Haha soft-skinned bitch. Go cry in the corner, emo boy.

Name: Anonymous 2015-06-12 0:34

>>35
why would you post such a thing?

Name: Anonymous 2015-06-12 0:46

>>36
Because you've insulted me with your weakness, pussy. Man up!

Name: Anonymous 2015-06-12 20:33

How Haskellers are seen vs how they see themselves

http://chrisdone.com/posts/haskellers

Name: Anonymous 2015-06-12 20:35

>>38
cool meme gifs

Name: Anonymous 2015-06-12 23:00

Muh nads
This expression indicates a Haskell programmer's confusion and lack of understanding. When confronted with something he can not understand or respond to, Haskell programmers mumble, "Muh nads", or "Muh nads, muthafucka." This is usually followed by crotch grabbing and foot shuffling.

Name: Anonymous 2015-06-13 13:07

Introduction

My background is in quant finance, mostly writing C++, Python, and (shudder) Matlab. Over the last few months I've been learning Haskell, so as an excuse to learn some more Haskell, I decided to try to solve a fundamental quantitative finance problem in Haskell. Quant finance tends to love tangled OOP, so I figured a functional programming style might be a new twist on the problem.

I was trying to think of a good problem to start with, and I came up with the idea of a simple (but powerful) Monte Carlo engine for Haskell. With that in mind, I started to think about architecture. I'm going to write this up in a few posts, but my rough plan is:

Today's post: specification of contingent claims
Implementation of the Monte Carlo engine and underlying models
Odds and ends (implementation of simple yield curves, volatility surfaces, etc) and future plans

The target audience for this blog post is folks who know a bit of Haskell and are curious how it might apply to this particular problem.

http://boundedvariation.github.io/

Name: Anonymous 2015-06-13 21:16

>>40
I think the problem of the monads is the same as the main reason they are used: they make the computational context implicit, clouding what really goes on. This is much the same as the problem with Lisp macros having too much power. They make the code terse, not concise: it's short alright, but boy is it a pain to understand and maintain.

Basically, since monads are so plentiful and varied, you cannot tell by looking at a piece of monadic code what it really does. You don't know if there's implicit state, backwards state, nondeterminism, laziness, side effects, GOTOs or a million other things in there. You don't know what flavors of monadic coffee are running through the plumbing hidden from you in that monad. And you might just say "fuck it, you should've just written it out explicitly".

Name: Anonymous 2015-06-17 20:08


_/_/_/ _/ _/ _/_/_/ _/ _/ _/_/_/_/ _/_/ _/_/_/
_/ _/ _/ _/ _/ _/ _/ _/ _/ _/ _/
_/_/ _/_/_/_/ _/ _/ _/ _/_/_/ _/ _/ _/_/_/
_/ _/ _/ _/ _/ _/ _/ _/ _/ _/ _/
_/_/_/ _/ _/ _/_/_/ _/_/_/_/ _/_/_/_/ _/ _/_/ _/ _/


_/ _/ _/ _/ _/
_/ _/ _/_/_/ _/_/_/ _/ _/ _/_/ _/ _/
_/_/_/_/ _/ _/ _/_/ _/_/ _/_/_/_/ _/ _/
_/ _/ _/ _/ _/_/ _/ _/ _/ _/ _/
_/ _/ _/_/_/ _/_/_/ _/ _/ _/_/_/ _/ _/




Name: Anonymous 2015-06-17 20:24

What's a "shill"? I remember "shill jobs" in the Thieves Guild in Skyrim, they were about planting false evidence in people's houses. So are /prog/ shillers the ones who post illegal stuff to make the government shut it down?

Name: Anonymous 2015-06-17 20:44

>>44
Lolfuck, I was the one that first posted this back on ye olde /progge/. And here we are, months later on a different domain, and you repost it. Brilliant, my memelord friend!

Name: Anonymous 2015-06-17 21:02

>>45
Are you upset that people appreciate your quality posting?

Name: Anonymous 2015-06-17 22:38

Name: Anonymous 2015-06-18 12:18

>>47
Wow, this thread was a year ago.

Name: Anonymous 2015-06-18 16:49

>>47
No I didn't:

18 Name: Anonymous : 2014-05-30 10:39
>>17
Fucking spammer. Better get some kick-ass mods and start Fus-Ro-Dahing, surely it's more fun than spamming a board which no one reads.

Name: Anonymous 2015-06-18 16:52

>>49
So you didn't write ``
What's a "shill"? I remember "shill jobs" in the Thieves Guild in Skyrim, they were about planting false evidence in people's houses. So are /prog/ shillers the ones who post illegal stuff to make the government shut it down?''
after all, huh?
12 Name: Anonymous : 2014-05-30 07:22
>>11
It's good that you remember my posts. Though I'm going for the Dark Brotherhood now. Do me some killing instead of shilling, you know.

Name: Anonymous 2015-06-18 16:55

>>50
Fuck, you caught me.

Name: Anonymous 2015-06-18 16:59

If you killed Cicero you are a scum.

Name: Anonymous 2015-06-19 9:48

>>52
But I didn't. I let him live.

Name: Anonymous 2015-06-19 10:15

>>53
cos im just a tenage ditbag babi

ur mums name's noel

she inserts things into herself

Name: Anonymous 2015-06-19 14:29

check 'em boys

Name: Anonymous 2015-06-20 11:57

Haskell performance is hard. For example, this version of fibs doesn't use memoization:

fib n = fibs !! n
where
fibs = 1 : 1 : zipWith noisyAdd fibs (tail fibs)


while this one does:

fib = \n -> fibs !! n
where
fibs = 1 : 1 : zipWith noisyAdd fibs (tail fibs)


..but not if you turn on the {-# LANGUAGE NoMonomorphismRestriction #-} pragma. So you'll have to rewrite your fibs as

fib :: forall a. Int -> a -> (Integer, a)
fib = pairWithFib
where
pairWithFib :: Int -> a -> (Integer, a)
pairWithFib n x = (fibs !! n, x)

fibs :: [Integer]
fibs = 1 : 1 : zipWith noisyAdd fibs (tail fibs)


to get memoization. Holy fuck, all hail purity and lazy evaluation indeed.

http://gelisam.blogspot.ca/2015/06/will-it-memoize.html

Name: Anonymous 2015-06-20 12:04

Who cares? RAM is cheap nowadays.

Name: Anonymous 2015-06-20 13:40

Who cares? Petrol is cheap nowadays.

Name: Anonymous 2015-06-21 5:10

>>56
The first example got me because of Haskell's grammar. I couldn't tell if the where was inside the -> lambda or not. The others are strange...

Name: Anonymous 2015-06-21 5:23

>>59
let <foo> where <bar> is more or less equivalent to let <bar> in let <foo>, right?

Name: Anonymous 2015-06-21 7:55

>>17
le ad hominem image

Name: Anonymous 2015-06-21 10:40

>>61
No, le ad educationem image.

Name: Anonymous 2015-06-27 13:19

Haskell Haskell save us from the imperative hell!
Haskell Haskell save us from the imperative apes!
Haskell Haskell deliver us to the heaven of purity!

Name: Anonymous 2015-06-27 20:36

Kikebook: Fighting spam with Haskell

One of our weapons in the fight against spam, malware, and other abuse on Facebook is a system called Sigma. Its job is to proactively identify malicious actions on Facebook, such as spam, phishing attacks, posting links to malware, etc. Bad content detected by Sigma is removed automatically so that it doesn't show up in your News Feed.

We recently completed a two-year-long major redesign of Sigma, which involved replacing the in-house FXL language previously used to program Sigma with Haskell. The Haskell-powered Sigma now runs in production, serving more than one million requests per second.

https://code.facebook.com/posts/745068642270222/fighting-spam-with-haskell/?_fb_noscript=1

Name: Anonymous 2015-06-27 20:43

>>64
So Kikebook uncovered a performance bug in aeson, and in order to improve performance, the Haskeller had to use unsafePerformIO. Hooray for purity!

https://github.com/bos/aeson/commit/05c9e0cbbebc861303fc7dd6b3dfd03844490621

http://www.serpentine.com/blog/2015/05/13/sometimes-the-old-ways-are-the-best/

Name: Anonymous 2015-06-27 21:21

>>65
Check 'em

Name: Anonymous 2015-06-28 6:51

Haskell Haskell save us from the capitalist hell!
Haskell Haskell save us from the capitalist apes!
Haskell Haskell deliver us to the heaven of Communism!

Name: Anonymous 2015-06-28 8:56

U MENA HASKAL

Name: Anonymous 2015-06-28 11:41

I wrote an IO monad in Rust; its called Burrito. (https://github.com/withoutboats/burrito)

---

Is it correct to consider burritos a meme in the context of PL...

---

A meme is a self-replicating idea. The analogy of monads to burritos by Crockford at the height of the monadic analogy tutorials is indeed such a self-replicating idea.

An internet meme "is an activity, concept, catchphrase or piece of media which spreads, often as mimicry, from person to person via the Internet". It also fits this definition.

Name: Anonymous 2015-06-28 12:19

>>69
lol linkfail

Name: Anonymous 2015-06-28 12:22

>>70
More like MonadFail.

Don't change these.
Name: Email:
Entire Thread Thread List