I would think competition of selling to retail be as fierce as successful ways to trade?
[...]
There are still few areas of trading that lack decent apps, but cause most traders do not venture into them, would seller of apps even bother to spend years even to develop those apps knowing few be sold.
Gotta clarify one thing. I have a job as software, been doing it for 20 years already and likely will (have to) do it for the rest of my life. So "success" with whatever extra-job work I do doesn't mean I necessarily have to strike it rich, although I wouldn't mind it, but to keep my skills sharp and my employment prospectives real, should I need them. Anyone who does software for a living knows how disfunctional the industry is and it's not getting any better. The competition is fierce and ruthless and you gotta do what you gotta do to stay in the game.
Remember, when you apply for a job, you compete against "rested minds" who can focus ADHD-style on whatever irrelevant crap it takes to pass the bar exam.
For instance. When you apply for a C++ developer position, you can write your algorithm this way:
=========
void compute(int n)
{
int i = 0;
for (int z = 1; ; ++z)
for (int x = 1; x <= z; ++x)
for (int y = x; y <= z; ++y)
if (x*x + y*y == z*z) {
printf("%d, %d, %d\n", x, y, z);
if (++i == n)
return;
}
}
=========
Or you can write it like this:
#include <iostream>
#include <optional>
#include <ranges> // New header!
using namespace std;
// maybe_view defines a view over zero or one
// objects.
template<Semiregular T>
struct maybe_view : view_interface<maybe_view<T>> {
maybe_view() = default;
maybe_view(T t) : data_(std::move(t)) {
}
T const *begin() const noexcept {
return data_ ? &*data_ : nullptr;
}
T const *end() const noexcept {
return data_ ? &*data_ + 1 : nullptr;
}
private:
optional<T> data_{};
};
// "for_each" creates a new view by applying a
// transformation to each element in an input
// range, and flattening the resulting range of
// ranges.
// (This uses one syntax for constrained lambdas
// in C++20.)
inline constexpr auto for_each =
[]<Range R,
Iterator I = iterator_t<R>,
IndirectUnaryInvocable<I> Fun>(R&& r, Fun fun)
requires Range<indirect_result_t<Fun, I>> {
return std::forward<R>(r)
| view::transform(std::move(fun))
| view::join;
};
// "yield_if" takes a bool and a value and
// returns a view of zero or one elements.
inline constexpr auto yield_if =
[]<Semiregular T>(bool b, T x) {
return b ? maybe_view{std::move(x)}
: maybe_view<T>{};
};
int main() {
using view::iota;
auto triples =
for_each(iota(1), [](int z) {
return for_each(iota(1, z+1), [=](int x) {
return for_each(iota(x, z+1), [=](int y) {
return yield_if(x*x + y*y == z*z,
make_tuple(x, y, z));
});
});
});
for(auto triple : triples | view::take(10)) {
cout << '('
<< get<0>(triple) << ','
<< get<1>(triple) << ','
<< get<2>(triple) << ')' << '\n';
}
}
