This site uses cookies.
Some of these cookies are essential to the operation of the site,
while others help to improve your experience by providing insights into how the site is being used.
For more information, please see the ProZ.com privacy policy.
Explanation: This term refers to exiting a process or a loop without cleaning up after allocated memory. There are two ways to use this term in programming, and those are quite different. 1)関数を抜く - skipping variables. This is a stylistic difference between computing a value in one line, without the use of intermediate variables. This makes code cleaner, but more difficult to segment the process for editing or troubleshooting. (a highly opinionated argument, I use intermediate variables.) The cons are if intermediate variables are not cleaned up after, can lead to memory leaks. Skipping a variable does not cause problems that lead to memory resource loss, nor does it surface when memory is in short supply. Not this.
2)処理を抜ける - Exiting a process/loop/function. A subroutine is exited mid-way, so that the process' proper exit steps such as unallocating memory to variables is not followed. This leads to memory leaks, and will cause issues when the memory space alloc'd to the program is exhausted. This is not something many compilers or IDE detect very well. This is the one.
Thank you yonedatransterp for the explanations in discussion for why some of the other options would not fly from a programmer's point of view. In this short PR case study, I felt there was a risk of sounding vapid, so I was looking to insert specialty terms to ground the piece where I could. Though had you not offered "exit," I would have taken Shinobi's "omission." Thanks to everyone who lent a bit of their minds to me. This was very informative! 4 KudoZ points were awarded for this answer
Dear all, sorry for the response lag, and thank you for so many enlightening comments. This text occurs in a short PR case study of a static analysis tool.
Need more context in order to discover the true meaning of the clause. The entire sentence would be helpful, perhaps with a summary of the paragraph or section. Yoneda may be right about 'exiting' a process or 'unexpectedly quitting', but 'omission' or 'oversight' are still plausible answers, depending what comes before and after the phrase.
Oversight - A interpretation of 漏れas not being a memory leak, but an error that makes it past checks, as in 「チェック漏れ」and「テスト抜け」. Doesn't really click with the rest of the sentence. 「チェック漏れやテスト抜けといった類のバグは、通常の検証テストでは発見できないため、」thats just bad writing. "since these errors such as those missed by error tests and debuggers are not detected by normal test procedures"? It isn't spectacular writing, but it certainly isn't spaghetti code. It doesn't make sense either.
At least, thats my C, C++, Java programming talking. Considering that an loop throwing an exception could very easily cause malloc'd memory to be lost without being free'd. JAVA doesn't need it, but I don't know how the GC handles some of the more complicated variable handling if the variable stays in scope. /me shrugs
And to list my disagreements with the alternatives
07:43 Aug 28, 2009
Memory Loss - most programs and OSs will give a memory shortage error, than to lose stored data. Data is in a perfect world, written to, and stored outside of RAM, since memory is a far more valuable resource than storage. Yes, the Japanese means "omission" or "misrecording" but the context just doesn't make programming sense.
Omission - Likewise, sounds convincing, but doesn't make programming sense. A debugger that can detect my intent, and determine that I've made an omission would be quite the thing. The term omission seems too general to be grouped in with memory leakage. "(code)omissions and memory leaks that only become apparent when system resources are exhausted" No, I have to disagree. The granularity of the two terms are incongruous to be placed in the same statement, and doesn't fit into my programmer sensibility.
addendum: The 抜けof a variable「関数を抜く」would mean "skipping a variable". while a stylistic preference, some programmer don't like to pass a value around using a variable, but would rather compute on it at once.
This reduces the number of code lines, and branching, but many modern compilers produce the same machine code. This doesn't cause problems, so it likely isn't this one.
I've never heard of "抜け" in my years programming in this ambiguous of a manner. Given the context of memory leaks, this is actually "exiting a process" or "exiting a loop". 「処理を抜ける」「関数を抜ける」are two ways to say this. It means that a loop exits, or a variable is exited and left an orphan. The variable is going to remain alloc'd, and not caught by garbage collection. This is one cause of memory leaks, as every time that occurs, a new variable is going to be alloc'd but not dealloc'd.
I think newer compilers of Java has some robust garbage collectors that pick up on these things, but if in C - I imagine memory leak detectors would be trained to sniff these things out.
また、メモリ資源を使い果たして初めて表面化する ような抜け、漏れといった類のバグは、通常の検証 テストでは発見できないため、目で網羅性をチェッ クするしかなかったが、XXAnalysis Toolはこのような原理 的に検知が無理なバグを検出することが出来るとい う点で極めて有効であった。 Mr. Anderson and Ms. Tanaka, thank you both for your entries and help on this one.
Explanation: Literally, "an omission that becomes apparent (or surfaces) only when the memory resources are low (used up)". I think this is referring to a fault in the program that is only discovered when memory resources are tight. 「抜け」refers to a measure that a good programmer should take but didn't, resulting in a problem that occurs only when memory is low.
Explanation: This 抜け is to miss something inadvertently, and so "oversight and omission" may better convey such nuance of "抜け、漏れ". This 漏れ is not leak, and it means omission for some reasons, as in "記入漏れ" "書き漏らし" etc.
There are are types of bugs that are not easily detected until the code gets machine-verified and compiled (without any errors), and it is placed on a stress/performance test. That's nasty. And the analysis tool in this text seems to bring in some level of intelligence to check the code through and through...
RieM United States Local time: 02:46 Specializes in field Native speaker of: Japanese PRO pts in category: 47
10 hrs confidence:
exits (exiting a process)
Explanation: This term refers to exiting a process or a loop without cleaning up after allocated memory. There are two ways to use this term in programming, and those are quite different. 1)関数を抜く - skipping variables. This is a stylistic difference between computing a value in one line, without the use of intermediate variables. This makes code cleaner, but more difficult to segment the process for editing or troubleshooting. (a highly opinionated argument, I use intermediate variables.) The cons are if intermediate variables are not cleaned up after, can lead to memory leaks. Skipping a variable does not cause problems that lead to memory resource loss, nor does it surface when memory is in short supply. Not this.
2)処理を抜ける - Exiting a process/loop/function. A subroutine is exited mid-way, so that the process' proper exit steps such as unallocating memory to variables is not followed. This leads to memory leaks, and will cause issues when the memory space alloc'd to the program is exhausted. This is not something many compilers or IDE detect very well. This is the one.
Example sentence(s):
This debugger will detect irregular exits in functions to reduce leakage.
yonedatransterp Local time: 23:46 Specializes in field Native speaker of: English, Japanese PRO pts in category: 4
Grading comment
Thank you yonedatransterp for the explanations in discussion for why some of the other options would not fly from a programmer's point of view. In this short PR case study, I felt there was a risk of sounding vapid, so I was looking to insert specialty terms to ground the piece where I could. Though had you not offered "exit," I would have taken Shinobi's "omission." Thanks to everyone who lent a bit of their minds to me. This was very informative!
Login or register (free and only takes a few minutes) to participate in this question.
You will also have access to many other tools and opportunities designed for those who have language-related jobs
(or are passionate about them). Participation is free and the site has a strict confidentiality policy.