Hacker News Reader

Comment by tombert | Hacker News Reader

As a former Jet employee, this makes me pretty sad.

I took the job at Jet because I wanted to learn more about F#, coming from a Haskell background, and I was happy to find that my coworkers were all really smart people and the codebase, while far from perfect, was written using functional concepts, and avoided the "writing C# in F#" trap.

I left Jet partly because there had been talks of absorbing Jet into Walmart, which was fine, but also moving everyone to a JVM stack and off of F#, and I'm not a huge fan of Java. This, in combination with an offer from one of the big "brand name" tech companies, gave me an impetus to move on.

Still, I will always miss my time at Jet. It was an incredibly fun work environment that fostered learning and was typically very good to its employees.

View on HN

Repeat after me: "JVM is not Java." Clojure and Kotlin are the perfect proof of that. If you actually look closer, JVM is a pretty cool piece of technology. Too bad that it is doomed to be associated with Java forever.

The performance characteristics are similar are they not?

In the context of the original comment, aren't the performance characteristics of .NET pretty similar to the JVM (though I have no experience with the former)? I don't see big reasons why someone who likes C# would hate Kotlin. F# is pretty different from the available JVM languages though.

The startup time of .NET is nothing like JVM's in my experience.

A .Net terminal "hello world" takes a good 2 or 3 seconds on my computer. Yay... :-/

How fast is it the second time?

You must be running an old version of .NET or running a computer from 2007. I just created Hello World with .NET Core 3.1 on my 2014 iMac and it's instantaneous first time and subsequent.

I would say that Scala on the JVM is comparable to F#.

Only to an untrained eye. F# is a firmly rooted in ML language family history, only making concessions where necessary due to the fact it's running on the CLR. Scala is a random walk of language design space, with different ideas either working or ending up complete trainwrecks, and the fact it's missing this clean ML core makes it a painful language to pick up coming in from F# (or in fact most other statically typed FP languages).

I mean, considering that Scala has a much more powerful type system than F# and you can actually implement FP concepts like monads, functors, etc makes it arguably more FP than F#.

While I haven't used F# much, as a professional OCaml and Scala dev, Scala is hands down the more powerful language. OCaml isn't bad, but it leaves a lot to be desired.

A little offtopic, but if OCaml got rid of its module system, added type classes, polymorphic functions, higher-kinded types, multi-core support and removed objects (not that it matters that much), it would be my dream language.

Basically, I want Haskell without the dogma. Though, I guess that's what unsafePerformIO provides!

Why do you say you cannot implement monads and functors in F#? sorry but this is bullshit

F# doesn't support higher-kinded types.

That doesn't make functors and monads impossible to implement.

Of course not, but it means that there is no type that abstracts upon all of them. For example, in Haskell, you can >>= and >> just about everything and it'll work. In OCaml (and I assume F#), you have to import the right kind of >>= and >>. This is quite burdensome and creates a lot of repetitive and nasty code. The lack of polymorphism in ML languages is such a bummer.

Ostensibly yes, but F# has limited and clunky compile time ad-hoc polymorphism mechanism that can be used to implement "type classes" - which however can be abused to great effect if you really want generalised binds https://github.com/fsprojects/FSharpPlus.

Not to mention it has subtype polymorphism on par with what you get in C# that you can really get a lot of mileage from (and which gets too easily glossed over by some FP neophytes), AND an extensive reflection API to bridge the gap if you have nothing else to fall back to.

Sure, Scala has fancier stuff on the high end of things, but it doesn't nail the basics the way F# does. I don't feel like sacrificing day-to-day productivity so I can skip duplicating some code with recursion schemes.

Your dream language sounds a lot more like F# than Scala tbh.

F# doesn't have (easy to use) type classes or higher kinded types, but has simplified modules and full access to .NET object system for all your polymorphism needs, and a much more seamless interop with the platform it's running on as there's significantly less "magic" happening in the compiler compared to Scala.

And the limitations too. If something (for example, unsigned numbers) is not provided by the JVM because it was declared useless for Java, most languages running over the JVM won't implement it either (and otherwise it would often mean resorting to a layer of more or less dirty and slow workarounds to circumvent the limitation).

> Too bad that it is doomed to be associated with Java forever.

Maybe because it's in the name ️

Eh, I don't think JavaScript is really associated with Java these days.

True, but that took decades of reeducation. For a language that literally had no relationship to actual Java.

Absolutely - hard to believe that at the time Java was SO COOL that the name 'JavaScript' seemed like a really good idea.

It is and always will be at least among people who are unfamiliar with technology.

It was referring to the JVM

It is a cool technology, but with the rise of docker (and related technologies), running things cross platform has less importance than it once did.

I'm not saying it has zero importance, just less than the 90s/00s.

If Java had been able to provide it historically, "cross-platform sandboxed acceptable-to-high-performance execution of untrusted code" effectively describes WASM, which seems to be a fairly major emerging technology these days.

Perhaps JVM bytecode is arguably just too complex for safe verification... (although JavaCard interpreters manage to do it for a restricted subset (with similar restrictions to WASM!) without too many problems)

I should have clarified; they were moving mostly to Kotlin and Java.

I don't have a problem with the JVM; virtually all my personal projects nowadays are in Clojure, and I actually gave a talk at Conj last year....so yeah, I'm a fan :).

This is disappointing to hear. When Jet was acquired, I thought a significant motivation (and justification for acquisition price) was to give Walmart access to the Jet’s tech stack. Apparently this was not the case.

I think that's still kind of true; a lot of the infrastructure was lifted or fitted into Walmart's stack, and IIRC the algorithms for the web scraping and indexing team was used.

Disclaimer: The accuracy of this should be taken with a grain of salt, I wasn't involved with any of the decision making.

Walmart's a big place, so I don't mean to contradict my sibling comment.

Across the Walmart.com websites I didn't see anything from jet tech. The only thing I heard talk of was essentially reporting to push Marc's basket economics passion.

I believe Jet's acquisition was essentially a way to buy Marc Lore as eCommerce CEO.

I've met with many Jet folks and they are an awesome crew to work with, but Jet didn't really operate at Walmart scale.

Walmart has been running on Jet tech stack heavily as far as supply chain side of things is concerned.

Both the distribution centers and the technology driving them have been integrated with Walmart systems early on after acquisition and many current and future developments in that area are based around formerly Jet tech written in F#.

That's not going anywhere.

I’m mostly mad your getting way more Karma than me right now.

I wouldn't touch a Java or JVM job either. Smart choice!

Reply on news.ycombinator.com