Here’s the trick. Connect to your DB using Sql*Plus and used the following actions:

SET markup HTML onspool test.htmlSELECT *  FROM mytable;spool offSET markup HTML off

When you type command “SET markup HTML on“, your command prompt will look “funky” don’t worry it is perfectly normal. After you exit you will find a nice html file. Certainly not the best format, but much more readable than plain 80 column text.

Here’s some tricks that can help in daily work with oracle. Very often, I need to extract query result from Oracle, or to be more precise ask people to send me query results. It is quite easy to save a file, that’s very true but the formatting is excruciatingly unreadable. There’s a flurry of tools that can allow you to export your query, but sometimes the only things you have at end because you’re connecting to production environment is a good old Sql*Plus.

Here’s the trick. Connect to your DB using Sql*Plus and used the following actions:

SET markup HTML on

spool test.html

SELECT *  FROM mytable;

spool off

SET markup HTML off

When you type command “SET markup HTML on“, your command prompt will look “funky” don’t worry it is perfectly normal. After you exit you will find a nice html file. Certainly not the best format, but much more readable than plain 80 column text.

Similarly I send email to people, but … other people are busy, or can’t or simply won’t answer. So you have to chase them. But again that means you have to remember to chase them.

That makes a lot of things to remember, on top of the usual things you have to do. It wasn’t really efficient, which is bad enough, but it also hampered my productivity.

So whenever I receive an email I need to answer, or send an email and make sure I receive an answer in the timeframe I expect (or chase that person), I started to create an outlook task for each of those email. This way I don’t have to clutter my mind with little things, and leave room for other more important things to remember. I suppose was the result of reading those article about GTD and productivity.

It worked for some time but … I rapidly found it boring. So I’ve made a little macro in outlook. A a very simple one indeed. I just select an mail, and launch a macro and it pops up the create task window, with the selected email automatically pasted in copy. I only have to set the reminder date.

In order to do that, I used the following a macro in outlook:

Sub MakeTaskFromMail(MyMail As Outlook.MailItem)
   Dim objTask As Outlook.TaskItem
   Set objTask = Application.CreateItem(olTaskItem)
   With objTask
       .Subject = MyMail.Subject
       .DueDate = MyMail.SentOn
   End With

   objTask.Attachments.Add MyMail
   objTask.Display

End Sub

Function GetCurrentItem() As Object
   Dim objApp As Outlook.Application

   Set objApp = Application
   On Error Resume Next
   Select Case TypeName(objApp.ActiveWindow)
       Case "Explorer"
           Set GetCurrentItem = objApp.ActiveExplorer.Selection.Item(1)
       Case "Inspector"
           Set GetCurrentItem = objApp.ActiveInspector.CurrentItem
       Case Else
           ' anything else will result in an error, which is
           ' why we have the error handler above
   End Select

   Set objApp = Nothing
End Function

Sub MakeTaskFromCurrentMail()
   Dim currentMail As Outlook.MailItem
   Set currentMail = GetCurrentItem()
   MakeTaskFromMail currentMail
End Sub

Now that works pretty well, but since I really lazy and like things to go smoothly, I created a little button that calls the macros, and that the final touch (one could even associate a shortcut).

That simple trick really eased my life and now i almost never forget to answer an email or chase someone to get my answer. Hopefully this will help others.

What is a core file and how to get one

Starting from the beginning, let’s first define what is a core file. A core file, also called core dump is basically a dump, or image of the memory of a computer at a given time. It’s like a photo of everything in memory of your computer at the time of the creation of the core, the registry the stack and heap, pretty much every live data. Usually people will say “Oh S…t the software has cored again”. It’s usually not a good sign.

In most of case the generation of a core dump is involuntary,  and is the result of a *violent* crash of a software. Amongst the common cause we can cite memory corruption, stack overflow, lack of memory or even device failure.

Despite the fact that a core file usually means you’ve got a serious bug in your software, they are tremendously useful. Since they are a snapshot photo of the memory at the time of the crash, this can help a lot to figure out what happened. With the help of a core file you can explore the exact conditions at the time of the crash.

Does it mean that core file are the paramount of debugging, the panacea to bug, certainly not. For instance in the case of memory corruption, by the time you get the core file, it’s already too late, the corruption happened seconds before … which means ages for a computer.

What to do with a core file ?

Now if you get a core file that’s good. You can use a debugger that’s able to use core on the systems the core was generated. Each system (Windows, Linux, Solaris …) has its own debugger, and each has its own function. So depending the system you’re using you will have to search for the appropriate tool. Here’s the list of what tools you can use to debug cores:

• Solaris : dbx
• Linux: gdb
• Mac OS: gdb

This list is by no mean complete since each system boast different tools. Windows is absent from the list because its a it different from other systems in that aspect. For more information about core dump equivalent on windows called minidump, you can check here.

How to generate a core and why ?

As we’ve said above, core dumps are generally the result of a violent crash, so why would one want to force the generation of a core dump ? The answer is to try to investigate dead lock or process hanging issues.  When your process is really frozen, you will have to kill it anyway, but if you do it right you can at the same time generate a core dump that will help you later on with your investigation.

You have two ways to generate a core:

• gcore <pid>: This command will generate a core file for a live process but leave the process running
• kill -5 <pid>:  as the name of the command, this will kill the process but also generate a core of your application

Additionally before using the kill command you may want to use the command pstack <pid>, which will generate a text file that constains the list of all process stack (and each thread of your process) currently running. Executing the command a couple of time before actually killing your application can prove useful, since it’ll give you a better image of what thead is active and doing what than a simple core would.