Data Technology Problem Solving - Financial Problems

Home Top Ad

Responsive Ads Here

Post Top Ad

Responsive Ads Here

Saturday, 14 December 2019

Data Technology Problem Solving

Data Technology Problem Solving - The 6 Principles of Scientific Problem Solving

This paper will disclose a logical way to deal with critical thinking. Despite the fact that it is composed to address Information Technology related issues, the ideas may likewise be appropriate in different orders. The strategies, ideas, and systems portrayed here is the same old thing, yet it is stunning what number of "issue solvers" neglect to utilize them. In the middle of I will incorporate some genuine models.

For what reason do issue solvers surmise instead of following a logical way to deal with critical thinking? Perhaps in light of the fact that it feels snappier? Possibly absence of involvement with proficient critical thinking? Or on the other hand perhaps in light of the fact that it feels like difficult work to do it logically? Perhaps while you continue speculating and not so much explaining, you produce more salary and include some employer stability? Or then again perhaps in light of the fact that you damage the main guideline of critical thinking: comprehend the issue.

Rule #1. Comprehend the *real* issue.

Is it accurate to say that it isn't clear that before you can tackle, you have to comprehend the issue? Possibly. However, more often than not the solver will begin taking care of without knowing the genuine issue. What the customer or client portray as "The Problem" is typically just the side effect! "My PC wouldn't like to turn on" is the manifestation. The genuine issue could be that the entire structure is without control. "Each time I attempt to include another item, I get a blunder message" is the indication. Here the genuine issue could be "Just the last 2 items I attempted to include gave an 'Item as of now exists' blunder". Another exemplary model: "Nothing is working"...

You start your examination by characterizing the "genuine issue". This will involve posing inquiries (and now and again confirm them), and doing some fundamental testing. Ask the client inquiries like "when was the last time it worked effectively?", "To what extent have you been utilizing the framework?", "Does it take a shot at another PC or another client?", "What is the precise mistake message?" and so on. Request a screen-print of the mistake if conceivable. Your fundamental testing will be to guarantee the start to finish gear is ready for action. Check the client's PC, the system, the Web Server, Firewalls, the File Server, the Database back-end, and so on. Best-case you will half quart point the issue as of now. The most pessimistic scenario you can dispense with a lot of zones for the reason for the issue.

A genuine model. The side effect as indicated by the client: "The framework hangs up indiscriminately times when I place orders". The earth: The client enters the request detail on a structure in a centralized server application. At the point when all the detail is finished, the client will tab off the structure. The centralized computer at that point sends this detail by means of correspondence programming to an Oracle Client/Server framework at the plant. The Oracle framework will do scope quantification and either restores a mistake or a normal request go back to the centralized server framework. This issue is very genuine, on the grounds that you can free customers on the off chance that they attempt to put orders and the framework doesn't acknowledge them! To endeavour to take care of this issue, individuals began by examining: 1) The heap and limit of the centralized computer equipment 2) Monitoring the system load between the centralized computer and the Oracle framework 3) Hiring specialists to investigate the correspondence programming 4) Debugging the Oracle scope quantification framework After putting in two or three months they couldn't tackle the issue.

The "Logical Problem Solver" was brought in. It took not exactly a day and the issue was fathomed! How? The solver goes through the day at the client to perceive what the "genuine issue" was. It was discovered that the issue just happens with trade orders. By examining the catch screen and client activities, it was discovered that with sending out requests the keep going field on the structure is constantly left clear and the client didn't tab off this field. The framework was not hanging, it trusted that the client will squeeze "tab" some other time. Issue comprehended. It tends to be noticed that the "Logical Problem Solver" had extremely restricted information on the centralized computer, of the request catching framework, of the correspondence programming, and of the Oracle scope quantification framework. Furthermore, this brings us to Principle#2.

Rule #2. Try not to be hesitant to begin the explaining procedure, regardless of whether you don't comprehend the framework.

How often have you heard "I can't contact that code, since it was created by another person!", or "I can't help since I am an HR Consultant and that is a Finance issue"? In the event that your clothes washer wouldn't like to turn on, you shouldn't be an Electrical Engineer, Washing Machine Repair Specialist, Technician, or whatever pro to do some fundamental shortcoming finding. Ensure the attachment is working. Check the excursion switch, and so on. "I have never observed this mistake" ought not to prevent you from endeavouring to illuminate. With the blunder message and an Internet Search motor, you can get bunches of beginning stages.

In each unpredictable framework there are several essential working standards. Framework A that peruses information from System B can be frightfully mind-boggling (possibly a Laboratory Spectrometer that peruses information from a Programmable Logic Computer by means of an RS-232 port). Be that as it may, a few rudiments to test for: Does the two frameworks have control? Is there a blunder message in the occasion sign on one of these frameworks? Can you "ping" or follow a system parcel from the one framework to the next? Attempt an alternate correspondence link. Quest the web for the blunder message.

When you have set up what the issue is, you have to begin fathoming it. Some of the time the underlying examination will point you straightforwardly to the arrangement (switch the power on; supplant the broken link, and so on). However, at times the genuine issue is mind-boggling in itself, so the following standard is to comprehend it straightforward.

Standard #3. Overcome it basic.

We should begin this segment with a genuine model. Under specific conditions, a put-away method will hang. The put-away method typically takes about an hour to run (when it isn't hanging). Along these lines, the engineer attempted to troubleshoot. Roll out certain improvements and afterward hold up one more hour or so to check whether the issue is understood. After certain days the designer surrendered and the "Issue Solver" dominated. The "Issue Solver" had to his transfer the information under which conditions the put-away methodology would hang. Along these lines, it was a straightforward exercise to make a duplicate of the technique, and afterwards with this duplicate to strip all superfluous code. All parameters were changed with hard-coded values. Bits of code were executed at once and the outcome sets were on the other hand hard-coded into the duplicate of the strategy. Inside 3 hours the issue was comprehended. A vast circle was found.

What the "Issue Solver" did, was to duplicate the issue and simultaneously attempted to segregate the code that caused the issue. In doing as such, the complex (and tedious) put away system became something quick and straightforward.

On the off chance that the issue is inside an application, make another application and attempt to reenact the issue inside the new application as basic as could be allowed. On the off chance that the issue happens when a specific strategy for a specific control gets called, at that point attempt to just remember this control for the vacant application and call that technique with hard-coded values. On the off chance that the issue is with installed SQL inside a C# application, at that point attempt to reproduce the SQL within a Database Query device (like SQL*Plus for Oracle, Query Analyzer for SQL Server, or utilize the code in MS Excel by means of ODBC to the database).

The minute you can repeat the issue in a basic manner, you are over 80% on your approach to illuminate it.

On the off chance that you don't have the foggiest idea where in the program the issue is, at that point use DEBUG.

Guideline #4. Troubleshoot.

Most application advancement apparatuses come standard with a debugger. Climate it is Macromedia Flash, Microsoft Dot Net, Delphi, or whatever improvement condition there will be a type of debugger. In the event that the apparatus doesn't come standard with a debugger, at that point, you can mimic one.

The primary thing you need to do with the debugger is to figure out where the issue is. You do this by including breakpoints at key territories. At that point, you run the program in investigating mode and you will know between which breakpoints the issue happened. Drill down and you will discover the spot. Since you know where the issue is, you can "overcome it straightforward"

Another decent component of most debuggers incorporates the office to watch factors, values, parameters, and so on as you step through the program. With these qualities known at specific advances, you can hard-code them into your "disentangled variant" of the program

On the off chance that an advancement device doesn't bolster investigating, at that point you can mimic it. Put in steps in the program that yields variable qualities and "hi I am here" messages either to the screen, to a log record, or to a database table. Make sure to take them out when the issue is settled... you don't need your record framework to be jumbled or topped off with log documents!

Rule #5. There is an abundance of data on the database back-end that will take care of an issue.

The "Issue Solver" was called to help tackle an exceptionally dubious issue. A task was moving framework from a centralized computer to customer server innovation. All worked out in a good way during testing, yet when the frameworks went live, out of the blue there were many, and very irregular "General Protection Faults". (The GPF-blunder was the general mistake trap in Windows 95 and 98). It was attempted to rearrange the code, troubleshooting endeavoured, yet it was difficult to duplicate. In the LAB condition, the issue would not happen! Troubleshooting follows messages to log documents showed that the issue happened arbitrarily. A few clients experienced it more than others, yet in the long run, all clients will get them! Intriguing issue.

The "Issue Solver" settled this after he began to examine the database back-end. Not certain on the off chance that it was by some coincidence or on the grounds that he efficiently moved the correct way in light of a logical methodology. Through following what's going on toward the back level, it was discovered that every one of these applications was making an ever-increasing number of associations with the database. Each time a client begins a

No comments:

Post a comment

The Health Care Crisis in a Faltering Economy

The Health Care Crisis in a Faltering Economy Numerous American's are composing their human services out of their spending limit bec...

Post Bottom Ad

Responsive Ads Here