download here
Wed Jun 25 09:59:02 HKT 2008
From /weblog/design/exception
Other than harder to read, this approach is easier to have side effect, consider the following case:
// Code which fail
public String service() {
try {
// a lot of other code....
return getRecord();
} catch (SQLException re) {
return "defaultRecord";
}
}
private String getRecord() throws SQLException {
PreparedStatement ps = getConnection().prepareStatement("select something from sometable");
try {
final ResultSet rs = ps.executeQuery();
try {
if (rs.next())
return rs.getString(1);
else
throw new NotFoundException();
} finally {
rs.close();
}
} finally {
ps.close();
}
// definition of NotFoundException, analog to IOException and FileNotFoundException
public final class NotFoundException extends SQLException {....}
The idea is, for any database problem, just return default value. However, if someone change the interface of NotFoundException to public final class NotFoundException extends RuntimeException {....} Then it break service() silencely :-/ Some to it is better to have
// Code which fail
public String service() {
try {
// a lot of other code....
return getRecord() == null ? "defaultRecord" : getRecord();
} catch (SQLException re) {
// proper exception handling
}
}
private String getRecord() throws SQLException {
PreparedStatement ps = getConnection().prepareStatement("select something from sometable");
try {
final ResultSet rs = ps.executeQuery();
try {
if (rs.next())
return rs.getString(1);
else
return null;
} finally {
rs.close();
}
} finally {
ps.close();
}
(google search)
(amazon search)
Mon Jun 16 02:16:12 HKT 2008
From /weblog/design
There are two key primary ways of scaling web applications which is in practice today. 1) “Vertical Scalability” - Adding resource within the same logical unit to increase capacity. An example of this would be to add CPUs to an existing server, or expanding storage by adding hard drive on an existing RAID/SAN storage. 2) “Horizontal Scalability” - Adding multiple logical units of resources and making them work as a single unit. Most clustering solutions, distributed file systems, load-balancers help you with horizontal scalability. Scalability can be further sub-classified based on the “scalability factor”. 1) If the scalability factor stays constant as you scale. This is called “linear scalability“. 2) But chances are that some components may not scale as well as others. A scalability factor below 1.0 is called “sub-linear scalability“. 3) Though rare, its possible to get better performance (scalability factor) just by adding more components (i/o across multiple disk spindles in a RAID gets better with more spindles). This is called “supra-linear scalability“. 4) If the application is not designed for scalability, its possible that things can actually get worse as it scales. This is called “negative scalability“. http://www.royans.net/arch/2007/09/22/what-is-scalability/ Report of building web application with 55k pageload with rail - http://shanti.railsblog.com[..]mongrels-handled-a-550k-pageview-digging XMPP a IM protocol about scalability - http://www.process-one.net[..]icle/the_aol_xmpp_scalability_challenge/ Excellent presentation and resources of making you website more scalable - http://www.scribd.com[..]9/Real-World-Web-Performance-Scalability
(google search)
(amazon search)
Sun Jun 01 23:43:50 HKT 2008
From /weblog/design/security
Discussion of crack protection - http://discuss.joelonsoftware.com/default.asp?design.4.579670 http://www.focusoncode.com/exe-packers-crypters-and-compressors/ , introduce tools - http://www.pelock.com/ Ten Immutable Laws of Security Law #1: If a bad guy can persuade you to run his program on your computer, it's not your computer anymore Law #2: If a bad guy can alter the operating system on your computer, it's not your computer anymore Law #3: If a bad guy has unrestricted physical access to your computer, it's not your computer anymore Law #4: If you allow a bad guy to upload programs to your website, it's not your website any more Law #5: Weak passwords trump strong security Law #6: A computer is only as secure as the administrator is trustworthy Law #7: Encrypted data is only as secure as the decryption key Law #8: An out of date virus scanner is only marginally better than no virus scanner at all Law #9: Absolute anonymity isn't practical, in real life or on the Web Law #10: Technology is not a panacea http://www.microsoft.com[..]s/security/essays/10imlaws.mspx?mfr=true
(google search)
(amazon search)
Wed May 28 17:47:28 HKT 2008
From /weblog/design
A paper show the evolution of a DSL - http://www.mockobjects.com/files/evolving_an_edsl.ooplsa2006.pdf A stock trading order example of DSL - http://debasishg.blogspot.com[..]05/designing-internal-dsls-in-scala.html What is the difference between API / DSL if we don't write a parser for our language? From Martin Fowler's blog - http://martinfowler.com/bliki/DslReadings.html , it is mentioned: Piers Cawley makes the point that a key characteristic of DSLs is their narrow focus on a domain. I think this is a very good summary, usually if most of the APIs are getXXX() , setXXX(), loadXXX() , createXXX() ........ Then we mostly design APIs that expose low level detail to the API user to work on, which, is work but user probably work nicer if we can come up with language like API that allow users to do their work in more descriptive level. I think if API design like that usually it will reduce the code duplication, what ever real duplication or conceptual duplication. It probably already apply "Tell, don't ask" style - http://c2.com/cgi/wiki?TellDontAsk A discussion about applying "Tell, don't ask" which lead to message passing architecture - http://beautifulcode.oreillynet.com[..]07/10/do_messages_want_to_be_asynchr.php One good sample with explaination - http://hamletdarcy.blogspot.com[..]-it-really-domain-specific-language.html http://nat.truemesh.com/archives/000727.html Few links - http://dreamhead.blogbus.com/logs/17667876.html
(google search)
(amazon search)
Sat May 24 15:35:35 HKT 2008
From /weblog/design
Discussion of style of writing code, like always have valuable for return value, and use return for parameter check - http://www.beust.com/weblog/archives/000308.html
(google search)
(amazon search)
Sat May 24 15:30:34 HKT 2008
From /weblog/design
Contain discuss about if value object should be immutable or it is still ok - http://c2.com/cgi/wiki?ValueObject
(google search)
(amazon search)
Fri May 23 18:44:43 HKT 2008
From /weblog/design/concurrency
10-ways-to-reduce-lock-contention-in-threaded-programs - http://www.thinkingparallel.com[..]ce-lock-contention-in-threaded-programs/ Discussion about lock the form and prevent 2 user edit it in the same time and currupt the object, what is the possible drawback. - http://www.dcmanges.com[..]-optimistic-locking-isnt-a-silver-bullet
(google search)
(amazon search)
Tue May 06 14:25:04 HKT 2008
From /weblog/design/interview
Donald Knuth on Multi-Core, Unit Testing, Literate Programming, and XP:
I also must confess to a strong bias against the fashion for reusable code. To me, "re-editable code" is much, much better than an untouchable black box or toolkit. I could go on and on about this. If you’re totally convinced that reusable code is wonderful, I probably won’t be able to sway you anyway, but you’ll never convince me that reusable code isn’t mostly a menace...
http://www.artima.com/forums/flat.jsp?forum=276&thread=229705
(google search)
(amazon search)
Tue Apr 29 01:46:55 HKT 2008
From /weblog/design/interview
Nice message cover DSL, IDE, multiple dispatch, message passing, and more http://msdn2.microsoft.com/en-us/magazine/cc500572.aspx
(google search)
(amazon search)
Sun Apr 06 01:23:28 HKT 2008
From /weblog/design
Date handling look simple but easy to fail in trap. Even worst is this is easy to have bad data which hard to fix. Here is an example - http://blogs.msdn.com/jensenh/archive/2005/11/23/496246.aspx One tip for testing application with time dependence, treat it as random - http://googletesting.blogspot.com[..]pot.com/2008/04/tott-time-is-random.html
(google search)
(amazon search)
Mon Mar 31 01:09:56 HKT 2008
From /weblog/design
A very nice blog that discuss why is Distributed so Hard: In one sentence, here's why: humans are notoriously bad at keeping "self" distinct from "other". Egomania, projection (transference), and enmeshment are well-known symptoms of this problem. OK, so I hear you saying, "yeah, but what does this have to do with programming?" It certainly seems absurd to suggest that if we are bad at something we know the most about (our "selves"), how could we possibly say that we have a good approach for the programming analogues - objects, modules, etc. http://www.artima.com/weblogs/viewpost.jsp?thread=46706 An paper introduct why space base design is better than n-tier design - http://www.google.com[..]0The%20End%20of%20Tier-based%20Computing Some key research of google for distributed computation - http://www.infoq.com/news/2007/06/google-scalability Someone think we are not yet (per Oct 2007) have good language support for distibuted computing - http://kasparov.skife.org/blog/2007/10/11/ A blog contain a lot distributed computing information - http://www.highscalability.com/ How Wikipedia manage their site - http://dammit.lt/uc/workbook2007.pdf Google tutorial for Design Distributed System - http://code.google.com/edu/parallel/dsd-tutorial.html http://en.wikipedia.org/wiki/Distributed_hash_table
(google search)
(amazon search)
Thu Mar 27 11:29:05 HKT 2008
From /weblog/design
"A similar pattern is that with objects that you need to open before usage and make sure that they are closed on usage completion." http://digerati-illuminatus.blogspot.com[..]2/initialize-pattern-and-open-close.html Discussion of various approach that implement immutable class - http://discuss.joelonsoftware.com/default.asp?design.4.601499
(google search)
(amazon search)
Tue Mar 18 01:25:25 HKT 2008
From /weblog/design
Nice suggestions, I think this can apply to most search function Don’t tell me everything you know - limit to specific set of datas , like ameture / professional Ask me the next most reasonable question Offer me to establish my search identity http://jooto.com[..]008/01/05/how-to-improve-search-engines/
(google search)
(amazon search)
Tue Mar 18 01:25:24 HKT 2008
From /weblog/design/exception
To prevent no one notice there is problem What the code is trying to do is make sure is that any exception thrown is brought to the attention of the user. I’ve been looking at a few approaches to help catch and handle these exceptions without the developer having to explicitly catch them at the UI level. You can create your own EventQueue, and have it catch uncaught exceptions when dispatching methods http://www.magpiebrain.com[..]2004/07/21/catching-uncaught-exceptions/
(google search)
(amazon search)
Wed Jan 30 11:05:55 HKT 2008
From /weblog/design
Writing shy code is just a small start at preventing the introduction of bugs, but it really helps. Just as in the real world, good fences make good neighbor - as long as you don't peek through them. http://www.computer.org/software/homepage/2003/s1const.htm http://www.pragmaticprogrammer.com/ppllc/papers/1998_05.html Other than that, there is also security risk if you show too much to other - http://www.indicthreads.com[..]_or_objects_java_security_problem_1.html An example of why passing Map around is wrong and show solution of that example - http://antagonisticpleiotropy.blogspot.com[..]spot.com/2008/01/hashmap-temptation.html
(google search)
(amazon search)
Mon Jan 28 14:50:51 HKT 2008
From /weblog/design/pattern
Suggest use to take a fresh look of original "pattern language" - http://perl.plover.com/yak/design/ , in his opinions, it is more about separate design to difference groups than create reusable design. Some more... http://www.relevancellc.com[..]007/5/17/design-patterns-are-code-smells http://www.codinghorror.com/blog/archives/000899.html Some say pattern should be language feature ... http://www.codinghorror.com/blog/archives/000308.html Closely related, there are no golden rules and silver bullet, Design Pattern can help us in some design problem and provide some design suggestion. However, we need to know what it good for and bad for http://jchyip.blogspot.com/2008/01/gefn.html http://jchyip.blogspot.com[..]est-practice-vs-pattern-vs-standard.html http://jchyip.blogspot.com[..]ndard-approach-does-not-necessarily.html
(google search)
(amazon search)
|