yes https://rancher.com/ is doing good job about k8s 
mkunikow
mkunikow
gausby
And the performance and benchmark is important as well. Please don’t judge other on your personal opinion.
I don’t know if that was directed at me for asking what kind of performance you are seeking. I hear the argument that x technology is not fast enough, but in my experience the languages I have worked with (now and in the past) has been fast enough—because it turns out that the performance I need for the problem space I am in is IO bound, and very rarely CPU bound.
gorav
Thanks for the tips. I have been thru those topics and covered Elixir in Action to a great deal.
Typically, when I am adding members to my team and dont find direct match in terms of specific language being used, I adopt this approach - look for devs who have solid foundation of concepts, make sure they are committed and interested in stack that we are using in the project and then give them time to pick up language specifics while tackling simple tasks. Its relatively a safe bet.
So, I am not thinking myself as a junior developer. What I was trying to convey is that I am willing to start as a Junior/Developer on a project to give comfort feeling to the employer to take “risk” with a dev with no prior commercial experience in Elixir (but fair understanding of the language and framework having done 2 non-commercial projects), prove myself and then progress to tackling tasks matching my skill-set while learning quickly the additional bits of knowledge that I need to gain to ensure effective delivery.
The point I was trying to make that even this approach did not help much in securing a job as Elixir developer since most of the requirements are primarily for “Senior Developer” or with prior experience, which is a big hurdle in adoption, IMHO.
hauleth
It highly depends on the developer background. If one has even slight experience with FP then it will be much easier. In general jumping from imperative language like Ruby/Java/Python/etc. to Elixir will introduce some friction, but it is understandable.
StefanHoutzager
- the learning resources + help from this forum are great. I came from an imperative / OO background.
darkmarmot
-
The Elixir plugin for Webstorm is actually the best IDE I’ve used for it by far (the color coding is so much better than the alternatives).
-
Raw CPU performance is pretty lackluster compared to things like C++ or even NodeJS – but being able to fan out to dozens of cores with virtually no effort is pretty amazing. Adding in things like Hastega (for GPU) and Rustler (for Rust NIFs) will probably cover a lot of critical performance paths in the future.
-
As someone who’s gotten paid to write in maybe 10 different languages… I agree. The shift to FP/OTP/Beam is a big one, but I think worth doing.
-
I think DocTests are amazing! You finally know the docs are correct – because they compile!
Refactors are painful, the sad lack of types can be somewhat mitigated with Dialyzer.
Thoughts —
Often agree.
zacky1972
Creator of Pelemay
Thank you for your introduction!
Hastega slide is here
Video is here
I hope your happiness!
hauleth
I do not know where sandy you feedback, but on slide with comparison between approaches this:
1..1_000_000
|> Enum.map(&foo/1)
|> Enum.map(&foo/2)
And this
1..1_000_000
|> Enum.to_list()
|> func()
def func([]), do: []
def func([h | t]), do: [h |> foo |> bar | func(t)]
Aren’t equivalent in execution, as first one will create new list with elem1 = foo(elem) and then it will create new list with elem2 = bar(elem1) while second will create it in single pass, so you will not traverse list twice. What you wanted is:
1..1_000_000
|> Stream.map(&foo/1)
|> Enum.map(&bar/1)
Which will work similarly to your example, but that will make Java example “outstanding” implementation (unless compiler is smart enough to optimise that out).
lpil
Creator of Gleam
It’s worth noting that there is an overhead to using streams so it’s worth benchmarking your application to ensure that this change has the desired performance benefit.