neeeeees

I may be missing something - why is tolower(c) incorrect here?

I think it’s just a much harder problem than Netflix or Youtube recommendations - Amazon has at least 500 million products, and people aren’t buying individual products at the same scale as they watch videos. Has anyone with >1000 products really nailed product recommendations without large precision losses?

“Ever” in practice is usually a few months or years.

Seems similar to this work out of Salesforce a few years ago: https://www.salesforce.com/blog/2017/08/salesforce-research-...

This sounds like Fundamental Attribution Error: https://en.m.wikipedia.org/wiki/Fundamental_attribution_erro...

The test suite is ultra important. Even in the unlikely case that you have an engineer who thoroughly understands the machine and language specs, you have a ton of existing, useful, programs that rely on under-defined behaviour in one or both of them.

This is really a build system issue - ie figuring out which parts of the (mono)repo are affected by which change. Bazel, for example, depends on explicit, per-directory, BUILD files, and does a fairly good job of finding dependants.

On the topic of haptics, I thought 3D touch was a gimmick, but LOVED it on my iPhone 6S. Extremely useful for previewing links, moving the cursor etc, and very intuitive. Then they scrapped it in favour of press and hold on the new iPhone, and it’s slowed me down considerably.

Very cool product, and could be useful for learning also.

I suspect the fundamental [business] limitation of a tool like this is that those willing to pay recurring big bucks (medium to large software shops) tend to rely minimally on 3rd party APIs.

Those who benefit the most (weekend projects, learning, rapid prototyping) where time is of the utmost value generally wouldn’t end up using it enough to become recurring customers.

Interesting suggestion! I'll definitely check it out. Looks like this, along with generics, will make the library a lot easier to write. Thanks!

Thanks! I've updated the doc to Markdown as suggested by other commenters, so it is now available at https://github.com/neeilan/neeilang/tree/master/doc/Lang.md

This main goal for me is learning and not developing a production-ready language. When picking the feature set, I wanted something like Java (OOP, GC, no arbitrary pointers) but without a VM.

I think implementing TypeScript natively would be a very interesting project, but the 'all valid JavaScript is valid TypeScript' part of the spec means you're also implementing an AOT JS compiler, which is much more challenging.

Not discouraging at all - that's a very valid point! Funnily enough, I wanted to try implementing an OO language because they are popular... I use them a lot, which makes it important for me to understand how they work.

Just an itch to understand the tools of the trade better!

1) LLVM IR is strongly typed, which makes it very challenging to implement a dynamically-typed language on top of it. AFAIK, there aren't many (any?) successful such implementations of dynamically-typed languages. I haven't used other backend libraries, but I do think that looser typing at the IR level would make it a lot harder to catch implementation bugs; at least with LLVM, you are likely to hit an assertion if you break typing rules in the IR.

2) The type-checker is fairly ad-hoc, and I admittedly didn't look much into the literature here. The general idea is that since variable/function/class field types are explicitly typed, every expression can be checked for violating it's expected type. Implementation-wise, this is facilitated using the visitor pattern [1]. For certain expressions, some extra flexibility is allowed - for example, assigning an object of a child class to a variable of the parent class is not a type error.

[1] https://github.com/neeilan/neeilang/blob/master/src/type-che...

Hi HN!

I’ve been working on this language for about 4 months now. While not “complete”, it does have a number of nice features like virtual functions, type inference, etc.

I reckon it will not be truly useful until GC is added, and that’s what I’m currently working on.

Any feedback is welcome and appreciated!

That is correct, and I should have made that clearer. However, a lot of it’s features are implemented in Swift (via custom operators, overloading etc) in addition to compiler intrinsics.

The point I had in mind was that a language like Swift may allow for both power and DSL-like expressiveness without requiring learning an entirely new language. In fact, standard arrays are implemented in Swift code (https://github.com/apple/swift/blob/master/stdlib/public/cor...) yet feel closer to say a Python list than a Java ArrayList from the user’s perspective.

Like a few others have mentioned, I do wonder how big the marginal return in baking in these features is.

From a quick look, stuff like FASTA/BAM parsing, translation, etc can be implemented in C-land a la numpy, and called from Python, right?

A language like Swift would also support the addition of powerful user-defined operators, as in the case of Swift for TensorFlow[1].

Language adoption is hard to drive, and I wonder if having domain-specific library calls built-in is worth the added effort for people in the field.

[1] https://www.tensorflow.org/swift

If you're looking for something more entertaining than a reference-type grammar book, I'd recommend Dreyer's English.

(https://www.penguinrandomhouse.com/books/232363/dreyers-engl...)

I’ve always found Impossible’s “versioning” scheme amusing.

One of my favourite burger joints recently shifted from offering Impossible v2 to v3 for their patty, as v3 supposedly resembled meat more closely.

However, I thought that v2 tasted much better while avoiding the “uncanny valley” of meat substitutes... I wish they would keep them all available rather than phasing out older versions.

I noticed something really interesting around the 2:09 mark in the video - the chimp taps a box, and goes on to the next one very quickly, but realizes that the initial tap didn’t register properly and goes back to fix it.

I definitely commit a “mistap” error like that at least once a week on my phone / iPad. I’m not sure I can spot and fix them that quickly!

A PM that worked on Excel in the late 2000s explained it to me like this: Most people use about 20% of the features in Excel - which should make it easy for competitors to copy, right? The kicker is that different people/industries tend to use a “different 20%” of the features, making the barrier to really compete very high.

What’s wrong with C#?

If you haven’t read it already, I highly suggest Sam Smith’s “The Jordan Rules”. It’s really fascinating to see the tension that’s present behind-the-scenes even on a team that is super successful on the court.