2600 is releasing a digital version (!) https://store.2600.com/products/new-issue?variant=30308928487479

Hello! Out of curiosity, is there anyone reading this message who has decent experience in an language with an advanced type system (e.g. Haskell) and yet find themselves preferring the untyped nature of Clojure for most (or for some specific) tasks?

here’s a nice blogpost on that topic: https://lispcast.com/clojure-and-types/

@hmaurer Ive used rust and scala if that counts

i prefer dynamic languages for tasks that involve "real" data primarily

@emccue most definitely counts 🙂

why so? (out of curiosity again; I’m not opinionated on the subject)

part of it is that the "advanced" typesystems are a cognitive burden

which isn't a bad thing neccisarily

rust is a fantastic language

but if most of my work is just "take data, shape it, shove it, twist it, bop it"

then simple stuff with the typesystem like "declare fields and optionality" starts to become a dev time burden and imo outweighs the "safety" benefits

at one of my coops i had a scala trait with 15 Option[...] fields

there is more but my stupid monkey brain can't think of it

(and obviously all of that is opinion)

there's also the concrete benefits of being able to "hack it"

tech debt is worth taking on if it lets you move at the pace the business needs to

if you attempt some kind of abstraction with rust and it doesn't work out then you might be stuck doing a refactor to ensure memory safety/etc

which is perfectly fine, at least for rust, and doing refactors in advanced typesystems kind of languages are as painless as is possible

but a dynamic language lets you take on that tech debt of accessing a "private" field or writing something that dispatches on a class and some string together, etc

scala in particular kinda stinks at doing that kind of stuff without brandishing a phd and the sword of artorius

@emccue thanks for writing all that out! the optionality part echoes some personal experiences as well

something i've noticed, at least with clojure

if i don't have a specific task its hard to write "skeleton code"

like, pre-coding abstractions

if im writing in a typed language its alot "easier" to keep my fingers typing before i even know what im supposed to be doing

thats not necessarily a condemnation of boilerplate - you might end up with the same interfaces and system boundaries at the end of a project regardless - but it is what I use as a sign that a project is a good fit for a dynamic language

if i can sketch it out in great detail beforehand in a dynamic system it might be a good fit for doing statically

if that makes sense

i dunno, im kinda just riffing

Yeah that perfectly makes sense

I am going through a similar experience right now where I am re-writing a project from Clojure to Haskell, and it strongly fits in the category of “can design in great detail beforehand”

im also not the most experienced person out there, so take anything i say with a mountain of salt

@emccue's points resonate with me

if you have a model that you know ahead of time, being able to encode that in the type system is a big win

but if it's a changing/unknown model, untyped is easier

you won't get the benefits of static typing

The author of the blog post himself! Thanks for chiming in @ericnormand 🙂

and you still pay the costs

Haskell's type system's "painless refactorings" assume that a large portion of the types are unchanging

which might be a valid assumption

but if it's not valid, the refactoring isn't painless

and you may be talking to an API that doesn't have the same level of consistency as Haskell

(which is almost by definition the case)

if you're trying to type that API's JSON response, good luck

oh i just noticed the blog post

there could be a ton you know about the JSON, but to describe the type in Haskell's type syntax would be hell

and undocumented, so it's not like you could just bite the bullet and do it

it's a matter of incremental discovery

which really sucks when you have to type out your expectations ahead of time

you'd rather make the API call and print out what it gives you

anyway, I think the Haskell type system is really valuable, but it's not the end of the story

I can imagine better type systems (and so can many Haskellers)

Interesting comment by someone I used to work with: https://twitter.com/GHengeveld/status/1180191410676469761

so it's not dynamic vs static

it's more about Clojure vs Haskell

I share Gert's view, but for Haskell. I only used Scala for about 18 months, before switching to Clojure.

I'm working on an episode of my podcast where I talk about why I prefer Clojure over Haskell, even though I think Haskell has some benefits

as far as type systems go, I think they're the future but we have to live in the present

a type system that I would use would have to be way more expressive and cost less

it's nice when you get type checking for free without having to change your coding habits

Back at university, I worked with ML and Miranda and SASL while I was doing my research work and designing/building yet another FP language so I could experiment with syntax and semantics (and implementation issues around GC).

When Haskell appeared, I had really high hopes for it to go global and take FP into the mainstream.

Type systems are a whole design space that a language like Clojure can avoid

type systems need to be designed, and Haskell's is 50% not designed

Every few years, I go and try to re-learn Haskell, but I just get frustrated with it each time.

since it's used for research

and the half that is designed is designed for research applications

Haskell is a rather well-designed language overall, but there's still so much room for figuring out the type system

Clojure is well-designed, too

I have spent a fair amount of free time in 2018 learning Haskell, just so I could have a better judgement of this. I liked it, but more as an intellectual challenge than something I actually want to work with. Having my SQL queries type safe isn't the most important thing to me.

yeah

that gets into one of the things I don't like about the Haskell ecosystem

but I'll save that rant for my podcast

Where I had most frustrations with Scala was around database interactions. I suspect I would find similar frustrations with Haskell.

It wouldn't surprise me if this was more or less the same problem as spec1 where you have to make up a name for a specific set of key/vals (like is very common with query results).

So in a type system you have to make a new type for every slight variation of a query result is what I mean.

Yeah, or you construct these giant, complex, compound types with lots of optional fields.

oh yes.. Maybe everything 🙂

yeah, from my experience that’s a pain-point in Haskell to which I haven’t found an answer to

I think row polymorphism could be an answer to that. They have this in PureScript and Elm. I think that could work for Haskell, but they haven't figured it out yet as a language extension. They do have libs but they tend to be complicated and slow.

yeah the libs in haskell for row polymorphism are not.. practical

let’s put it this way

I asked a question to a couple of Haskell folks at a speaker dinner last week: what's the state of row polymorphism in Haskell nowadays? One of them replied: that's a troll question.

oh, Clojure thing on HN front page right now 😛

Another reply was: when are you going to remind us that spec is not a type system?

that's a real troll question

I think Haskell is going to have the same effect Lisp did

it's going to be a great experimental language that other languages borrow features from

Which reminds me: y'all should try this podcast episode with Hal Abelson: https://corecursive.com/039-hal-abelson-sicp/

He has a nice perspective on JS as a progression of Lisp and why it became popular

you know how that one guy did the experiment where he had some people go into psych wards and pretend to hear a voice that said "thud"

and that revealed that practicing psychologists were basically inept and not doing things in a scientific way even slightly

then there was a push to "standardize" stuff which is where we got the DSM

and then there was a news story about how alot of early psychology experiments aren't reproducible

thats what I wish would happen with programming

i want either something absolutely terrible to happen or someone to indisputably shame everyone so that everyone gets scared into actually trying

def. the wrong crowd for this rant, but "industry standards" and "best practices" feel like they are mostly gobbldeygook

I've met so many people who say "I want to use the best tool for the job"

but it honestly feels like a cop-out

I know that screams "hey we've tried to make standards before and design by committee is terrible"

but like

there is no guidance on how to pick the best tool

there is no actual adult in the room who knows

I keep thinking about one of the recent talks by the guy who made rails

where he talks about how open source is a gift, not a commitment, etc

but he brings up how he had to market rails

because, technology aside, the way to win people over was through marketing

it never mattered if you had tool that was good for solving a problem

Java won over C++ people back in the before-i-was-born's, but only with the help of a massive marketing effort

and it appealed to their personal experience, not to any real yardstick of "good"

and languages are only half of it

what database should I use?

mysql? why?

postgresql? why?

whats the difference and why does it matter?

"oh postgres can let you query over a blob of json" or "mysql can't do transactional data declarations"

honestly, i would just pick postgres because ive "heard good things"

but i can't tell you what any of those things are

ive been on a team that used a nosql database in a way that required joins

and it wasn't just lack of foresight, it was a lack of understanding why we would use something to begin with

nobody who learns sql is first shown why people even do the normalized stuff

how some old dudes in the past concluded that graph databases and object databases weren't flexible enough and now its just momentum (even if they are right)

its just "the standard"

the javascript situation is a microcosm of this kind of stuff

react/redux were a good set of things

but people used the tools by reputation, not on their merits

and boom react codebases move to vue, or dojo, or yam

(i made that last one up)

or from whatever tool that was high in the hype cycle to something else

but really the programming level of stuff is such a small part of the actual engineering needed to make a thing exist

how do I run a thing in a way that people can access?

There is a huge part of my small brain that still thinks of the internet as read only

like a computer in my house cant use the internet, not really

i have an ip, and i can expose a port, but my ip changes

its the "internet people" who can put stuff online

i should go through blogspot, or wordpress, or some minecraft server hoster, or aws, or whatever

even as a developer there isnt an escape

how do i run code?

well you write it, and run it on your own computer - simple!

but if you want to run it in a way that can support a buisiness you need to pick a way to do logging, a place to host the code, a way to scale to more people, how to deal with storing data

and there are people who think about that stuff constantly

but I heard splunk was good, so i am going to just google how to get splunk running on aws

grafana is great, but how did you set it up?

did you download it onto a node manually?

did you run a docker container?

why docker?

why does docker have a central thing you need an account with an external company to use?

i don't know where im going with this

all I know is that I feel emotionally exhausted

there isn't a programming language or anything in tech that makes me happy anymore

every company has their own homegrown solutions to stuff

and open source won't fix the problem

and I am not confident in my ability to make a rational decision anymore

Yeah, decades ago, it was all a lot simpler. You could actually run an internet service on your computer at home. I wrote my own mailing list server software in C and ran it on my home computer connected via dial-up -- and I managed mailing lists for fans of Peter Hammill (and a few other things).

Everyone using the mailing list knew that the server was only running from 7pm to 7am weekdays and then all weekend. It was too expensive to stay connected during "peak" day time.

(I paid per-minute for that connection)

I don't know how you'd even do that these days -- but of course why would you? There are so many mailing list services out there.

its kinda like how video game consoles are locked now

and even when they aren't, how can people even begin

maybe thats not the best example actually

unreal and unity do give a starting point for sure

and its a good one

maybe what the CS world needs is a religon

not just fads

im still in university for another year before im thrown on the job market

and one of our assignments for the software development class was to write some text specification for a toy problem

3 functions max

(they gave us a problem - it was just a trivial one)

and we picked our language for the class so we are supposed to say "do it in language X"

and it gets sent to another team

we got back a flimsy "we didn't know clojure so we wrote it in python"

which hurts their grade, but it kinda feels like people don't want to learn stuff

When I did CS, we did some pretty substantial final year projects. Mine was to write an APL interpreter. A friend wrote a Lisp interpreter (that had full native system call integration -- so you could use Lisp to write system utilities which was cool).

I wanted to write mine in Algol 68, which I loved, but none of the lecturers knew it well enough to review my project, so I ended up writing it in Pascal instead.

everyone in the class picked java, python, kotlin, typescript, or javascript

vast majority java and python

which isn't wrong but its telling that those are the only 2 languages other than racket that our college includes in the curriculum

so not many people actually learned stuff outside of lecture

regarding types, is TypeScript winning territory or are there still a lot of JS devs who prefer "vanilla" JS?

@borkdude my impression is that it is growing still, though no clue what the upper limit is

I see https://twitter.com/brandonbloom sometimes tweeting about his gripes with TS

@borkdude I work with a JS dev who is vehemently against TS

from my perspective TS is really nice

TS is a pure superset of JS tho', right? So why would a JS dev be so against it?

@seancorfield yes

In my experience, most JS devs are fine with TS as long as people don't start writing C# or Java like code with it (heavy class and enheretance use). This especially become a problem when C# or Java shop move to a node with TS backed, or devs with mostly experience in those languages start setting the direction for front end projects.

JS makes it hard to bring over those practices. TS seems to encourage it.

I have seen a lot of pro-type arguments like this: "48% of bugs in production would have been caught by the type system"

those are true positives

what about the false positives?

how many non-bugs would the type system have identified?

after using types, do you really have 48% fewer reported bugs in production?

that would be nice to know

or maybe a better metric: how many hours total have you saved?

Also how many of the same bugs would a good test suite catch?

meaning time saved from debugging column minus time spent coding the feature in the first place

i wonder if it just moves the cost around

does it have any effect on velocity or similar measures?

I've wondered if it detracts from the focus on the bigger domain problems by focusing too much time pleasing the type checker.

these questions are never answered

having worked in a haskell codebase, I did feel like it caught stuff

but then it was something that wouldn't have been an error in clojure

whereas maybe those things are problems in javascript that a type checker could really help with

all this said, I still have dreams of writing type systems for clojure

static analysis is useful