bestpractices

09 Dec 09

2. Do batch update

You can send multiple queries to the database at a time using batch update

feature of statement objects this reduces the number of JDBC calls and improves

performance. Here is an example of how you can do batch update,

statement.addBatch( "sql query1");

statement.addBatch(" sql query2");

statement.addBatch(" sql query3");

statement.executeBatch();

All three types of statements have these methods to do batch update.

Paste number 91726: Laziness examples

paste.lisp.org/91726 - Preview

laziness clojure example bestpractices

30 Nov 09

The Programmer's Paradox: Spaghetti Code

theprogrammersparadox.blogspot.com/...spaghetti-code.html - Preview

programming bestpractices kiss tdd analysis

4. Fixing one bug creates several more.
Fundamental Laws of Spaghetti Code:

1. You can't understand it just by looking at it.

2. Repetitive code will always fall out of synchronization.

3. The work will always gets harder and slower as it progresses.

4. Fixing one bug creates several more.

5. You can't enhance the code if you are spending all of your time fixing the bugs.
24 more annotations...
- You can't understand it just by looking at it.
- 4. Fixing one bug creates several more.
- 4. Fixing one bug creates several more.
- If we are interested in a a reasonable definition for spaghetti code, it would have to be any code were the internal structure is way more complex than necessary. Where the complexity of the code
- It's not the syntax itself, but what it obscures from the processing that matters.
- That is, if you hide the "right stuff" (coming up from a lower level), then the code appears far more readable. If you hide the "wrong stuff", then it becomes impossible to tell exactly what is going on with the code.
- The last thing programs need is unnecessary complexity.
- I'm not sure that's an entirely correct statement. It's more like: if you're skilled, and you should be able to understand it, but you don't then it is probably over-complicated.
- THE PERILS OF DUPLICATION
  
  2. Repetitive code will always fall out of synchronization.
- . When we do this, it increases the probability that some future set of changes will cause a bug because two different "sources" of the same information that are no longer the same.
- 3. The work will always get harder and slower as it progresses.
- What's really funny is how many excuses people will make for not cleaning up the code.
- "history"
- "backwards-compatibility"
- Anytime a group of programmers generates more bugs then they fix, it is either because they don't have the necessary experience to understand and fix the code, or that the code itself is hopelessly scrambled.
- They just move the bugs around the system.
- The single biggest issue with code is time.
- it is always so hard to hear programmers making excuses about how they don't have enough time to fix something
- Unit tests are just more code in the system that are going to be wrong, need fixing, must be updated, and take time.
- recovering time lost to maintaining spaghetti code should be the first priority of any development project.
- It's a critically bad mistake to not fix code early on
- I do think it is actually easier for programmers to build over-complicated code, than it is for them to build simple and elegant code.
- Programmers have big egos, and they like to work on the hard projects. So, even if their task isn't particularly hard, they'll do everything in their power to make it as difficult and hard as possible. It's a common weakness.
- They are instead the ones that make all of their solutions look as simple and trivial as possible.

23 Nov 09

Richard Dingwall » The trouble with soft delete

richarddingwall.name/...the-trouble-with-soft-delete - Preview

database softd delete bestpractices data business

First is the standard deleted flag to indicate an item should be ignored:
nother style uses meaningful status codes:
20 more annotations...
- a fixed lifetime that starts and ends at a specific time (it might not have started yet):
- soft delete columns are easy to implement, but incur a cost to query complexity and database performance later down the track.
- It’s like a tax; a mandatory WHERE clause to ensure you don’t return any deleted rows.
- It’s very simple to do, but if you forget to do it in even one place, bugs can creep in very fast.
- I’ve found that most RDBMSs are actually pretty good at recognizing soft delete columns (probably because they are so commonly used) and does a good job at optimizing queries that use them
- It has around five million rows in total, but of that, only a very small percentage (2%) are still active and interesting to the application. The rest are all historical;
- the reasons why you might want to implement soft deletes in a database.
- To provide an ‘undelete’ feature.
  Auditing.
  For soft create.
  To keep historical items.
- two styles
- There is an undelete feature available somewhere in the UI, or
  Undelete requires running commands directly against the database.
- If there is an undo delete button available somewhere for users, then it is an important use case that needs to be factored into your code.
- you can just get them from the previous night’s backup.
- to keep a record of when an item was deleted, and who deleted it
- One possible conclusion from this thought is that you simply log all DML operations on the table. You can do this pretty easily with triggers
- The soft delete pattern can also be extended for item activation — instead of simply creating an item as part of the active set, you create it in an inactive state and flick a switch or set a date for when it should become active.
- We need to keep this data somewhere, but it’s no longer immediately interesting to the application because either
- haven’t included deleted items here because there are very few cases I can think of in business applications where data is simply deleted (unless it was entered in error) — usually it is just transformed from one state to another. Udi Dahan explains this well in his article Don’t Delete — Just’ Don’t:
  
  Orders aren’t deleted – they’re cancelled. There may also be fees incurred if the order is canceled too late.
  Employees aren’t deleted – they’re fired (or possibly retired). A compensation package often needs to be handled.
  
  Jobs aren’t deleted – they’re filled (or their requisition is revoked).
- instead of lumping differently-used sets of items together in one huge table with a flag or status code as a discriminator, consider splitting them up into separate tables.
- these guidelines
- Primary transactional tables should only contain data that is valid and active right now.
  Do you really need to be able to undo deletes? If so, there are dedicated patterns to handle this.
  Audit logging at the row level sucks. Do it higher up where you know the full story.
  If a row doesn’t apply yet, put it in a queue until it does.
  Physically separate items in different states based on their query usage.

22 Nov 09

TDD is not about testing!!! | Making Good Software

www.makinggoodsoftware.com/...tdd-is-not-about-testing - Preview

tdd testing principles bestpractices

TDD as invented by Kent Beck, (who also invented Xtreme programming and Junit),
TDD is a design practice, is more related with emergent design than with testing. TDD is pointless if it is not combined with other agile engineering practices, as pair programming, or agile philosophies as YAGNI and KISS, in TDD having a large set of tests is a nice side effect, not just its purpose.
1 more annotations...
- next time you say you are doing TDD make sure you don’t mean that you are doing test first development.

15 Nov 09

Google Closure: How not to write JavaScript

www.sitepoint.com/...re-how-not-to-write-javascript - Preview

google closure jquery comparation programming library criticism bestpractices

“It’s a JavaScript library written by Java developers who clearly don’t
get JavaScript.”
var a = "I am a string!";

2
alert(typeof a); // Will output "string"

3
var b = new String("I am also a string!");

4
alert(typeof b); // Will output "object"
1 more annotations...
- Unfortunately, unlike the built-in properties supplied by
  Object.prototype, custom properties added to
  Object.prototype will show up as an object property in any
  for-in loop in the page.

14 Nov 09

Elegant Code » Tips for ORM Data Access

elegantcode.com/...tips-for-orm-data-access - Preview

orm data access bestpractices tips

11 Nov 09

What DNS Is Not - ACM Queue

What DNS is not is a mapping service or a mechanism for delivering policy-based information. DNS was designed to express facts, not policies. Because it works so well and is ubiquitous, however, it's all too common for entrepreneurs to see it as a greenfield opportunity. Those of us who work to implement, enhance, and deploy DNS and to keep the global system of name servers operating will continue to find ways to keep the thing alive even with all these innovators taking their little bites out of it.

queue.acm.org/detail.cfm - Preview

sys dns bestpractices net

30 Oct 09

12 Tips to improve your jQuery code | Geekology

www.geekology.co.za/...-tips-improve-your-jquery-code - Preview

jquery bestpractices tips javascript

DOM manipulation is one of the slowest operations JavaScript (and hence, jQuery) can perform.
Use IDs instead of classes in selectors
3 more annotations...
- When you need to perform multiple methods on elements, jQuery can chain those methods together.
- 11. Use jQuery’s noConflict() method to rename the jQuery object when working with multiple frameworks:
  
  Many JavaScript frameworks use the “$” symbol to reference the framework. If you use multiple frameworks in your project, use the jQuery.noConflict() method to release the “$” object and assign jQuery to a custom-named object:
- 12. Use shorthand for the $(document).ready() event:

26 Oct 09

Validity of development tactics - Invisible to the eye

giorgiosironi.blogspot.com/...ty-of-development-tactics.html - Preview

programming analysis bestpractices

24 Oct 09

Wise programming techniques for writing quality code - Developer Art

developerart.com/...iques-for-writing-quality-code - Preview

programming bestpractices

8 Signs your code sucks | Turnleaf Design

www.turnleafdesign.com/?p=246 - Preview

programming bestpractices

13 Oct 09

El secreto del éxito | K-Government

www.k-government.com/...el_secreto_del_xito - Preview

software analysis programming bestpractices

os mejores resultados se han dado en los proyectos de tamaño y complejidad mediana.
siendo los más pequeños los más satisfactorios. De hecho, y perdonan la inmodestia, todos los proyectos que he realizado yo solo (y no todos eran necesariamente pequeños) han sido coronados por el éxito.
2 more annotations...
- Si en el equipo de trabajo abundaba el personal funcionario, el fracaso estaba asegurado.
- Pero sobre todo y principal, evitad todo tipo de relación con la Administración pública y no cobréis ni un euro por el trabajo realizado.”

09 Oct 09

6 Advanced JavaScript Techniques You Should Know

//2. Object Literals to Pass Optional Arguments
function showStatistics(args) {
document.write("Name: " + args.name + " ");
document.write("Team: " + args.team + " ");
if (typeof args.position === "string") {
document.write("Position: " + args.position + " ");
}
if (typeof args.average === "number") {
document.write("Average: " + args.average + " ");
}
if (typeof args.homeruns === "number") {
document.write("Home Runs: " + args.homeruns + " ");
}
if (typeof args.rbi === "number") {
document.write("Runs Batted In: " + args.rbi + "");
}
}

showStatistics({
name: "Mark Teixeira"
});

showStatistics({
name: "Mark Teixeira",
team: "New York Yankees"
});

showStatistics({
name: "Mark Teixeira",
team: "New York Yankees",
position: "1st Base",
average: .284,
homeruns: 32,
rbi: 101
});
//Using Namespaces to Prevent Conflicts
if (typeof MY == "undefined") {
MY = new Object();
MY.CUSTOM = new Object();
}

MY.CUSTOM.namespace = function() {
function showStatistics(args) {
..................
}
showStatistics({
name: "Mark Teixeira",
team: "New York Yankees",
position: "1st Base",
average: .284,
homeruns: 32,
rbi: 101
});
}
MY.CUSTOM.namespace();

sixrevisions.com/...ipt-techniques-you-should-know - Preview

javascript tips bestpractices code snippets

function showStatistics(args) {
document.write("Name: " + args.name + " ");
document.write("Team: " + args.team + " ");
if (typeof args.position === "string") {
document.write("Position: " + args.position + " ");
}
if (typeof args.average === "number") {
document.write("Average: " + args.average + " ");
}
if (typeof args.homeruns === "number") {
document.write("Home Runs: " + args.homeruns + " ");
}
if (typeof args.rbi === "number") {
document.write("Runs Batted In: " + args.rbi + "");
}
}

showStatistics({
name: "Mark Teixeira"
});

showStatistics({
name: "Mark Teixeira",
team: "New York Yankees"
});

showStatistics({
name: "Mark Teixeira",
team: "New York Yankees",
position: "1st Base",
average: .284,
homeruns: 32,
rbi: 101
});
Object-oriented JavaScript implements namespace-like principles due to the fact that properties and methods are declared inside of objects, thus there are less likely to be conflicts. A conflict could arise, however, through object names. And very likely, the conflict will occur "silently", thus you may not be alerted to the issue immediately.
2 more annotations...
- if (typeof MY == "undefined") {
 MY = new Object();
 MY.CUSTOM = new Object();
 }
 
 MY.CUSTOM.namespace = function() {
 function showStatistics(args) {
 document.write("Name: " + args.name + " ");
 document.write("Team: " + args.team + " ");
 if (typeof args.position === "string") {
 document.write("Position: " + args.position + " ");
 }
 if (typeof args.average === "number") {
 document.write("Average: " + args.average + " ");
 }
 if (typeof args.homeruns === "number") {
 document.write("Home Runs: " + args.homeruns + " ");
 }
 if (typeof args.rbi === "number") {
 document.write("Runs Batted In: " + args.rbi + "");
 }
 }
 
 showStatistics({
 name: "Mark Teixeira",
 team: "New York Yankees",
 position: "1st Base",
 average: .284,
 homeruns: 32,
 rbi: 101
 });
 }
 MY.CUSTOM.namespace();
- Rendering Readable HTML