|
David I'm not sure you're able to have a rational conversation with me. I don't buy this premise, but for the sake of argument let's say it's correct (not really). The original comment was most millionaires are self made rather than have it be inherited. That has nothing to do with luck upon making said money.
Now, since you clearly just want to disagree with me, I'll simply say winners make their own luck. Losers complain. You can say there's luck in not being born in a tiny village in Africa, but if you live in the western world the knowledge is out there. Argue with that.
But I will say this, if you know zero millionaires your opinion means nothing to me.
Jeremy Falcon
|
|
|
|
|
Jeremy Falcon wrote: your opinion means nothing to me.
That's quite obvious, even if I do know any millionaires. You don't want to consider anything outside of what you've already convinced yourself of.
|
|
|
|
|
You don't. I know. Good bye.
Jeremy Falcon
|
|
|
|
|
Jeremy Falcon wrote: I'll simply say winners make their own luck. Losers complain.
DING DING DING!! This guy gets it.
(and in the following, when I say "you", I certainly don't mean you personally. I know you're smart enough to realize that)
I think that's the fundamental idea here. Some people are satisfied enough claiming life just dealt them a bad hand and run with that, but ultimately everyone has to take responsibility for their own destiny. Of course there's exceptions (for one, I wouldn't want to have been born in North Korea), but when one lives in the so-called land of opportunity, he only has himself to blame for his own outcome.
True, some happen to have things fall on their lap. They're in the extreme minority however, and it's delusional to expect the same to happen to you. You can't use that as an example for what to expect. You want something? Work for it. Not reaching your goals? Turns out you didn't want it badly enough, in spite of your beliefs. You didn't have the balls to make the tough choices and decided to take the easier path.
It's like people spending their lives blaming their parents for the way they turned out. No, at some point, you grow into an adult and your day-to-day decisions are your own.
|
|
|
|
|
Preach, brother.
dandy72 wrote: It's like people spending their lives blaming their parents for the way they turned out. No, at some point, you grow into an adult and your day-to-day decisions are your own.
What I usually say is you can blame them all you want to if you're under 18 and living in their house. There are abusive parents for instance, I should know... mine were.
But, once you're out of their control and an adult. Newsflash, it's your choices now. Granted, you may have been given a terrible blueprint for life from your parents, but nothing but your own mind is preventing you from learning a new blueprint from others.
People need to hear that a hell of a lot more than the victim mentality nonsense.
Jeremy Falcon
|
|
|
|
|
Jeremy Falcon wrote: What I usually say is you can blame them all you want to if you're under 18 and living in their house. There are abusive parents
For sure, as I wrote this I kept telling myself to re-edit and add "...until you're 18" but just forgot to add it in the end - I didn't mean to come across as insensitive, and I fully realize there are truly sh*tty situations.
But when I see people well into their 40s, 50s or even much older, complaining they never got ahead in life because daddy liked the bottle more than he liked them - yet haven't been in contact for decades - I'll start to call bullshit.
|
|
|
|
|
|
|
What's the OO way of concealing wealth?
Encapsulation.
|
|
|
|
|
Inheritance or composition ... the usual debate 
|
|
|
|
|
Make a million dollar app?
modified 8-Sep-24 0:29am.
|
|
|
|
|
abstraction.
you create incomprehensible financial instruments that you can use to short the housing market that you tanked, all without going to prison.
Hypothetical based on actual events.
Check out my IoT graphics library here:
https://honeythecodewitch.com/gfx
And my IoT UI/User Experience library here:
https://honeythecodewitch.com/uix
|
|
|
|
|
or maybe it's just me projecting.
|
|
|
|
|
|
Wordle 1,176 3/6*
β¬π¨π¨β¬π¨
β¬π¨π©π©π©
π©π©π©π©π©
"I have no idea what I did, but I'm taking full credit for it." - ThisOldTony
"Common sense is so rare these days, it should be classified as a super power" - Random T-shirt
AntiTwitter: @DalekDave is now a follower!
|
|
|
|
|
β¬π¨β¬π¨π¨
β¬β¬π©π©π©
π©π©π©π©π©
In a closed society where everybody's guilty, the only crime is getting caught. In a world of thieves, the only final sin is stupidity. - Hunter S Thompson - RIP
|
|
|
|
|
Wordle 1,176 6/6
β¬β¬π¨π¨π¨
π©β¬β¬π©π©
π©β¬β¬π©π©
π©β¬β¬π©π©
π©β¬β¬π©π©
π©π©π©π©π©
Bad luck! Sheer bad luck! 
Ok, I have had my coffee, so you can all come out now!
|
|
|
|
|
You solved it though 
In a closed society where everybody's guilty, the only crime is getting caught. In a world of thieves, the only final sin is stupidity. - Hunter S Thompson - RIP
|
|
|
|
|
Wordle 1,176 4/6*
β¬β¬π¨π¨π¨
β¬π¨π©π©β¬
π©π©π©π©β¬
π©π©π©π©π©
|
|
|
|
|
Wordle 1,176 3/6
π¨β¬β¬π©β¬
β¬π¨π¨π©π©
π©π©π©π©π©
|
|
|
|
|
Wordle 1,176 3/6
π¨π¨β¬β¬β¬
β¬π¨π¨π©π©
π©π©π©π©π©
Within you lies the power for good - Use it!
|
|
|
|
|
Wordle 1,176 4/6
β¬β¬π¨β¬β¬
β¬π¨π¨β¬β¬
β¬π¨π©β¬π©
π©π©π©π©π©
"A little time, a little trouble, your better day"
Badfinger
|
|
|
|
|
I need my vector graphics library to be feature complete enough to render most SVG.
I have that, with some compromises for embedded, such as using TTF instead of WOFF or whatever for the font formats.
The trouble is there is just so much to it. You have fills, strokes, gradients, textures, fonts, paths, basic shapes, and all kinds of minutia therein.
I've fleshed out my header file for my class, and it's huge, and I'm not entirely finished with it.
I'd like to break it up somehow because I'm overwhelmed, but I need to get a lot of it done before I can even test a little.
I pasted the class proto here, sans supporting structures to give you an idea of the mess I'm up against.
I hate messes.
class canvas final {
void* m_info;
canvas(const canvas& rhs)=delete;
canvas& operator=(const canvas& rhs)=delete;
public:
typedef gfx_result(*on_write_callback_type)(const rect16& bounds, rgba_pixel<32> color, void* state);
canvas();
canvas(size16 dimensions);
canvas(canvas&& rhs);
~canvas();
gfx_result initialize();
bool initialized() const;
void deinitialize();
canvas& operator=(canvas&& rhs);
on_write_callback_type on_write_callback() const;
void* on_write_callback_state() const;
void on_write_callback(on_write_callback_type callback, void* state=nullptr);
size16 dimensions() const;
void dimensions(size16 value);
rect16 bounds() const;
rgba_pixel<32> stroke_color() const;
void stroke_color(rgba_pixel<32> value);
canvas_gradient stroke_gradient() const;
void stroke_gradient(const canvas_gradient& value);
canvas_texture stroke_texture() const;
void stroke_texture(const canvas_texture& value);
canvas_stroke_style stroke_style() const;
void stroke_style(const canvas_stroke_style& value);
canvas_dash stroke_dash() const;
void stroke_dash(const canvas_dash& value);
canvas_paint_type stroke_paint_type() const;
void stroke_paint_type(canvas_paint_type value);
rgba_pixel<32> fill_color() const;
void fill_color(rgba_pixel<32> value);
canvas_gradient fill_gradient() const;
void fill_gradient(const canvas_gradient& value);
canvas_texture fill_texture() const;
void fill_texture(const canvas_texture& value);
canvas_paint_type fill_paint_type() const;
void fill_paint_type(canvas_paint_type value);
stream* font() const;
void font(stream& ttf_stream, size_t index);
float font_size() const;
void font_size(float value);
canvas_fill_rule fill_rule() const;
fill_rule(canvas_fill_rule value);
canvas_compositing_mode compositing_mode() const;
void compositing_mode(canvas_compositing_mode value);
float opacity() const;
void opacity(float value);
::gfx::matrix matrix() const;
void matrix(const ::gfx::matrix& value);
rectf fill_bounds() const;
rectf stroke_bounds() const;
gfx_result move_to(pointf location);
gfx_result line_to(pointf location);
gfx_result quad_to(pointf point1, pointf point2);
gfx_result cubic_to(pointf point1, pointf point2, pointf point3);
gfx_result arc_to(sizef radiuses,float angle, bool large_arc, bool sweep, pointf location);
gfx_result rectangle(const rectf& bounds);
gfx_result rounded_rectangle(const rectf bounds, sizef radiuses);
gfx_result ellipse(pointf center, sizef radiuses);
gfx_result circle(pointf center, float radius);
gfx_result arc(pointf center, float radius, float a0, float a1, bool ccw);
gfx_result close_path();
};
Check out my IoT graphics library here:
https://honeythecodewitch.com/gfx
And my IoT UI/User Experience library here:
https://honeythecodewitch.com/uix
|
|
|
|
|
honey the codewitch wrote: The trouble is there is just so much to it. You have fills, strokes, gradients, textures, fonts, paths, basic shapes, and all kinds of minutia therein.
Lots of software suffer from the checklist syndrome. The designers' / developers' / maintainers' fear is that some customer will ask: 'But can you do so-and-so? Well, if you can't, then I'll have to look for some other alternative!'
In my very first project after getting my degree, the marketing people came to me with checklists from the great reviewers of our software sector: This is what they are looking for. What can we provide today, and when will you have the rest implemented?
My impression is that commercial software have relaxed a little bit with checklists, but open source developers have become increasingly more determined that noone shall reject FOSS because of lacking features. (The current manual of gcc options come in three volumes, doesn't it? ). I use some commercial software for my home PC and private projects, and FOSS people trying to pressure me into replacing it with FOSS is regularly arguing: But can your software do this? And that? Answering: But I have never had any use for those functions! is - in these discussions - an invalid argument. Even if I never needed a function: If my software doesn't provide it, it proves my software inferior, and I am silly continuing to use it.
Another field where you see this feature creep at full power is in programming languages. Once, language design was clean and manageable. Today, maybe version 1.0 doesn't include everything that all the other languages have - but by version 7.3 they certainly will! Isn't about every single programming language today 'multi-paradigm'? (Who was that stating 'Any sufficiently high-versioned standard is indistinguishable from a can of worms'? That goes for programming languages as well!)
Often, you see software turned down (typically by reviewers, not potential users) on completely irrelevant grounds. To take my oldest example: For my thesis, 40 years ago, I was doing an analysis of a database project that was abandoned. One of the arguments was customers rejected a DBMS that limited a database to 4 GB size. I asked what is the largest database of the current DBMS. The biggest one was 160 MB (note that this is 40 years ago! ) - 4% of the limit of the new system. (That wasn't a design limitation, only the specific proposed first implementation.) I laughed at it then, but during the following 40 years, I have seen similar things numerous times. Reviewers, and potential customers as well, don't have a clue about their real needs. They unconditionally go for 'More is better'. The number of check marks is a primary evaluation criterion, when you don't have sufficient expertise to consider your own need for each feature. Most customers don't. I suspect that a lot of reviewers don't, either.
So, I don't think SVG is any special at all. That is the way software is today.
(Bonus 100% true story: One of my classmates was for his thesis implementing an animation of a data flow model; you could watch how inserting an instance into a data store lead to data traffic among the involved classes. The work was done on a brand new PERQ graphic workstation. The system library could draw any pixel on the screen -- nothing else. (Rather primitive, the way you prefer it ) This data flow model involved 'processes', drawn as rectangles with rounded corners. PERQ couldn't draw 90Β° arcs. My friend had to implement that himself - our graphics textbook told us how to. The textbook algorithm used a sine function. PERQ had nothing of the sort, so he had to implement a small trig library. The Numerical Methods textbook provided the method, using floating point values. PERQ didn't provide any floating point, so he had to implement a floating point software package, before implementing the trigonometric functions, before implementing the graphic functions for drawing circular arcs, and then he could draw rectangles with rounded corners.
Personally, I prefer the graphic packages of today, capable of drawing circular arcs as a basic function. Disclaimer: I am not currently working in an embedded environment. (And when I was, graphics was totally irrelevant in our applications.)
Religious freedom is the freedom to say that two plus two make five.
|
|
|
|
|
You're right, a lot of people have no idea what they need, and that SVG isn't special in its bloat. It's just overwhelming to deal with.
But I really want nice pretty vector graphics for my little ARMs and stuff, and now the 32 bit ones have enough ooomph to do it.
I just got sick of interfaces that look like they were crafted in the mid 1990s. LVGL seems to find its way around that, even with raster graphics, but I couldn't make heads or tails of its rendering process.
I wasn't really going to do a whole vector engine, aside from loading and rendering a reasonable SVG subset which I already had finished, but not one with an exposed API you could draw with.
The reason I did is I could not find efficient algorithms for doing anti-aliased draws with alpha-blending. The anti-aliasing would cause pixels to be drawn in the same place twice, which fouls alpha-blending.
With vector graphics you get the mess basically as a series of polygons except all the lines are actually bezier curves. When you go to render, the way it's done, the issue above isn't an issue.
But it's sort of an all or nothing deal because the latter works nothing like the former at all.
Check out my IoT graphics library here:
https://honeythecodewitch.com/gfx
And my IoT UI/User Experience library here:
https://honeythecodewitch.com/uix
|
|
|
|
|
General 
News 
Suggestion 
Question 
Bug 
Answer 
Joke 
Praise 
Rant 
Admin 
Submit an article or tip
