|
I run into that with C++ sometimes.
all i wanted to do was extend
rgb_pixel<24> foo;
foo.channel<channel_name::R>(63);
so you could set multiple channels at once.
rgb_pixel<24> foo;
foo.channel<channel_name::R,channel_name::G,channel_name::B>(63,31,47);
You'd think you could do with a parameter pack (template<typename... ChannelNames> but no, because I'm already using a parameter pack and you can't take two to a template.
Anyway, I dug and dug and dug even through some esoteric techniques to stash parameter packs in tuples[^] which I still don't understand
Finally I gave in. You know what I did?
template<typename Name>
constexpr inline void channel(typename channel_by_index<channel_index_by_name<Name>::value>::int_type value) {
constexpr const int index = channel_index_by_name<Name>::value;
channel<index>(value);
}
template<typename Name1, typename Name2>
constexpr inline void channel(typename channel_by_index<channel_index_by_name<Name1>::value>::int_type value1,
typename channel_by_index<channel_index_by_name<Name2>::value>::int_type value2) {
constexpr const int index1 = channel_index_by_name<Name1>::value;
channel<index1>(value1);
constexpr const int index2 = channel_index_by_name<Name2>::value;
channel<index2>(value2);
}
template<typename Name1, typename Name2, typename Name3>
constexpr inline void channel(typename channel_by_index<channel_index_by_name<Name1>::value>::int_type value1,
typename channel_by_index<channel_index_by_name<Name2>::value>::int_type value2,
typename channel_by_index<channel_index_by_name<Name3>::value>::int_type value3) {
constexpr const int index1 = channel_index_by_name<Name1>::value;
channel<index1>(value1);
constexpr const int index2 = channel_index_by_name<Name2>::value;
channel<index2>(value2);
constexpr const int index3 = channel_index_by_name<Name3>::value;
channel<index3>(value3);
}
5 times (last two omitted)
C++ is better than this. I'm not. This is after posting in r/cpp_questions and posting a question here and getting nowhere.
I feel bad about this code. It's terrible. And I'm stuck with it until I get better at C++
Check out my IoT graphics library here:
https://honeythecodewitch.com/gfx
And my IoT UI/User Experience library here:
https://honeythecodewitch.com/uix
|
|
|
|
|
|
I asked him if he could explain the gaps in his resume.
He said "yeah, they are spaces and you type them using the space bar."
I hired him on the spot!
|
|
|
|
|
Sander Rossel wrote: they are spaces
Ah! That's an instant red flag! Real programmers use tabs! 
"Go forth into the source" - Neal Morse
"Hope is contagious"
|
|
|
|
|
I don't like the game anyway but It's official England are crap at football
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
|
|
|
|
|
|
Looks like it's expensive to be lazy.
A home without books is a body without soul. Marcus Tullius Cicero
PartsBin an Electronics Part Organizer - Release Version 1.4.0 (Many new features) JaxCoder.com
Latest Article: EventAggregator
|
|
|
|
|
I see no reason to reward laziness.
|
|
|
|
|
Especially doing front end applications that interface with large databases ?
Dealing with large SQL requests ?
Anything related to UI/UX ?
CI/CD = Continuous Impediment/Continuous Despair
|
|
|
|
|
Hopefully the back-end API's support pagination and sophisticated searching. (That's a UI/UX clue as well.) 
|
|
|
|
|
Have you seen (or read) this book: Designing Data-Intensive Applications: The Big Ideas Behind Reliable, Scalable, and Maintainable Systems[^]
I read about half of it and it was so deeply technical I couldn't even believe it.
People all over the Internet _say_ they're reading it or have read it, but I couldn't complete it.
i'm not that smart though. I gave up because it explained Databases etc. in such a deep way it went flying over my head. But, that is probably easy. 
Check it out, because I think it may be what you're looking for.
|
|
|
|
|
|
I haven't heard of any, but you might find that different RDBMS vendors handle parallelization of large queries differently.
I know how to search millions of rows in parallel on SQL Server in T-SQL, including how to configure the database system and the hardware it runs on (important!).
I'd be hard pressed to tell you how using Oracle or Postgre. I don't even know if they have "distributed partitioned views" or what they would call them.
My point is you might need to look at books that target a particular flavor of database engine.
Check out my IoT graphics library here:
https://honeythecodewitch.com/gfx
And my IoT UI/User Experience library here:
https://honeythecodewitch.com/uix
|
|
|
|
|
Any book I've read would be dated by 20 years. But, I can give some points from real world experience...
For a SQL/RDBMS
- Do not normalize past level 3 for most things. It's not worth the performance hit.
- Do not use old school Hungarian notation like
tblUsers for names. - Learn what an index is and how to properly use it (hint, they help with reads).
- Learn when to use a flattened/denormalized table (hint, when speed is a must or for a reporting db/table).
- If you're in MySQL, learn the different storage types.
- Learn how to use diagrams well.
- For all things pure, make sure you get a proper handle foreign key constraints to help with data integrity.
- Learn when or when not to use a compound key (hint, many to many).
- Speaking of, learn when to use a many to many relationship (hint, clicety).
- Learn the pros and cons of building a self-referential table (hint, when building a hierarchy of data).
- Lean when to use views (hint, permissions and data access restrictions, read only denormalization).
- Understand why concepts like code-first DB design is only purported by those who don't understand proper DB design.
 - Understand that by their design relational DBs are slower than non-relational ones.
- Learn to use triggers to automate some things that would otherwise be tedious.
- And for all things pure again, get a grasp on transactions and connection pools.
- Learn to use SQL profiling tools, these will be your BFF.
There may be a few more points I didn't think of of the top of my head, but mastering those will put you ahead of most peeps.
For a NoSQL
- Learn when to use one. If you need to do semi-realtime anything, NoSQL is awesome. So, stuff like logging is perfect for it.
- They make a great reporting DB if you want to use this rather than a flattened table in your relational DB above.
- They don't use schemas (for the most part) so the learning curve is a breeze compared to SQL.
- Do not use them for mission critical data where it's ok to run a bit slower when data integrity is paramount.
Don't follow the buzzword/hype train. NoSQL is awesome but there's a time and place for both relational and non-relational DBs. NoSQL is super fast and that's its main benefit, but that's not always the only concern.
Jeremy Falcon
modified 8hrs ago.
|
|
|
|
|
FWIW, since you mentioned UI/UX specifically and dealing with large data sets, reporting and datagrids will likely be things you will need. Pay the one-time fee for a suite of quality data-centric libraries that are built to handle large data...pagination/asynch ops/aggregates/etc.
The suite we use is fantastic and well worth the expense...libs work in windows and web development. I won't 'name names' unless requested, but I believe they are a sponsor here. Also, they have tons of tutorials and demos.
"Go forth into the source" - Neal Morse
"Hope is contagious"
|
|
|
|
|
If I find myself repeating the same thing over and over it occurs to me that I need to optimize.
Doubly so when working with a computer - after all, the computer is there to do work so I don't have to.
There's something to be said for repetition of course. Practice helps, and there's something to be said about tried and true methods, especially in production code, but again, repetition raises the question of optimization.
This is why design patterns make me low key uncomfortable. I feel like they should be baked into the language, rather than having to repeat the same boilerplate over and over again. With C# they spend all this time adding fluff to the language, when they could be baking in design patterns. Seems a missed opportunity.
I'm a fan of the idea of Domain Specific Languages for this reason, even though I've never used one aside from Synthmaker/Flowstone which I'm not sure counts.
What I'd really like is a language that allows one to augment the grammar, sort of like C# source generator tech except it extends the keywords and syntax of the language and then uses the new grammar to generate code.
Check out my IoT graphics library here:
https://honeythecodewitch.com/gfx
And my IoT UI/User Experience library here:
https://honeythecodewitch.com/uix
|
|
|
|
|
Maybe as a hobbyist my opinion does not count for much as I do not live this everyday. But I feel that the language should be as simple and basic as possible. Let libraries and frameworks do the real heavy lifting. I use C++ which has pointers, references, classes, inheritance, polymorphism, and templates built in. Using that people were able to build libraries like the STL and frameworks like MFC and QT among many others.
I feel if all that was built into the C++ language itself then the language becomes too overbearing and too hard to learn.
But then again, maybe I am totally missing your whole point.
Within you lies the power for good - Use it!
|
|
|
|
|
No, you make a good point, and C++ is a great example of what happens when a language tries to solve everything.
It's just that if libraries could fill the gap by themselves, I feel like they would have already?
It seems to me that libraries tend to fulfill one pattern while creating another (the one you have to use to interact with a library) and based on some DSL work by a former Microsoft mucky muck whose name escapes me at the moment but whose work I've looked over in the past, it seems like having language support for some of these patterns is really the way to solve that last mile integration issue.
Check out my IoT graphics library here:
https://honeythecodewitch.com/gfx
And my IoT UI/User Experience library here:
https://honeythecodewitch.com/uix
|
|
|
|
|
Quote: It's just that if libraries could fill the gap by themselves, I feel like they would have already?
Stop inventing new problems and processes. Then the current libraries will be enough.
As long as there is a perceived need for something new, someone will write a library to fill that need. Take your pixel library for instance. I am sure there is already libraries out there that would do what yours does, but not the way you want it done. So you wrote another library for it.
Just more people reinventing the same wheel over and over again.
Within you lies the power for good - Use it!
|
|
|
|
|
Forgive me but I think you're missing my point.
You can't write a library to do this:
public component Foo {
public Bar { get; set; }
}
The issue there is at some point you need to insert those actual methods into your code, or inherit from something that already implements Bar which you can't do if Bar is your project specific property.
As such, you're left with one other option for automating this. Source Generators, which require some kind of input spec. Metadata attributes don't quite cut it here, because they aren't descriptive enough. Being able to extend the language via Source Generators solves this. That was the last mile integration I was talking about.
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: What I'd really like is a language that allows one to augment the grammar,
They call it Forth. 
"In testa che avete, Signor di Ceprano?"
-- Rigoletto
|
|
|
|
|
I would argue that Forth doesn't have any grammar to speak of. It's just a string of words strewn together.
Would stream-of-consciousness language* be an appropriate name?
*) Name calling made with love: in another life I wrote a Forth interpreter for a PDP-11
Mircea
|
|
|
|
|
|
honey the codewitch wrote: What I'd really like is a language that allows one to augment the grammar,
Extensible languages, bell-bottoms and polka dots were a thing in the 60-es. They didn't age too well
For your reading pleasure check this SPG language.
Mircea
|
|
|
|
|
There are all kinds of ways to skin that cat though, and the 1960s you had some severe limitations in terms of compilers due to the limited RAM and speed of computers in that era.
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
