Closed. This question needs to be more focused. It is not currently accepting answers.
Want to improve this question? Update the question so it focuses on one problem only by editing this post.
Closed 8 years ago.
Improve this question
I just don't see the point of encapsulation, I see that in some cases you can modify a getter/setter to modify the behavior of something or keep track of state, but whenever I am creating a non-conventional getter/setter, I use a word like "modify," or "obtain," so what is the point of wasting hours writing repetitive methods that are practically pointless and inefficient?
I just don't get it, when I was a wee young programmer, I was told by some guy in an IRC, that not having it was the cause for a bug in my program, but I have known for years now that is not the case, I've just been doing it anyway, so what is then point?
If I need to refactor later there are ways around it weird ones but they are ways at least in languages with overloaded operators, and API's don't always have to be backwards compatible so I don't see the point.
Can anyone enlighten me to the necessity of encapsulation?
In many cases you are right - small programs doesn't need encapsulation probably.
Some MS infrastructures (C#/WPF I think in several binding scenarios) requires encapsulation (using properties) and will not work without it.
If you do more in get / set than changing the value or returning it - it will make your code nicer and more robust (do checks, or other staff in the setter for example).
No one forces you to use it anyway...
Related
Closed. This question needs to be more focused. It is not currently accepting answers.
Want to improve this question? Update the question so it focuses on one problem only by editing this post.
Closed 1 year ago.
Improve this question
I have a use case that I want to use to help independent creators talk about their interests on Twitter using their experiences.
It goes like this:
You have an interest you want to talk about Entrepreneurship
You have an experience like Pain
Is there a way for an AI (like GPT) to generate prompts that uses these two words to create a list of open-ended questions that provoke thoughts such as these:
If entrepreneurship wasn't painful, what would it look like?
What do you know about entrepreneurship that is painful that starters should know?
How can you lower the barrier to entrepreneurship so that it's a less painful opportunity for a person to take?
If so, how will it work, and what do I need to do?
I've explored Open AI's documentation on GPT-3, I'm unclear if it solves this problem of generating prompts.
Thanks!
You should provide some samples so that the GPT-3 can see the pattern and produce a sensible response from your prompt.
For example, see the following screenshot from your case. Note that the bold text is my prompt. The regular text is the response from GPT-3. In that example, I was "priming" the GPT-3 with relevant pattern: First line, the general description, then the Topics, followed by Questions. This should be enough for booting up your ideas and customizations.
Closed. This question needs details or clarity. It is not currently accepting answers.
Want to improve this question? Add details and clarify the problem by editing this post.
Closed 3 years ago.
Improve this question
So I'm currently learning OpenGL, and while working through some of the tutorials, I've noticed that most of them create multiple buffer-array-objects (BAO) for the vertex-positions, normal-vectors and uv-coordinates. But there is also the option to just create a single BAO, where each element includes all the necessary information about a single vector. So what's the "good" or rather "recommended" way of doing things? Create multiple ones or just a single one?
From Buffer Object - OpenGL Wiki (recommended reading):
Buffer Object Usage
Buffer objects are general purpose memory storage blocks allocated by OpenGL. They are intended to be used in a great many ways. To give the implementation great flexibility in exactly what a particular buffer object's data store will be, so as to better optimize performance, the user is required to give usage hints. These provide a general description as to how exactly the user will be using the buffer object.
BO's are shared between the client and the server (in OpenGL terms). How many of them you should use, is entirely up to you. Your instincts seem to be good however. You should never optimize before you just get it working. But after you've had some experience with OpenGL, you'll probably find there are use cases, where a little early optimization can save you a lot of refactoring later on.
I can't help you much with where to draw those lines, but I would say that you should think first, about what and when you intend to render as execution progresses.
Closed. This question is opinion-based. It is not currently accepting answers.
Want to improve this question? Update the question so it can be answered with facts and citations by editing this post.
Closed 8 years ago.
Improve this question
This might not be the ideal place to ask this question, but I'm really at a dead end and don't know where else to ask (suggestions would be appreciated).
I'm trying to come up with a name for 4 new API's for my company's C Library.
These API's are being added to an existing set, so they have to match an already made pattern, which limits my choices.
What all of the API's (existing and new) do is allow the user to get/set the value string or nonstring variables used in a program.
The way mine are different is that they allow you to get the value using the name of the variable, as apposed to already existing methods.
Here is what I currently have:
VariableGetValueString
VariableSetValueString
VariableGetValue
VariableSetValue
The only problem with this, is that it does not make it clear that it uses the NAME of the variable. I cannot think of a non-cluttered sounding name that makes this clear to the customer.
Preferably, there should be nothing removed from the names, as it matches the patterns of the other API's (which do not explicitly state their retrieval methods in their names, though this one should, for extraneous reasons).
Any help is appreciated, and though I know there is no definitive answer, I will obviously accept the one that fits the best.
Sorry again if this is a poor place to ask the question, I would love suggestions of a more appropriate place if there is one.
EDIT:
Some existing API names are:
VariableGetTaskString
VariableGetTask
VariableGetGlobalString
VariableGetGlobal
Along those lines. Task and Global refer to the scope of the variable. They weren't named very well in the first place, which makes my job more difficult, but they cannot be changed because customers have grown used to them and the changes would break old programs. I didn't include these initially because of how little help they offer (in my opinion).
The parameters of each API will make it obvious to the customer what each one does, but it would be preferable for the name to do that as well. Thanks for your feedback.
EDIT 2:
Here is an example of a call into the API:
if(!VariableGetValueString(Handle handle, LPCSTR variableName, TaskID taskID, LPSRT value, DWORD bufferSizeinBytes)
{
//retrieve failed.
}
if(!VariableGetValue(Handle handle, LPCSTR variableName, TaskID taskID, PDWORD value)
{
//retrieve failed.
}
Hope thats clear enough. Feel free to keep asking for more, I'll edit this all day. Thanks for the continued support.
Here are some possibilities:
suggestion 1
UseVariableNameToGetTaskString(...);
UseVariableNameToGetTask(...);
UseVariableNameGetGlobalString(...);
UseVariableNameToGetGlobal(...);
suggestion 2
VariableGetTaskStringByVarName(...);
VariableGetTaskByVarName(...);
VariableGetGlobalStringByVarName(...);
VariableGetGlobalByVarName(...);
suggestion 3
VariableGetTaskStringByName(...);
VariableGetTaskByName(...);
VariableGetGlobalStringByName(...);
VariableGetGlobalByName(...);
How about:
NamedVariableGetValueString
NamedVariableSetValueString
NamedVariableGetValue
NamedVariableSetValue
so that the distinction NamedVariable means a variable specified by name, whereas just Variable means a variable specified by ID or whatever the old functions use.
How about:
getVariableName()
and
setVariableName(char* value)
Closed. This question is opinion-based. It is not currently accepting answers.
Want to improve this question? Update the question so it can be answered with facts and citations by editing this post.
Closed 7 years ago.
Improve this question
What do you do when you encounter a programming problem that is really hard for you to solve, and you have no idea yet?
Usually, how do you solve it at last?
NOTES:
Could someone introduce something about problem solving practice?
If I can, I leave it alone for a while. Often the solution will pop into my head when I least expect it. (If only we always had the luxury of waiting - often we don't.)
Edit: Another hugely useful thing to do is describe the problem to someone else. Even if they can't help, the very act of explaining it to someone who's unfamiliar with the problem will often clarify things in your mind. Sometimes you get straight to a solution that way, without the other person saying a word. 8-)
I just think it over when a pencil and paper.
Break it down into each part
Look at what parts I know
Research parts I don't
Put it all together
Profit
For me the trick is breaking it into manageable bits.
-- Edit
I must agree with the poster above about talking to someone else, as well. Even if you don't have anyone you can talk to, explain it to a fluffy toy, and the answer will often become obvious.
I find using a whiteboard to explain the problem to someone else very useful.
Sometimes I'll search Stack Overflow to see if anyone has encountered the same or a similar problem; if they haven't, I'll sometimes post a question about it.
The book Peopleware put it in a nice way, that despite being a different context also works here.
The manager's function, they write, is
not to make people work but to make it
possible for people to work.
In this case you are your own manager, so its up to you to make it possible for yourself to work. If its something difficult you are struggling with, then you need to listen to yourself.. what is it you need in order to get started solving it.
For me, it can be that a major class in the project has the wrong name and is inelegant. In order to solve the problem in an elegant way these needs to be fixed first, otherwise it will end out as a half baked solution.
10 cents
For many problems, writing unit tests can help. Break it down (as silky suggests) and try writing tests for the various pieces. Then write code to make the tests pass. Check out some of the literature on TDD.
Writing throwaway "spike" code is also a handy way to figure out new things.
Well, it depends on the kind of problem, whether it's something you can research. For the things you can't, often specific design problems where I have problems keeping all the factors in mind at once, I've found two methods to work well:
Get rid of all possible distractions (computer, phone, people), e.g find an empty conference room. Take along pen and paper and draw a free-form diagram of the factors involved in the problem; sometimes tables also work well. I've found that the ability to concentrate hard without distractions and the graphical representation usually enable me to find a solution.
For really hard problems, sleep over it. Maybe that's just me, but I sometimes come up with the best ideas when I think about something in that half-dazed state right before I fall asleep - and strangely, I can always remember them come morning.
Closed. This question is opinion-based. It is not currently accepting answers.
Want to improve this question? Update the question so it can be answered with facts and citations by editing this post.
Closed 7 years ago.
Improve this question
When contributing to a very old, and apparently no longer maintained, open-source or public domain project, is it suggested practice to follow the original author's coding style even if it is terrible?
More importantly, are there any reasons why one would want to follow the original author's coding style rather than clean it up significantly?
Follow the original coding style. It is far, far better to be consistent, even if it's not pretty to you.
If you do decide to clean up the coding style, do it separately from any other changes. Don't clutter up source control diff's with style changes. Make one (or several) checkins where the only thing you're doing is changing code style. Do not mix in real changes with meaningless changes, it makes it impossible to locate relevant changes when reviewing source control commits.
If you know that it's unmaintained, and you're making changes to it, then I suspect that you'll become the defacto owner/maintainer going forward.
So, that said, I'd e-mail the original author/maintainer, see what they think about the formatting or style changes, and go forward with guns blazing.
If you're not submitting patches, then no. Run it through a code filter and automatically format the code in your preferred style, then hack away.
If checking into source control, you may want to leave it alone as all the style changes will make comparing to previous versions impossible.
If you do want to change the style do it with the baseline code before you make any other changes and then check it in.
Then check it out and make your coding changes. That way it will be easier to track your changes from the point you took it over.
I personally would leave the style alone unless you are making significant changes.
As stated by others, ensure that any style modifications are checked in to your version control system separately from your functional modifications.
However, my suggestion is to be bold and clean up the code as you see fit; "Leave the campsite cleaner than you found it". Cheesy, but true ;)
Just make sure that you are prepared to defend your changes ;)
Heck no! Whatever you do don't make it worse for heavens sake!
If you're adding your own code do it in your own style. This will at least make part of the codebase easy for you to maintain and understand. If you're making minor updates to existing code then you may want to follow that style.
I'm in the same boat, I have to maintain an ancient, business critical, Access 2 based system which is a complete mishmash of styles.
If it's not even maintained why are you worrying about it?
I'd write using my own preferred style, and clean up any code I had to work with. I do that regularly at work even...
Well, I'd say if you are just making a small modification within say a function, it might be clearer to go along with the bad style.
If you create new methods, classes, properties, etc., use a clear, efficient style. You might add a comment at the start of these sections, so that others can understand what's going on. You might even add a short note at the top explaining when you started on the code, and that you were using a different style, etc.
What would your answer be if the question were: Should you maintain the same shoddy workmanship when you are remodeling your home?
If you're fixing a broken wall tile in the bathroom, then it's not worth re-tiling the entire wall because they didn't use the right drywall.
When you're remodeling the kitchen, then you may correct the plumbing for that room or straighten out a bad floor. That's because it makes the rest of the job easier for you. And that's what it's all about, what kind of benefit does it give you verses the cost to you/your client.
You wouldn't rewire a lamp because it needed a new bulb.
If you're coding to a company-defined standard (or even just a team-defined standard), and the code that you're working on does not match the standard (or is so old that it doesn't match the current standard), then definitely clean up the code if you're going to be making major changes anyway. (As others have mentioned, do that to the baseline code, and check it in. Then check it out again and make the changes that you have to make to fix bugs, add features, etc.)