2,724 karma · joined May 30, 2016
Java keeps getting more popular, pushed by the very solid innovations that Oracle has been trickling into it every release, and Kotlin has certainly picked up a lot of momentum these past five years.
Maybe this technical choice makes that person happy, but what if it makes ten other developers on the team unhappy, or unable to do their work because they don't know this new technology?
What if that technical choice makes the whole code base unmaintainable in the following months because it gets abandoned, or is just so niche that it's impossible to hire developers familiar with it?
Basically, a timid but interesting step to get Swift to move toward ownership semantics, on top of its current Arc based memory management.
Rust has become all that, and for a change, I am happy to observe that we're stuck with a pretty good language.
What other ways do you have in mind?
I am not aware of any Haskell functionality or compiler flag that enables implicit parameter passing, like Java, Kotlin, and Rust allow.
That's like saying "There will never be bugs".
There will be bugs.
And when you come across one and you can change a variable and have another variable affected in some other part of your program and you have no idea how these two variables are connected, you are going to have a nightmare of a time debugging.
Basically, a formalization of Dagger/Guice into a language.
Rust, Haskell, Kotlin, yes. They force you to consider the error path.
Go makes it all too easy to just ignore errors and produce crashy code.
A string with quotes goes into the executable.
A `String` exists at runtime and is an entire string.
An `&str` is a slice of a string: it points to an existing string for a certain number of characters.
Not all programs or programmers require this amount of knowledge, but if you want to understand programming at a deeper level, Rust is a great tool to dive into the deep end to understand complex topics about programming languages.
All programming paradigms can do that, you are not making any particularly salient point about OOP here.
OOP doesn't mean that everything needs to be an object, but inheritance and shared behaviors are concepts that map neatly between the real world and the programming world, which is why OOP has been such a resounding success.
We have refined this approach now (e.g. using delegation over inheritance), but these basic concepts of shared behavior and reuse remain.
The negative reactions that a lot of people have toward Lisp's parentheses are not because of the call function syntax but because parentheses are used everywhere else in Lisp's syntax.
For example, STX. You could emulate it with PHA, TXA, STA, PLA.
But overall, you are correct that the 6502 was extremely primitive in various ways, especially compare to the 8080 and followers.
I apologize for being skeptical but the wording in the contract seems to be extremely handwavy and they don't give me any confidence that if my bill goes from $4 to $200 that month because I made it to the front page of reddit, my bandwidth will magically be waived.
Right now, I feel 100% sure that my credit card would get charged.
You have enumerated a lot of alternatives so far (prepaying, waiving attack costs) but you still haven't addressed the number one scenario that everybody has been asking about, and which was the reason why Heroku was such a hit: do you offer a flat fee which, if exceeded, simply shuts down the app until the next billing cycle?
That statement is upvar [1]. Read its description and despair.
> Add a mult command to memcached.
Kotlin and Java are the main languages supported on Android.
Monads are the same thing, but for functions.
They adjust the output of one function so it can become the input of the next one.
Yes, which is why it's recommended to name your closure parameter (instead of using `it`) when you nest these.
You are missing the point.
What Kotlin gets right here is that most of the time, these closures only have one parameter so it allows you to not declare that parameter and instead, use `it`. Smalltalk (and many other languages) missed that simple quality of life improvement, but once you get used to it, it really makes the code more readable. Obviously, you can always decide to pick your own name anyway, so Kotlin's approach subsumes Smalltalk's here.
> I think Smalltalk seems "quirky" compared to your Kotlin example only becuase we've all gotten used to a standardized C-inspired syntax.
My examples are not complaining that Smalltalk uses [] instead of {}, please reread what I wrote. Smalltalk is making a lot of bizarre syntactic choices that really only impede readability with unnecessary symbols (e.g. the . terminator).