1. 3

    Chez scheme would probably win among the optimizing compilers in that list. It takes less than 5 minutes to build itself 2-3 times with optimization enabled.

    Last time I looked go barely does any optimizations at all! As for pascal, I recall reading that the language was designed to be compilable in a single pass through the source in order!

    1. 4

      Niklaus Wirth, notably, would not accept additions to the compiler that didn’t actually speed up the compilation of the compiler itself.

      1. 1

        The same story holds I believe for the chez scheme compiler. At least so I’ve heard

      2. 3

        Go now has an SSA intermediate form and does quite a lot more optimisation.

      1. 2

        Ooo. Thx for the shout out :)

        1. 10

          Regarding Eq and PartialEq being better in Rust than in Haskell:

          It is slightly better, but still terrible.

          Eq being a subtype of PartialEq is a mistake, conveniently obscured by its terrible naming.

          Instead, have Equality and Identity (i. e. say what it does not what it is) and suddenly things just work:

          trait Equality
            fun ==: Bool = ...
            fun !=: Bool = ...
          
          trait Identity
            fun ===: Bool = ...
            fun !==: Bool = ...
          
          NaN !=  NaN // NaNs are not equal ...
          NaN === NaN // ... but are identical!
          

          Same for Ord and PartialOrd: call it Comparable and Sortable and don’t have a subtyping relationship between them!

          1. 3

            Not even true for nan, you can have many NaNs that are not bitwise equal either, so NaN === NaN wouldn’t hold anyway. It’s even used in NaN packing.

            I don’t think there is a useful notion of identity as you describe, besides “bitwise equality” (which is a form of equality, being transitive, reflexive, etc.) Rust designers made a good call on that one.

            1. 5

              you can have many NaNs that are not bitwise equal either

              Different NaNs are different under ===, it’s bitwise equality.

              I don’t think there is a useful notion of identity as you describe

              It’s in the IEEE754 spec.

              Rust designers made a good call on that one.

              This design works. There is nothing more to say about it. Rust’s doesn’t.

              1. 1

                Yup. I would call it semantic vs representation equality, but yeah :)

                1. 1

                  Fair enough, you have a very specific bitwise equality on floats, some of which can’t even be printed differently. I don’t think it’s a good idea to have a whole typeclass/trait just for that though.

                  1. 1

                    A typeclass is fairly cheap. The mess Haskell/Rust produce? Not so much.

            1. 1

              Sublime merge inherits sublime text syntax highlighting?

              1. 2

                Hecate has been wonderful at helping support / build a contributor community around documentation for ghc! It’s not a bad way to get your feet wet contributing to a modern compiler that’s old enough to drink!

                1. 2

                  This looks almost cool. I’m surprised they don’t mention Datalog or its various recent siblings and children. I’m mostly surprised since the set flavored semantics they mention. Which very easily turns into stuff like monoids a la Haskell/ abstract algebra, as well as sane semantics on set valued computations forcing most/all functions/operations having some sort of monotonicity.

                  I could also just be totally misunderstanding the design I’m lazily guesstimating they have! :)

                  1. 9

                    Great news! I am eager to try this!

                    Turn on -XLinearTypes, and the first thing you will notice, probably, is that the error messages are typically unhelpful: you will get typing errors saying that you promised to use a variable linearly, but didn’t. How hasn’t it been used linearly? Well, it’s for you to puzzle out. And while what went wrong is sometimes egregiously obvious, it can often be tricky to figure the mistake out.

                    So, basically, GHC just got its own “Syntax error” a la OCaml… just a bit more specialized :p.

                    1. 11

                      Maybe it’s just me, but to me OCaml’s errors are terse and unhelpful and GHC’s errors are… verbose and unhelpful. ;)

                      There are interesting papers that show working ways to improve both, but I wonder why none of those improvements are in the mainline compilers.

                      1. 2

                        Good error reporting is easiest if it’s built into the compiler front end from the start. If a new algorithm comes along to improve the error information it’s almost never going to be a simple job to drop it into an existing compiler.

                        You need type information & parse information from code that’s potentially incorrect in both spaces, so any error algorithm usually has to be tightly integrated into both parts of the compiler front end. That tight integration usually means that improving compiler errors is a significant amount of work.

                        1. 3

                          It varies. What puzzles me is that a lot of time ready to use, mergeable patches take much longer to merge than they should.

                          Like this talk: https://ocaml.org/meetings/ocaml/2014/chargueraud-slides.pdf

                          1. 1

                            Do you also have a link for a patch for the improved error messages?

                            A lot of work has been going on to move OCaml to a new parser and improve error messages. Even though there is a lot still needed to be done, latest releases have started improving a lot. Maybe we can still extract some useful bits from that effort and try again

                            1. 2

                              Turns out it was even made into a pull request that isn’t merged yet: https://github.com/ocaml/ocaml/pull/102

                              1. 1

                                Thanks. It is quite an informative PR actually, and explains why the change is not there yet and once can infer why it is easier to add informative messages in new languages and complier but it may be quite hard to retrofit them to seasoned ones

                      2. 7

                        Would you be kind enough to give me an ELI5 about what linear types are and what you can do with them?

                        1. 29

                          In logic, normal implication like A implies B means whenever you have A, you can derive B. You have tautologies like “A implies (A and A)” meaning you can always infinitely duplicate your premises.

                          Linear implication is a different notion where deriving B from A “consumes” A. So “A linearly implies B” is a rule that exchanges A for B. It’s not a tautology that “A linearly implies (A and A).”

                          The classic example is you can’t say that “$3 implies a cup of coffee” but “$3 linearly implies a cup of coffee” makes sense. So it’s a logical form that reasons about resources that can be consumed and exchanged.

                          Same in functional programming. A linear function from type A to type B is one that consumes an A value and produces a B value. If you use it once with an A value then you can’t use it again with the same A value.

                          This is nice for some performance guarantees, but also for encoding safety properties like “a stream can only be read once” etc.

                          1. 6

                            Keynote: Linear Haskell: Practical Linearity in a Higher-Order Polymorphic Language https://skillsmatter.com/skillscasts/11067-keynote-linear-haskell-practical-linearity-in-a-higher-order-polymorphic-language

                            1. 5

                              It can be used to model protocols with type signatures. The following is in theory what you should be able to do.

                              data ConsoleInput
                                  = Input String ConsoleOutput
                                  | ExitInput
                              
                              data ConsoleOutput
                                  = PrintLines ([String] ⊸ Console)
                                  & PrintLastLines ([String] ⊸ ())
                              
                              greet :: ConsoleOutput ⊸ ()
                              greet console
                                  = let PrintLines f = console
                                    in step2 (f ["name?"])
                              
                              step2 :: ConsoleInput ⊸ ()
                              step2 ExitInput = ()
                              step2 (Input input console)
                                  = let PrintLastLines f = console
                                    in f ["hello " ++ input]
                              

                              If you combine it with continuation passing style, you get classical linear logic and it’s a bit more convenient to use.

                              If you model user interfaces with types, they should be quite useful.

                              I’m also examining and studying them: http://boxbase.org/entries/2020/jun/15/linear-continuations/

                              1. 1

                                Wikipedia gives a reasonable overview. The closest analogy would be something like move semantics – for example ownership in Rust can be considered as manifestation of linear types.

                                1. 6

                                  Rust ownership is linear affine types. Linear types are similar but differ in the details. A shitty way of understanding it is affine types mimic ref counting and prevent you from having a ref count < 0. Linear types are more a way of acting like RAII in that you might create a resource but just “know” that someone later on in the chain does the cleanup.

                                  Which I’m sure sounds similar but affine types allow for things like resource leaks but linear types should guarantee overall behavior to prevent it.

                                  This all assumes my understanding and explanation is apt. I’m avoiding a ton of math and i’m sure the shitty analogy doesn’t hold up but behaviorally this is how I have it in my brain.

                                  1. 2

                                    Linearity Design Space: https://i.imgur.com/s0Mxhcr.png

                                    1. 2

                                      I’m personally of the stance that the 2020 linear ghc stuff is more <= 1 usage, and kinda misses out on a lot of really fun expressivity that can fall out of making full classical linear logic first class. But that’s a long discussion in its own right , and I’ve yet to make the time to figure out the right educational exposition on that front

                                      1. 1

                                        it definitely seems more limited in scope/ambition compared to the effort ongoing for dependent types, for better or worse. Can’t say I know much about what first class linear logic would look like, but perhaps now there will be more discussion about such things.

                                        1. 2

                                          The really amazing thing about full linear logic is it’s really sortah a rich way to just do mathematical modelling where everything has a really nice duality. The whole thing about linearity isn’t the crown jewel (though wonderfully useful for many applications ), it’s that you get a fully symmetric bag of dualities for every type / thing you can model.

                                          The paper that really made it click for me was mike shulmans linear logic for constructive mathematics paper. It’s just a fun meaty read even at a conceptual level. There’s a lot of other work by him and other folks that taken together just point to it being a nice setting for formal modelling and perhaps foundations of category theory style tools too!

                                      2. 1

                                        Not sure I can agree that Uniqueness types are the same as Linear types. Care to explain they’re similar sure but not the same thing and your… screenshot of a powerpoint? isn’t very illustrative of whatever point you’re trying to make here.

                                        And from my experience with Idris, I’m not sure I’d call what Rust has Uniqueness types.

                                        1. 1

                                          They are different rows in the matrix because they are different, of course.

                                          it’s from this presentation about progress on linear ghc a little over a year ago https://lobste.rs/s/lc20e3/linear_types_are_merged_ghc#c_2xp2dx skip to 56:00

                                          What is meant by Uniqueness types here is “i can guarantee that this function gets the unique ptr to a piece of memory” https://i.imgur.com/oJpN4eN.png

                                2. 2

                                  Am I the only one thinking this is not how you ship language features?

                                  If the compiler can’t even report errors correctly, the feature shouldn’t ship.

                                  1. 15

                                    If the compiler can’t even report errors correctly, the feature shouldn’t ship.

                                    Its more this is an opt-in feature with crappy error reporting for now using computer programming design features not in use in most programming languages. Its going to have rough edges. If we required everything to be perfect we’d never have anything improved. Linear types like this also might not have a great way to demonstrate errors, or the domain is new so why not ship the feature for use and figure out what kind of error reporting you want based on feedback.

                                    1. 13

                                      Many people do not realize that haskell is a research language and GHC is one of the main compilers for it. This is an experimental feature in a research language. If it works out well, then it will be standardized.

                                    2. 5

                                      Other people have sort-of said it, but not clearly enough I think. This is not a language feature being added. It is a feature-flagged experimental feature of a particular compiler. Most such compiler extensions never make it into real Haskell, and the ones that do take years after they are added to a compiler to make it to a language spec.

                                      1. 4

                                        for all practical purposes isn’t “real Haskell” defined by what ghc implements these days?

                                        1. 2

                                          Yes, all the other implementations are dead. They still work, but they won’t run most modern Haskell code, which usually uses a bunch of GHC extensions.

                                          1. 1

                                            You might say “isn’t it not popular to write standards-compliant Haskell these days?” and you’d be right. Of course it’s often trendy to write nonstandard C (using, say, GNU extensions) or nonstandard HTML/JavaScript. However, ignoring the standard being trendy doesn’t mean the standard doesn’t exist, or even that it isn’t useful. I always make sure my Haskell is Haskell2010, and I try to avoid dependencies that use egregious extensions.

                                          2. 2

                                            Honestly curious: are there any other Haskell compilers out there? Are they used in production?

                                            Also, what is a definition of a true Haskell? I always thought it’s what’s in GHC.

                                            1. 5

                                              There’s a Haskell which runs on the JVM - Frege. But it makes no attempt to be compatible with the version of Haskell that GHC impements, for good reasons. Hugs is a Haskell interpreter (very out of date now, but still works fine for learning about Haskell.) There a bunch of other Haskell compilers, mostly research works that are now no longer in development - jhc, nhc98 etc etc.

                                              But GHC is the dominant Haskell compiler by far. I don’t think there are any others in active development, apart from Frege, which isn’t interested in being compatible with GHC.

                                              (“True Haskell” is the Haskell defined in the Haskell Report, but real world Haskell is the Haskell defined by what GHC + your choice of extensions accepts.)

                                              1. 2

                                                There are other compilers and interpreters. None of them is anywhere near as popular as GHC, and usually when one does something interesting GHC consumes the interesting parts.

                                                There is definitely a standard, though: https://www.haskell.org/onlinereport/haskell2010/

                                                The whole reason language extensions are called “extensions” and require a magic pragma to turn on is that they are not features of the core language (Haskell) but experimental features of the compiler in question.

                                              2. 1

                                                In short, GHC Haskell is a language designed by survival-of-the-fittest.

                                              3. 3

                                                Overly terse error messages are bad, but they are better than wrong error messages. Some things are much harder to give helpful error messages for than others.

                                                I wish people spend more time improving error reporting, at least in cases when the way to do it is well understood. There is no reason for say TOML or JSON parsers to just say “Syntax error”. But, YAML parsers are pretty much doomed to give unhelpful errors just because the language syntax is ambiguous by design.

                                                And then some errors are only helpful because we know what their mean. Consider a simple example:

                                                Prelude> 42 + "hello world"
                                                
                                                <interactive>:1:1: error:
                                                    • No instance for (Num [Char]) arising from a use of ‘+’
                                                    • In the expression: 42 + "hello world"
                                                      In an equation for ‘it’: it = 42 + "hello world"
                                                

                                                How helpful is it to a person not yet familiar with type classes? Well, it just isn’t. It’s not helping the reader to learn anything about type classes either.

                                                1. 1

                                                  I’ve seen some good suggestions on r/haskell for improving the wording of these errors.

                                                2. 2

                                                  The error they’re talking about is a kind of type error they’ve not worked with. It’s produced if you forget to construct or use a structure. I I’m guessing it’s technically “proper” but the produced error message may be difficult to interpret.

                                                  They’ve ensured it’s a feature you can entirely ignore if you want to. Everybody’s not convinced they need this.

                                                  I otherwise dunno what they’re doing and I’m scratching my head at the message. Something like “Oh cool you’ve done this… … … So where are the types?”

                                                  1. 2

                                                    So you never got a C++ template error in the good olden days? Seriously though, it just got merged. It’s not released or “shipped” in any means.

                                                    1. 0

                                                      So you never got a C++ template error in the good olden days?

                                                      No, because I looked at the language, figured out that the people involved completely lost their fucking mind, and moved on.

                                                      Seriously though, it just got merged. It’s not released or “shipped” in any means.

                                                      They took 4 years to arrive at the current state, which I’ll approximate at roughly 10% done (impl unfinished, spec has unresolved questions, documentation doesn’t really seem to exist, IDE support not even on the radar).

                                                      So if you assume that there will be a Haskell version in the next 36 years, then this thing is going to end up in some Haskell release sooner or later.

                                                      1. 2

                                                        So if you assume that there will be a Haskell version in the next 36 years, then this thing is going to end up in some Haskell release sooner or later.

                                                        Could you elaborate on this? If practical users of linear types will only use them if they have good error messages, and early testers want to work out the kinks now, what’s wrong with having a half-baked linear types feature with no error messages permanently enshrined in GHC 8.12?

                                                1. 111

                                                  Thanks for your efforts!

                                                  After four links, a domain can’t have a majority of its stories submitted from a single user.

                                                  As a datapoint, I currently can’t submit stories from my domain as I’ve submitted 14 (9 by others). I’m probably biased, but most stories have been reasonably well received so I’d consider that a loss.

                                                  1. 47

                                                    A simple tweak to this rule: bumping against the ceiling makes new submissions from that domain require mod approval. If posts are consistently well-received, mods can whitelist that (UserName, Domain) pair?

                                                    1. 9

                                                      I like this idea! If this is too much moderation overhead, maybe users with sufficiently high karma could see this queue and add approvals?

                                                      1. 12

                                                        Maybe. I dunno. I just threw it out there, but concerns around mod overreach and cabals of power-users are as old as time.

                                                        Tying site privileges to karma creates all sorts of Goodhart’s-law-shaped problems.

                                                        1. 3

                                                          Yeah, but maybe the same trust system that lobsters already has would work here: namely, a mod can delegate this queue to a user they trust? It’s all highly transparent anyway so abuse could be punished?

                                                          1. 2

                                                            A hidden, secondary confidence score that is calculated based on outcomes that are subjectively chosen is where pushcx may be heading with this in due time. Putting a number to it might be a good idea.

                                                      2. 39

                                                        As a datapoint, you are not alone. I wrote:

                                                        in the meantime bumping up against this limit posts a note to moderators so if it goes wrong we’ll see problems

                                                        This definitely went wrong.

                                                        My apologies to those inconvenienced by it, there’s a lot more false positives than I recognized. We’ve had a couple suggestions on how to reduce the error rate like only looking at the last N months or skipping it if any of the domain’s stories have done especially well (better than average or median?). I especially appreciate the folks writing and tweaking queries to try to build up our understanding, and I expect there’s probably some novel angle to separate noise from signal that we’ll think of in the next few days.

                                                        1. 10

                                                          There’s a “homepage” link in the profile. Perhaps the limit could be increased for your declared domain, (possibly, only if it’s unique across users?)

                                                          1. 4

                                                            This is a good idea, but what if the user is submitting from two blogs? For example, their personal blog and the blog of a project (perhaps a project the user contributes to) that the Lobsters community might be interested in.

                                                            1. 8

                                                              We have an authored by checkmark, that might work?

                                                              1. 2

                                                                How many people are doing that? I think it may be acceptable collateral damage.

                                                                1. 1

                                                                  Aren’t hats available for that purpose?

                                                                  1. 2

                                                                    Hats can’t be attached to posts… yet? Also, hats are generally used more for speaking on behalf/with significant involvement for more major projects, less associating sites to users. I suppose it can be changed…

                                                                    1. 1

                                                                      To clarify, are you suggesting that hats be used as a signal for increasing the (proposed) limit as to how many times a user can submit stories from a particular domain?

                                                                      1. 2

                                                                        No, but to have people make it clear that they are posting personal or project related. A separate limit per hat would be an idea yes for the post limit.

                                                                2. 2

                                                                  Perhaps rate limiting posts rather than an absolute limit (or some combination of trust - whatever that means, account lifespan, etc to generate a score/threshold coupled with rate limits).

                                                                3. 35

                                                                  Yes, this rule doesn’t really make sense to me. Users who write good stories will most likely be punished in this category.

                                                                  1. 25

                                                                    yes, I came to the comment section to ask specifically how to handle posting entries for our own blog posts. I enjoy blogging and this is one of the few places I share my blog posts. Don’t how to handle this now.

                                                                    1. 5

                                                                      So, it is mostly me posting my own stories as can be seen in https://lobste.rs/domain/andregarzia.com

                                                                      1. 4

                                                                        Yeah. I don’t blog about stuff as much as I should and lobsters is one of the good signal to noise places I’d wanna share with.

                                                                      2. 17

                                                                        Looking at @arp242 submissions, they look relevant and interesting, so I agree it seems to be a problem with the new algorithm. It will reduce the amount of interesting niche content - precisely what Lobste.rs should be about.

                                                                        I’m probably in the same boat as @arp242 as I submit posts from my domain. One of my submissions is a book announcement with 26 upvotes, and the other five are Elm and Postgres posts and projects, which are neither low-effort nor frequent (this is over two years). I agree with @akkartik’s comment that the timeframe needs to be taken into account too.

                                                                        I was going to suggest that the problem could be addressed by checking whether the user submitted other sites or participated in discussions, with an additional check for community approval in the form of a certain number of upvotes across submissions/comments. However, after looking at @UV’s comment history I see that they would have still gamed that, primarily because it’s still easy to get upvoted low-effort comments here.

                                                                        1. 16

                                                                          Same boat. On the other hand, maybe this will motivate me to start digging through your archives to find interesting things, because I can’t rely on you just posting them here for me ;)

                                                                          1. 11

                                                                            Yeah, it’s a hard choice. I like to think that my own stories, at least as of the past couple of years, are a reasonable fit for this community, and at my current rate of about one post per year I don’t feel like I’m spamming down the site. At the same time, we’ve all seen those account which just post blogspam article after blogspam article from the same domain.

                                                                            Maybe these measures are necessary, but I consider it a good thing that people like yourself, and drew devault, and other people who write in-depth about technology topics they’re genuinely interested in, are able to post their stories here.

                                                                            Besides, this restriction would mostly affect real users who have the community’ best interests at heart, right? If I was a marketing shill and wanted eyeballs I can show content advertising to, I could just create a new account every fourth article, right?

                                                                            1. 8

                                                                              If I was a marketing shill and wanted eyeballs I can show content advertising to, I could just create a new account every fourth article, right?

                                                                              I think we’re actually good in that case! You’d have to invite the alt account, making what you’re doing SUPER obvious. And then we’d bad the entire domain, so you’d never get links from lobsters ever again :D

                                                                              1. 3

                                                                                I sat down at my laptop after work to respond to this because, yes: I was aware of the perverse incentive, but at least it’s pretty darn obvious and it reveals bad intentions. And I was distracted from finishing this comment to investigate and confirm that, yes, this happened.

                                                                                1. 2

                                                                                  Why was this user banned? The user submitted 3 things, all of which are relevant and on topic? One of the github links is pretty low quality, but again, not off topic.

                                                                                  Or, maybe the things I want to see no longer align with the site…

                                                                                  1. 2

                                                                                    They were a sockpuppet of vermaden, not a person. I left the three on-topic stories that he submitted as cover for a link promoting his blog.

                                                                                    1. 2

                                                                                      Thanks for the explanation!

                                                                                      So, if that’s provably the case that the account was a sock puppet, ban vermaden?

                                                                                      But, how is having multiple accounts any different than asking “joe rando” to post on my behalf, which I did today (it happened to be posted by someone I actually know, but only after I asked)?

                                                                                      I’m going to start following the hashtag on twitter “#promotemeonlobsters” and submit links that appear to be on topic, that don’t appear to be spam to me.

                                                                                      If I get enough people also do this, there will be a wide variety of potential submitters to these stories, making this silly change irrelevant. Additionally, cannot exactly ban submissions found in that stream, since I can plausibly deny I found it there, and not directly from the source by happenstance.

                                                                                      OR, you could stage same domain posters, showing them to a random sampling of users until they reach some upvote threshold (say 3?), at which point everyone can see them. While you’re at it, perhaps this should be the way all posts start out…

                                                                                      1. 2

                                                                                        I thought about banning vermaden for the sockpuppeting, but I don’t read him as a badly intentioned content marketer, I read him as overly enthusiastic about FreeBSD. And if he’s clever enough to find bugs and foolish enough to not realize I’m paying a lot of personal attention to him while he does it, I’d rather let him continue a bit to catch other bugs/misdesigns.

                                                                                        1. 1

                                                                                          I’ve reread your comment multiple times now, am taken aback, and instead of replying how I really feel about it, I’m going to :eyeroll: and leave it be.

                                                                              2. 8

                                                                                Want to second this.

                                                                                It feels like a rule that will punish personal blogs. I’ve been posting stories from my personal blog here before, I’m not sure if there are stories from my blog others posted. I think they match the content people expect here (mostly infosec related) and I don’t think that’s abuse, some of them got well received.

                                                                                If I’d post on medium etc. I wouldn’t have that problem.

                                                                                1. 5

                                                                                  It could be time bounded, or tested against multiple time ranges?

                                                                                  For instance, user cannot post from a domain if more than half of stories in the last 6 months are from them.

                                                                                  Or combine that with the original: a user cannot post a domain if they are more than half of all time posts AND they posted more than half within the last 6 months. That way if you could be the majority of all time, but not the majority of recent posts, or vice versa, and still be allowed to post for a certain domain.

                                                                                  And “the last 6 months” could be 3 months, could be 1 year, or what-have-you.

                                                                                  1. 3

                                                                                    I agree. The four link thing is kinda messed up. I write essays every couple of weeks or so, all about making better tech. I’ve spent some time making sure there’s no ads, no email lists, no sales at all on these links. I can’t make them any more innocuous, and I use the comments and feedback from here to learn more and (hopefully) write better stuff.

                                                                                    It doesn’t make sense that I can’t keep doing this. Perhaps the four link rule would work better when the domains were already high traffic sites? You don’t wanna kill the mom and pop grocery stores simply because you don’t like the new WalMart moving into town.

                                                                                  1. 3

                                                                                    Company: Facebook

                                                                                    Company site: facebook.com/careers

                                                                                    Position(s): Software engineer

                                                                                    Location: ONSITE in NYC, Seattle, or Menlo Park

                                                                                    Description: I’m on a runtimes optimization team. We’re looking to hire some experienced and also some junior people in the next 6-8 months.

                                                                                    Tech stack: C++

                                                                                    Contact: DM me on lobste.rs to kick off, comment for clarification questions, etc

                                                                                    1. 2

                                                                                      Placement on teams is after the boot camp thing? I’ve my on-site next week though based near astor place area atm area already. Would love to informal coffee chat about that area of work in the nyc office sometime

                                                                                      1. 1

                                                                                        Correct. But you generally get to choose from all the teams available after chatting and working with them – not placed by upper management.

                                                                                      2. 1

                                                                                        We have openings for Production Engineering roles (hybrid SRE/SWE roles) as well in those same 3 offices + Boston.

                                                                                        Tech stack is too large to list and a lot is obviously custom built in house, but in general coding, systems and networking skills are required.

                                                                                        We support teams across all of infra, from networking, storage to product teams and more.

                                                                                        Happy to answer questions by DM.

                                                                                      1. 2

                                                                                        Zero for erasure is a pretty fun design choice and one I’ve actually played around with in some language design stuff four years ago.

                                                                                          1. 1

                                                                                            Oh awesome, this is quite a bit more readable than the paper. Thanks for sharing!

                                                                                          1. 3

                                                                                            The code is on GitHub here ! https://github.com/plasma-umass/coz

                                                                                            It seems like worth trying out tool

                                                                                            1. 3

                                                                                              At least two of the authors have been using automatic differentiation prolifically for at least a decade before it was cool ;)

                                                                                              Barak P and Jeffrey mark siskind specifically.

                                                                                              I’m definitely printing this out and taking a deep read.

                                                                                              1. 71

                                                                                                Here’s a script to migrate your repos to hg.sr.ht:

                                                                                                https://hg.sr.ht/~sircmpwn/invertbucket

                                                                                                1. 4

                                                                                                  I like competition in general. Sometime I love watching it happen, though. :)

                                                                                                  1. 6

                                                                                                    hey @SirCmpwn thanks a ton for that script. Just imported 19 repos (both git and hg) into sr.ht. Some of those repos were 9 years old. : )

                                                                                                    1. 3

                                                                                                      Great :)

                                                                                                    2. 1

                                                                                                      I went ahead and got a subscription for Source Hut even if I may only use it as a mirror for now.

                                                                                                      I think diversity is good and would like to play more with it in the future :)

                                                                                                      1. 0

                                                                                                        I’m trying to do this migration and i’m gettin some errors related to JQ, “parse error: Invalid string: control characters from U+0000 through U+001F must be escaped at line 2, column 34”

                                                                                                        where the bug track or whatever i can report this to you for? :)

                                                                                                        1. 2

                                                                                                          Can you pull down the latest script and try again? I haven’t set up a bug tracker for this script.

                                                                                                      1. 1

                                                                                                        my mac blocks launching the app, something about “apple thinks this is malicious”, anyone else seeing that?

                                                                                                        edit: to open totally unsigned apps on mac, you need to ctrl+click i guess?

                                                                                                        1. 1

                                                                                                          Yeah. The release notes have a paragraph on this but it’s located at the bottom which makes it a bit surprising upon first encounter.

                                                                                                        1. 1

                                                                                                          i’ve been juggling some consulting, and slowly getting my numerical haskell project ready for alpha. The first layer (and the bulk of the alpha) is a very very awesome array library. (though i’m still fine tuning a lot of the api). One really cool thing i’ve realized is that a very well designed array library looks kinda like a very very optimized database library specialized to a read heavy workload.

                                                                                                          1. 2

                                                                                                            i actually think theres a nice evolutionary roadmap to make haskell a compelling substrate. The abstraction and performance are there, whats missing is a nice “cookbook” of idioms that make it clear how to structure analytical codes and scripts. People are still figuring that out honestly

                                                                                                            1. 3

                                                                                                              I’m just curious if there are any open-source projects that anyone knows of that could particularly benefit from having some extra help!

                                                                                                              1. 5

                                                                                                                NMatrix ( https://github.com/SciRuby/nmatrix ) for Ruby is one I’m aware of that I believe is always looking for active contributors.

                                                                                                                1. 4

                                                                                                                  i’m in the process of getting Numerical Haskell ready for release, which I hope will provide a path towards eventually improving the state of mathematical/numerical computation. Thats said, will be a anther few weeks before its “easy” to jump in and help contrib.

                                                                                                                  1. 2

                                                                                                                    All of them?

                                                                                                                  1. 2

                                                                                                                    I actually gave a talk that expanded on Nathan’s Ideas with some toy examples and background info last summer at the NYC Haskell meetup https://vimeo.com/69025829 was the video (nb i didn’t write the video title, was someone else) plus example code https://bitbucket.org/carter/who-ya-gonna-call-talk-may-2013-ny-haskell

                                                                                                                    1. 1

                                                                                                                      I have an ongoing love/hate relationship with Scala.

                                                                                                                      I find it incredibly complex, often hard to reason about, I semi-regularly hit issues where I am rewritting code because the type inference gets confused. I often find it harder to understand other people’s scala code than even some of the more obscure mixin ladden ruby code that I’ve seen (my previous high watermark for code I regularly interacted with that left me scratching my head.) I maintain some legacy scala code that code work just as well as Java code. And on and on. I could write/talk about the issues I have with scala and the tradeoffs in it and how it used. All of those things aside, there is a core of goodness in scala.

                                                                                                                      I wish there was a simpler, easier to reason about, type safe, flexible, functional friendly, well supported jvm language. Perhaps someday there will be but at the moment, the closest thing to my ideal for the tool I need when I reach for Scala, is currently Scala, warts and all because nothing else tops it on the “well supported” front.

                                                                                                                      I’m also interested in knowing what are the alternatives if you want:

                                                                                                                      runs on jvm statically typed (w/ a powerful type system rather than a weak one like java’s) good jvm interop functional friendly, ideally also oo friendly well supported simple core to the language

                                                                                                                      and what of those you give up with the various alternatives.

                                                                                                                      Anyone care to comment on the strengths/weaknesses in the general categories above of any languages they use?

                                                                                                                      1. 4

                                                                                                                        I don’t believe Scala has “good” JVM interop:

                                                                                                                        • Full interop to awful Java code is not a part of what I consider being good
                                                                                                                        • Interop shapes Scala and causes Scala to not be able to do good things and requires it to do very bad things
                                                                                                                        • It’s not safe, e.g. I think NullPointerExceptions should be handled at every interop point (into OptionT)

                                                                                                                        Scala’s interop with Java is just a cost. I’d much prefer an FFI:

                                                                                                                        • I’d write a quick and sensible Java API wrapper around any nonsense Java API
                                                                                                                        • Scala language could change independent to FFI
                                                                                                                        • We could encode null and exceptions in the types!

                                                                                                                        Frege, Ermine and Idris all provide something like what I want. The “well supported” part is a question, but I don’t even know what I’d consider to be a “well supported” language.

                                                                                                                        Also, I think the JVM is extremely overrated. People often say they use it because it’s fast - but they only consider that Java-like code on the JVM is fast - so far, functional code is often quite slow on the JVM.

                                                                                                                        So, we want fast, functional and the JVM - it might eventually be possible to achieve all three but without much development, we can really only choose two. My pick is moving Scala code to Haskell.

                                                                                                                        1. 2

                                                                                                                          emphatic agreement about the horror / pain that is every Scala value being nullable by default. That alone has kept me from really trying to write good code in scala