10 Ways To Explain Things More Effectively

http://www.globalknowledge.com/training/generic.asp?pageid=2131&country=United+States&translation=English
10 Ways To Explain Things More Effectively
April 1st, 2008
By Calvin Sun
In the course of your work, you may sometimes need to explain technical concepts to your customers. Having them understand you is important not only for technical reasons, but also to ensure customer satisfaction. The ability to explain things clearly and effectively can help you in your career, as well. Here are a few tips to help make your explanations understandable and useful.
#1: Keep in mind others’ point of view
You’ve probably seen the famous illusion that looks like either a young woman or an old woman. Two people can look at that same picture, and they can have opposite views of what they’re seeing. Keep this idea in mind when explaining a concept. Something that might be perfectly understandable to you might be incomprehensible to someone else. Don’t be the person customers complain about as using "geek speak."
#2: Listen and respond to questions
It’s easy to become annoyed when someone is asking questions. However, try to resist that reaction. A better attitude is to be happy that the other person is interested enough to ask questions. To minimize confusion and misunderstanding, try to paraphrase or summarize a question before you answer it. This step is particularly important if you’re in a group setting, and you’ve just taken a question from someone in the audience. Repeating the question for the entire group helps everyone better understand your answer.
#3: Avoid talking over people’s head
When you explain things to people, do their eyes glaze over? Chances are it’s because you’re talking over their head. Symptoms of such behavior include the use of jargon and acronyms. Remember, the people you’re talking to probably lack your specialized knowledge, so you should use readily understandable terms.
The same goes for acronyms. They’re important, but if you use them, define them in "longhand," followed by the acronyms in (parentheses), so that everyone’s clear. Doing so avoids the scenario of situation normal, all fouled up (SNAFU).
Even within IT, the same acronym can mean different things. For example, both "active server page" and "application service provider" have the acronym ASP. A story from the Vietnam War era further illustrates this point. A young woman brought her boyfriend home to meet her father, a retired military officer. The woman was nervous because the boyfriend was a conscientious objector. When the father asked the young man to talk about himself, the latter replied, nervously, that he was a CO. The father clapped the young man on the back and congratulated him, thinking the latter was a commanding officer.
 
#4: Avoid talking down to people
Avoid the other extreme as well. Don’t insult people by assuming that they’re only as intelligent as a three-year-old. An attendee at one of my communications training classes described it aptly as "Barney communications."
Greek mythology has references to two monsters, Scylla and Charybdis, who sat on opposite sides of a narrow strait of water. If a ship sailed too close to Scylla, it was destroyed and the sailors eaten up. If the ship sailed too close to Charybdis, it was destroyed by a whirlpool that Charybdis created. The ship had to go right between them to survive. Follow that same principle with your customers: Make your explanations neither too complicated or too simple.
 
#5: Ask questions to determine people’s understanding
The people you’re talking to shouldn’t be the only ones asking questions. You should be asking questions as well, to make sure they understand. Your questions can be open ended, which gives people a chance to provide detailed information, or they can be closed ended, which generally calls for a simple yes/no response. In either case, asking questions tells people that you’re interested that they understand.
 
#6: Focus on benefits, not features
What’s the difference? A feature is some inherent property of an object. A benefit, on the other hand, is a way the feature helps a person. For example, one of the features of a Styrofoam cup, because of the material used, is insulation. Someone who’s planning a party probably doesn’t care how the cup provides insulation. That person is more interested in the fact that such a cup keeps hot things hot and cold things cold.
In the same way, try to focus on benefits of technology rather than features of technology. This distinction becomes more important the higher the level of the person you’re talking to. The CFO probably has little need to know about the specific commands and steps involved in setting up database mirroring. That person will want to know, however, that such a practice reduces the chances of data loss.
 
#7: Use analogies to make concepts clearer
An analogy involves explaining an unfamiliar concept in terms of a familiar one. For example, in drawing an analogy between a firewall and a bank teller, you could say that people don’t just go directly into a bank and take money out. They go to the teller and identify themselves; the teller makes sure they have enough money; and then the teller gives them the money. Similarly, a firewall ensures that people who want access to a system really are permitted to have that access.
When choosing an example for an analogy, first figure out the general principle you’re trying to explain. Then, choose something from real life that illustrates that principle. Say, for example, that you’re trying to explain memory leaks. Suppose you conclude that the principle involved is that of taking without giving back completely. An example/analogy might be the consequences of pouring a cup of pancake batter into successive measuring cups, or the consequences of lending money to your brother-in-law.
 
#8: Compare new concepts to familiar ones
Another illustrative technique is to use a familiar or existing product as a comparison. If you’re explaining a new release of a software product, the comparison is easy. Simply discuss the additional capabilities it has over the previous one or how key features are different. If the person hearing your explanation is also an IT person and is familiar with different or older technology, try explaining in those terms if you can. For example, when explaining thin clients, consider a comparison to the old 3270-type terminals that IBM once used for connection to mainframes.
 
#9: Use the concepts of subsets and supersets
Brooklyn is a subset of New York City, because all of it is a part of that city. Conversely, New York City is a superset of Brooklyn, because the former contains, in addition to all of the latter, other boroughs as well. These concepts are helpful in describing, for example, a "lite" versus a "professional" version of a software product. If the latter does everything the former does, plus more, it truly is a superset of the former, and the former is a subset of the latter. Be careful, though: If the "lite" version does even one thing that’s missing from the professional version, there’s no longer a subset/superset relationship.
 
#10: Confirm that your explanation makes sense
Once you’ve finished explaining your point or answering a question, ask a final question yourself. Make sure the people who heard your explanation truly did understand it. Consider asking them to give you the explanation in their own words, just to double-check.
About the Author
Calvin Sun works with organizations in the areas of customer service, communications, and leadership. His Web site is http://www.calvinsun.com and his e-mail address is csun@calvinsun.com.
This article is reprinted courtesy of TechRepublic.com.

Team Building – 6/13/2008

CIP/CER Team换了新的Leadership,Lawrence不再是我们的Manager了。觉得有点可惜,他是招我进公司的Manager,很感激他,现在天天能够Work for fun,幸せだな!!~~不过新来的Team Leader Joe也很nice,至少这几个月的共事大家都很开心,希望将来CIP/CER Team能够在Joe的带领下更加壮大起来。还有就是Bob不再是CER的TD了,转到我们Team做Developer了,相信和这样smart的前辈一起工作会很开心。呵呵~

IMG_0451上厕所时拍的,Prada的眼镜果然是有点效果呀😀

Team Building大家都很high。Joe和Bob都是彪哥高手,Joe的那个“吻别”唱得绝对煽情;Frank骨子里原来是个野兽派,和“叫兽”有的一拼;Stephen和Jimmy是豪放派的;Emma依旧是那个麦霸;Michael明显就是来恶搞的;Ryan也很不错;James和Jacky太害羞了。我么,呃,只会唱日文歌,估计是被BS了,其实不能怪我,钱柜的电唱机点日文歌只能输假名来查。我靠,那也实在困难了点吧😀

It’s time to SSCLI

If you still don’t know what the SSCLI (Codename "Rotor") is, I think you need to make up a missed lesson here. Actually, I also already was late for learning such a important topic since Mar 11th, 2006, when the 2nd version of Rotor was pushed out. (Even though I am, indeed, a .NET fan. :S) Why I need to learn SSCLI? During working with CER (Custom Error Report) for Autodesk, when parsing callstack in a dump file originated from a .NET application, I am always annoyed with those "NOT FAMILIAR" CLR native stack frame.

Recently, I read through some good posts on cnblogs, some nice guys are writing down some thing good for beginner. But most of them are tedious, and a little difficult for beginner to understand. So, I did some experiment, and write down here to be my first study notes for my SSCLI learning.

How to dump CLR Header?

For the definition of CLR Header (IMAGE_COR20_HEADER), you can find it under the SDK folder of the installation of Visual Studio 2005.

> ildasm MetadataDemo.exe /output=result.txt /header /noil

Instead of only CLR Header, other PE header are also dumped out. Here, I use /noil to avoid the output of MSIL. Result is as below:

// —– CLR Header:
// Header size:                        0x00000048
// Major runtime version:              0x0002
// Minor runtime version:              0x0005
// 0x000020a0 [0x000005d8] address [size] of Metadata Directory:       
// Flags:                              0x00000001
// Entry point token:                  0x06000001
// 0x00000000 [0x00000000] address [size] of Resources Directory:      
// 0x00000000 [0x00000000] address [size] of Strong Name Signature:    
// 0x00000000 [0x00000000] address [size] of CodeManager Table:        
// 0x00000000 [0x00000000] address [size] of VTableFixups Directory:   
// 0x00000000 [0x00000000] address [size] of Export Address Table:     
// 0x00000000 [0x00000000] address [size] of Precompile Header:        

// Metadata Header
//    Storage Signature:
//              0x424a5342 Signature
//                  0x0001 Major Version
//                  0x0001 Minor Version
//              0x00000000 Extra Data Offset
//              0x0000000c Version String Length
//              ‘v2.0.50727’ Version String
//    Storage Header:
//                    0x00 Flags
//                  0x0005 Number of Streams
//    Stream 1:
//              0x0000006c Offset
//              0x000001f4 Size
//              ‘#~’ Name
//    Stream 2:
//              0x00000260 Offset
//              0x00000268 Size
//              ‘#Strings’ Name
//    Stream 3:
//              0x000004c8 Offset
//              0x00000028 Size
//              ‘#US’ Name
//    Stream 4:
//              0x000004f0 Offset
//              0x00000010 Size
//              ‘#GUID’ Name
//    Stream 5:
//              0x00000500 Offset
//              0x000000d8 Size
//              ‘#Blob’ Name

//    Metadata Stream Header:
//              0x00000000 Reserved
//                    0x02 Major
//                    0x00 Minor
//                    0x00 Heaps
//                    0x01 Rid
//      0x0000000900021547 MaskValid
//      0x000016003301fa00 Sorted

// Code Manager Table:
//  default

Flags is just like a property of .NET PE file, which points out if the assembly is 32-bit only/il only. You can use CorFlags.exe to dump/modify those flags. Entry Point Token, as it name, it is just a metadata token (or we can say, Symbol, that’s why we don’t actually need .pdb when debugging .NET application. .pdb for .NET assembly just stores some extra source line information), which gives out the address of the entry in metadata table, where we can find the address of fist MSIL method that will be executed when launched. 0x06000001, 6 is the index of metadata table, and 1 is the index of the entry in this table. So, metadata token is a pointer pointing at the entry in metadata table. Actually, when you use /tokens option for ildasm.exe to disassem .NET assembly, you will find the target function following call intruction is marked with a hex number. Yes, it is metadata token. For example:

.method /*06000003*/ public hidebysig specialname rtspecialname
          instance void  .ctor() cil managed
  {
    // Code size       7 (0x7)
    .maxstack  8
    IL_0000:  ldarg.0
    IL_0001:  call       instance void [mscorlib/*23000001*/]System.Object/*01000001*/::.ctor() /* 0A000011 */
    IL_0006:  ret
  } // end of method MyApp::.ctor

Metadata is some binary formatted information stored in PE, that is used to provided extra important information functioning as RTTI, .NET reflection, and so forth. The format of them are undocumented, and we can only use tools provided by Microsoft to dump it out. Don’t think metadata as something mystery, it seems exactly like a micro-relational-like database stored in PE. You can use ildasm.exe with combination of /metadata:RAW, /metadata:SCHEMA and /metadata:HEAPS command line to see how it stores in PE (Truncate some line of the output due to redundant):

// ================================= M E T A I N F O ================================================

// ===========================================================
// Metadata section: 0x424a5342, version: 1.1, extra: 0, version len: 12, version: v2.0.50727
//            flags: 0x00, streams: 5
// Stream 0: name: #~, size 500
// Stream 1: name: #Strings, size 616
// Stream 2: name: #US, size 40
// Stream 3: name: #GUID, size 16
// Stream 4: name: #Blob, size 216
// Metadata header: 2.0, heaps: 0x00, rid: 0x01, valid: 0x0000000900021547, sorted: 0x000016003301fa00
//
// Strings: 613(0x265), Blobs: 216(0xd8), Guids: 16(0x10), User strings: 40(0x28)
//  0(0): Module               cRecs:    1(0x1), cbRec: 10(0xa), cbTable:    10(0xa)
//   col  0:  Generation   oCol: 0, cbCol:2, USHORT
//   col  1:  Name         oCol: 2, cbCol:2, string
//   col  2:  Mvid         oCol: 4, cbCol:2, GUID  
//   col  3:  EncId        oCol: 6, cbCol:2, GUID  
//   col  4:  EncBaseId    oCol: 8, cbCol:2, GUID  
//  1(0x1): TypeRef              cRecs:   19(0x13), cbRec:  6(0x6), cbTable:   114(0x72)
//   col  0:  ResolutionScope oCol: 0, cbCol:2, ResolutionScope
//   col  1:  Name         oCol: 2, cbCol:2, string
//   col  2:  Namespace    oCol: 4, cbCol:2, string
//  2(0x2): TypeDef              cRecs:    2(0x2), cbRec: 14(0xe), cbTable:    28(0x1c)
//   col  0:  Flags        oCol: 0, cbCol:4, ULONG 
//   col  1:  Name         oCol: 4, cbCol:2, string
//   col  2:  Namespace    oCol: 6, cbCol:2, string
//   col  3:  Extends      oCol: 8, cbCol:2, TypeDefOrRef
//   col  4:  FieldList    oCol: a, cbCol:2, Field 
//   col  5:  MethodList   oCol: c, cbCol:2, Method
//  3(0x3): FieldPtr             cRecs:    0(0), cbRec:  2(0x2), cbTable:     0(0)
//   col  0:  Field        oCol: 0, cbCol:2, Field 
//  4(0x4): Field                cRecs:    0(0), cbRec:  6(0x6), cbTable:     0(0)
//   col  0:  Flags        oCol: 0, cbCol:2, USHORT
//   col  1:  Name         oCol: 2, cbCol:2, string
//   col  2:  Signature    oCol: 4, cbCol:2, blob  
//  5(0x5): MethodPtr            cRecs:    0(0), cbRec:  2(0x2), cbTable:     0(0)
//   col  0:  Method       oCol: 0, cbCol:2, Method
//  6(0x6): Method               cRecs:    3(0x3), cbRec: 14(0xe), cbTable:    42(0x2a)
//   col  0:  RVA          oCol: 0, cbCol:4, ULONG 
//   col  1:  ImplFlags    oCol: 4, cbCol:2, USHORT
//   col  2:  Flags        oCol: 6, cbCol:2, USHORT
//   col  3:  Name         oCol: 8, cbCol:2, string
//   col  4:  Signature    oCol: a, cbCol:2, blob  
//   col  5:  ParamList    oCol: c, cbCol:2, Param

Above is the some of the metadata schema used in PE. And you will see the content of it as following (Truncate some line of the output due to redundant):

// =================================================
//  6(0x6): Method               cRecs:    3(0x3), cbRec: 14(0xe), cbTable:    42(0x2a)
//   col  0:  RVA          oCol: 0, cbCol:4, ULONG 
//   col  1:  ImplFlags    oCol: 4, cbCol:2, USHORT
//   col  2:  Flags        oCol: 6, cbCol:2, USHORT
//   col  3:  Name         oCol: 8, cbCol:2, string
//   col  4:  Signature    oCol: a, cbCol:2, blob  
//   col  5:  ParamList    oCol: c, cbCol:2, Param 
// ————————————————-
//    1 == 0:00002050, 1:0000, 2:0096, 3:string#38, 4:blob#a, 5:Param[8000001]
//    2 == 0:00002080, 1:0000, 2:0096, 3:string#3d, 4:blob#e, 5:Param[8000001]
//    3 == 0:00002095, 1:0000, 2:1886, 3:string#41, 4:blob#14, 5:Param[8000003]

Above is the metadata table for method. you will see there are three entry in it. "string#xx" is the symbol of this method, and "blob#x" stores the signature of the method. Both of them a another metadata token pointing to some special metadata area.

// String Heap:  613(0x265) bytes
// 00000001: <Module>
// 0000000a: MetadataDemo.exe
// 0000001b: MyApp
// 00000021: mscorlib
// 0000002a: System
// 00000031: Object
// 00000038: Main
// 0000003d: Add
// 00000041: .ctor
// 00000047: One
// 0000004b: Two

See it? It’s so great that you will find the three entries in method table are for Main, Add, and a constructor of some class. You can use the same methodology to looking for signature and parameter list of the method. In fact, metadata is a key in .NET. When you using System.Reflection, even during JIT-compiling, CLR is just probing in that way.

 

OK, that’s all today.

Hope that can help. 😀

おかえり – 絶対彼氏

http://player.youku.com/player.php/sid/XMjkyOTMxNDA=/v.swf

おかえり sweet home
帰る場所 愛をありがとう

また平気なフリをして
悲しみの色を塗りつぶして 笑ってしまうんです
信じることの大切さ わかってるのに
いざという時 疑ってしまうんです

空っぽの体 流れる時に
浮いてしまいそうになるけど
あなたのこと 抱きしめたい
このキモチが突き動かすの

おかえり I’m home
一言で満たされる心
おかえり sweet home
帰る場所 愛をありがとう
sweet home

自分のことばかりを考える大人はズルイんだと
思っていたんです
でも必死で変えることを
叫んでる人もいるんだと やっと知ったんです

当り前の幸せなんか この世界に一つもない
"あなたのため" そう思えた
このキモチが突き動かすの

おかえり I’m home
スピードが加速してく毎日
おかえり sweet home
変わらない ずっとある景色
sweet home

探して なくした
心の傷が
立ち向かう 強さに変われたのは
「おかえり」があったから

おかえり I’m home
一言で満たされる心
おかえり sweet home
帰る場所 愛をありがとう

おかえり I’m home
大丈夫 あなたがいるから
おかえり sweet home
待っててね もうすぐ着くから
sweet home