survic's blog on Programming or Enterprise Computing

Silverlight, ActiveX, AIR, Sandbox, and Offline

2009-05-18T14:53:00.005-07:00

1. Silverlight 2 stand-alone with ActiveX

Silverlight 2 stand-alone html application (it is better to change the .html to .hta, the host is MSHTA.EXE), using javascript (file mode, so full trust) to call activeX (note that this approach is not cross platform).

http://www.galasoft.ch/mydotnet/articles/article-2008042301.html
http://geekswithblogs.net/lbugnion/archive/2008/04/24/silverlight-running-standalone-full-trust-applications.aspx

http://blogs.microsoft.co.il/blogs/tamir/archive/2008/04/27/how-to-make-silverlight-be-air.aspx

2. If the requirement is not offline, but to access files and ports, can use special ActiveX with javascript.

3. Silverlight 3 OOB is not that useful

--a. Silverlight 3 OOB is within browser sandbox, so, cannot access file etc.
--b. Silverlight 3 OOB (out of browser) cannot use html/javascript, so, it cannot be used together with the hta technique.

4. The above is not cross-platform (but for intranet, it is good that it does not need to install any “extra” stuff), for that, AIR is the way to go.

5. Is it possible to use both AIR and pure Silverlight3? Not sure: (i) Can Silverlight3 be invoked from AIR? (ii) Silverlight cannot invoke AIR (sandbox), but it can save to the storage, and AIR can poll that. (iii) Silverlight cannot mash up AIR. (iv) AIR perhaps can mash up Silverlight. As a result, it looks like we can use AIR as the “shell” (base application), and invoke Silverlight screens (because it is in sandbox, so, it does not know other instances; so, the shell must be very lightweight and can be instantiated many times without performance issues).

6. For Serial port etc, it needs a generic "proxy" that translates port to socket(). Javascript can then use socket. Note that this makes it not portable. So, if we do not need offline feature, then, we can simply develop small ActiveXes to access things out of the sandbox, and use Silverlight for UI, and use javascript to glue things togother.

The so-called process is actually parts of the architecture, and the so-called architecture is actually parts (use cases) of the process

2009-05-18T07:31:00.004-07:00

The so-called process is actually parts of the architecture, and the so-called architecture is actually parts (use cases) of the process. Both of them are about three things:

1. use cases
2. data fields
3. architecture use cases (transaction-failure handling; network-performance plus offline client, reports, direct database jobs; security, auditing)

Key understanding:

1. use cases: this is the art. The core of the art is to find the representative use cases so that they are only a few but cover all data fields. Also note that they need to be described using UI terms, however, they are use cases -- using UI language and eventually doing UI design do not mean you need to jump on UI design in the very beginning.

2. data fields: this is the science. All computing are based on this, including object oriented programming -- the core of domain model is in data model. However, note that this does not mean you need to jump on database physical design in the very beginning.

3. Architecture use cases. They are use cases. "Architecture" is not magic; they must be organized in use cases. Users can and must understand them -- that is, if you organize them in use cases.

documents and paper computer

2009-02-16T11:32:00.007-07:00

documents and paper computer

In addition to "use cases" and "data fields (data points)", another key word is "documentation". I treat "documentation" as if it were source code, and as a result, it corresponds to the real system directly -- I treat it as a "paper computer".

By doing this, there is no "process". Note that "use cases/business rules" and "data fields (data points)/technical approaches" (I believe "implementation strategies" is too difficult to say quickly in meetings, so, I traded the phrase with "technical approaches") are the top-most level of the structure ("architecture") of a system.

Note that we can talk some "technical approaches" to users. All those are key words in software support/development.

Also note that "technical approaches" includes technical items in "use cases/business rules", for example, "transactions", "newwork (web services, report server, eim, remote)", "security", and "audit" are "use cases/business rules".

the wording I am using: "use cases" and "data points"

2009-02-10T14:01:00.002-07:00

I know I change a lot, and I play with words a lot.

Now, again, I am changing the wording of the top level thinking “formula”. They are "use cases" and "data points".

Yes, I am putting “rules” and “implementation strategy” back to where they belong – low level.

I changed “common data” to “data points”, because “common data” is too abstract to users. I want the wording easy to understand, intuitively.

Also, “points” kind of intuitively leads people into details, closer to implementation. This is especially true when you use "screens" for "use cases".

I guess I will keep using them for a while.

Now, you may say, why, why are you paying attention to the wording so much? It is important. Without a good wording, you will not say them that often, then, you will be misled, or, worse, you will mislead. Saying something, saying something aloud, saying something aloud in front of a team, are a very powerful action, and that action definitely affect your other actions and behaviors.

Use "rules" and "non-typical implementation strategy" to replace "use cases" and "common data" respectively

2009-01-26T09:59:00.005-07:00

Use "rules" and "non-typical implementation strategy" to replace "use cases" and "common data" respectively

For a technical team, the concept (or “wording”) of “rules” is better than “use cases”, because “rules” is more technical. Users are more attentive and more tolerate to details. It is more "cut to the chase". Note that I correct myself of my previous blogs. Now, I believe the concept of “rules” corresponds/replaces to “use cases” (for technical teams), instead of replacing “common data”.

For a technical team, the concept “implementation strategy” corresponds/replaces the concepts “common data”.

Note that “rules” and “implementation strategy” are more “mixed”: “rules” has “common data” factors, and “implementation strategy” has “use cases” elements. However, their respective “starting point" is “use cases” and “common data” respectively.

I know, it is very confusing, but it is actually simple in action: for a technical team, always have a list, with “rules” and “implementation strategy” as your cheat sheet, then, you will be safe and can proactively respond everything.

Just one more bit of details. Usually there are too many details, too many “implementation strategies” – i.e., the list can be too long to be effective as a “cheat sheet”. So, the secret is to scan through the common, usual, routine “implementation strategies”, and, identify those uncommon, non-typical ones.

You may ask, what are the criteria of “common” and “uncommon” (i.e. “special”, "non-typical") ones? Easy, the 90% rule (I know, usually people say 80% rule – but in technical areas, we need to be tougher).

Of course, to pay attention to the non-typical ones, you have to master the common ones first, even most of the time, you do not need to do them yourself, since you only pay attention to the non-typical ones – it sounds like a paradox, but that is the secret of delegation or helping others to help yourself – that is actually your value as an experienced professional.

thumb typing is good for IT professionals

2009-01-24T23:29:00.004-07:00

Diagrams and spreadsheet are bad, plain text is good, and therefore thumb typing is good for IT professionals

The key is, drawing is not that important. If drawing is really that important, than, thumb typing is useless, we neither have to use tablet, or, paper.

I find that drawing is not that important. Diagrams are totally overvalued. After all, the general computing thesis is that what you can describe, you can realize it in computing, it is not that what you can draw or clicking. For software engineering, structure English (or structured any natural languages) is the king, not diagrams, not spread sheet. Whenever you find your documents are mostly diagrams and spread sheet, you should treat it as a red flag, something is wrong.

It took me so long for me to realize the importance of thumb typing. I will strongly recommend to everybody in my family to begin to use thumb typing.

I know young people have been doing the texting for a while. However, I am not talking about texting. I am not that generation; I am not interested in texting. Frankly, I believe it is simply temporary anti-culture, combined with the temporary limitation of computing devices – I am talking about those texting abbreviations – BFF, best friend forever, what a heck!

Even in thumb typing, I prefer the whole wordings. To me, using not absolutely common abbreviations is a sure indicator that the author is inconsiderate and therefore not professional, period. I know, this does not mean too much to a teenage. I totally understand, believe me, I was young before also :-)

I also know a lot of business people have been using PDA for a long time. However, I am not sure most of them are using them to take notes.

As a result, although it took me for a while to plunge into thumb typing, I believe I am still among those not too many people who have recognized the value of thumb typing and are doing it seriously.

[OK, after I wrote the above, I googled thumb typing, and I found a lot materials, see below. Some of them were written in 1999 -- it means that I am soooo late! However, I can still say that those are pioneers. From what I have observed, I am not that late to use it as an everyday routine notes-taking device to replace paper-based notes-taking
http://www.blackberryforums.com/general-blackberry-discussion/800-blackberry-thumb-touch-typist-guide-typing-60-wpm-without-looking.html

It says a lot of things, but all I feel I really need to know is the fact that "we can": it is possible to use thumb typing to think-write, and there are two other tips:

a. Note the left thumb holding Num can give you a Uppercase for the right thumb.
b. When typing number, left thumb holding the Alt key, and right thumb push the number keys.

---Just type the quick brown fox jumps over the lazy dog.

---I will try more aggressively to be able to do blind/touch typing with thumbs.
]

Also, I want to share that, in the beginning, on blackberry, I just send myself emails as my notes. Very soon, I found out that it is a bad idea. I cannot find my notes! They are buried in those emails.

Now, I am using “tasks” to take notes, and periodically “select” and copy them to emails as a backup. Of course, now, “tasks” is my first icon on my blackberry.

There is another thing that sucks. The company has a group security policy: the blackberry locks itself after several minutes. I have to enter password to unlock it every time I need to takes notes. I tried to ask them to make the timeout longer, but you kow the result, Sigh.

For blind/touch typing, I am not sure whether I need a physical keyboard or a simulated one. I am using an old blackberry. The new blackberry model is like an iphone, with larger screen, but a simulated keyboard. I do not have the new model, I guess it is a blessing for typing.

thumb typing all the time -- on blackberry for to-do-item notes

2009-01-15T12:11:00.003-07:00

Thumb typing, or, thumb-and-index typing, is not that difficult. You can do that pretty fast after a few hours. The problem is the software – there is no auto-spell checking, and no auto-correction in blackberry (perhaps I missed something).

Thumb typing is faster than writing pad and real time recognition, but I guess we need both, because we still need drawing. Mouse drawing is not good. Touch screen is useful here.

Anyway, thumb typing is worth it. I know, I am slow to pick it up, but I will begin to really do thumb typing on my blackberry to make notes, instead of using pen and paper.

This means I will use thumb typing all the time. Note that I have electronic notes that I take in VIM (not MS Word, since VIM also have spell checking – it does not have auto-correction – or I should say I am not using that, I am not user whether VIM has auto-correction or not). Those notes are detailed, and have a lot of content – that is why I use electronic notes for them long time ago. I always laugh at my college who are still using papers to do those kind of notes. It is amazing, a lot of them still doing that, make notes on paper!

However, I have been using paper doing the to-do-item notes all the time. This kind of notes, they are short, just a reminder. Also, they must be extremely portable, not limited on computers.

Now, I am going to move this to blackberry. I cannot draw anymore, but for those to-do-item notes, I do not do drawing anyway.

Note that I blog this, because I believe this kind of thing is important for computer professionals. Too many computer professionals are too behind on using computers!

Personal Paperless Evolution: Use more laptop, printing pdf on paper, and thumb typing notes

2009-01-11T18:16:00.007-07:00

As a new year resolution, starting now, I will always use electronic notes, instead of marking the notes on the margin of paper materials -- this means paper material will officially disposable at any time.

Today, I cleaned up my paper materials, there are only a few of them, I will gradually move the notes to electronic notes. They are not critical, I have already been doing this, it is just a "clearing house" activity, I guess.

More explanations:

1. The key of doing this is to use my labtop more often (the battery is OK, I just need to stop my bad habit of prefer reading paper materials and making notes on them). When I travel or at home, I will use my blackberry and my kindle more often -- even when I have to use paper material (OK, I still prefer reading on paper than on computer. Kindle is fine, but Kindle cannot handle pdf), at least I must use thumb typing on blackberry or kindle to take notes.

2. As mentioned above, Kindle is a big disappointment to me, I was hoping it can help me to realize the "paperless revolution" in my "home-office" and my personal life. It did not. Now, I have to re-do it by an evolutionary approach.

Now I know, a "reader" should be have larger screen (perhaps by folding it or better bending it without the middle dividing line) so that it can handle pdf without any reformatting. It must be touch screen with stylus support to avoid thumb typing. Also, it should have a fold keyboard for typing. In short, it is a tablet computer with an electronic paper screen.

I almost regret of buying Kindle, I should have gone to iLiad 1000, which has a price tag close to $900. However, the screen of iLiad is still small and not convenient for typing (does it support external key board? not sure); futher, it does not have color, which is important for some business documents. Also, it does not support video.

This leads to a question, why epaper screen? Because it is easy to eyes, and it saves battery -- both are not that important for business documents.

So, after all, I guess for pdf documents, let's keep it in labtop (or tablet - if you have it); for "ordinary" books, use kindle. So, I guess my decision on Kindle is an OK one, although Kindle is indeed disappointing -- the technology is slower than I expected. As a result, we need to adapt to the current status of the technology. Printing pdf on paper (sorry, trees, we still need to cut you!), and thumb typing.

Summary of 2 "blocks" and their sub-blocks

2009-01-11T16:08:00.004-07:00

Summary of my previous summary

I will do things according to the following 2 "blocks" and their sub-blocks:

1. “Common data”: this leads to "OUR" Object, UI, Relational, and their mappings -- OR mapping and OU mapping.

2. "Use cases": this leads to UI and "facade" -- in Siebel, "business service" and "workflow", they then lead to networking (which in turn includes 4 parts: web service, EIM, reporting, and remote), logging, and security.

summary and new start

2009-01-10T14:50:00.007-07:00

I reviewed all my blogs of the past a few years – that is one advantage of blogging over private notes: it forces you to face your history of ideas! I found that sometimes I contradicted myself, and I debated with friends, and I changed my mind. The important thing is not the conclusions, but the arguments, the process of arguing, and more importantly, the understanding, insights, and friendship.

OK, another immediate contradiction of myself: Now, I want to have a summary ("conclusions"!), so that we can invent more in the coming year(s).

1. "Philosophy": science and technology, regardless of modern and ancient, are one. The saying that modern science is totally different from ancient science and from technology is a myth. At a high level, they are the same. We can and should use science-thinking ("scientific thinking) in technology, and vice versa.

2. "Time" -- the basic sequence

“Analysis/Design/Coding/Testing” corresponds to “Problems/Theory/Solving Problems using the theory/Testing”.

Note: in "problems", you have both "common data" and "use cases", not just "use cases".

3. "Space" -- the basic structure (or “architecture” -- but I prefer small words in science/logic, instead of big words in engineering)

“Common data” (this leads to "OUR" Object, UI, Relational, and their mappings -- OR mapping and OU mapping) and “use cases”. "Use cases" leads to UI and "facade" -- in Siebel, "business service" and "workflow", they then lead to networking (which in turn includes 4 parts: web service, EIM, reporting, and remote), logging, and security.

Note: “Common data” is a “new” phrase I have begun to use. I discussed/debated a similar topic sometime ago in my blogs, “data model vs. domain model”. I believe “data” is more user-friendly and, well, manager-friendly. I add “common” before "data", to emphasize that the concept has inherently an element of “design”, “structuring”, or well, “modeling”. In short, it is a compromise between “data model” and “domain medel” -- but I still do not like “domain model”: it is too programmer-oriented, not user-friendly. Users are totally confused when you use the word “domain model”, but they know, I mean, really know, “data”. Note that it is not just wording. Inherently, “domain model” has too much “technical” baggage. "Domain model" concept belongs to a more limited technical context, instead of a top level concept that can be used together with the concept of “use cases”.

A special note: I notice that there is a mapping between "time" and "space", or, a common spot in both "time" and "space": the "use cases" (UIs and facades) maps to "testing". This is understandable: the so-called "space" is the basic structure for software, which must follow the basic structure of human logic, which is the so-called "time" all about.

4. Technical team dynamics (or "team culture" or "team leadership" or "team moral" -- pick the phrase you like):

a. Basic estimate of human capability, science, technology, and education: a good high school new graduate or an average college new graduate can start to work productively within two weeks on any computer technologies, within a good team and with good mentoring.

b. Rotating/pro-vertical (avoid single threading) and lean (cut self-enforcing communication overhead)

Single threading is bad. When project is late, you cannot put more people on the bottlenecks. Worse, it damages team moral. It is the basis of unfairness, laziness, and even outright blackmailing. Based on my observation, it is the root cause of more than 80% of problems in IT.

The irony is that out of the 80%, more than half of it is from the “solution” of the problem: heavy communication overhead. It is a self-enforcing overhead -- people first compartmentalize the team, create the hunger for information, and then, they “coordinate”. Gradually a lot of people cannot do things anymore, they only “communicate” and “coordinate” while they are devaluing the whole profession into production-line work, with extremely heavy, costly, error-prone, and misleading overhead. The double irony is that this "solution" actually aggravates the "single threading" problem.

We can do better. We need, can, and should be more effective by being lean. However, to do that, we need to find a better way to solve the single threading issue.

Observing other professional fields, we can find that the real solution is the opposite of the current “solution”: instead of limiting, we expand the scope – every developer should at least have 2 or 3 “fields” (remember that even an average college new graduate can pick up things in a field within two weeks!), then, we can rotate the fields within the team. Also, when we do “division of labor” in a certain project, we should always prefer “vertical” division (end-to-end of a vertical slice), instead of “horizontal” layering division (e.g., one person in UI, another person in Business layer).

c. “Document driven”, meeting minutes, source control, and source control friendly format. The essence of the “document driven” is that all documents, including meeting minutes, user oriented documents, and even “private” or “personal” notes, should be treated as “source code”.

There are two big challenges.

One is that people want to keep some “private” and “personal” notes – this will be resolved by rotating mentioned above.

Another one is “source control friendly format”: some user oriented documents, for example, “requirements” or “user manuals”, are not easy to be put into version control friendly format. Currently, too often they are in MS Word together with spreadsheets, which both are ugly and horrible for version control friendly minds! – This is actually pretty easy to resolve in web technology (wiki etc). I hope the corporate world will catch up on this quickly.

d. “Process” must be simple, and not arbitrary. In more detailed terms: it must be in place before projects. Preferably, its wording should be consistent with common usage in the industry, like "analysis", "design", "coding", "testing", “use cases”, and “common data”.

A Paper on TDD and Karl Popper

2008-12-12T08:53:00.002-07:00

http://www.springerlink.com/content/b2m76810u5715802/fulltext.pdf

G. Concas et al. (Eds.): XP 2007, LNCS 4536, pp. 253–256, 2007.
© Springer-Verlag Berlin Heidelberg 2007
-------------------------------------
Epistemological Justification of
Test Driven Development in Agile Processes

Francesco Gagliardi
Department of Physical Sciences — University of Naples Federico II
Via Cintia — I-80126 Napoli, Italy
francesco.gagliardi@libero.it

Abstract.

In this paper we outline a methodological similarity between test
driven software development and scientific theories evolution. We argue that
falsificationism and its modus tollens are foundational concepts for both software
engineering and scientific method. In this perspective we propose an epistemological
justification of test driven development using theoretical reasons
and empirical evidences.

Keywords:

Software Testing; TDD; Agile Programming; Epistemology; Falsificationism;
Modus Tollens.

1. Ghezzi, C., Jazayeri, M., Mandrioli, D.: Fundamentals of Software Engineering. 2nd edn.
Prentice-Hall, Englewood Cliffs (2003) (ISBN: 0133056996)
2. Dijkstra, E.W.: Notes On Structured Programming. 2nd edn., T.H.-Report 70-WSK-03,
Technological University Eindhoven, Department Of Mathematics, The Netherlands (1970),
(Url: http://www.cs.utexas.edu/users/EWD/ewd02xx/EWD249.PDF
3. Popper, K.R.: The Logic of Scientific Discovery (Translation of Logik der Forschung).
Hutchingson, London (1959)
4. Kaner, C., Falk, J., Nguyen, H.Q.: Testing Computer Software, 2nd edn. John Wiley and
Sons, Chichester (1999) --------------
5. Bach, J.: What software reality is really about. IEEE Computer 32(12), 148–149 (1999),
doi:10.1109/2.809258
6. Pettichord B.: Testers and Developers Think Differently. STQE magazine, vol. 2(1), pp.
42-46 (2000), (Url: http://www.stickyminds.com/sitewide.asp?Function=edetail&Object
Type=ART&ObjectId=506) --------------------
7. Coutts, D.: The Test Case as a Scientific Experiment. (url: http://www.stickyminds.com/
sitewide.asp?ObjectId=8965&Function=DETAILBROWSE&ObjectType=ART) --------
8. Edwards, S.H.: Using software testing to move students from trial-and-error to reflection-inaction.
SIGCSE Bull. 36(1), 26–30 (2004), http://doi.acm.org/10.1145/1028174.971312

-------------------------------------------short quotes

It is proved that an ideal test suite exists for any program, but unfortunately it is
also proved that there is no constructive criterion (i.e. algorithm) to derive a test suite
satisfying that property.

The incomputability of ideal test suite is the primary cause of the existence of several
empirical criteria to define the test suite such as category partition, boundary
analysis, special values detection, an so on.

---------------

This firmly links software development to methodologies of natural sciences and to
epistemology, in particular to theory of falsificationism by Popper. And we need to
adopt this perspective if we want to increase the comprehension of methodology and
practice of software development.

In this perspective TDD is the unique ‘scientific’ methodology to develop software
systems because it uses the falsificationism and embraces continuous testing.

Summarizing, the successful of TDD in agile processes is based on the rediscovery
of scientific method.

Read, baby, read

2008-11-23T15:00:00.002-07:00

It is toward the end of the year, holidays are approaching!

Looking back, since the end of last year, I have been carrying out my resolution of the journey of going out the box of the software process (being it UP or TDD), and back to the richness of life.

More readings, not just outside the readings of MS technologies, or, Siebel technologies, or, Unix, Internet. Much more than that. Reading is nice, it is like watching TV or go to theaters or movies. Reading does not need to be a burden, even for non-fictional readings.

Software engineering is not a "field" or "discipline", it is an inter-disciplinary area. Do not let those process fool you. You can get more useful techniques in philosophy of science (and other areas) than in those theories of software processes.

Expand our readings. Read, baby, read.

2008-11-23T14:32:00.002-07:00

Another site that with similar recommedatoin of readings.

It seems that "testers" are deep thinkers, shame on "project managers", "analysts", "architect", "developers", and "programmers"! -- of course, I am NOT a tester, so, I do not really care about the testing specific things.

http://www.satisfice.com/bibliography.shtml

Systems Thinking
Quality Software Management, Vol. 1: Systems Thinking
1991, Gerald M. Weinberg
An Introduction to General Systems Thinking
1975, Gerald M. Weinberg
Secrets of Consulting: A Guide to Giving and Getting Advice Successfully
1986, Gerald M. Weinberg
General Principles of Systems Design
1988, Gerald M. Weinberg, Daniela Weinberg

Heuristics
Tools of Critical Thinking
David A.Levy, 1997
Exploring Requirements: Quality Before Design
1989, Don Gause, Gerald M. Weinberg
How to Solve It
1945, George Polya
How to Read and Do Proofs
1990, Daniel Solow

Ways People Think and Learn
Cognition in the Wild
1996, Edwin Hutchins
Thinking and Deciding
1994, Jonathan Baron
Lateral Thinking: Creativity Step by Step
1990, Ed De Bono
The Social Life of Information
2000, John Seely Brown, Paul Duguid
Things That Make Us Smart: Defending Human Attributes in the Age of the Machine
1993, Donald Norman

Scientific Thinking
The Sciences of the Artificial, 3rd Ed.
1996, Herbert A. Simon
Conjectures and Refutations: The Growth of Scientific Knowledge
1992, Karl Popper
Theory and Evidence: The Development of Scientific Reasoning
1996, Barbara Koslowski
Abductive Inference: Computation, Philosophy, Technology
1996, John R. Josephson, Susan G. Josephson
The Pleasure of Finding Things Out
1999, Richard Feynman
Science as a Questioning Process
1996, Nigel Sanitt
Administrative Behavior, 4th ed.
1997, Herbert Simon

Software Testing
Testing Computer Software
1992, Cem Kaner, Hung Quoc Nguyen, Jack Falk
Software Testing: A Craftman's Approach
1995, Paul C. Jorgensen
Bad Software: What to Do When Software Fails
1999, Cem Kaner, David Pels

Example of an Implicit Specification
The Windows Interface Guidelines for Software Design
1995, Microsoft

Teamwork and Communication in a Technical Team
Quality Software Management, Vol. 3: Congruent Action
1994, Gerald M. Weinberg

Karl Popper and Software Engineering

2008-10-18T22:44:00.003-07:00

Karl Popper and Software Engineering

I believe now -- 2008, in software engineering, a pure “practitioner” point of view is hitting a dead end. We need an “academic” or conceptual revolution. The revolution is to throw out the inductionism in software engineering. Karl Popper did it in Philosophy of Science. We need to expand that to software engineering.

In my previous blog, I proposed the following theory:

“Analysis/Design/Coding/Testing” corresponds to “understanding problems and anomalies/theory/solving issues using the theory/ experiment-test the theory”. Now, I am going to make it even simpler: “Analysis/Design/Coding/Testing” corresponds to “Problems/Theory/Solving Problems using the theory/Testing”.

You may say, it is just a word-game. I say it is a huge, revolutionary change. Now, "analysis" is to understand problems, not “gathering” those so-called “requirements” anymore! In meetings with users, when we ask “what is the problem” and “how do we solve the problem”, it is always more effective than asking “what are the requirements”! In fact, we all know that “requirement gathering” is the source of all problems in software development. Now, we know why – OK, pun is intended here!

I googled about it (Karl Popper and Software Engineering). Surprise, Surprise, I am not the only one!

http://blogs.msdn.com/imtesty/archive/2007/01/15/the-science-of-software-testing.aspx A deep thinker in MS!

The following is a short quote (please go to the above URL for a complete read, it is fun!):

Testing as a science
Computer software is similar to a scientific hypothesis; both are inherently fallible. The basic framework of the software debugging process is analogous to the trial and error practice that advances scientific hypotheses. Computer software is simply technical conjecture. Test engineers attempt to refute the assumption of flawless software through rigorous tests mostly designed to prove that defects exist (falsification).

The falsification process sharply contrasts with data-driven approaches such as induction and deduction, which attempt to justify validity based on the repetition of facts. Justificatory approaches mostly attempt to support claims through confirmation. Confirmation primarily endeavors to validate the error-free uncertainty by using specific data that demonstrates proper functionality. This approach clearly only proves that software functions correctly under certain conditions; it does not prove that the software is error free.

Problem Solving Areas (PSAs), Problem Solving Lean Process (PSLP), Analysis/Design/Coding/Testing and General Problem Solving

2008-10-05T18:39:00.008-07:00

Problem Solving Areas (PSAs), Problem Solving Lean Process (PSLP), Analysis/Design/Coding/Testing and General Problem Solving

Ya, you may say that all this blog is about names; but good names indicate the maturity of a theory.

1. I changed the 8 core "techniques" into 8 core "Problem Solving Areas (PSAs). See the 8 PSAs at the bottom of the blog.

2. In this blog, I changed the process name into “problem solving lean process”: it is a lean process, with problem solving in its focus.

3. I retreat from my noble fighting with “Analysis/Design/Coding/Testing”; now, I believe it is a paraphrase or a parallel mechanism of the “problem solving process”: thinking about problems, a theory, solve issues in the theory, and experiments for the theory. By doing this, I have “saved” the analysis/design/coding/testing, and, more importantly, saved myself from craziness! As a result of this realization, on the one hand, I am now a big fan of the micros-waterfall, because it is the same micro-mechanism of any problem solving processes. On the other hand, I do believe the micro-waterfall is flexible, any step of this micro-waterfall reflects the whole – for example, in analysis, there is testing already.

---------------------------8 PSAs

1. "OR mapping" (including "UOW", Unit of Work, equiv. to Siebel's BO)
2. ("O") "entity": rules in entities, rules engine(******), scripting in entities
3. ("U") "Web2 UI": ("ActiveX" and "Ajax")
4. "Data Binding" ("OU mapping")

5. "transaction" (and non-transaction, with "facsades" and "workflows") (business service and workflows, tasks. Also here: "unit testing" ******)

6. "networking (at application level, as "connected applications")"
--i. async and sync EAI (background) "messaging" for integration and need "user push notification" (activities or an area on every screen)
--ii. batch EIM
--iii. offline web client
--iv. reporting server
7. "logging (that is runtime-configurable)"
8. "security"("authorization" and "authentication")

Seven square number of Problem-Solving-Items (PSI)

2008-08-02T17:30:00.005-07:00

Seven square number of Problem-Solving-Items (PSI)

What are problem solving items?

As a first-level approximation, they are requirements + “architecture” requirements.
However, they also include technical design items, source control items, testing items, support items. They include all problems. For details why I put all of them together, please read my previous blogs.

Of course, we all know that our corporate world does not like the word “problems”, we find all different words for it, “issues”, “challenges”, etc. I do not like those other words, and I like the word “problem” – I like all the honesty, history, weight, and power that go with it. However, I do understand and appreciate the needs from the corporate world; so, I add a positive word with it, and add an “unit” word, hence the phrase, “problem-solving-items”.

What is the “7-square”?

Psychology shows that the short memory of human’s brain can only handle 7 items. The optimal is half of it, around 3. That is the reason that when we speak or write, we use 1, 2, 3, or 4, not that often we use more than 4. If we really need to, we re-organize them, make it two levels, 1, 2, 3, under each item, we have a, b, c.

You may believe it is trivial. I do not believe so. I believe the universe is “consistent” or even “anthropic” – see http://en.wikipedia.org/wiki/Anthropic_principle . As a result, I believe those 1, 2, 3 things are “consistent” with those “thesis”, “antithesis”, and “synthesis” in Hegel’s philosophy.

I apologize to drag you into this physics-philosophy-psychology indulgence, that is my weakness; but I am also very practical and pragmatic, so, let’s be back to the real business.

IT (Information Technology) is about handling large amount of information. Its complexity comes from the large amount of seeming unrelated items. As a result, we have to maximize the capacity of human minds. In short, we have to use 7, not 3; further, we have to use two levels, instead of just one. And use two levels all at once – we have to treat the two levels as if there were one, i.e. we have to treat 49 items all at once, and not make the two levels too restrictive.

In short, next time you think about IT, just think about “49 PSIs”!

------------------
There are no categorical differences between the "problem solving" in sciences and that in engineering disciplines.

Further, the best minds, or, at least best documented best minds, due to the very nature of basic sciences, are not in engineering, but in basic sciences.

As a result, in addition to Lean literatures, I will resume my love for reading philosophy and history of sciences.

http://www.cs.cmu.edu/afs/cs/usr/wing/www/publications/Wing06.pdf

http://philsci-archive.pitt.edu/archive/00004037/01/The_reductionist_blind_spot-08-05-01-2300.pdf

Problem Solving Logic-Centric Lean Process (PSLCLP)

2008-08-01T12:10:00.002-07:00

I believe I am in a creativity storm.

I believe I found out the problem of all “software processes” and “IT project management”. It is the “inductionism”, we need a “deductionism” paradigm shift just as Karl Popper did in philosophy of science.

I believe the key is indeed “requirement gathering” – the starting point of the waterfall, it is wrong, everything is wrong.

We need to replace it with “problem”. The whole thing should be “problem solving”.

The name of the process should be Problem Solving Logic-Centric Lean Process (PSLCLP), I know, it is long. The key is to remember “problem solving”.

testing, testable, Lean, science, and Occam's razor

2008-08-01T08:21:00.005-07:00

The effort to apply Lean to software makes me think, very hard.

It is about the core waterfall, by that I mean: analysis, design, implementation, teat, and deployment.

I want to eradicate them. To me, those concepts are simply a pretentious way to say that we are working toward a new system.

TDD is good in the sense that it has already started to break this core waterfall: it says that let’s put aside “analysis, design, coding, and testing”, let’s treat everything as testing – that certainly is disruptive and revolutionary!

Of course, the problem is that, this revolution concept is mixed and therefore buried or at least eclipsed by other concepts like “stories” -- but that is another story, of course.

Then, the concept in philosophy of science hits me: “testable".

Usually we believe software engineering is engineering, and therefore we use metaphors from other engineering. However, perhaps we should think about software more in the terms of science – philosophy of science, logic of science, and logic-psychology of problem solving?

After all, modern engineering is based on science; and recent science is more and more “big science”, i.e., engineering based science – science of man-made.

After you cut the fat of the waterfall, we can see some many new things, or, new old things!

More about why Lean and science: heard about Occam's razor (http://en.wikipedia.org/wiki/Occam ). Science is the leanest enterprise by human being!

some blogs I got when I googled ockham razor and six sigma:

http://usercentricea.blogspot.com/2008/05/occams-razor-and-enterprise.html

How to apply LCLP on Siebel CRM development

2008-07-30T11:56:00.003-07:00

How to apply LCLP on Siebel CRM development

It is logic centric; then, what is the logic?

It is the 8 core techniques, of course – as promised :-) it is all just about re-packaging.

A little further now though. Because of LCLP, we can justify that we jump on those 8 core techniques directly.

Because we do it directly, we can immediately split those into a few dozen items.

Also, “techniques” are too “doer-centric”, so, let’s change it into “special design areas”.

So, the result of applying LCLP on Siebel CIM development is that we directly jump to a few dozen “special design areas” – the groupings are still those 8 core techniques, of course.

-----------------examples:

---- LOV, constrained LOV, static and dynamic, how to make greatParent-parent-child LOV.

---- State model

---- ldap/asi adapter: because Siebel does not use a generic database account, so, even we use ldap/asi, we have database accounts. The adapters will help the sync.

---- …………

LCLP and cheese without fat

2008-07-30T11:50:00.003-07:00

This is basically a comment I left on:
http://vikasnetdev.blogspot.com/2008/07/leading-project.html

Based on the comments of previous blog, I have to change ALP (architecture-centric Lean Process) to LCLP (Logic-Centric Lean Process, note that I cannot use LLP) .

Comparing with Lean, I feel TDD or agile is not enough, even I am willing to go along with TDD, since it is the closet we have for now in software industry.

I would like to remove all the concepts that lead to waterfall. For example, the so called "requirement gathering". It implies a step in the waterfall. Requirement gathering is simply communication with users. I deny the concept of "requirement gathering", because there is no special ways in "requirement gathering" -- comparing with "design" (or, a better wording, "logic"), it is vague, and the faster you can jump on to design, the better. "Requirement gathering" is simply an inefficient or less-than-optimal design. All this means, let's talk about screens flows, screens layout and data entities and related business rules, security, notifications, logging, installation, source control, etc. directly and as technical and specific as users or audience can understand, and with no certain orders other than the necessity of the logic.Cut to the cheese, lean, it is the cheese without fat.

How do you like that, cheese without fat :-)

--------------------------A notes on July 31
I know I go to extreme sometimes, that is my weakness – but that is also my strength, by doing that, I get to the bottom of things quickly.

I am trying to eradicate all waterfall concepts, even just some traces of it. This exposes the needs for order.

I said that there is “no certain orders other than the necessity of the logic”, the tone is certainly mostly negative. After thinking about it, I know I need to emphasize the positive side of it also.

The key is, after removing the waterfall, we can see the orders introduced by the “necessity of the logic” more clearly, and therefore, can follow those orders, and do things more efficiently and more effectively.

Actually, that is the whole point of removing waterfall. Waterfall ordering eclipses the real orders: it oversimplifies things to one dimension.

This leads to a very counter-intuitive statement: the most harmful situation of waterfall process is actually for large projects, when you cannot simplify things like that, even using many iterations, it simply just does not work.

Typically, in a mid-to-large sized project, there are a few dozen of “dimensions” (you can “group” them into two or three groups, but those groupings are vague). Experienced team leads or good project managers pick up those dimensions quickly, and follow them up through the whole project.

Along each dimension, there are pretty clear patterns, and among those dimensions, there are also some vague but useful patterns. Ya, those dimensions and patterns are “technical”, but good leads or project managers do not only know some “project management” terminologies, they are technical enough to know those dimensions and patterns.

How to lead a project: the opposite of “waterfall” is “architecture-centric”, not “iterations”

2008-06-22T11:49:00.007-07:00

How to lead a project

We must lead a project around the concept of “architecture”: “architecture design”, “high level design”, or “design”. However, note that because “architecture” has too much overloaded meaning, I use the wording “high level design” whenever I can.

The waterfall concept, that we do software in the order of requirement gathering, analysis, design, coding, testing, deployment, support, is simply wrong. However, the opposite of “waterfall” is “architecture-centric”, not “iterations”. "Iterations" are simply small waterfalls. Many small wrongs do not correct one big wrong. Further, the wrongness about the waterfall concept is not its frigidness; it is its emptiness and pretentiousness – it is its tendency to encourage people to think non-senses – things that cannot add values to the project (its frigidness is actually fine if you can deal with its emptiness and pretentiousness). We need to replace the “waterfall” concept with the concept of the “architecture” and the “dependencies” in the architecture. Note that “architecture” and “dependencies” are very rich concepts.

1. The project is within a bigger architecture.
2. The project itself has its own internal architecture, or, high level design.

3. The high level design of the project has the following parts:

a. “Functional” (in Siebel, we call it “configuration”). It includes OR mapping and OU mapping (i.e. ORU mapping) and rules. Here we have two important notes:

(i) functional is part of the architecture. Some people may say that the “functional part” is not part of an architecture design (i.e. high level design). That is not true. OR mapping, OU mapping/binding, and rule engine are certainly parts of an architecture design (high level design); the usage patterns of ORU mapping and rule engine are also part of an architecture design (high level design). It is actually very easy to see -- once we stop seeing things through waterfall glasses, and begin to see things through “architecture-centric” point of view: there is no “requirement gathering” or “analysis”, there are just vague designs, and designs are simply vague or unfinished systems.

(ii) UI must be easy for automated testing. Some people may say that testing is not part of a high level design. Wrong! Testing is part of the architecture, just as logging is part of the architecture. To ensure that, automated UI testing must be part of the early development.

b. “Architectural” (in Siebel, we call it “Integration and conversion”). It includes “transaction” (in Siebel, it is BS and WF), “networking (in Siebel, it includes EAI/web service, EIM, offline client, reporting server), logging, and security. Again, an important note here is that automated unit testing is part of a high level design. Here, automated unit testing is included in the concept of “transaction” -- a good high level design should always make it automated unit testable at transaction level.

c. “Admin”: this can be treated as an extension of b.

(i) Source control is an extension of automated unit testing; this is because it is through automated unit testing that source control is “attached” to the architecture and therefore must be treated as part of an architecture. Using source control is part of a high level design.

(ii) In Siebel, when we set up development environment; we need to go through hoops in setting up “offline client”.

So, here “admin” includes “deployment admin” and “system admin”. Note that by getting into "system admin", I begin to accomplish my new year resolution that I will consolidate my knowledge into a complete vertical stack, bottom up, from hardware, OS, to browser scripting.

The differences between ALP and TDD

2008-06-12T06:10:00.000-07:00

The differences between ALP and TDD

ALP is architecture-centric. It requires finish architecture design in the first a few days (for most projects), or, a few weeks (for really large projects).

ALP treats “stories” or “use cases” as vague materials. It directly focuses on three things: (a) the OR mapping -- key concepts (glossary) and (logical) database tables-columns, and (b) the OU mapping (or binding) -- key concepts (glossary) and screens and buttons, and (c) rules – key concepts, screens-buttons, database tables-columns, and business logic, in the contexts of typical scenarios.

You may say that TDD can do those things also, or, further, good TDDs do those things also. That is true. The same can be said to RUP. That is why it took me so long to make this explicit. However, I feel it is important to make it explicit, all good processes are alike; however, there are too many bad TDDs and bad RUPs.

Architecture-centric Lean Process, ALP

2008-06-06T13:54:00.002-07:00

The name “Team Capability Model” is not well-known, so, it seems that we have to keep using the word “process” – so, here is a new name for it: Architecture-centric Lean Process, ALP.

In addition to the content of the concept, I like the name also. It has some tensions built-in (“Lean” usually means less “architecture”), and, it sounds official and formal.

An Architecture-Driven Team Capability Model

2008-06-01T22:54:00.004-07:00

After a few years in written form in my notes and in the blog, I believe the “8 core computing techniques” is mature enough to have a more official or formal name, so that it can be used in any documents in the “corporate culture”.

I put some thought on it; the best way for it to "break in" the corporate culture is to use it as a "capacity model" (note that it is not just a “process” -- it has much more content). Because it is all about architecture, so, it is an architecture-driven capacity model.

1. A person’s or a team’s CAPABILITY is determined by its ARCHITECTURE CAPABILITY.
---- I know, this is a peculiar usage of the word “architecture”. Please see below.

2. A person’s or a team’s ARCHITECTURE CAPABILITY equals:

“Business knowledge”
+ “Technologies”
+“Processes”

All of those are elements of architecture:

(a) “Business Knowledge” simply means (i) OR mapping, (ii) OU mapping, and Rules.

(b) “Technologies” simply means (i) Transactions (note: capable of unit-testing at this level is like logging, is part of the architecture, it is NOT just a feature of a “process”), (ii) Networks, (iii) Logging, and (iv) Security.

(c) “Processes” simply means the “order of doing things”, based on the DEPENDENCIES in the architecture.

Lean vs UP or TDD

2008-05-13T08:05:00.004-07:00

In http://survic.blogspot.com/2007/12/post-processesontologies-open-eyes-on.html

I wrote: if you know those (8 core) techniques, you surely already know those "processes". "Processes" is simply experiences you gain when you use those "8 core techniques".

In http://survic.blogspot.com/2008/05/use-lean-process-directly-instead-of-up.html

I wrote: we should refuse to talk about "software proceess" -- we should use lean process in software directly, instead of UP or even TDD.

I am now more convinced.

The key is, being “lean” requires that we must do things as close or direct as possible to where the real values are happening.

The “8 core techniques” are where the real values are happening.

So, we should replace all those TDD or UP with 8 core techniques, and call it “lean”.

You may ask, even we know the content of those 8 core techniques, we need to ask: what category do they belong?

The answer: they are architecture elements.

So, a “lean” process means that we deal with architecture elements directly, iteratively and incrementally – which means, as long as you are making progress and you know about it and you can provide hard evidences for it, then, in whatever order, do whatever is necessary.

Lean process is very different from TDD and UP. Obviously, it is “heavier” then TDD, because it has a “default architecture”, and is totally architecture driven.

Also, it “includes” or “tolerates” or "consumes" the concepts of “requirements”, “use cases”, etc., because all of those concepts are simply iterations toward “screens and buttons” and “façade methods”. “Testing” is a real concept in “lean”, but that simply because testing is inherently part of the architecture, just like logging is. Note that “lean” is better, because now you always know the context, and know that it can be extremely flexible yet can always focus on the real result.

It also "includes" or "consumes" DDD – all those mappings (OR and OU) and related rules are DDD, or, you many say that DDD is the iterations toward OR and OU. Again “lean” is better, because you know the context, and you know it can be extremely flexible yet can always focus on the real result.

Dynamics and ontology of blogging

2008-05-03T14:41:00.008-07:00

I use blogging as a notes-taking mechanism. Doing it this way helps me to separate private details from the issues themselves immediately. It makes my thinking more objective; makes me continuously theorizing, and hence think continuously.

I blog on technical, medicine, business, and culture topics.

The above line is an example of "immediate theorizing". On the one hand, the above line reminds me that I have a few blogs; so, it serves the function of notes taking. On the other hand, it makes me think about the classification/ontology of blogging.

State of the handhelds

2008-05-03T13:03:00.004-07:00

1) Why I am interested in it?

A new wave of computer innovation is coming, and handheld is a key component.

More specifically, handheld devices have reached to the power that they are more powerful than a PC when PC took off. GPS, mobile email and calendar, phone, camera, instant messaging, mobile web, mobile office productivity -- you think and get feedback and write down anytime and anywhere -- your brain is always active and more importantly, at peak level. Soon voice , handwriting, and imaging processing will enhancing them, then, we will have the equivalent of "office" for "general site automation".

To maintain a wide perspective, we should keep it in mind that there is an academic field, HCI (human computer interface), for handheld development. Also, there is a few high tech fields related to handheld: "put viewing devices on glasses",
"multi-touch screen", "voice, handwriting, and imaging processing", "natural language processing".

2) In general, there are two technologies: one is touch screen (palm, apple), one is physical keyboard (blackberry).

Note that perhaps we should talk about human needs first. However, from HCI point of view, human needs and technologies are a hen-egg relations. You may say that needs are the mother of all innovations. However, do no forget human body and behaviors are themselves "build-in technology systems"!

We put technologies first here, for a simple "shallow" reason: because there are only two of them for now, it is easier to introduce them, and we can use the concepts in the discussion of human needs.

3) There are many levels of input need. Depending on the technologies, you can have different separations. For easier thinking and comparison, we always try to force a "canonical" level system.

Note that we only talk about the "write" side; the "read" side is easy from HCI design perspective.

A. No-hand (driving on local streets): voice processing is the key here.

B. One-hand (driving in highway, walking in familiar area; this can further divided into left hand and right hand): I am very surprised that it seems that very few people think about this explicitly. This is a very important category; it should be buried in category C (below) or category A.

C. Two-hands but in constraint space or other environmental resources, by thumb typing, and handwriting. Note that thumb typing can do a lot – actually the draft of this blog was written by thumb typing. However, handwriting can do even more – it is almost a shame that after more than 30 years large scale use of computers, the main input method is still typewriter technology – the keyboard. It is possible that handwriting and voice processing will make breakthrough via handheld.

Note that this seems to be the major focus for blackberry. You can make a sub-division by slide-keyboard. For iPhone, it is between B and C.

D. Two-hands optimal. In this category, flexible or folding keyboard is the way to go.

Silverlight, JSON, and Entity Framework and .net Being the Primary Enterprise Platform

2008-05-02T14:34:00.004-07:00

Silverlight, JSON, and Entity Framework and .net Being the Primary Enterprise Platform

JSON support is ready.

Silverligiht is coming.

Entity Framework: it is more complicated. Perhaps it is not as good as the java-port, nhibernate, just like springframework and other things (for one thing, EF uses code generation approach -- ugly thing, isn't it). However, the key is, the official, recommended architecture on .net is exactly the same as lightweight Java's.

Soon .Net will surpass Java/javascript.

However, the power of silverlight is that it is cross platform. I hope Linux world can take advantage of this -- however, regardless Linux/Windows, Java is now officially behind.

Silverlight marks the start of the end – now, .net can begin to claim that it is a superior platform. We are seeing a historical turning point.

A dominating platform that is not open-source based, it is very scary – it is not that I am brain-washed by open-source arguments, it is my real world many years experience: companies come and go, if you do not have source code, it is trouble.

You may say, that is only for application level. For system level, it is OK that you do not have source code. Actually, for many years, java VM is not open source. I have to agree.

However, I have to say that considering our dependency on computers, it is still scary; too much is at stake. I seriously believe that eventually the governments will do something to guarantee some healthy competition between open source and MS.

All in all, while I will continue to pay attention to Linux (and Unix in general), open-source C/C++, and Java, I have to say that perhaps we should welcome the fact that .net is going to be better than java (java is going to be the underdog), from now on, especially this accompanies that fact that M$ is adopting, encouraging, and enforcing a more and more non-mort culture.

I do not regret entering into .net -- after all those years, finally I can brag about it to my Java colleague.

You may say, is it even possible that M$ is enforcing a non-mort culture? I believe so. It is to the best interest of MS. It is called segmentation of markets. M$ will certainly keep its low end, mort market. However, it will also establish its high end market. The key is that its key selling point is that its high-end market is a continuum of its low end market. Another key point is that high end must lead low end – this is a technical necessity – it seems that M$ finally gets this, just recently: you can simplify a good system to make it easier, but it is a technical impossible that you “complexify” a bad system to make it good. So, more accurately, combining the two key points together: M$’s key selling point is that M$’s low end market is the continuation of its high end market.

REST and data

2008-05-02T13:20:00.004-07:00

Here is my previous blog about REST: http://survic.blogspot.com/2007/08/rest-web-service-is-all-about-data-or.html#links

I wish I could say that I wrote my blog before all of those:

http://www.redmonk.com/cote/2007/04/30/microsofts-rest-moves-project-astoria/
http://astoria.mslivelabs.com/Default.aspx
http://blogs.msdn.com/pablo/
http://blogs.msdn.com/astoriateam/archive/2008/04/24/using-rest-services-in-silverlight.aspx

Use lean process directly, instead of UP or even TDD

2008-05-01T09:32:00.001-07:00

Vikas's insight on lean process and TDD is wonderful. We need to apply "lean", "6-sigma", etc. to "software process".

Further, because there are so much baggage in "software process", I (tentatively) suggest that we should refuse to talk about "software proceess" -- we should use lean process in software directly, instead of UP or even TDD.

MS and Morts: lightweight.java and alt.net

2008-05-01T08:54:00.009-07:00

My friend Vikas has a good post about a also-very-good-post about an interesting post (click the links, you will know what I am talking about!):

http://vikasnetdev.blogspot.com/2008/04/is-microsofts-mvc-is-going-to-be.html

My comments:

1. It is indeed a tipping point, historical moment for MS!
Even it is too little too late, especially too late, almost 10 years late, in Internet time.

I do love silverlight though; it is definitely next-gen-ajax.

Because we have ajax-and-next-gen-Ajax (silverlight), although you may say MS's ajax is part of asp, but that misses the point: ajax makes traditional asp irrelevant. As a result, asp's MVC is less relevant -- Ajax/silverlight makes the previously-official-asp irrelevant, it gives Alt.net a huge opportunity.

2. MS is distancing from morts -- for that, I love MS -- it is innovating.

3. Alt.net is basically following lightweight.java -- I certainly do not mean to insult alt.net people; they are doing creative work now, and will surpass java soon.

Note that I am using alt.net as a concept, not a community, as a result, Spring.net and NHibernate are certainly part of alt.net -- conceptually speaking -- but I am not sure whether all people in spring.net and nhibernate are in the community of "alt.net".

Expand perspective in two directions: higher level (Siebel/Javascript) and low level (hardware/C/C++)

2008-03-15T21:30:00.005-07:00

Expand perspective in two directions: higher level (Siebel/Javascript) and low level (hardware/C/C++) and therefore forget about all fat “processes”

A. I will be in Siebel space for a while, while this is happening, my plan is to have an integrated perspective of enterprise computing, from bottom to up.

Yes, this means I want to go back to the root of computing: the hardware. I want to pay more attention to handset, games, and, Linux. I want to refresh my Linux C/C++, and system administration and protocols, and then, get a little bit .Net on Linux.

I will keep using .net, because silverlight is so attractive; but I will pay more attention to Linux-based things, simply because they are open source, and I have an open way to hardware.

In short, for me, it is time to "merge" C/C++ (shell, perl), java, C# (VB), Javascript (perl) together – they are all C family anyway. Note that Siebel (and Ajax) will improve my javascript to a "serious professional" level. Also note that although I am gradually moving far and far away from perl and VB; however, because javascript is a scripting language (for Siebel, javascript is a server side scripting, exactly like perl!) and perl-like regular expressions are now in all modern languages, I can pickup perl anytime. As for VB -- as long as I keep C#, I can certainly re-pick up VB anytime.

By doing this, I will feel more “solid” when I do the programming in C#/Java/Javascript.

B. I will introduce Siebel techniques to spring:

1. OR mapping extensively: this is already in spring-hibernate, but Siebel's way adds more discipline and systematic taste. This also include OX mapping – xml to object mapping, and web services.

2. OU mapping -- databinding ideas: Siebel's databinding is strict and thorough.

3. Extensive use of rule engine. Again, this is not really originated from Siebel, but Siebel 8 makes it happen.

4. Event, security, transaction, logging etc. I will introduce some good ideas and practices as the usage patterns for spring's AOP.

new version of 8 core techniques and rules

2008-01-25T10:49:00.002-07:00

I added marks (******) next to rules and unit testing.

Rules are important, and rules are the essence in OR mapping/OU mapping. There are two reasons:

a. Nowadays mappings are easy. OR/OU mappings are "assumed". They are just the "basics" (so, VB/C# guys, learn OR now! java guys, learn OU now!). As a result, the focus is "rule engine": the extent of "rule engine", and how to use "rule engine with those mappings". In short, nowadays, when you talk about rules, you already assume there they are based on OR/OU mappings.

b. More importantly, I noticed that users care much less about those "mappings" (a.k.a. "glossary", "domain model") than "rules". As a result, I feel it is better to use "rules" as the subtitle, instead of "mappings". I am effectively using a more "use-case-oriented" item to represent the "domain model" section -- it is not "fair" to the "domain model" section, however, this way is more effective for communications with users. Again, although "rules" has a lot of "use case" characteristics, I put it under "domain model" section, because it also relates to domain model very closely, further, I use it to represent the whole section. The key that I can do this is that modern (i.e. OO based) rule engine usage always has a very strong requirement on a clear OO model, as a result, in real work, you do tend to mix rules with OO domain models.

-------------------------------------------
-------------------------------------------
(Note: I merged "logging" together with aop logging, and moved it to aop logging)

1. "OR mapping" (including "UOW", Unit of Work, equiv. to Siebel's BO)

(Note: I moved UI here; I added two new items to it, to expand the concept of OU mapping: "O", "OUmapping")

2. ("O") "entity": rules in entities, rules engine(******), scripting in entities

3. ("U") "Web2 UI": ("ActiveX" and "Ajax")

4. "Data Binding" ("OU mapping")

5. "transaction" (and non-transaction, with "facsades" and "workflows") (business service and workflows, tasks)
----------(I merged "unit testing" (******) together with "transaction")

6. "networking (at application level, as "connected applications")"
--i. async and sync EAI (background) "messaging" for integration and need "user push notification" (activities? or an area on every screen???)
--ii. batch EIM
--iii. offline web client
--iv. reporting server

7. "logging (that is runtime-configurable)"

8. "security"("authorization" and "authentication")

why Android now? 10 million $

2007-12-29T23:49:00.000-07:00

http://code.google.com/android/adc.html

Companies and OS's for handhelds

2007-12-29T22:24:00.002-07:00

current companies and OS's for handhelds:

Apple, Microsoft, Nokia, RIM, Palm
OS X, Windows Mobile, Symbian, BlackBerry, Palm

post-processes/ontologies: open eyes on technologies, economies, and politics

2007-12-29T21:49:00.001-07:00

technologist, technology analyst, economist, and political analyst

After my previous blogs, I found that I began to see many things differently. It is not easy to summarize all those changes of mind and heart, so, I just put those job titles here.

Note that it is not just "processes" and "ontology" anymore, it is much "thick" now. I now believe the concept of "processes" misses the point. Ya, "processes" are important, but if you know those (8 core) techniques, you surely already know those "processes". "Processes" is simply experiences you gain when you use those "8 core techniques".

As for "ontology", they are extremely important; there is another phrase, "methodological analysis". Here, just like the concept of "ontology" in both computer science and philosophy, "methodological" can be interpreted as both the concept of "process" in software engineering, and a concept in philosophy that is in parallel with "metaphysical" and "epistemological". Combining "ontology" and "methodological analysis", you have all the conceptual tools to tackle any issues in our information age.

I know, all those sounds abstruse and philosophical. That is indeed the exact point I want to make next: they are important, but too abstract, for everyday thinking. To really apply "ontology" and "methodological analysis", we need concrete "examples", hence all those job titles -- we need to open our eyes, on technologies, economies, and politics.

it is time for handhelds and games -- Google's Android now and Wii later

2007-12-27T16:37:00.001-07:00

----------excerpt from http://blogs.sun.com/jag (I hope it is "reasonable use"; also, take a look of the "Cell phones in Japan": it is amazing, but I cannot cut/paste it here, please go to James Gosling's blog!)

One of the games was a bowling game that you play roughly the same way that you'd use a Nintendo WII: you hold the phone as though it's a bowling ball, and you go through the motions of throwing the ball. You use a button press to release the ball. When this happens, it does the physics. But the phone doesn't have accelerometers to measure how you move the phone. They used one of the most glorious hacks I've seen in years: images are captured by the camera as you swing it in your hand, which are then analysed and correlated and motion vectors are computed from the interframe deltas.
-------------------------

Note: as you will see in the following, this is not M$ vs Java, it is much broader, although the core is the same, as always.

It is time to expand software development vision to devices and games, for example blackberry (and other "handhelds") and wii.

I mentioned blackberry in my previous blog. To reflect the light of holidays, I should have mentioned games also, e.g. wii. Sorry, I do not like Xbox, and I do not like playstation; I feel "pure computer game" is too boring, I like "physical" game.

My deep believe is that serious computing is enterprise computing, even they look not that exciting or "high tech", in reality, they are the real high tech stuff. However, now I believe it is time to deal with handhelds and games. They are "connected" of course: handhelds need enterprise system, and although/while it is not clear how games can be "incorporated" into the corporate world, there is clearly some effort to integrate wii into the web.

As I indicated in my previous blog, the keys are (a) they are massive market now; (b) the devices are powerful enough so that we can leverage PC experiences.

It is interesting to compare iphone (real product now) and gphone (conceptware) and Android (google), you can see the positive and negative sides of Apple and Google.

I noticed that Apple is also in the process of opening iphone to 3rd party software.

http://arstechnica.com/news.ars/post/20071105-its-official-google-announces-open-source-mobile-phone-os-android.html
Google is leading its way or catching up (depending your point of view; it is a significant thing regardless which view you take).

Again, the keys are that (this time I put it in one sentence) the java dream that ubiquitous devices and network applications in the hands of the mass is finally coming; there are killer applications (GPS is one of them, I believe camera/scanner is also one of it, and barcode and RFID technologies).

What do all those things mean?

All those things make you think -- we need to broaden our perspective.

In the past, I did that to my 8 techniques: the first step is to expand the 8 techniques to "business processes", and then, "ontology". They are all fine (but I am now putting less and less emphasis on formal processes -- I am more and more convinced that they are simply flexible applications of 8 techniques, nothing more). However, I did not put the dreams of AI and device network (drones of the borg ;-) in the picture.

time to invest in handheld software development?

2007-12-22T19:24:00.001-07:00

Now, handhelds are inexpensive enough to be interesting to the mass.
Also, they are now powerful enough that they are close to PC (or Apple) computers, so that we can leverage the PC/Apple software experiences.

I anticipate that within a few years, everyone will have a PDA, with real key board, GPS, camera/scanner, OCR, recorder, voice recognition.

I will begin to look into handhelds. Basically, they should be just like a PC/Apple 10 or 15 years ago, the only difference is that they are smaller and portable.

new 8 core concepts, with or without Siebel

2007-11-22T18:41:00.001-07:00

This is a major update! I changed the order a little, to reflect Siebel thinking, and OR/OU mapping/binding thinking.
-------------------------------------------
-------------------------------------------

(Note: I merged "logging" together with aop logging, and moved it to aop logging)
1. "OR mapping" (including "UOW", Unit of Work, equiv. to Siebel's BO)

(Note: I moved UI here; I added two new items to it, to expand the concept of OU mapping: "O", "OUmapping")
2. ("O") "entity": rules in entities, rules engine, scripting in entities
3. ("U") "Web2 UI": ("ActiveX" and "Ajax")
4. "Data Binding" ("OU mapping")

5. "transaction" (and non-transaction, with "facsades" and "workflows") (business service and workflows, tasks)
----------(I merged "unit testing" together with "transaction")

6. "networking (at application level, as "connected applications")"

--i. async (it uses direct also) EAI (background) "messaging" for integration and need "user push notification" (activities? or an area on every screen???)

--ii. batch EIM

--iii. offline web client

--iv. reporting server

7. "logging (that is runtime-configurable)"

8. "security"("authorization" and "authentication")

Mashing up integration UI, service UI, and application UI -- the final reason why web is better than smart client and hence ajax is the key

2007-11-17T23:18:00.000-07:00

Mashing up integration UI, service UI, and application UI -- the final reason why web is better than smart client and hence ajax is the key.

First of all, application UI means application itself!

As I pointed out in my previous posts, webmethods' philosophy is interesting but perhaps too radical: we should put application UIs in integration platform (e.g. webmethods), instead of application platform (e.g. M$'s Visual Studio).

I put some thinking about it. Actually, this does not need to be that either/or. As long as you use web, it is just a link away. So, I guess webmethods's philosophy is indeed unnecessarily radical. As long as it is web, who cares.

However, webmethods's philosophy does make it clear that web is the key; further, in order to make it interactive, you need to use ajax.

This also means, "service architecture" and "application architecture" are the same thing, exactly identical, synonym.

Getting deeper into Siebel while keeping everything in perspective

2007-11-17T21:51:00.001-07:00

Getting deeper into Siebel while keeping everything in perspective

I am getting deeper into Siebel.

My focus is EIM ("Enterprise Integration Manager", Siebel's name for batched based integration, including the launch-eve initial data load) and EAI ("Enterprise Application Integration", for Siebel, it specifically means non-batch based integration).

This focus is good for me, because I tend to be curious (or ambitious -- or whatever) about the whole thing ("architecture" or whatever name you use to refer the holistic view).

To avoid getting lost in details, I need to set up the context so that the context will tell me the directions.

The "context" must be "native" to Siebel, as a result, "spring" is no good: I cannot mention "spring" to Siebel architects, or any Siebel experts in general. In the context of 5th-level-platform, techniques in 4th-level or 3th-level platform are not received.

However, some abstract concepts can be tolerated. for example, AOP and OR mapping. Also, Siebel experts can certainly tolerate concepts already used in Siebel, for example, UI-O mapping (data binding), rules engine, and workflows.

So, the rule is: do not use "spring" to talk about Siebel; however, do insist on using abstract concepts to talk about Siebel. I will update those items often, until they are stable -- I believe those are the keys for learning and applying Siebel. They are the base of my contributions to the design and spec of all Siebel activities.

"OR mapping" (including "UOW", Unit of Work, equiv. to Siebel's BO)
"Web2 UI": ("ActiveX" and "Ajax")
"Data Binding" ("OU mapping")
--
"aop entity rules": rules engine and other rules in entities (BC)
"aop scripting" (synonym for AOP in general, both entity and facade -- scripting is injected by AOP)
---------
"aop security"("authorization" and "authentication")
"aop logging"
"aop transaction" (more precisely, non-transaction, workflows)
"aop network" batch EIM and async EAI (background) "messaging" for integration and need "user push notification" (activities? or an area on every screen???)

The key is that for integration purpose, we need a common conceptual ground -- if we cannot even have a common "conceptware", how can we have a common software!

EDA/ESB is SOA2: Why fine-grained SOA is good and ESB-based UI is good

2007-10-31T13:07:00.000-07:00

EDA/ESB is SOA2: Why fine-grained SOA is good and ESB-based UI is good

------SOA2: As I pointed out in my previous blog, the key of SOA is nothing but EDA/ESB/MOM. As a result, we should say that all those SOA hypes are just "warming-up round, or, round 1" of SOA. The real SOA, i.e., SOA2, is EDA/ESB/MOM.

ESB is MOM with a "service" interface, instead of "proprietary" interface (e.g. JMS. Note that JMS is a standard; however, it is too narrow, so, it is "proprietary" in the big schema of things).

------Fine-grained SOA: because at ESB level, we can do so many things, for free. So, we should make service fine-grained, that is, as fine grained as practically possible. Will that slow down things, like early days of COM or EJB? Ya, but that is where "practically possible" counts.

------ESB-based UI: Some ESB vendors (e.g. Webmethods) put UI support above ESB. It is a powerful concept; we should discard "proprietary UI" (M$'s VS or Java IDEs; of course, except the ones with ESB-based UI -- e.g., Webmethods uses Eclipse for its ESB-based UI), and replace them with ESB-based UI.

(a) Advanced web2/Ajax based controls for free (if you buy the product, of course!).
(b) It makes look-and-feel more consistent.
(c) It enforces SOA: you have to use SOA2 now.

(d) However, note that a good ESB can support using proprietary UI, and still provide all ESB benefits. Actually, it is more an issue of the IDE of the proprietary UI: you can put the service in ESB, and then, in your proprietary UI, you call the API from the ESB. As you can see, there is no reason not using ESB-based UI!

SOA, EDA, JMS, ESB, webmethods

2007-10-28T19:08:00.000-07:00

SOA, EDA, JMS, ESB, webmethods

The real deal of SOA is not XML, contracts etc. crap. The real deal of SOA is JMS (MQSeries etc). Messaging is fine, but people say email is messaging, and also all other web service as messaging. You can say async messaging, but in JMS you can use sync. Some new name is EDA (event driven architecture), ESB (enterprise service bus) EMB (enterprise messaging bus).

WebMethods is the only company that has been working on this and ONLY working on this, as a result, it is a good source for this vision.

The key, however, is from JMS practices (and in turn, MQSeries practice): if you push, then, you need to consider push failure, so, you need async messaging.

Just in case, I am not trying to sell webmethods. As a matter of fact, above I just pointed the way to avoid the expensive stuff: as long as you have a simple queue (either database table, a file, or MSMQ) to handle failure, and you have a mechanism to recover the failures (either automatic or manual), then, you are fine. Who needs expensive software packages! -- I study them because they are "free" to me (I mean, the company bought it!), and also, I learn those full-fledged stuff simply to see how I can accomplish the same thing with plain old code, perhaps just 10 lines!!!

--------------
Great people think alike and the same time :-) Here is a link to Vikas's blog:

http://vikasnetdev.blogspot.com/2007/09/soa-and-business-intelligence.html

more siebel notes later

2007-10-18T12:34:00.000-07:00

My previous blogs are just the first round of my Siebel notes.
I will put more siebel notes later. As I explained before, I used spring to see internals of Siebel and to see how siebel can work with other systems; and I use siebel as the source of architecture best practices (like OR mapping, rules engine, etc.).

siebel internals and integration: spring

2007-10-18T10:42:00.000-07:00

siebel internals and integration: spring

This post is really short: why we need to think about spring when we do siebel? because siebel is "third-party", we do not know its internals. Spring can provide insights.

Spring is the "standard" best-practice framework on both C#/.net and java, so, it is the best reference for integration also.

stored procedures on oracle -- more words

2007-10-18T08:54:00.000-07:00

stored procedures on oracle -- more words

-----------------how (this should be a very simple system, because we do not use them that often -- but when we use them, we really need them immediately, so, the how should be lightweight and can be done everywhere! see "when" below)

For Oracle SP, the key is how to debug or test a sp easily:

1. It is crucial that we develop sp using both sqlplus and other query tools (e.g. toad, even the "simplified" toad). --- More secifically, we need to get used to test-run a sp in "simplified" toad.

2. It is also crucial to "print out" things, using exception and a adhoc table.

-----------------when
1. They should not be used in routine, ordinary, everyday-practice situations.

2. If you really want them (for consistency sake, or, for people who are used to use sp as a managerial control tool), only use simple CRUD. Do not try to use "data logic" to cover up putting "business logic" in sp. "Data logic" is only an optimization issue; so, there is no such a thing as "data logic".

3. SP can and should be used to optimize some logic when necessary.

4. Also, for some aspect of business logic that is already well-isolated (i.e., will not likely to be re-used), and it is pretty low-level, then, we can say they are "data logic" -- but again, there is no such a thing that is wide-spread layer of data-logic!, and we can do it in sp.

A pragmatic piecemeal route towards Ajax and silverlight

2007-10-18T08:36:00.000-07:00

A pragmatic piecemeal route towards Ajax and silverlight

1. No third-party controls, e.g. no ComponentOne
--If really need it, just use the a few controls in a limited places that you really need them (e.g. calendar).

Why? because they simply trouble. Up-front trouble, in development trouble, support trouble, and upgrade trouble. Trouble.

2. Instead, continue to use M$ "build-in" controls.
(a) However, use more "check boxes" to increase user interactivity features (so that it is obvious that we need ajax!
(b) Also, begin to use javascripts: do not use them all at once; however, use them seriously. Do not just hack them. Before you know it, you will have a lot of javascripts, and people get used to it.

-------------------
3. Introduce M$ Ajax server controls; however, use them judiciously, not large scale and systematically. Use them only to make people used to ajax.

4. Use client side library (the best, ext and yahoo), but wrap them using server controls yourself.

5. If you can use alpha in some environments (i.e. not "mission critical"), use silverlight as the primary technology (hence, javascript is only the glue, not the primary language).

simplified command pattern (non-emit) AOP: anonymous delegate and generics

2007-09-16T23:38:00.000-07:00

simplified command pattern (non-emit) AOP: anonymous delegate and generics

In my previous blogs, I mentioned that with C# 2.0, we finally can do similar things like java's anonymous inner class for object-adapter pattern. This will simplify command pattern AOP.

Basically, it is an easier and better way of strict inheritance of template method pattern.

Generics here is just a helper, it makes the "template" more like, well, a template -- you do not really need it, a lot of times, if your template does not need to be general.

Note that this is still too expensive, so, it can only be used for facade-level methods; so, it cannot replace real (i.e. emit-based) AOP that can be used for entity get-set methods.

I know, I used too much "patterns" here, so, here are code -- copied/pasted.

-----------------------------------------
-----------------------------------------

public static EmployeeDetails FindEmployee(int empId)
{
WindowsIdentity id = HttpContext.Current.User.Identity as WindowsIdentity;
WindowsImpersonationContext wic = id.Impersonate();
try
{
BrowseOrganizationServiceWse bosw = new BrowseOrganizationServiceWse();
bosw.SetPolicy("kerberos");
FindEmployeeResult fer = bosw.FindEmployee(empId);
EmployeeDetails ed = fer.Item as EmployeeDetails;
return ed;
}
finally
{
wic.Undo();
}
}

--------------------------------templeate ThreadStart deledagate is simply return void

private static void RunMethodImpersonating(ThreadStart method)
{
WindowsIdentity id = HttpContext.Current.User.Identity as WindowsIdentity;
WindowsImpersonationContext wic = id.Impersonate();
try
{
method();
}
finally
{
wic.Undo();
}
}

---------------------------

public static EmployeeDetails FindEmployee(int empId)
{
EmployeeDetails ed = null;

RunMethodImpersonating(
delegate
{
BrowseOrganizationServiceWse bosw = new BrowseOrganizationServiceWse();
bosw.SetPolicy("kerberos");
FindEmployeeResult fer = bosw.FindEmployee(empId.ToString());
ed = fer.Item as EmployeeDetails;
}
);

return ed;
}

-----------------------------
-----------------------------
-----------------------------
-----------------------------

try
{
// cmd is from IDbCommand (SqlCommand, OracleCommand, OleDbCommend etc) type.
// This is the command which we want to run against our database.

using (IDbConnection conn = ProviderFactory.CreateConnection())
{
cmd.Connection = conn;

conn.Open();

// use the cmd object.

} //"using" will close the connection even in case of exception.
}
catch (Exception e)
{
// 1. Trace ?
// 2. Rollback transaction ?
// 3. Throw a wrapper exception with some more information ?
}

--------------------------
--------------------------
--------------------------

public delegate T CommandHandler(IDbCommand cmd);

--------------------------
--------------------------template
--------------------------
///

/// Simple command executer "design pattern".
///

/// The type to return
/// The command
/// The handler which will receive the open command and handle it (as required)
/// A generic defined result, according to the handler choice
public static T ExecuteCommand(IDbCommand cmd, CommandHandler handler) //*1
{
try
{
using (IDbConnection conn = ProviderFactory.CreateConnection()) //*2
{
cmd.Connection = conn;

// Trace the query & parameters.
DatabaseTracer.WriteToTrace(TraceLevel.Verbose, cmd, "Data Access Layer - Query profiler"); //*3

conn.Open();

return handler(cmd); //*4
} //"using" will close the connection even in case of exception.
}
catch (Exception e)
{
// Trace the exception into the same log.
Tracer.WriteToTrace(TraceLevel.Error, e, "Data Access Layer - Exception"); //*5

throw WrapException(e); //*6
}
}

-----------------------------------
-----------------------------------
public delegate T ReaderHandler(IDataReader reader);

-----------------------------------
-----------------------------------
///

/// Execute the db command as reader and parse it via the given handler.
///

/// The type to return after parsing the reader.
/// The command to execute
/// The handler which will parse the reader
/// A generic defined result, according to the handler choice
public static T ExecuteReader(IDbCommand cmd, ReaderHandler handler)
{
return ExecuteCommand(cmd,
delegate(IDbCommand liveCommand) //*1
{
// This is the anonymous delegate handler.
// REMINDER: The original template sends the live command as parameter.
IDataReader r = liveCommand.ExecuteReader();
return handler(r);
});
}

-----------------------------------
-----------------------------------
///

/// Retrieve the persons according to the specified command.
///

/// Typed collection of person.
public static List GetPersonsList()
{
IDbCommand cmd = ProviderFactory.CreateCommand();
cmd.CommandText = "SELECT Name,Age,Email FROM Persons";
cmd.CommandType = CommandType.Text;

return DalServices.ExecuteReader>(cmd,
delegate(IDataReader r)
{
List persons = new List();

while (r.Read())
{
// Create a Person object, fill it by the reader and add it to the "persons" list.
Person person = new Person(r["Name"].ToString(), Convert.ToInt32(r["Age"]), r["Email"].ToString());
persons.Add(person);
}

return persons;
});
}

----------------------------------
----------------------------------
----------------------------------

///

/// Retrieve the persons xml according to the specified command.
///

/// Xml representation of the persons.
public static string GetPersonsXml()
{
IDbCommand cmd = ProviderFactory.CreateCommand();
cmd.CommandText = "SELECT Name,Age,Email FROM Persons";
cmd.CommandType = CommandType.Text;

return DalServices.ExecuteReader(cmd,
delegate(IDataReader r)
{
StringBuilder builder = new StringBuilder(500);

builder.Append("");
while (r.Read())
{
// Create a Person object, fill it by the reader and add it to the "persons" list.
Person person = new Person(r["Name"].ToString(), Convert.ToInt32(r["Age"]), r["Email"].ToString());
builder.Append(person.ToXml());
}
builder.Append("");

return builder.ToString();
});
}

///

/// Execute the db command in "NonQuery mode".
///

/// The command to parse
/// Affected rows number
public static int ExecuteNonQuery(IDbCommand cmd)
{
return ExecuteCommand(cmd,
delegate(IDbCommand liveCommand)
{
return liveCommand.ExecuteNonQuery();
});
}

///

/// Execute the db command in "Scalar mode".
///

/// The type to return after parsing the reader.
/// The command to execute
/// A generic defined result, according to the handler choice
public static T ExecuteScalar(IDbCommand cmd)
{
return ExecuteCommand(cmd,
delegate(IDbCommand liveCommand)
{
return (T)liveCommand.ExecuteScalar();
});
}

Why and How to use server side ajax – even you do not like it – part 2

2007-09-01T18:22:00.001-07:00

Why and How to use server side ajax – even you do not like it – part 2

As my previous blogs show, my basic estimate is that it will take one or two years for Ajax controls to be really mature so that we can safely wrap them on the server side (and still use javascript API). Before that, it is simply not cost-effective; we will spend a lot of time on dealing with bugs, limitations, and covering-ups. You can avoid all those by learning to treat javascript as an engineering language and is required for every developer.

However, it is not at its prime time, yet; its prime time will be after a few months or half a year after Orcas release; as a compromise, at least before Orcas, I have to use C1WebGrid etc., instead of client side ajax controls (the best is ext, and yahoo is also good).

As I pointed out in my previous blogs, the key is to pay attention to the javascript API.

However, the problem is, you cannot find those APIs! Although they are advertised in some fancy wording, the reality is, they are not ready yet! Actually, the reality is even uglier: because the engineering section is not really ready yet, the whole thing is in the hands of marketing people, they do their best to do their spin to make the weakness of the product into features. For example, they turn the fact that there is not client side javascript API into something “you can use ajax automatically” – you would think that since you can do it automatically, so, you certainly can do it manually – no, you cannot! The reality is: the product is not ready for that yet!

A good example is the C1WebGrid and C1WebDialog. C1WebGrid is not really ajax ready yet (ya, it has canned ajax features; that means almost nothing nowadays!); C1WebDialog is a little better. However, both are marketed as ajax ready. If you believe those marketing hypes for C1WebGrid, then, you will really be disappointed, or, misled, by thinking that “ajax can only so little”. As a result, in such a situation, user developers have to lower their standard, and use postback mostly, and use callback whenever they hit one by chance and luck. Note that some marketing materials lead you believe that update panel does not use postback. That is not true. Update panel uses postback. As a result, if it is not client side API, it uses postback, even it is not the whole page postback. As a result, we need to talk about how to do Postback or updatePanel in a way to limit their damages.

Updatepanel postback is still bad, comparing with real client side API call back, for two reasons: (a) Postback always invokes the whole machinery of postback, so, it is bad for performance hit. However, this part of it is not big deal for us, because its damage is only performance, as long as it is fast enough for users, we are fine. (b) More importantly, a lot of times, postback has to use a twisted way to do things. For example, the "multi-value selection shuttling grid pairs": you have two grids, the left or top grid, and the right or bottom grid; the left one is for the available, the right one is for the selected; so, you do the selection by move a row from the left to the right. The selection action is a pure client side thing, until you click “submit selections” button. However, postback makes this a server side operation. Worse, sometimes, to make things perform better, you have to create a workaround on the UI: you put a checkbox on each row, and let users select a few rows, then, click a “select” button ( but this select button is not the “submit selections” – the reason is that there is paging on the available grid – that is actually the reason why we need to shuttle the selected one to a new grid) – the whole thing is getting more and more confusing when you try to put more and more workarounds.

I believe we have a few options:

(i) Find those workarounds;

(ii) Say no to users;

(iii) Buy more new controls, for example, a shuttle control. You will need perhaps a dozen of controls. This has two sides:

(1) new controls has more canned-ajax (i.e., build-in ajax without javascript);

(2) new controls has more javascript APIs.

Obviously, iii-(2) is our real hope! However, iii-(1) is actually also a good one – once you have a dozen pretty good controls, your javascripting will be very “regularized” – if you need to do any javascripting at all! So, the approach is that we will try to push to buy more new controls. Most of the time, it has to be from the same vendor -- for political reasons; however, sometimes, as long as it is “server side controls”, it is also fine.

In short, here is the summary:

(a) For now, for some old so-called ajax-enabled server side controls, most of the time, we have to use postback/updatePanel, insteald of real callbacks;

(b) We buy most recent server side controls, for both purposes: (i) we can begin to use a little bit javascript API, and (ii) we do not need javascripts directly.

--------------------------------------------

Below are the notes that I study the user manual of C1WebGrid.

http://www.componentone.com/Support.aspx?ItemType=2&TabTypeID=2&PanelIndex=2&TabMapID=144&Itemid=0&Tabid=171&SubCategoryTypeID=0

http://helpcentral.componentone.com/

http://helpcentral.componentone.com/Article.aspx?ID=71

Note: You must create a ComponentOne Account and register your product with a valid serial number to obtain

support using some of the above methods.
-----------------------
The ComponentOne Studio for ASP.NET 2.0 installation program will create the directory C:\Program

Files\ComponentOne Studio.NET 2.0. This directory contains the following subdirectories:

bin Contains copies of all ComponentOne binaries (DLLs, EXEs).

Common Contains support and data files that are used by many of the demo

programs.

Help Contains online documentation for all Studio components.

C1WebGrid Contains samples for C1WebGrid.

http://helpcentral.componentone.com/ProductResources.aspx.

-----------------------

Select the ComponentOne C1WebGrid assembly from the list on the .NET tab or browse to find the

C1.Web.C1WebGrid.2.dll file and click OK.

-----------------------

• an assembly resource file which contains the actual run-time license (host dll or for asp 2.0 App_Licenses.dll assembly)

• a "licenses.licx" file that contains the licensed component strong name and version information (Show All Files on the Project menu) ---- to add the file, add the control to the form (then, can delete the control)

----------------------------------

Right-click C1WebGrid and select Show Smart Tag from the context menu. Select Property builder from

the C1WebGrid Tasks menu.

Or,

1. Select the C1WebGrid component.

2. Select Properties Window from the View menu on the Visual Studio toolbar.

Or,

1. Right-click C1WebGrid and select Auto Format from the context menu. The Auto Format dialog box opens.

The reverse angle of "Siebel and spring.net" and the steps of using Siebel

2007-08-30T20:15:00.000-07:00

The reverse angle of "Siebel and spring.net" and the steps of using Siebel

When I say "Siebel and spring.net", I mostly mean to use spring.net to mimic Siebel. Here, Siebel is the "big brother", the "role model".

However, it is not that simple. I do not want to lose my C# or Java or VB skills.

In a sense, it is similar as I keep refreshing my C/C++ skills, periodically.

However, it is also very different, quantitative difference: C#, java, VB are still extremely useful for application development, while C/C++ are less useful for direct applications nowadays; however, they are useful, for understanding OS, and systems like Siebel (you may say an application level OS).

Without spring level of C# or java understanding, or directly C/C++ level -- they call it engineering level -- of understanding of Siebel itself, you will never really understand Siebel.

This is not just a theoretical bias: Siebel will be merged with/into Fusion -- without knowing Fusion or spring.net-like frameworks, you simply cannot understand new versions of Siebel easily and quickly.

Conclusion: you need to know spring.net (or spring itself, and OR mapping, and Ajax), in order to understand Siebel quickly and thoroughly.

It is important to note that plain C#/Java/VB simply does not cut it. You must know frameworks, OR mappings, AOP, databinding, Ajax. etc.

Hence, "Siebel and Spring.net", two sides, both are crucial.

A conclusion for practice: to use Siebel, there are three steps:
(i) immediately set up a usable system, using out-of-box features;

(ii) while (power) users are experimenting the system, you must do some second round of "requirement discovery and design". Because you need to find the features within Siebel, so, when use Siebel, at this stage, the key is NOT talking to users, it is letting users to experiment with Siebel, and you experiment it also, and read all documents, and and try to create a small (a few screens) but "deep" configured module. "Deep" does not mean heavy scripting, it means it includes all key powerful features (including scripting, but again, it does not need to be scripting heavy; but it should include using export to copy/paste some work!) . Again, the key is to get a small but "deeply configured" model done, while users are experimenting.

(iii) users are asking for some features that can be easily done; users also ask for some features that need "deep configuration". Negotiate a little (because Siebel must have a reason not doing that way! Perhaps the business process that Siebel suggests is a better way!). Then, prioritize, and use the deeply configured one as an example, implement more modules.

Obviously, step (ii) is crucial; and to do it right and quick, you need to know spring.net ;-)

Siebel (offline) client and need a toad-like tool for sybase anywhere

2007-08-30T15:05:00.000-07:00

Siebel (offline) client -- talking about offline -- Siebel has been doing for a long time! Sometimes it is called thick client, or simply, client, confusing.

The offline client is also used for development environment. It uses sybase. Its build tool is like sqlplus -- we need a toad-like tool for sybase anywhere. Perhaps oledb connection can be fine, even use access -- I do not like access though; too much clicking, awkward.

BO-scoped workflow/EAI (and service), and BO-scoped rule engine

2007-08-30T14:59:00.000-07:00

BO-scoped workflow/EAI (and service), and BO-scoped rule engine

A. BO scoped workflow, service, and EAI.

(i) workflow/task: you can always call workflow as a service -- workflow is executed within a service (the workflow engine). In other words, service is the underlining mechanism. If a scope is not enough, then, you can create another subworkflow.

(ii) service: you need service, because service can handle transaction, workflows cannot. BO can have a default scope of transaction. Just a note here, the Siebel server has some internal component. If you need to use it directly from client, then, you need to use "server request broker" -- a service interface.

(iii) EAI: service needs scripting, and we prefer declarative programming (to avoid clicking, we must learn to hack sif/xml exports), so, we want to avoid service per se. Also, service cannot use objects as parameters. So, we use EAI that can handle both transactions and object parameters.

B. BO-scoped rule engine

I used rule engine before, in a large project in java. We experimented it in many ways, and finally we concluded that it is not as powerful as it sounds. Inferences are not really that useful, for two reasons: (i) machine performance: we cannot load all the rules and (more importantly) and all those objects needed for those those rules in memory! (ii) human accountability: when something is not right, we cannot say that it is AI -- we are accountable! Basically this means we do not want it to be that powerful! We want predictability! -- As a result, perhaps M$'s no-inference rule engine approach is correct! Wait a minute, perhaps M$ only sees the part of it -- the real thing about rule engine is that it eliminates the effect of the order of rules. This is very important, because by a strong inference engine, we do not need to worry about the order anymore; in other words, this means (i) we need to be careful to specify the rules in such a way that they are order-independent. (ii) the string inference engine can help us to do that.

Anyway, because of the concept of "scope", rules engine is just a glorified "(intra and inter-) entity validation/logic" mechanism -- yes, this is the reason that I have not blog rule engine per se that much -- it is already covered by entity validation/logic (note: rules can change values also, so, it is not just "validation" per se). Rules are grouped special kind of fine-grained AOP.

In Siebel, BO scoped can help the system to help us also, by providing smaller number of options. Note that currently, Siebel cannot provide help for lookup values. It should; I guess, it will be in next version.

C. Why BO is so important? As indicated in my previous blogs, BO is UnitOfWork. For web or SOA, it is the request (or conversation, if we relax it a little bit). It ties OR mapping, facade, valiation/entity logic, and UI-view all together. If you really push it, asking what exactly is it? I would answer it is OR mapping with a context of AOP (coarse-grained facade and fine-grained entity).

Siebel Scripting: third party tool and future of scripting

2007-08-30T09:13:00.000-07:00

Siebel Scripting

http://www.toolsandmethods.com/wordpress/?p=3
http://www.toolsandmethods.com/wordpress/?p=9

I will try the tool, as a learning tool. I am not sure I will ask the company to buy it, though.

To balance it, I want to say that when Oracle tries to merge Siebel into its Fusion architecture, it could "upgrade" eScript to java. I am not saying it will, but a possibility.

However, it is unlikely, because this will make M$ upset. Technically, java is better than eScript (even you add type and do some compiling -- treating it as if it were java -- another way to "handle" or "deal with" javascript -- remember google did it by compiling Java into javascript.). However, M$ shop is a big market.

More about Siebel BO, unit of work, service, workflow/task, escript and hacking sif/xml export

2007-08-29T18:43:00.000-07:00

More about Siebel BO/unitOfWork, service, workflow/task, less escript by editing sif/xml export

1. Siebel BO and Hibernate unit of work

They are equivalent.

Note: A unitOfWork usually lasts longer (or, a lot of times the same) than a web-request but shorter than a web-session. This is what's called the session-per-"conversation" (for shopping carts or wizards) pattern by the hibernate-guys. If you use session-per-request, then, it is the idea of "view-BO" pair in Siebel -- told you!

2. A way to do minimum scripting

Workflow is good for making business rules explicit for power users. So, even it is now clumsy (not easy to test, drag and drop is much slower than typing in IDE etc), it is good that we keep using it.

So, we only need some "util" services from scripting -- at this level, it should be pure javascript. Not data.

All the logic outside validation and rules should be in workflow units that has low-level workflow logic. Usually this is necessary, because we need transactions (see below).

If we need explicit transaction, then, we use scripting to organize workflow units into a service.

Then, we use a workflow (or a task) to wire those workflow units, connect it to a big button or a web service.

3. I agree with the philosophy of less eScript, declarative programming is good. However, declarative does not mean "clicking": I believe Siebel is evil in this regard. There is a loophole here, I am going to hack it -- we can edit the sif/xml export files!

A minor but crucial correction about BO in Siebel

2007-08-28T18:34:00.000-07:00

A minor but crucial correction about BO in Siebel

A BO by itself is still an entity, just a composite entity.
I mis-identified it with a facade, because it is almost the return value of a facade.

Another reason is that in "configuration", Siebel does not expose "facades"; yet, we still need a concept for facade, and BO is the closest thing we can get.

However, in workflow, scripting (eScript, i.e., javascript), and integration, the real 'facades" are exposed, they are, well, "business services", or "service mode workflows" -- all those are so "obvious", of course.

Again, my new "default architecture" is Siebel plus (i.e. in the "integration") Spring.net (or Spring itself, we do not care whether it is C# or java -- esp. when you use spring) that leads to OR mapping and Ajax that "mimic" Siebel.

Note that Siebel is not just a CRM software. It is a platform -- a small one, but nevertheless a general-purpose one -- it can be everything and anything. To me, it is a system for centralized security and logging, and it is an OR mapping system, validation system, and UI framework with excellent databinding and Ajax-like feature (mostly via ActiveX -- hey, nobody is perfect). The only downside is that it is expensive, and proprietary; to "correct" the problem, we have spring (+ OR + pure Ajax).

My new "default architecture": Siebel and Spring.net (and spring.net will lead to OR mapping and Ajax, via custom classes)

2007-08-27T20:10:00.000-07:00

Finally, I find my new "default architecture": Siebel and Spring.net (and spring.net will lead to lower layer -- OR mapping and higher layer -- Ajax, via custom entity classes)

Siebel is already done, and it is beautifully done -- nobody can argue against that!

Spring.net has everything or at least can lead us to find everything that Siebel has.
-- spring.net itself is in the "middle"; however, it will lead to OR mapping (i.e. end of stored procedures) and pure ajax (i.e. end of server side ajax).

------------------details:

"Weak" but clear technical reasons (those reasons are implied in Java culture) that spring.net leads to OR mapping and Ajax.

(a) AOP leads to fine-tuned validation logic that needs custom classes; AOP also leads to non-code generation approach. Both lead to OR mapping. Note that if there are too much resistance on OR mapping, then, we can use code generation as an intermediate step. The key down side of OR mapping is that OR mapping software is too big to be maintainable, even you have all its source code.

(b) Fine-tuned validation logic also encourages high-interactive client. Windows is not an option. Silverlight is still one or two years away; so, pure ajax is the way to go. Note that the argument is that ajax not just makes user happy; pure ajax also makes development cleaner.

A recent note/modification: siverlight is the key here -- on the one hand, it will set the new standard here and therefore push ajax forward; on the other hand, it will compete with ajax, and win. So, it is possible that we will never use heavy javascript -- we use a dozen of new ajax third party controls, then, we switch to silverlight. So, the key of ajax is "new third party controls" (because we cannot wait for M$ for this!) -- client side or server side does not really matter; as long as it is "new", because new server side controls will always have client side API anyway (but we must discipline ourselves to use javascript minimum, because silverlight is already on the horizon, no need to use heavy javascript).

In short, strong "custom class" approach needs AOP; strong "custom class" approach will lead both OR mapping and ajax (or/and silverlight). As a result, AOP will lead OR mapping and pure ajax. Spring.net is AOP, so, spring.net will lead to OR mapping and pure ajax.

---------------new insights on CSLA and Castle:
You talk about "custom class", then, you need to talk about CSLA. It is really necessary to re-realize all CSLA via spring.net AOP.

pure ajax and Castle: Castle is right, if you use pure ajax, why bother asp?!

Use Siebel as the core, integrated it with other similar web-based software, and customize it with in-house modules that use spring.net and ajax

2007-08-27T19:38:00.000-07:00

Use Siebel as the core, integrated it with other similar web-based software, and customize it with in-house modules that use spring.net and ajax

By doing this, users immediately have something to experiment with. Also, Siebel will determine the architecture as web-based (since it is highly interactive, even it is via ActiveX, so, it also determines Ajax), and ubiquitously using web services (because of Siebel's EAI methods).

Further (I know I repeated this a lot in my recent blogs -- I am trying to rationalize a new mode of development), after a team working with Siebel's configuration and customization, the team then can really understand what "enterprise application" mean, and will totally give up those VB6 mindsets, and accept Java mindset -- I know Siebel is in C++; but C++ and Java are close enough. In enterprise development, you strive to make all things just like Siebel: every enterprise development is to make a general configurable system; also, every application development is API development.

More specifically, Siebel will lead to the adoption of centralized security and logging, generalized validation, OR mapping, and UI regularity as easy as "let's do something to make the work like working on Siebel" -- Siebel is so good, you cannot argue against that!

Another justification of this Siebel-first approach is that we start from CRM, then, ERP -- this is a micro-relive of the e-business IT revolution. That is actually how Siebel has been growing.

siebel links

2007-08-27T15:24:00.000-07:00

edelivery.oracle.com
license.keys.oracle.com (1 month)
8.0.0.0.media pack (40G)
8.0.0.1. patch

supportweb.siebel.com bookshelf
-- installation guide
-- deployment planning guide
-- performance & scalability guide
-------
-- release notes
-- maintenance release guide
-- system requirements & supported platforms
-- tech notes
-- siebel alerts

siebel data model reference (it has FK, but note that the FKs are not enforced in database).

OR mapping in Siebel

2007-08-27T14:21:00.000-07:00

OR mapping in Siebel

OK, I lied, I am not sure whether Siebel really has OR mapping internally.

However, to understand it for configuring and customizing it, you should know OR mapping concept: in configuring it, you are effectively configuring the OR mapping; further, it is UI-O-R mapping -- i.e., Siebel makes the UI highly regular, as a result, the mapping is three way, and this three way mapping is actually the core for Siebel.

Once you make the UI highly regular, then, UI-O is really easy. So, the core of the core is back to OR mapping.

As a result, it has all those interesting stuff when you talk about OR mapping. For example, "party" is basically a parent class. It has 1-1 extensions. It also has 1-m relations.

It also has all those concepts such as lookup-table ("master data") and transaction-table ("customer data"). For security, you have user-position-organization-division. Also, those "user keys" concept for non-surrogate composite keys.

Note that the starting point of all those is that you do not think the so-called "behavior". Data, data, data, that is all it is about, just different layers.

There are behaviors, in entities and in facades; however, they are secondary -- SOA, REST, "configuration", OR mapping, all point to the same direction: pay attention to data, not behaviors -- antique OO is more and more irrelevant.

Siebel development environment

2007-08-27T14:17:00.000-07:00

Siebel development environment

It is an odd thing: Siebel development environment is similar to its offline mode. It uses a local database.

You could set up a server on your development machine. However, that machine must be a window 2003 server. You can hack it on XP, but it is hack.

html editors for Siebel

2007-08-27T13:36:00.000-07:00

Believe it or not, you need an external editor for Siebel development/configuration/customization.
Of course, Vim is good, notepad2, notepad++ are good.

The best? NVU.

a bug in siebel tool and the work around

2007-08-27T13:23:00.000-07:00

If you drag a text field from toolbar, it cannot align correctly.
Work around: do not use toolbar, just copy another one on the screen.
or, create another control, then, use that control, instead of text field.

Use Siebel as part of the source of your architecture ideas and spring.net and ajax

2007-08-27T10:03:00.000-07:00

Use Siebel as part of the source of your architecture ideas

1. As explained in my previous blog, Siebel is pretty good -- even it has its "weirdness".
2. The special thing about Siebel is that its UI has strict rules corresponding to its entities and facades. It can do that because its UIs have strict rules -- sometimes counter-intuitive, but general and powerful.
3. Other than that, Siebel is basically a proprietary "close-to-best-practices" for all other things ("8 core techniques"), including centralized security, logging, validation, and even OR mapping, and it does not use stored procedures (and even not FKs! -- that is too extreme though).
4. As a result, Siebel is worth it to be a source of your architecture.
5. Further, once you use Siebel, it is inevitable that it will influence your architecture. You have to build other things to inter-operate with it.
6. The key of using Siebel as the source of your architecture, but not just "copy" it, is to abstract it into "8 core techniques" -- then, it is obvious that we should use spring.net and ajax.

Oracle Stored Procedures examples and notes

2007-08-26T12:11:00.000-07:00

Oracle Stored Procedures examples and notes

I used SP for a long time; then, stopped using it; then, used it again, then, stopped, then, again ... you got the idea. It seems that it will be a while that we can say we will never use it for ordinary development, and it will certainly be here "forever" for special situations. So, here are the minimalist examples and notes.

My stand of using SP? Do not use it if you can use OR mapping, or, if it is a new project (even you do not use OR mapping -- and in that case, non-parameterized sqls are also fine -- as long as you parse the sql to prevent sql injection -- you need to parse it for the single quote anyway. Remember, developer productivity is number one, everything else should be treated as explicit feature request); however, it does not hurt that much, just a little bit waste.

The key to prevent SP from being harmful is to keep it super simple. It should be purely a pure thin wrapper of CRUD sqls.

The following has more info than necessary; however, it is clear that the following shows the minimalist CRUD approach.

-------------------------------CRUD examples
-------------------------------
-------------------------------
http://www.devshed.com/c/a/Oracle/Developing-Simple-PL-SQL-Stored-Procedures-for-CRUD-Operations/1/
http://www.c-sharpcorner.com/UploadFile/john_charles/CallingOraclestoredproceduresfromMicrosoftdotNET06222007142805PM/CallingOraclestoredproceduresfromMicrosoftdotNET.aspx

---------------insert

create or replace procedure p_emp_insert (p_empno emp.empno%type,
p_ename emp.ename%type, p_sal emp.sal%type, p_deptno emp.deptno%
type) as
begin
insert into emp
(
empno,
ename,
sal,
deptno
)
values
(
p_empno,
p_ename,
p_sal,
p_deptno
);
Commit;
exception
when dup_val_on_index then
raise_application_error(-20001, 'Employee already
exists');
when others then
raise_application_error(-20011, sqlerrm);
end;
/
---------------we could add validation in the above SP, but do we really want to do that? My vote is no. We do not want that! validation should be the responsibility of facade and entity.

create or replace procedure p_emp_insert (p_empno emp.empno%type,
p_ename emp.ename%type, p_sal emp.sal%type, p_deptno emp.deptno%
type) as
Invalid_sal exception;
Invalid_deptno exception;
begin
if p_sal<100>10000 then
raise invalid_sal;
end if;

declare
dummy_var varchar(10);
begin
select 'exists' into dummy_var
from dept
where deptno = p_deptno;
exception
when no_data_found then
raise Invalid_deptno;
when others then
raise_application_error(-20011, sqlerrm);
end;

insert into emp
(
empno,
ename,
sal,
deptno
)
values
(
p_empno,
p_ename,
p_sal,
p_deptno
);
Commit;
exception
when invalid_sal then
raise_application_error(-20001, 'Salary must be in
between 100 and 10000');
when invalid_deptno then
raise_application_error(-20001, 'Department doesn't
exist');
when dup_val_on_index then
raise_application_error(-20001, 'Employee already
exists');
when others then
raise_application_error(-20011, sqlerrm);
end;
/
---------------update

create or replace procedure p_emp_update (p_empno emp.empno%type,
p_ename emp.ename%type, p_sal emp.sal%type, p_deptno emp.deptno%
type) as
Invalid_sal exception;
Invalid_deptno exception;
Invalid_empno exception;
begin
if p_sal<100>10000 then
raise invalid_sal;
end if;
declare
dummy_var varchar(10);
begin
select 'exists' into dummy_var
from dept
where deptno = p_deptno;
exception
when no_data_found then
raise Invalid_deptno;
when others then
raise_application_error(-20011, sqlerrm);
end;
update emp set
ename=p_ename,
sal=p_sal,
deptno=p_deptno
where empno=p_empno;
if sql%notfound or sql%rowcount=0 then
rollback;
raise Invalid_empno;
end if;
commit;
exception
when invalid_sal then
raise_application_error(-20001, 'Salary must be in
between 100 and 10000');
when invalid_deptno then
raise_application_error(-20001, 'Department doesn't
exist');
when invalid_empno then
raise_application_error(-20001, 'Employee does not
exist');
when others then
raise_application_error(-20011, sqlerrm);
end;
/
---------------delete

create or replace procedure p_emp_delete (p_empno emp.empno%type) as
Invalid_empno exception;
begin
delete from emp
where empno=p_empno;
if sql%notfound or sql%rowcount=0 then
rollback;
raise Invalid_empno;
end if;
commit;
exception
when invalid_empno then
raise_application_error(-20001, 'Employee does not
exist');
when others then
raise_application_error(-20011, sqlerrm);
end;
/
---------------select without ref cursors

create or replace procedure p_emp_details(p_empno emp.empno%type,

p_ename OUT emp.ename%type, p_sal OUT emp.sal%type, p_deptno OUT
emp.deptno%type)
as
begin
select ename, sal, deptno
into p_ename, p_sal, p_deptno
from emp
where empno = p_empno;
exception
when no_data_found then
raise_application_error(-20001, 'Employee not
found');
when too_many_rows then
/* this would not happen generally */
raise_application_error(-20002, 'More employees exist
with the same number');
when others then
raise_application_error(-20003, SQLERRM);
end;
/
----------driver of the above sp:

declare
s emp.sal%type;
en emp.ename%type;
d emp.deptno%type;
begin
p_emp_details(7369, en,s,d);
dbms_output.put_line('name of employee: ' || en);
dbms_output.put_line('Salary: ' || s);
dbms_output.put_line('Deptno: '||d);
end;
/

---------------example of select without ref cursors

create or replace procedure count_emp_by_dept(pin_deptno number, pout_count out number)
is
begin
select count(*) into pout_count
from scott.emp
where deptno=pin_deptno;
end count_emp_by_dept;

------

Using System;

using System.Collections.Generic;

using System.Text;

using System.Data.OracleClient;

using System.Data;

namespace CallingOracleStoredProc

{

class Program

{

static void Main(string[] args)

{

using (OracleConnection objConn = new OracleConnection("Data Source=ORCL; User ID=scott; Password=tiger"))

{

OracleCommand objCmd = new OracleCommand();

objCmd.Connection = objConn;

objCmd.CommandText = "count_emp_by_dept";

objCmd.CommandType = CommandType.StoredProcedure;

objCmd.Parameters.Add("pin_deptno", OracleType.Number).Value = 20;

objCmd.Parameters.Add("pout_count", OracleType.Number).Direction = ParameterDirection.Output;

try

{

objConn.Open();

objCmd.ExecuteNonQuery();

System.Console.WriteLine("Number of employees in department 20 is {0}", objCmd.Parameters["pout_count"].Value);

}

catch (Exception ex)

{

System.Console.WriteLine("Exception: {0}",ex.ToString());

}

objConn.Close();

}

}

}

}

--------------another example select without ref cursors, with a function

create or replace function get_count_emp_by_dept(pin_deptno number)
return number
is
var_count number;
begin
select count(*) into var_count
from scott.emp
where deptno=pin_deptno;
return var_count;
end get_count_emp_by_dept;

---------note it uses "return_value" as the parameter name

using System;

using System.Collections.Generic;

using System.Text;

using System.Data.OracleClient;

using System.Data;

namespace CallingOracleStoredProc

{

class Program

{

static void Main(string[] args)

{

using (OracleConnection objConn = new OracleConnection("Data Source=ORCL; User ID=scott; Password=tiger"))

{

OracleCommand objCmd = new OracleCommand();

objCmd.Connection = objConn;

objCmd.CommandText = "get_count_emp_by_dept";

objCmd.CommandType = CommandType.StoredProcedure;

objCmd.Parameters.Add("pin_deptno", OracleType.Number).Value = 20;

objCmd.Parameters.Add("return_value", OracleType.Number).Direction = ParameterDirection.ReturnValue;

try

{

objConn.Open();

objCmd.ExecuteNonQuery();

System.Console.WriteLine("Number of employees in department 20 is {0}", objCmd.Parameters["return_value"].Value);

}

catch (Exception ex)

{

System.Console.WriteLine("Exception: {0}",ex.ToString());

}

objConn.Close();

}

}

}

}

---------------use select with ref cursors

create or replace package human_resources
as
type t_cursor is ref cursor;
procedure get_employee(cur_employees out t_cursor);
end human_resources;

-------
create or replace package body human_resources
as
procedure get_employee(cur_employees out t_cursor)
is
begin
open cur_employees for select * from emp;
end get_employee;
end human_resources;

------
Using System;

using System.Collections.Generic;

using System.Text;

using System.Data.OracleClient;

using System.Data;

namespace CallingOracleStoredProc

{

class Program

{

private static void prvPrintReader(OracleDataReader objReader)

{

for (int i = 0; i < i =" 0;" objconn =" new" source="ORCL;" id="scott;" password="tiger" objcmd =" new" connection =" objConn;" commandtext = "human_resources.get_employee" commandtype =" CommandType.StoredProcedure;" direction =" ParameterDirection.Output;" objreader =" objCmd.ExecuteReader();" i =" 0;" i =" 0;" objconn =" new" source="ORCL;" id="scott;" password="tiger" objcmd =" new" connection =" objConn;" commandtext = "human_resources.get_employee_department" commandtype =" CommandType.StoredProcedure;" direction =" ParameterDirection.Output;" direction =" ParameterDirection.Output;" objreader =" objCmd.ExecuteReader();" ename="p_ename," job="p_job," mgr="p_mgr," hiredate="p_hiredate," sal="p_sal," comm="p_comm," deptno="p_deptno" empno="p_empno;" empno="p_empno;" objconn =" new" source="ORCL;" id="scott;" password="tiger" objadapter =" new" objselectcmd =" new" connection =" objConn;" commandtext = "human_resources.select_employee" commandtype =" CommandType.StoredProcedure;" direction =" ParameterDirection.Output;" selectcommand =" objSelectCmd;" objinsertcmd =" new" connection =" objConn;" commandtext = "human_resources.insert_employee" commandtype =" CommandType.StoredProcedure;" insertcommand =" objInsertCmd;" objupdatecmd =" new" connection =" objConn;" commandtext = "human_resources.update_employee" commandtype =" CommandType.StoredProcedure;" updatecommand =" objUpdateCmd;" objdeletecmd =" new" connection =" objConn;" commandtext = "human_resources.delete_employee" commandtype =" CommandType.StoredProcedure;" deletecommand =" objDeleteCmd;" dtemp =" new" count =" {0}" deptno =" p_deptno" p_deptno =""> 30,
p_recordset => v_cursor);

LOOP
FETCH v_cursor
INTO v_ename, v_empno, v_deptno;
EXIT WHEN v_cursor%NOTFOUND;
DBMS_OUTPUT.PUT_LINE(v_ename || ' | ' || v_empno || ' | ' || v_deptno);
END LOOP;
CLOSE v_cursor;
END;
/

-------vb.net

Dim conn, cmd, rs

Set conn = Server.CreateObject("adodb.connection")
conn.Open "DSN=TSH1;UID=scott;PWD=tiger"

Set cmd = Server.CreateObject ("ADODB.Command")
Set cmd.ActiveConnection = conn
cmd.CommandText = "GetEmpRS"
cmd.CommandType = 4 'adCmdStoredProc

Dim param1
Set param1 = cmd.CreateParameter ("deptno", adInteger, adParamInput)
cmd.Parameters.Append param1
param1.Value = 30

Set rs = cmd.Execute

Do Until rs.BOF Or rs.EOF
-- Do something
rs.MoveNext
Loop

rs.Close
conn.Close
Set rs = nothing
Set param1 = nothing
Set cmd = nothing

Set conn = nothing

---------------strong typed ref cursor

create or replace package REFCURSOR_PKG as
TYPE WEAK8i_REF_CURSOR IS REF CURSOR;
TYPE STRONG REF_CURSOR IS REF CURSOR RETURN EMP%ROWTYPE;
end REFCURSOR_PKG;

-------------another example with VB.net code
CREATE OR REPLACE PACKAGE curspkg_join AS
TYPE t_cursor IS REF CURSOR ;
Procedure open_join_cursor1 (n_EMPNO IN NUMBER, io_cursor IN OUT t_cursor);
END curspkg_join;
/

CREATE OR REPLACE PACKAGE BODY curspkg_join AS
Procedure open_join_cursor1 (n_EMPNO IN NUMBER, io_cursor IN OUT t_cursor)
IS
v_cursor t_cursor;
BEGIN
IF n_EMPNO <> 0
THEN
OPEN v_cursor FOR
SELECT EMP.EMPNO, EMP.ENAME, DEPT.DEPTNO, DEPT.DNAME
FROM EMP, DEPT
WHERE EMP.DEPTNO = DEPT.DEPTNO
AND EMP.EMPNO = n_EMPNO;

ELSE
OPEN v_cursor FOR
SELECT EMP.EMPNO, EMP.ENAME, DEPT.DEPTNO, DEPT.DNAME
FROM EMP, DEPT
WHERE EMP.DEPTNO = DEPT.DEPTNO;

END IF;
io_cursor := v_cursor;
END open_join_cursor1;
END curspkg_join;
-------------

Imports System.Data.OracleClient

Dim Oraclecon As New OracleConnection("Password=pwd;" & _
"User ID=uid;Data Source=MyOracle;")
Oraclecon.Open()

Dim myCMD As New OracleCommand()
myCMD.Connection = Oraclecon
myCMD.CommandText = "curspkg_join.open_join_cursor1"
myCMD.CommandType = CommandType.StoredProcedure
myCMD.Parameters.Add(New OracleParameter("io_cursor", OracleType.Cursor)).Direction = ParameterDirection.Output
myCMD.Parameters.Add("n_Empno", OracleType.Number, 4).Value = 123
Dim myReader As OracleDataReader
Try
myCMD.ExecuteNonQuery()
Catch myex As Exception
MsgBox(myex.Message)
End Try

myReader = myCMD.Parameters("io_cursor").Value

Dim x, count As Integer

count = 0

Do While myReader.Read()
For x = 0 To myReader.FieldCount - 1
Console.Write(myReader(x) & " ")
Next
Console.WriteLine()
count += 1
Loop

MsgBox(count & " Rows Returned.")

myReader.Close()
Oraclecon.Close()

/

-----------rowtype

declare
type r_cursor is REF CURSOR;
c_emp r_cursor;
er emp%rowtype;
begin
open c_emp for select * from emp;
loop
fetch c_emp into er;
exit when c_emp%notfound;
dbms_output.put_line(er.ename || ' - ' || er.sal);
end loop;
close c_emp;
end;
---------- "record"

declare
type r_cursor is REF CURSOR;
c_emp r_cursor;
type rec_emp is record
(
name varchar2(20),
sal number(6)
);
er rec_emp;
begin
open c_emp for select ename,sal from emp;
loop
fetch c_emp into er;
exit when c_emp%notfound;
dbms_output.put_line(er.name || ' - ' || er.sal);
end loop;
close c_emp;
end;

------------ref cursor is dynamic

------------(this is crucial for practical use in SP)

declare
type r_cursor is REF CURSOR;
c_emp r_cursor;
type rec_emp is record
(
name varchar2(20),
sal number(6)
);
er rec_emp;
begin
open c_emp for select ename,sal from emp where deptno = 10;
dbms_output.put_line('Department: 10');
dbms_output.put_line('--------------');
loop
fetch c_emp into er;
exit when c_emp%notfound;
dbms_output.put_line(er.name || ' - ' || er.sal);
end loop;
close c_emp;
open c_emp for select ename,sal from emp where deptno = 20;
dbms_output.put_line('Department: 20');
dbms_output.put_line('--------------');
loop
fetch c_emp into er;
exit when c_emp%notfound;
dbms_output.put_line(er.name || ' - ' || er.sal);
end loop;
close c_emp;
end;
--------------ref cursor within a loop

declare
type r_cursor is REF CURSOR;
c_emp r_cursor;
type rec_emp is record
(
name varchar2(20),
sal number(6)
);
er rec_emp;
begin
for i in (select deptno,dname from dept)
loop
open c_emp for select ename,sal from emp where deptno = i.deptno;
dbms_output.put_line(i.dname);
dbms_output.put_line('--------------');
loop
fetch c_emp into er;
exit when c_emp%notfound;
dbms_output.put_line(er.name || ' - ' || er.sal);
end loop;
close c_emp;
end loop;
end;

-----------------nested proc (it is like class's static method. it is just like package)

declare
type r_cursor is REF CURSOR;
c_emp r_cursor;
type rec_emp is record
(
name varchar2(20),
sal number(6)
);
er rec_emp;
procedure PrintEmployeeDetails is
begin
loop
fetch c_emp into er;
exit when c_emp%notfound;
dbms_output.put_line(er.name || ' - ' || er.sal);
end loop;
end;
begin
for i in (select deptno,dname from dept)
loop
open c_emp for select ename,sal from emp where deptno = i.deptno;
dbms_output.put_line(i.dname);
dbms_output.put_line('--------------');
PrintEmployeeDetails;
close c_emp;
end loop;
end;

------------------by passing parameters, we can move the print proc outside

declare
type r_cursor is REF CURSOR;
c_emp r_cursor;
type rec_emp is record
(
name varchar2(20),
sal number(6)
);
procedure PrintEmployeeDetails(p_emp r_cursor) is
er rec_emp;
begin
loop
fetch p_emp into er;
exit when p_emp%notfound;
dbms_output.put_line(er.name || ' - ' || er.sal);
end loop;
end;
begin
for i in (select deptno,dname from dept)
loop
open c_emp for select ename,sal from emp where deptno = i.deptno;
dbms_output.put_line(i.dname);
dbms_output.put_line('--------------');
PrintEmployeeDetails(c_emp);
close c_emp;
end loop;
end;

-------------------------------notes
-------------------------------
-------------------------------
-------------------------------

A. Environment

1. create or replace will keep all grants, so use it, instead of drop then create again
2. execute PPP.XXXX('para1'); or BEGIN addtuple1(99); END; . then \
3. errors is in user_errors

(in sqlplus: show errors procedure ;

4. source is in all_source (or dba_source), user_objects

5. sometimes need to recompile: alter procedure/package XXXX compile

6. sqlplus: "." (period) means the end
7. sqlplus: "/" means "run;"

B. Package, Procedures
1. always use package to organize procedures, as namespace.
2. also, package has an extra feature: it is like static class, its static initializer is at the bottom of the body: immediately before the end, you add a begin block for package initializer.
3. note that "package body" is the meat; package itself is just a useless trace of C++ heritage.
4. in package body, you put pl/sql block. A block always has: declare (optional), begin, exception (optional), end.
5. in exception section: you use "when ZERO_DIVIDE, then", you can use "when others". To raise exception, you can use "RAISE" (typically used outside exception section, to handle it yourself in the SP's exception section later), or (to let it bubble up by the system), RAISE_APPLICATION_ERROR (from -20001 to -20999)
6. in command section: you can use if-then-elsif-then-else, and loop (exit when, or, while XXX, or, for-XXX-in).
7. The most interesting thing is its cursor related stuff: <======================= (a) a cursor is just like a "reader" in ADO. For example, we can declare: "cursor rad_cursor is select * from RADIUS_VALS". <======================================== (b) note that rad_cursor is an instance (not a type); however, we can have a type based on the instance: ----(i) rad_val rad_cursor%ROWTYPE; ----(ii) radius rad_val.Radius%TYPE; (c) to loop through a cursor, we can use simplified syntax, so that we do not need to write open, fetch-XX-into-YY, and close, or test rad_cursor%NOTFOUND (or rad_cursor%ROWCOUNT), we simply say: "for rad_val in rad_cursor". (d) in the loop, we can have some pl/sql's special sqls. For example: ----SELECT e,f INTO a,b FROM T1 WHERE e>1;
----DELETE FROM T1 WHERE CURRENT OF T1Cursor;

(e) note: (b)(c)(d) are not really necessary if you do things right. All we really need is to wrap basic CRUD sqls with SPs, with absolutely no processing (i.e. logic) at all (the so-called "data logic" is really just performance optimization -- as a result, in normal development, we do not even think about it -- we deal with it with systematic measurement etc. In general, in almost all projects, if you do it right, you do not need to do any "data logic" optimizations).

C. Other things like Functions, Triggers, etc.
----. comment /* */
----. usually we use procedures (use out parameter for return values), not functions. However, function can return a value. Function can be used in sql (it should well-behaved, i.e., no out parameter, it should not change things).
----. trigger naming convention: BU_ROW_XXXXXX, "B" means before, "U" means update, "ROW" means row-level, XXXX for table name. We can combine I and U etc, in the body, we can use "if inserting than" to differentiate them.
----. trigger can be triggered by a column; further, we use "when" to add extra conditions to be triggered.
----. in trigger, we can use :new.YYY, :old.XXX to get the column values.

Siebel CRM: technical and process

2007-08-25T18:30:00.000-07:00

Siebel CRM: technical and process

A. Technical:

1. ActiveX, instead of Ajax: Siebel CRM (8.0) is web based. It does not use Ajax, instead, it uses two modes, one is "high interactive" mode, which uses ActiveX; another one is for non-IE clients, uses "standard mode", which uses pre-ajax stuff. It is said that it used java applet before activeX (that is why those ActiveXs are still called "applet" in Siebel), then, because java was too slow, so, java was replaced by ActiveX. Obviously, it is a wrong decision that ajax is not used.

2. Siebel UI is a little bit less intuitive than ordinary web or window applications. However, by doing this, it enables its UIs to be generic enough to handle complex situations systematically.
(i) For example, it uses command menus, instead of command buttons.
(ii) Also, it uses a pattern: select a node on the left-side-tree-view, to get the right-side-list-view, then, select a row on the right-side-list, then, select a child node on the left-side-tree (usually, this step should happen on the right-side, by a child list), then, the right-side will have a child list to show the content of the child node.
(iii) Another example is that all UIs are always made of two "applets" (that is, in addition to the tree): "list" (i.e., grid), "form" (many label+text boxes/drop down menus) , plus some tabs or links (category tabs, view tabs, and screen tabs) -- you can put the list "applet" on top, then, this is the "aggregate view" style (users are familiar with this view; because they are used in all ordinary web sites); you can also put the form "applet" on top, then, it is the "detailed view" -- however, in this situation, this view is counter-intuitive, because most users expect to see a three-tier view: the grand-parent at the top, then, the parent, then, the grand-children.
(iv) Also, in the "high interactive" mode, it uses in-place editing, and uses in-place editing-like style to do searching. In ordinary web application, editing uses the form "applet"; further, searching also uses the form "applet".

Those things are not intuitive, further, some are not necessary -- not using them can make Siebel UIs more intuitive and still be generic -- however, as a whole, they are good enough, and they make the following "mapping" possible:

"applet" -- entity objects (in Siebel, entities are called "business components")
"view" -- facade objects (in Siebel, facades are called "business objects")

3. Siebel facades are in a proprietary application server. Actually, its UIs are also in the app server. The generic "web server" is still used though, mostly for load balancing. As a result, for integration, web service is used to get data from those facades.

4. Another surprise about Siebel is that its database does not even enforce FKs. FK are enforced in its facades and entities.

Some thoughts:

On the one hand, after understanding the details of Siebel, I appreciate more about the statement that in the world of lightweight (i.e., no entity bean, but OR mapping) java and .net, Siebel is too expensive for its value. As long as you have an experienced team lead (or architect) so that you know how to say no to unreasonable non-essential UI features and know how to use OR mapping, systematic Ajax with databinding, centralized security and logging (and transaction and networking), and validation, then, the difference between creating your own application and configuring Siebel is not that big.

On the other hand, I do see the value of saying no to unreasonable non-essential UI features, and OR mapping, systematic Ajax with databinding, centralized security and logging (and transaction and networking), and validation. If you can do those things right and fast, then, it is worth millions!

B. Process:

Siebel 's success also points out that it is important to have a working prototype. This is the major advantage of on-shelf software. For an enterprise level application that usually will take two or three years, you can demo a prototype immediately, and then put it to user's hands within a few weeks or a few months.

However, it is amazing to hear that you need produce large amount of documents before implementing Siebel. I do not believe it. I believe it is crap. The key of using Siebel is to do some preliminary research (and "requirement gathering) to decide to use Siebel, then, use a few weeks to set it up and use it. Then, fine tune it, configure it, and even customized it. Of course, we need to document along the process; however, heavy weight upfront documentation without letting users try Siebel out is simply wrong.

domain modeling, concept analysis, knowledge structure, ontology, "applying" knowledge and faith

2007-08-25T12:47:00.000-07:00

domain modeling, concept analysis, knowledge structure, ontology, "applying" knowledge and faith

This blog is try to expand the perspective of "8 core techniques" + "3 questions" (high-level use cases, uses cases, domain model). More accurately, it is to expand "3 questions", because it is "3 questions" that expands "8 core techniques" into business process perspective. In this blog, I will continue to expand that into everyday life.

There are two questions: (a) can domain modeling be used as a general concept analysis tool? -- perhaps we need a concept of "knowledge structure"; (b) everything is knowledge, is that really true?

(a) Let's say, can we apply domain modeling in physics study? Putting it that way, to be frank, I doubt it. However, how about computational physics? Then, the difference between "ordinary" physics and computational physics? I believe there are three elements here.
(i) In domain modeling, the key is the multiplicity. Is multiplicity the key for other concept analysis? I really doubt it. However, is multiplicity really the whole story of domain analysis? No. Further, having a sense of multiplicity will help qualitative analysis.
(ii) It seems that when we do "ordinary" concept analysis, we tend to blur the border between the reality and the concept, i.e., the representation of the reality. It is not a good habit. When we do "domain modeling", we know the difference, because we know we are doing data modeling or in-memory-object modeling. However, "data" or "in-memory-object" are obvious too nerdy, too computer/software-centric. So, I believe "knowledge structure" (or, "ontology") is a good concept. It is more tangible than "concept analysis", and therefore can remind us the border between reality and the representation of reality, while it can be applied to "wet" brain, and used naturally everywhere and not (too) nerdy.
(iii) From academic point of view, "knowledge structure" should be a important concept in philosophy, more specifically, ontology, philosophy of language, philosophy of science, metaphysics, epistemology, and, my favorite (seriously, perhaps someday I will go back to study of psychology) psychology of sleep: http://pespmc1.vub.ac.be/KNOWSTRUC.html (the result of the googling after I wrote this blog).

more links from googling "ontology"

http://en.wikipedia.org/wiki/Ontology
http://ontology.buffalo.edu/
http://www-ksl.stanford.edu/kst/what-is-an-ontology.html
http://www.jfsowa.com/ontology/

---------------- a quote from wikipedia about the differences between the ontology studies of computer science and philosophy

What ontology has in common in both computer science and philosophy is the representation of entities, ideas, and events, along with their properties and relations, according to a system of categories. In both fields, one finds considerable work on problems of ontological relativity (e.g. Quine and Kripke in philosophy, Sowa and Guarino in computer science (Top-level ontological categories. By: Sowa, John F. In International Journal of Human-Computer Studies, v. 43 (November/December 1995) p. 669-85.), and debates concerning whether a normative ontology is viable (e.g. debates over foundationalism in philosophy, debates over the Cyc project in AI).

Differences between the two are largely matters of focus. Philosophers are less concerned with establishing fixed, controlled vocabularies than are researchers in computer science, while computer scientists are less involved in discussions of first principles (such as debating whether there are such things as fixed essences, or whether entities must be ontologically more primary than processes). During the second half of the 20th century, philosophers extensively debated the possible methods or approaches to building ontologies, without actually building any very elaborate ontologies themselves. By contrast, computer scientists were building some large and robust ontologies (such as WordNet and Cyc) with comparatively little debate over how they were built.

--------------------------

(b) Let's say that we use "knowledge structure" (ontology) everywhere, but can we really do it in art experience, or, even better, religious experiences? Note that I am referencing to "experiences", not art theory/aesthetics or theology -- they can be treated as knowledge, obviously. This is just another form of the difference between reality and the representation of reality -- but more directly, and cannot be "postponed" anymore. By "postponed" I mean, in other places, for example, in technology or engineering or mathematics, or even business, we can "postpone" the differences between "reality" and "knowledge of reality" by "transforming" ("learning") "reality" to "knowledge of reality" -- it seems that it is OK that we do that -- actually, most of the time, in our more and more sophisticated world, it seems that it is the preferred way to do that -- when you do something, you must know what you are doing, do not "just do it".

However, in art it is not the case; it it even more "not the case" in the faith life (or "religious life" -- but it seems that "faith life" has a more positive tone).

It seems that knowledge and faith are not symmetric. Knowledge is a space-like, while faith is a singularity -- when you begin to talk about faith, then, the content of your talk is transformed into knowledge!

However, the singularity is the most active part of our life. Put it in another way, it is the "engine" of the "learning", and more importantly, "applying", of the huge space of knowledge -- obviously, you'd better "oil" the engine nicely!

OK, this blog is (still) a technical one, as result (and purely so), the point I am trying to make here is not about the faith life -- that is personal -- it is about "knowledge structure": except one and only one singularity that we cannot really talk (whenever we talk, it is changed into knowledge), everything is knowledge; consequently, everything can be covered by the concept of "knowledge structure". As a result, let's use "ontology" more often.

Why and How to use server side ajax -- even you do not like it

2007-08-18T16:29:00.000-07:00

Why and How to use server side ajax -- even you do not like it

Think about it, SP now is not that harmful, because we all accept the statement "never put (business) logic in SP" -- this is the way to "neutralize" SP (if you realize that all "data logic" belongs to "business logic" -- other than performance optimization -- then, you basically have nailed SP to nothing!) . We need to find the equivalent thing in server side ajax.

The key of using server side ajax is to understand the two sides:

1. "Configuring" via XML is not necessary, but for now (pre-Orcas) it is indeed a little bit simpler than javascript.

2. The harm is that you do not know when to stop, and continue to hack features on the server side, while it is really easy to do it via javascript API of those server side controls.

So, the key is to remember the javascript API of those server side controls.

Why and How to use stored procedures -- even you do not like them

2007-08-18T15:56:00.000-07:00

Why and How to use stored procedures -- even you do not like them

1. Stored procedures certainly have their values. For example, when you do not use web services, and you have multiple-platforms, stored procedures provide all the benefits of web services. As a matter of fact, web services (or application servers) are simply stored-procedures-moved-out-from-databases.

2. However, in everyday development, it is antique practice to do stored procedures. I know, M$ marketing and some tutorial demo people are still recommending it; but if you take the words from marketing people or tutorial people as your engineering guidelines, then, you are kidding yourself!

3. The real valid reason of using stored procedures is consistency. If you are in a M$ shop, and if there are a lot of code using SP, and people are used to using SP, then, you have to use it -- until there is a big project that you can break the obsolete tradition (I will explain when next).

4. The above reason also implies that SP does not really hurt that much, it is just a little bit waste. As a result, you should not be too enthusiastic about removing SP. You must choose your battle, concentrate on making productive changes that really benefit the team, not making those purposeless changes.

5. Then, when should you push really hard to eliminate the SP practice? When you use OR mapping! Until then, keep using SP -- it is harmless for now.

6. Of course, you should not put logic in SP; or, relaxing it a little bit, you can put "data logic" in SP -- frankly, it is really a political compromise; for my taste, absolutely no logic at all -- the whole SP will go away, why bother to think about where to draw the line between "data logic" and "business logic", crazy. If you think about it, "data logic" is really just a performance optimization concept. As a result, using it as everyday practice guideline is really counterproductive.

Too many technologies, framework or not and aop, and spring.net

2007-08-18T09:46:00.000-07:00

Too many technologies, framework or not and aop, and spring.net

A. It is a common feeling that M$ offers too many technologies. This is especially troublesome for team leadership -- some "new" developers keep introducing stuff, all M$ "recommended".

To deal with it, we have to say: you cannot use new technologies, just because you can and they are new. They must be relevant and make sense.

I go further. Using new technologies must fit into two categories: it directly meet users' needs of certain features, or, it solves the issues that the "8 core techniques" try to solve.

(1) The core of the core? coarse-grained AOP, of course: centralized security, logging, transaction, and networking.

(2) Below it, the logging (implementation) and database acess.

(3) Above it, fine-grained AOP (entity logic-validation), and MVC (or, MVPC) -- i.e., databinding.

If a new technology does not help solving those problems (and not directly address a feature needed by users), then, forget about it.

B. Framework or not

(1) The key is how effective a coding guideline or an architecture guideline can be. My bet is that they rarely work! You cannot solve an engineering issue by using pure managerial techniques. You must "automate" the "guidelines", which is a framework!

-- The only real effective guidelines are those that enforced by a framework.

(2) Another key is how fast you can get implement features in security, logging, transaction, networking (and validation), with reasonable (acceptable) quality. My experience is that you rarely can, without a framework.

-- The only fast and easy way to implement reliable security, logging, transaction, networking (and validation) is to use a good (and easy) framework. -- note that here, a framework helps you get things done faster, not slower!

Note that I backed off from spring.net, because I cannot convince people about this, and I have to accept the consensus at that time. However, it turns out that it all depends on the size of your vision and perspective. If it is large enough (e.g. anything > 7 person-year, no mention a whole enterprise system), then, it should be spring.net.

Also note that I am more and more convinced that AOP is the center here, not IOC or TDD. The key is that AOP is inherently feature-oriented -- you need those security features!

C. choice among Spring.net, castle, M$ entlib 3.0:

(1) needs politically correctness for a M$-only shop: M$ entlib 3.0
(2) likes dynamic new challenges: castle
(3) is pragmatic, mature: spring.net (plus log4net, no need to use M$'s logging)

another set of wording about layering from SOA

2007-08-18T09:40:00.000-07:00

UI or service
facade -- processor
dao -- connector
db -- resources ----- I like "resources", it connect to REST: the key concept of REST is that service expose resource directly, "antique OO encapsulation" is not true after all, at least not totally true.

How to use and participate Open Source

2007-08-04T12:37:00.000-07:00

How to use and participate Open Source

For thin frameworks, you must learn to tear them apart; for frameworks that are absolutely necessary, you cannot really tear them apart. However, you can do something close to tearing it part – only use its core, never cut/paste big examples, or, “user extensions”. Gradually, by combining those libraries, you effectively, well tearing them apart.

Yes, I am talking about javascript libraries – they are absolutely necessary, so, you cannot simply tear them apart.

The key is that do not try to cut/paste everything. Once you have a key feature (e.g., a grid in ext), you should stop paying attention to big examples.

---------------------more elaborations
Must: go through all other small tutorial examples, so that you have the ability to search/ask the forum for small pieces of code (not even examples, just a few lines code or even just ideas)

Must NOT: continue looking for/at big examples (you need to do that in the very beginning, to make sure that the whole thing is capable), but you must not try to use it immediately. You must build from scratch at the core-grid level -- prematurely trying to use "user extensions" or "big examples" will actually slow you down.

--------in short: big examples are only for evaluation
--------when development, make sure start from core of the framework!!!

---------------------even more elaboration
I understand the pressure to get something done -- you need cut/past things. However, that kind of pressure will only slow down you, unless what you really need is just some superficial demo (actually, this is a technique to reduce pressure -- offer managers some superficial demos, i.e. download something, make it run, change UI wording by hard-coding the working in UI to make it looks like relevant to what you are doing.

Those demos can be treated as evaluation task. For real development, you need to fine-tune thing, so, you need all details! So, sooner or later, you have to do it. If you do it in the beginning, it is streamlined, much more efficient, and must fewer crises.

By doing the above, even if you "just" use it, you are participating the open source.

REST -- web service is all about data (or "resource")

2007-08-02T19:18:00.000-07:00

REST -- web service is all about data (or "resource")
---- REST and “domain model must follow data model” again, CSLA again, and FIT again

1. Theory or perspective -- REST and data warehouse: REST is just a completion of the data-warehouse vision: it is totally OO crap saying that data should be wrapped. At higher level, data is visible by users – actually, at that level, data is all users cares. Business logic is just a means to reach the data (‘state”).

“Completion”, because data-warehouse only point out the “GET” (or “R” in CRUD”) – via dimensions – users know dimensions.

REST now put all CRUD (“GET”, “POST”, “PUT”, “DELETE”) in the picture. The key is the idempotent feature: GET is automatically that way, DELETE and PUT also, but is tricky, POST you need to do something.

Note you may simply say REST (“resource”) is closer to “document” point of view, and SOAP is closer to “procedure” point of view. However, for most real programmers, “document” is nobody, nothing, null – it cannot invoke any associations and thinking! The only powerful concept here is “data”. We must understand that from a high level point of view, “data” and “document” are the same thing. SOAP wants to hide data; REST want to expose data. Note that the data is not tiny details, but things like “dimensions”!

This is consistent with other data-centric point of views: for high level analysis, talk data. Do not say users do not know data, they know, and data are all they really care!

Also, saying that you cannot create domain model by data model – again, antique OO crap. The opposite is true: the backbone of the domain model must be data model – if not, then, domain model is wrong.

2. Practice -- REST and client-server: REST makes things simpler for client (with JSON, even vb3 and javascript can do it!), but-and-so, it requires more from the servers (so, regular SOAP must be enhanced-i.e.-wrapped, to deal with issues like e.g. the idempotent issue. Note that if idempotent issue only happens if you think data.

3. Summary: Web Service is at higher level than facade. So, it cannot be procedural anymore, it must be resourceful or restful -- it must be like data warehouse's dimensional.

4. It is funny that CSLA has CRUD everywhere, yet most people cannot see that it begs for REST point of view (its mantra is so-called "a class is determined by its behavior" -- antique OO crap!). Also, it has cross-concern regularity everywhere, yet the most people cannot see (or do not want to mention) AOP! CSLA always surprises me.

5. Also, REST makes more sense to FIT – you shall pay attention to data! FIT is all about data, isn’t it?!

the open source way: there are many ways -- at least three -- to do it; be aware

2007-08-02T10:40:00.000-07:00

There is a minor issue with ext -- when turning the autosize on, it is slow when there are many -- e.g. > 10 -- columns. So, I will not turn it on. Not a big deal.

However, this reminded me a thing: even it is the best, ext is NOT the only one. Rico is good to get ideas, and YUI is good to get javascript engineering ideas and good documentation about it -- this is because YUI is from Yahoo, and only Yahoo knows how to do javascript engineering; this is especially true for ext, because ext grew out of YUI, so, all Yahoo doc applies to ext almost directly.

So, the following should always be there:

--------------
http://localhost/rico2/rico/examples/asp/ex8.asp
download it, on the example index.html,
and click the online http://dowdybrown.com/dbprod/rico2/examples/php/ex6.php

YUI and jackslocum's old posting when it is YUI-ext and other's posts, e.g.
http://www.rodrigodiniz.qsh.eu/YahooGrid.aspx

aptana is crap. Use vim or notepad2, before orcas

2007-08-01T19:50:00.000-07:00

Just to be fair, I have to tell the truth: aptana is crap, at least for now.

For now, use Vim (my choice), or, if you are not capable of using vim ;-), use notepad2.
When Orcas comes out, use it.

My guess aptana is targeting poor java programmers, or flash/air programmers: they do not have Oracas ;-)

a. Aptana cannot handle debugging -- you need firebug (or, script debugger if you really hate firefox AND yourself! -- but script debugger does work though, after you configure it right -- just weaker than firebug!).

b. Aptana cannot handle intellisense -- your need your brain for that.

c. Aptana cannot even handle block comment -- you need VS2005.

d. Aptaqn cannot even handle paring braces, brackets, parenthesis (very important for javascript), VS2005 cannot handle them either; but both vim and notepad2 can!

Note: when you do web or other server intensive development, it is very important that you MUST be able to use notepad(2) or vim to do development, at least once for a while (i.e., every time you need to introduce a new thing, set up new stuff, you MUST start from notepad, if you do not, it means you are just a VB6-like clicker, not a programmer), otherwise, you have no way to really understand things -- this is a good interview question for web developer: Do you use a notepad or notepad-like editor other than visual studio, how often? -- of course, most VB6-turned developers fail this question -- believe it or not, they are incapable of using notepad!

summary or simplification of javascript coding style

2007-08-01T14:05:00.000-07:00

http://javascript.crockford.com/code.html

summary or simplification of javascript coding style:

1. keys of keys:

a. declare variables in the beginning of the function (like old C style)
(i) this can be important to avoid confusion. Javascript variable has no block scope
---------however, I must add that this is a uphill battle with Java (and now some C# people who have really reinvented themselves from VB6 -- this is a very good interview question for C# people -- if they worked in C# for a while, then, they know; otherwise, they will still use VB6 style) guys. I myself cannot do it. So, I will not do it. I will keep it in mind, but I will do it java style (and modern C++ style also)-- i.e., when I use it, I declare it. I do not declare it before I use it. ---- this actually can help prevent from declaring a variable -- now, it is easy, I always var it; otherwise, I have to check whether I var-ed it or not in the beginning of the function.

b. First line does not start from a new line
(i) this is to avoid semicolon insertion
(ii) which can create the "return null problem" (return null when the value is not the same line with "return")

c.
update: I found another good one: always put "," at the beginning of the line for array elements. This way, you will not forget to add it or remove it when cut/paste. Forget removing ',' is especially bad, becuase firefox is fine, but IE will freak out -- long after you have done the coding!

2. Keys:

a. === and !==: use them most of the time, instead of == and != (also: use the old c trick, 3 === myVarv ------ update: forget about it; does not work! Also, it seems that it is not intuitive, against rule of literate programming. Further, the "===" has a strong psychological effect, you will not use "=" within if anymore! ---- also, within if etc, there should never be valid "=". All those can eliminate the problem -- hepefully).

(i) It is almost always better to use the === and !== operators. The == and != operators do type coercion. In particular, do not use == to compare against falsy values.
(ii) note: if you use ==, if one of them is a number, then, if the other is a string, the string will be changed to a number.

b. + sign as parseInt (+ is necessary because other wise it will be a string if one of them is string!)
total = subtotal + +myInput.value;
is better written as
total = subtotal + (+myInput.value);

3. You must do, but you will remember when you need them:

a. use object.hasOwnProperty(variable) to get the "true members"

for (variable in object) { if (object.hasOwnProperty(variable)) { statements; } }

b. "do" block: it needs ";" (unlike while or for)
(this is important only because we must not forget the ;
because inserting ; by compliler is bad thing -- see above return null issue)

do { statements; } while (condition);

c. "with Statement" -- never use it!

The with statement should not be used.
use a variable, and assign the namespace/class name to the variable:

var o = ooo.eee.oo.ah_ah.ting.tang.walla.walla;
o.bing = true;
o.bang = true;

4. Nice to do:

a. No m_ or _ etc. for private members
---- because javascript has no such concept.
---- sse the right provate mechanism, so that all are provate except the "returned".

b. Braces should be used around all statements as long as it is a compound statement, do not use the one-line version (i.e. no brace version), even for single statements, when they are part of a control structure, such as an if or for statement. This makes it easier to add statements without accidentally introducing bugs.

c. indent 4 spaces, do not use tab.

d. do not use "continue Statement" because it tends to obscure the control flow of the function.

official reasons for using ajax client model -- even in a MS shop

2007-08-01T13:06:00.000-07:00

Official reasons for using ajax client model -- even in a MS shop

1. sufficient: Orcas has superb support of javascript; so, soon javascript will be more important than C# !

2. necessary: We can wrap it in server side dlls (i.e. the “server side model”) – some people is doing that. However, whenever there is an even tiny issue, you have to jump many hoops to get there – and there are going to be many issues in the coming one or two years (early days for ajax-stage-2 – MS’s asp ajax and orcas marks the beginning of mass-and-better-ajax, hence, ajax-stage-2). So, for at least one or two years, the client side model is the less-pain approach

REST, JSON, SOAP, integration, and migration

2007-07-31T01:08:00.000-07:00

Rest, JSON, SOAP, integration, and migration

REST -- I read the paper. The real thing is what I already know, cgi is the best. Do not try to "improve" it, keep it simple; and make it simpler (not more complex!) by introducing some simple regularity.

XML is not the way to go. It is not simple; so, it must go! JSON is simple, so, it will stay.

With JSON, with simple http (based on tcp/ip) protocol support of get and post, with simple convention (e.g. everything goes into JSON, no need of separate parameters. Just one string for JSON), and JSON parsing (~100 lines simple code -- it can be done and is already done in any and every language easily), then, we have a distributed computing system!

As a result, I do not like SOAP. Yes, it can support JSON. However, you have to handle SOAP. Too complicated.

However, for political reasons, I have to use SOAP, sometimes.

So, I will use both. However, I will use asp's page to implement REST, and the primary work horse.

Direct reasons:

(a) It is much easier to handle the cross-domain thing. M$ insists on no-cross domain. The only way to support it is to use scripttag-callback. M$ web service does not support it.

(b) It also makes using Ext easier.

(c) I can use it in VB3 code (ya, go nuts!), after I use a plain dll that support http and cut/paste json code!!

All three examples shows that REST is so flexible, because it is so simple!!!

Note: cut/paste http calls and Json code is OK, it is not duplicate business logic. This is important, because the same mechanism is for VB6 -- by doing this, we can take out VB3/VB6 code piece by piece. Some people argue that for VB6, you should use a dll. That creates dll registering issue, and unnecessarily makes thing complicated. Non-business logic code duplication is fine. Give me a break -- we need to get things done, while remove old code -- this is the only way!

Long live Json+rest! Cgi forever -- my insight and experience from perl cgi and javascript more than ten years ago are still extremely relevant -- it is amazing, especially in Internet time.

Note that cgi philosophy is directly form unix philosophy: text based, small programs glued with scripting ...

thought leader: the reason why YUI is the best architected javascript

2007-07-24T22:03:00.000-07:00

It is because of this great man: http://www.crockford.com/

http://video.yahoo.com/video/play?vid=cccd4aa02a3993ab06e56af731346f78.1710507
http://video.yahoo.com/video/play?vid=cccd4aa02a3993ab06e56af731346f78.1027823
http://video.yahoo.com/video/play?vid=cccd4aa02a3993ab06e56af731346f78.992708
http://video.yahoo.com/video/play?vid=630959
http://video.yahoo.com/video/play?vid=cccd4aa02a3993ab06e56af731346f78.2006940
http://developer.yahoo.com/yui/theater/

If you do not read and watch those, you are not doing any serious javascript programming.
------------------------

I obviously underestimated YUI -- its good design is not from Java, but directly from Java's parents -- lisp and C++ communities.

He is obviously a thought leader!

I feel very good about the site, because it says there is only one javascript book, and that is the O'reilly definitive book -- and I read it many years ago, and I believed that that is the only good book for javascript!

Also, now I know, I can follow YUI, because the Java style is just a disguise, I trust YUI will use Ruby style, because crockford definitly knows the essence of Ruby.

http://javascript.crockford.com/tdop/tdop.html -- I do not believe Ruby has this! I would say, who needs Ruby, javascript is the coolest thing! -- at least its JSLINT part of it.

BTW, I am now using firefox as my everyday browser. When I do blog, it gives me spell checking. Very nice. Who needs M$! -- now, I understand the statement, M$ as we know it is already dead! its FUD has no use now. No real adventure investor needs to pay attention to M$ anymore. Ya, it still alive, just like IBM, who cares. M$ is quickly a IBM-2nd.

-------------he pays attention to details also:

All variables should be declared before used. JavaScript does not require this, but doing so makes the program easier to read and makes it easier to detect undeclared variables that may become implied globals.

The var statements should be the first statements in the function body.

It is preferred that each variable be given its own line and comment. They should be listed in alphabetical order.

    var currentEntry; // currently selected table entry
var level;        // indentation level
var size;         // size of table

JavaScript does not have block scope, so defining variables in blocks can confuse programmers who are experienced with other C family languages. Define all variables at the top of the function.

Use of global variables should be minimized. Implied global variables should never be used.

Using Extjs Grids; YUI: separation of UI and Entity/Facade by using JSON, separation of HTML, CSS, and Javascripts; JQuery: chaining sugar coating

2007-07-24T09:28:00.000-07:00

1. The three screencasts are the best (the screen is not clear, and seems that when I play them, they stopped about 80% -- enough though). You can download the source code for the 2nd and 3rd.

http://extjs.com/learn/Screencasts

2. only one written tutorial worth reading:

http://extjs.com/learn/Tutorial:Using_Ext_grid_form_dialog_to_achieve_paging_list%2C_create%2C_edit%2C_delete_function

3. The community is very active. It also has google search with it, very convenient.

At the bottom of the page: http://extjs.com/learn/

I used it to get the info for using it with asp.net ajax extension. Excellent.

4. The time on YUI is definitely worth it – it has similar style with YUI (it grew out of it, so no surprise there). Any deep (architecture ideas etc.) stuff, we need go back to YUI. Among all those javascripts, only YUI has an easy and yet very good structure (because of its java heritage, obviously---- what is it? ---- separation of UI and Entity/Facade by using JSON, separation of HTML, CSS, and Javascripts).
----(also because of its java heritage! -- the dark side of it!) YUI only misses the syntax sugar coating of chaining that JQuery does best; however, Ext has some of it.
----with aptana's intellisense, the long names are fine actually!

5. I am coding my code based on the three examples on 1 and 2 now. The fun begins ;-)

Dump Rico and prototype, use YUI and EXT

2007-07-23T11:39:00.001-07:00

Dump Rico and prototype, use YUI and EXT

Rico code base is bad.
Prototype is not as good as JQuery anyway; also, the coding style is really not that important – once you get the JQuery idea.

EXT roots from YUI, but now is independent lib. It has LGPL, which makes it OK for commercial uses. Also, EXT has JQuery style also.

So, the best way? EXT and YUI. Also, YUI can lead you to EXT via the YUI-EXT trail!

EXT has close relation with AIR, which is good for offline etc.

sites that help you to refresh css and html

2007-07-20T07:14:00.000-07:00

I am digging into the YUI and prototype-rico.
It is time to give html/css a systematic (re)treatment.
Here a site:

http://www.w3schools.com/css/showit.asp?filename=ex1

I know, there are so many there, and books. However, I do not believe we need books here. Come on, you are a programmer, and it is just html/css! Seriously, books are no good here for the following reasons:
(a) Most books on this are for dummies, or, for academics, either way, bad for programmers.
(b) Online resources are very good – inherently -- you can see it in action.

This site is good, because it is to-the-point (O'Reilly style, if you may).

Other sites (google css reference or css tutorial)

http://htmlhelp.com/reference/css/quick-tutorial.html
http://htmlhelp.com/reference/css/
http://www.css-ref.com/
http://www.html.net/tutorials/css/
http://www.westciv.com/style_master/academy/css_tutorial/

Stop investing the so-called server side model of Ajax -- when Orcas comes out, even dummies in asp.net world will use javascripts directly

2007-07-19T17:50:00.000-07:00

The title explains itself. We all believe that .net stretched VB6-ers. However, nobody notices that asp.net actually created a new low of M$ -- yes, it is even lower than VB6. Think about it, javascript is a designer’s language, now, it is treated as an assembly language.

You may say, GWT is the same thing. Yes, but that is different – it is direct, head on. The “server side ajax” model is not that – it is simply an even-lower-than-VB6 approach.

Again, you may say this is a FUD, or, reversed FUD (since it is used against M$!): do not invest in the server side model of Ajax, when Orcas comes out, you will be nobody other than a dummy-worse-than-vb6er.

a big mistake -- well, IMHO -- on YUI site

2007-07-19T14:47:00.000-07:00

On http://developer.yahoo.com/yui/, the "Getting Started" is really confusing.

However, after you download it, and set up the download as a local site, then, in the root index.html, there is this:

>>>>>Check out the examples of YUI in action. We recommend starting with the Event Utility and Dom Collection examples; Event and Dom provide an important foundation for JavaScript developers using YUI. Once you've reviewed those two foundational pieces, go on to explore utilities like Drag and Drop and Animation or UI controls like Button, Calendar and TabView. If you're interested in YUI's CSS components, read through the examples for Reset, Base, Fonts, and Grids in that order.

-----------IMHO, this is gold, why they do not use this in the top level "Getting Started"? ---- big mistake, I would say.

JSON and Oracle: who saide javascript is not typed?!

2007-07-18T21:20:00.000-07:00

For oracle, you only use four types: varchar2, number, char (because of the padding, it should only be used for "Y" and "N"), and date

JSON make it shorter: string (with""), number (no ""), false and true, no date!

For date, M$ has a cleaver convention: /\Date(12341324)\/ because \/ is not necesasry to escape \, so, it is used here to signal date!
Another way is to use military format (or other ISO format) 2007/07/18. The thing is, there is no way to signal that it is indeed a date, not an ordinary string field.

javascript IDE

2007-07-17T18:45:00.000-07:00

A logical step of pure ajax: it is time to get a javascript IDE

http://www.aptana.com/
firefox and firebug

Why? it is too awkward to do it in VS.

This is a huge step; but also anticipated: what good can come from M$?!

It has build-in support for all popular Ajax client side javascript frameworks!

Best of all, it is a java app!

By the way, I really enjoy prototype -- its Ruby influence (M$ try to make javascript like a C#, prototype makes it like a Ruby -- way to go!)

the real business: prototype+rico and Script.aculo.us+behavior+eventselectors

2007-07-15T17:31:00.000-07:00

dojo, prototype, Mochikit, Yahoo UI (YUI), or, my own 2K library (from my old O'reilly's javascript cookbook!) and plus web service.

Everything else, e.g., controls, server or client, are just so-called "convenience tools" -- actually, inconvenient tools – I am now even against http://dotnetslackers.com/articles/ajax/ASPNETAjaxGridAndPager.aspx

I know, in the past weeks, I stepped through many things, silverlight, spring.net, etc. Now, I am only for javascript + webservice + activeX for client-side-printing-serial-port-comm. I am against everything else, including asp.net per se -- who need asp.net anymore!

It does not make sense to use small ad hoc javascripts anymore. It is time to use javascript frameworks/libraries.

After reading http://www.sitepoint.com/article/javascript-library/2
and some research, prototype is the one, because I want some powerful yet simple (once I know the framework) grids!

Another reason: funny thing -- prototype is the ajax choice for Ruby on Rails -- we cannot avoid RR, it is everywhere!

http://www.brandonquintana.com/index.bcq?id=13&page=blog&title=prototype+behaviour+rico+and+scriptaculous

so, prototype+rico+Script.aculo.us+behavior+eventselectors, of course, we need to know how to make it work with the web service support from "asp.net ajax".

http://64bytes.com/archive/2007/05/10/ASP.NET-Web-services--AJAX--prototype.js.aspx -----
http://www.wtfdeveloper.com/Default13.aspx ----------------

http://www.sitepoint.com/article/painless-javascript-prototype/
http://www.prototypejs.org/
http://prototypedoc.com/
http://www.sergiopereira.com/articles/prototype.js.html#Reference

http://script.aculo.us/
http://openrico.org/downloads -----------------------
http://borkweb.com/story/prototype-makes-javascript-painless
http://borkweb.com/story/oooo-eventselectors-for-prototype
http://www.snook.ca/archives/javascript/prototype_disse/

------------------------prototype+rico is large. However, javascript can be cached and compressed. So, I do not believe it is a problem. If you are really concerned, use YUI (there is a new kid, JQuery, however, it does not have grid, you have to use ext; but ext has intentionally ambiguous license for commercial use for in-house development -- for web, in-house-intranet and internet is a thin line anyway).

-----------------------so, YUI is also a choice, worth to explore.

the bread and breath of Ajax -- when with asp.net, of course

2007-07-15T10:03:00.000-07:00

ScottGu's blog:

http://weblogs.asp.net/scottgu/archive/2007/07/04/july-4th-links-asp-net-asp-net-ajax-visual-studio-silverlight-and-iis7.aspx

It has link to this ---- this is a wonderful one -- if you use ajax, it is your bread and breath! Hey, this is not my idea, it is directly derived from ScottGu's!

http://dotnetslackers.com/articles/ajax/ASPNETAjaxGridAndPager.aspx

I wasted $40+ -- more about asp.net ajax books

2007-07-15T08:44:00.000-07:00

I wasted $40+

I am pragmatic, and I get into action immediately. However, deep in my brain, I am an holistic thinker/learner. As a result, I need books, I am a book worm.

I am a member of Safari. However, they do not have “professional asp.net 2.0 Ajax”. So, I went to Border, and bought one.

It is a waste – I guess, I can count that as a donation to Border – I go there a lot, but not buying enough.

The best: the online doc (and videos, from the official site and the “interface training”, and also, the ScottGu’s blog – he is the man!!, and the forum – however, I am talking about things close to a book, so, let’s be back to the books) – you definitely should not need other books.

However, if you like me, a book worm who cannot have a peace of mind without reading “real books”, then, get O’Reilly’s Programming ASP.NET AJAX.

I learn my lesson, again: you can use M$ technologies, but at least, get books from O’Reilly -- at least some of your book must be from O’Reilly: you need some fresh air!

The book is very good, very hand-on, and it has references of other O’Reilly books – only for this purpose, it is not waste – the online doc does not have that.

The only downside is, it is still a “rough cut”; so, if you are not a member of Safari, perhaps it is not for you yet; or, perhaps there is another way to get it.

I am not a sales person from O’Reilly! To prove it, I will make a complaint: for “rough cut”, you have to pay case by case, book by book (i.e., “rough cut” is not included in the monthly pay), which is fine and fair. As a result, you can get pdf file, instead of being forced to read it online.

Now, I just do not understand what hack it takes so long for them to generate a pdf file – even we assume that I am the first one to order it after it is updated and they do not have a cache. It has been a week now! Then, I tried to find an email address to complain, I cannot find one. I do not like it a single bit! Imperfect world.

silverlight or ScriptSharp, or both, or, just javascript

2007-07-14T13:28:00.000-07:00

The reason I like silverlight is to avoid entity logic (e.g. entity validation). However, it seems scriptsharp can do that also -- it is exactly what I wished about a year ago! Of course, I cannot take the credit at all; it is just very encouraging that you can wish, somebody will realize that for you ;-)

http://www.nikhilk.net/Project.ScriptSharp.aspx

of course, it is even before silverlight, so, I guess we do not have too much hope for that.

The pragmatic approach for me is: (a) No client side logic! Educate users, "deal with it!" (b) if users push back, for those minimum cases, translate C# into validator or directly javascripts.

Rick client? Ya, potentially, and case by case!

---- By the way, I recently found Google Web Toolkit (GWT) uses the same technique, but it is java, of course. However, there is no mentioning of GWT in ScriptSharp, as usual. It is a shame -- nothing new from M$ -- I thought it is too good to be true, some creative ideas from M$, ha!

"Server side Ajax" is just equivalent to dataset (or, stored procedure), they are all dirty words from M$

2007-07-09T17:36:00.000-07:00

I suddenly realize that Javascript is literally the java within M$. As a result, typical M$ developers are not good at it; and further, they are not prepared for it.

It is amazing. A few years ago, “do you do some javascript” is a tricky interview question – it is tricky, because if your answer is too good, then, you will not be recruited, because that means you are not a serious programmer, just a javascript web designer. Now, “do you do some javascript” is a real question, it points out whether the asp developer is just yet-another-VB-type, or, a serious programmer. If you know some javascript, it means you know some “low level stuff” – my goodness, asp turns javascript into low level stuff!!

Browsers are OS, ActiveX are device drivers, Javascript is perl: if you do not know javascript, you are nobody in web2 world.

Flash/flex proved that javascript is powerful. The server side approach of Asp Ajax tries to hid it; it is very bad. I hope the client side approach will take off soon. Client side Asp Ajax (i.e., “pure ajax”) plus silverlight – that is the way to go.

This leads to another issue. I believe some M$ people know this also. However, they always have some party line, saying "each way has its niche, bla bla", even some very smart people. So, it is very crucial you know that server side Ajax is just equivalent to dataset (or, stored procedure), they are all dirty words from M$.

javascript and aop, orcas

2007-07-07T17:03:00.001-07:00

http://calculist.blogspot.com/2005/07/aop-in-javascript.html

and:

http://weblogs.asp.net/scottgu/archive/2007/04/24/javascript-intellisense-in-visual-studio-orcas.aspx

Minimum for 8 techniques (i.e., totally bottom-up)

2007-07-06T21:29:00.000-07:00

Minimum for the 8 techniques (i.e., if/when it is really a small project)

1. Ad hoc ado wrapper: for logging database access
2. Just use trace or debug, not log4net
3. Just Façade: this is crucial for later anonymous delegate
4. Entity (no dataset): this is crucial.
5. Use "pure Ajax" or "native Ajax" (i.e., use webservice; the page is really just a skeleton -- note: this style makes wpf/silverlight and "native ajax" almost the same!)
---- It is not just web, it is web2!!!!!!!, it is RIA!!!!!
---- Ya, since silverlight is still alpha, most of the time, we cannot affort to go through silverlight-ajax-wpf cycles. Sometimes, I like Ajax more than Silverlight, because Ajax is closer to flash -- it is javascript based. Ya, the real difference between silverlight and ajax is C# and java ;-) –---------- OK, seriously, it is javascript replication of the C# entity classes. Now, it can do the data part automatically (databinding!); for logic (methods) we have to do it manually. As a result, before silverlight, we should keep the logic part minimum: let’s do most of the validation at the façade level, what the hack, users sometimes do not like validate two times, they want it one time! (if we do client side validation, we have to do it more than one time, because client side validation is inevitably not sufficient) – it is a trade-off for users also, why we make it more difficult than necessary!

6. Always very short eventhandlers
7. Standardize page flow calls
8. Wrap new and always virtual

-----------Update: you may say, not big deal. It is a big deal! Now, I cannot use the asp.net 2.0 build in objectdatasource anymore, because of “always new”!

the build-in objectdatasource is a typical M$ brain-dead joke and not really usable anyway, see:

http://vaultofthoughts.net/ObjectDataSourceAWorkingAlternative.aspx

-----------Just to clarify. It seems that we should not do build-in datdabinding for both WPF and ASP, we need to use databinding for silverlight and ajax.

silverlight databinding

2007-07-05T17:43:00.000-07:00

I googled "silverlight databinding", and I found those, amazing:

http://www.netcrucible.com/blog/2007/06/24/streamed-template-processing-for-data-binding-in-silverlight/

http://blogs.msdn.com/webnext/archive/2007/07/03/silverlight-data-binding-with-xml.aspx

three analysis questions and eight programming techniques

2007-07-04T14:23:00.001-07:00

OK, enough for technology craziness. My pragmatic attitude and “tearing things apart” attitude is taking over now. As I said, I want this blog to be an honest trace record of the journey. The reality is always a result of many forces.

I am backing off from spring-everywhere stand – however, I still believe it could be done; it is just not that, well, pragmatic, that it is everywhere and all the time. Because it could be done, so, from now on, spring will always be my “reference” architecture. ------ a second thought: other than the last one (all virtual), and the wrapping "new" is to prepare the wrapper for Castle or Spring.net, the whole thing is perfect for absorbing CSLA also -- each item can benefit from CSLA, especially I would like to see how CSLA deal with silverlight's databinding (or not, I've just found a link -- I will put it in my next blog). Ya, both CSLA and spring have validation. I know, I am riding the fence now. As I said, I like CSLA a lot -- once it is simplified.

The key for backing off the extreme stand is that it is not about whether it could be done or not, it is about ("cooperative" and "friendly") competition for delivering client-visible business values. Another way to put it, I see those “values” as territories. You must cover the territories as fast as you can. If you do not, somebody else will. Once you put it this way, it is really very clear that it is to both our clients’ and ourselves’ best interests to deliver business values, instead of “architectures”. This is XP tradition also, by the way.

Let’s be back to the reality; let’s reiterate the forest view, the big picture:

A. Process -- always ask three questions:

(1) Application level use cases (or, stories)
(2) Screen level use cases (or, stories)
(3) Ubiquitous glossary, i.e., data schema with example data. Note example data are crucial

B. Technology -- always pragmatic AOP. The bottom line is the AOP rule -- “separation of concerns” (you may say it is also an OOP rule; however, OOP never directly and intuitively says it; also, OOP cannot really do it anyway!). There are several core concerns (not surprisingly, they correspond to my “eight core techniques”; however, I “collapsed” the façade items, and “expanded” entity times – it is understandable, I am now paying more attention to fine-grained AOP – even now, in this blog, I am withdrawing a little bit from an extreme stand I posted in my previous blogs – I know, back and forth, it is me – I want to explore all the extremes), and we must always separate them. Before I list them, you may say that since fine-grained (i.e., entity property level) AOP is so powerful, we can do everything dynamically; why bother those static “separations”. The answer: (i) so that we do not need to use fine-grained AOP everywhere and all the time where/when it is not absolutely necessary; (ii) for fewer bugs. Bugs are done by human minds; human minds can deal with linear and static things with fewer bugs.

(1) adowrapper (can be simple and ad hoc ones, so that we can log data access easily)
(2) log4net logging (wrap it or not; not important; log4net is a small dll)

(3) façade
--Dao: it includes dao, i.e., a dao can be called directly as a façade; as long as more complex logic are in façades, there is no need to separate dao from façade – some may say that it is needed for transaction handling; but the system should be smart enough to figure that out
--command desing pattern: we could use command as façade. However, I tend to use anonymous delegate within façade; as a result, explicit command is not necessary.

(4) entity (M) -------I use MVPC -- I use both P and C: P is for fake C from M$ ;-)
--dataset: note that this entity is the real one, not dataset; actually, dataset should be forever forbidden, except in some extremely isolated, rare, and well-justifiable contexts).
--validation: a simple, almost “ad hoc” validation mechanism (ad hoc “framework”) can be used here.

(5) view (V) Always use silverlight.
--fallback to ajax. Silverlight is good because all entity logic can be done without tranlating into javascript, while for ajax, it is already a headache just for validation logic (only part of entity logic). ------need activeX-javascript to make ajax model closer to desktop's power.
--fallback to WPF when it is really necessary. ClickOnce is not enough. The so-called “30 min. download” is not as easy as it sounds. It is a huge technology tumbling stone. Do whatever is necessary to avoid fat clients. Period.

(6) presenter-in-view’s-code-behind
--databinding is good: it can be thinner with databinding;
--but more difficult: because entity is not dataset, so, databinding must be “custom-class databinding”;
--silverlight needs "manual" databinding: silverlight does not support it; we need to do it by ourselves -- http://www.lhotka.net/weblog/WindowsFormsDataBindingIssueConclusion.aspx , or/and, spring’s web databinding) ----------I've just found a blog, very nice one (see my next blog) (P)

(7) view flow: user control -- always to use user control to wrap the whole page, and a page is used only for flow; at least it should have a standard method call so that it can be easily searchable. (C).

(8) Unit testing everywhere all the time – OK, this is a lie (I am pragmatic; what I really care is that it is doable that it is everywhere and all the time -- as long as we put all logic outside UI, this is done automatically; however, I do not care about actually doing unit testing all the time – give me a break: if it is not likely that it will break, why bother, let QA department deal with it – I am busy to deliver business values!). However, I added one important thing that I obtained from recent technology craziness (the irony is that I put this in my blog long time ago, but I did not really do it systematically):

--Always wrap all “new”: no need for a full fledged abstract factory, just put all those ceateXXX in a class, all createXXX are static. We do not need to switch the kit at runtime. Compile time switching (for testing), we just switch the class. As a result, we can do this in a very simple and ad hoc style. Who said AOP is difficult? Who needs those abstract classes or interfaces! ------For added flexibility (“configure the class” based on where is it!), we want to enter calling class also. We do not enter method name and variable name, we could, but it is too much trouble, and who needs that kind of flexibility anyway (you rewrite the code!) Note that we add class name very easily, we need to do it anyway for logging! -----note that using this approach, we do not need to add the called class in the data member of the calling class. Spring encourages us to do that, so, let’s do it; it does not hurt anything.

--Always use “virtual”: for all methods/properties, unless you really know you want it non-virtual (just like in java, virtual is the default, unless you really need to mark it “final”)

The key of silverlight is to enable it to be able to use serial ports, using ActiveX

2007-07-03T23:42:00.000-07:00

The key of silverlight is to enable it to be able to use serial ports, using ActiveX.
Note that we also need it to work on ajax without silverlight.

spring has command pattern based aop also

2007-07-01T22:10:00.000-07:00

It is not easy to say it is a good thing or a bad thing, just a note here: spring.net’s DAO stuff is not emit-based (i.e., fine-grained) aop, it is not even IoC based. They are command pattern based.

It is good, because you have all the skill set in case you have to do aop without emit; it is bad, because it is not elegant – emit-aop can handle it much cleaner.

It is inherited from Java spring, which was pre-aop-is-in-age.

XML parsing code runtime step through

2007-07-01T10:53:00.000-07:00

We need to be serious about XML. It is part of the sql-code-xml triad.

To deal with XML, “compile time” validation is not enough. You need runtime step through: you need locate the XML parsing code, and when necessary, step through it.

For streaming style, search for XmlReader, reader.Read(),ReadStartElement, reader.NodeType, ReadInt16, ReadInt32, ReadDouble, ReadString, reader.AttributeCount, reader.GetAttribute, XmlNodeType.EntityReference, reader.ResolveEntity();,XmlNodeType.EndEntity, MoveToAttribute, MoveToFirstAttribute, and MoveToNextAttribute, MoveToElement MoveToContent, XmlTextReader, tr.Validation, ValidationEventHandler(ValidationCallback). Note that streaming is not SAX’s push, it is ADO-reader-like pull. The order of the pulling is depth-first (it makes sense; if it were width first, then it is more like XPath/DOM).

For XPath/DOM level, XmlDocument, .Load(, .Compile(, Select(, MoveToNextSelected, .CopySelected(,.Evaluate("sum(

Needless to say, it is important that you need to understand the mapping of the XML and C# code objects; the key is the naming convention.

Another way to start silverlight now

2007-06-30T20:02:00.001-07:00

Anotehr way to start silverlight now:

Port Silverlight to plain WPF when porting to ajax takes too long!
(see my previous blog)

Because it easier to develop WPF in VS 2005, so, in practice, it is more likely the following:
(a) Develop WPF with silverlight in mind (it is a learning curve, the first step is to avoid using build-in databinding and grid – I know, it is pain, but it is worth it!),
(b) Then, port the WPF to silverlight (takes some time),
(c) Then, port it back to WPF (a few minutes).

http://blogs.msdn.com/usisvde/archive/2007/05/16/porting-wpf-to-silverlight-1-1-1st-of-a-series.aspx

http://blogs.msdn.com/usisvde/archive/2007/05/19/porting-wpf-to-silverlight-1-1-2nd-of-a-series.aspx

http://blogs.msdn.com/usisvde/archive/2007/05/19/porting-wpf-to-silverlight-3rd-of-a-series.aspx

http://blogs.msdn.com/usisvde/archive/2007/05/20/porting-wpf-to-silverlight-4th-of-a-series.aspx

http://blogs.msdn.com/usisvde/archive/2007/05/22/porting-wpf-to-silverlight-5th-of-a-series.aspx

-----------------
http://blogs.msdn.com/ebooth/archive/2007/05/19/view-source-reflector-tool-for-net-silverlight-sites.aspx

-----------------
Why silverlight now? Now download of the runtime! So, first demo the silverelight, users will want it, and then, say, OK, either we use alpha version, or, we need to download the runtime.

-----------------
Finally we can do web with similar productivity and features as winform. Also, finally, we .Net developer can do Linux programming now … As a matter of fact, it is very likely that silverlight can be outside the browser, and it will take over Linux desktop very quickly – .Net will beat Java on Linux just like that!

Use silverlight1.1 as a prototype version for ajax

2007-06-30T17:15:00.000-07:00

Use silverlight1.1 as a prototype version for ajax

I cannot wait for using silverlight, a way to use silverlight1.1 now is to use it as a prototype tool for ajax, because silverlight can be faster to development, because all validation is in C#.

It is true that silverlight controls are still primitive; however, prototype does not need to be that fancy.

In fact, the core of silverlight is very mature (it is .Net 3.0!); so, it is NOT like other alpha stuff. As a result, if it acceptable (big if, of course), we can borrow the “internet tradition”, use alpha in production! At least, when it is beta, we definitely can use it in production.

I bet this will be a strategic technique for all “progressive” or “cutting edge” shops or development teams.

----On the one hand, I bet this will be a strategic technique for all “progressive” or “cutting edge” shops or development teams.

----On the other hand, I believe not that many teams can use this technique. For two reasons: (a) most winform based teams are not “progressive”, they are basically still in VB6 world; (b) most web teams are still busy with Ajax, they already accepted that fact that they have to duplicate validation-entity logic in javascript -- I always hear that life is not perfect, just deal with it. To come up with this simple technique, you must do both winform and web, and refuse to compartmentalize them and refuse to accept the “fact’ – the everlasting truth of AOP is more powerful than the ugly, temporary “fact”.

A note: as I indicated in my previous blog, silverlight is in the sandbox, so, we must use javascript and very-thin-activeX-communication-ports to glue things together. Right, life is not perfect, after all.

You may say, why not WPF? Downloads – it is not just downloads; it means all those bureaucratic processes. Note that it is not just 3.0; 3.5 is coming; and who knows what is after that! I want to be always on the cutting-edge, automatically – the key word is “automatically”: I just begin to use the new technology, no paperwork is needed, no manager talk is needed -- even I love our managers!

I want to emphasize it again, it is crucial that it is a “automatic” process. Even it is “just” a little bit “manual”, then, the spirit of internet “continuous beta forever” (i.e., “continuous innovation forever”!) is gone forever. You cannot blame managers – in a sense, sometimes it is part of managers’ job to cool things down …

Is Spring.net too complex for small projects?

2007-06-30T13:03:00.000-07:00

Is Spring.net too complex for small projects?

My answer is: No! It is good for every project.

(a) On the one hand, “small projects” are not THAT innocent at all! Any small projects are part of bigger system. To be a good citizen, you got to be reliable for those “cross-cut concerns”, and to be reliable means you got to do it AOP way – everybody makes mistakes, doing it manually is simply not acceptable!
(b) On the other hand, Spring.net is not THAT complex at all. Yes, its concepts are counter-intuitive for beginners. That is especially true because even the inventors do not really know how to categorize its essence (OK, here is the shameless self-promotion: that is why my blog is valuable – I know its essence – it is AOP, not IoC. IoC really is just a simple technique to centralize all those factories for AOP -- yes, by categorizing it this way, it means you always, at least potentially, want to use AOP everywhere – which is indeed very true!). However, the code is really lightweight. A decently experienced programmer can maintain it for sure – I am not crazy, I am serious and telling the truth, notice that I am saying “maintain”, not “develop it from scratch” (the reason? Because spring.net is designed this way; it is a beauty; a beauty is always easy to maintain!). Also, I do not want to warrantee that for Nhibernate – so, ya, you could say Nhibernate is a potential maintenance risk, and I would agree to a certain degree (but if it is extremely popular, and it is easy to switch to another package, then, I would say that the potential risk is limited, and it is worth it – it is – then, we should do it). However, the point here is that for Nhibernate, it is an argument about quantity; for spring.net, it is an argument about quality – there is absolutely no risk at all. The key is, of course, to understand AOP; once you understand AOP and accept it as the new pivotal concept of the new paradigm (ya, I know, it sounds like converting to a cult; but it is actually converting to the beginning of a new mainstream), you will see how simple, easy, elegant, and beautiful spring.net is. I am regret that I did not get that a while ago, because I dislike XML, until asp 2.0 makes me -- with harsh force -- to get used to it – sometimes being too pragmatic is not good, you got to have an open and soft mind, to give something beautiful a chance to steal your heart. I know it is still not too late – partially because I have a relatively open mind  but lesson learned, I will be more open-minded in the future … wait, with one exception, not to M$ -- I am too gullible to their propaganda! I know I may miss something beautiful from M$ -- sigh, not easy to do … “experiences” or “bias”, it is a fine line …