text:
Writing Adolescent Fiction/Character names/Boys

Organization note
This list of general boys' names is divided into three tiers. In the first tier are the top 236 names among boys of high school age in the past few decades. In the second tier are other names you might run into more than once in your lifetime. Unusual names go into the third tier. Before adding a name, please check all three tiers to make sure it is not already on the list. If the name you are adding is an uncommon ethnic name, you might consider adding it to one of the other lists at Character names instead.

 * 1) Aaron
 * 2) Abdul
 * 3) Adam
 * 4) Amden
 * 5) Adrian/Adrien
 * 6) Aidan/Aiden
 * 7) Ajay
 * 8) Alan/Allan/Allen
 * 9) Alessandro
 * 10) Alexander/Alex/Sandy/Alec
 * Ali
 * 1) Andre
 * 2) Andrew/Andy/Drew
 * 3) Angel
 * 4) Angelo
 * 5) Arjun
 * 6) Arthur/Art
 * 7) Axel
 * Ash
 * 1) Ashton
 * 2) Ashley
 * 3) Barrett
 * 4) Bernard/Barry
 * 5) Beau/Bo
 * 6) Benjamin/Ben/Benji
 * 7) Blake
 * 8) Brad/Bradley
 * 9) Brandon
 * 10) Brendan
 * 11) Brent
 * 12) Brett/Bret
 * 13) Brian/Bryan
 * 14) Bruce
 * 15) Bryce
 * 16) Byron
 * 17) Caleb
 * 18) Cameron
 * 19) Carlos
 * 20) Carlton
 * 21) Carson
 * 22) Casey
 * 23) Chad
 * 24) Charles/Charlie/Chuck
 * 25) Chase
 * 26) Christian/Chris
 * 27) Christopher/Chris/Kris/Topher/Kit
 * 28) Clayton/Clay
 * 29) Clifford/Cliff
 * 30) Cody
 * 31) Cole
 * 32) Colin
 * 33) Colton
 * 34) Connor
 * 35) Corey/Cory
 * 36) Craig
 * 37) Curtis/Kurt
 * 38) Cyrus
 * 39) Dakota
 * 40) Dale
 * 41) Damian/Damien/Damion
 * 42) Daniel/Dan/Danny
 * 43) Darren
 * 44) Darryl
 * 45) Darnell
 * 46) David/Dave/Davy
 * 47) Davis
 * 48) Dean
 * 49) Dennis
 * 50) Derek
 * 51) Desmond
 * 52) Devon/Devin
 * 53) Diego
 * 54) Dick
 * 55) Dominic/Dom
 * 56) Donald/Don/Donnie
 * 57) Douglas/Doug
 * 58) Duane/Dwayne
 * 59) Dustin
 * 60) Dylan
 * 61) Edward/Ed
 * Eli
 * 1) Elijah
 * 2) Eric/Erik/Erick
 * 3) Ethan
 * 4) Eugene/Gene
 * 5) Evan
 * 6) Fabio
 * 7) Felipe
 * 8) Felix
 * 9) Frank/Frankie
 * 10) Fraser
 * 11) Gabriel/Gabe
 * 12) Garrett/Garret
 * 13) Gary
 * 14) Gavin
 * 15) George
 * 16) Glenn
 * 17) Gerik
 * 18) Gordon/Gordie/Gord
 * 19) Graham
 * 20) Grant
 * 21) Gregory/Greg
 * 22) Hans
 * 23) Harold/Harry/Hal
 * 24) Henry/Harry/Hank
 * 25) Howard/Howie
 * 26) Hunter
 * Ian
 * 1) Isaac
 * Isa
 * 1) Isaiah
 * 2) Jackson/Jaxon/Jaxson/Jax
 * 3) Jacob/Jakob/Jake
 * 4) Jaime /Jamie
 * 5) Jamal
 * 6) James/Jim/Jem
 * 7) Jared
 * 8) Jason/Jay/Jase
 * Jay
 * 1) Jeffrey/Geoffrey/Jeff
 * 2) Jeremy/Jerry
 * 3) Jerome
 * 4) Jesse
 * 5) Jesús
 * 6) Joel
 * 7) Joey
 * 8) John/Jack
 * 9) Jonathan/Jonathon/Jon
 * 10) Jordan/Jordy
 * 11) Jorge
 * 12) Jane
 * 13) Janice
 * 14) Janiqua
 * 15) Janiquea
 * 16) Janique
 * 17) Jallinson
 * 18) Jose
 * 19) Joseph/Joe/Joey
 * 20) Joshua/Josh
 * 21) Juan
 * 22) Julio
 * 23) Justin
 * 24) Karl/Carl
 * Kai
 * 1) Keith
 * 2) Kelan
 * 3) Kenneth/Ken/Kenny
 * 4) Kero
 * 5) Kevin/Keven
 * 6) Kurt
 * 7) Kyle
 * 8) Lance
 * 9) Lawrence/Larry
 * Lee
 * 1) Leonard/Len
 * 2) Leonardo/Leo
 * 3) Logan
 * 4) Louis/Lewis/Lou
 * 5) Lucas/Luke
 * 6) Luis
 * 7) Liam
 * 8) Malcolm
 * 9) Marchie
 * 10) Manuel/Manny
 * 11) Marc/Mark/Marcus/Markus
 * 12) Marco
 * 13) Martin/Marty
 * 14) Matthew/Matt
 * 15) Max/Maxwell
 * 16) Michael/Mike
 * 17) Miguel
 * 18) Miles
 * 19) Mitchell/Mitch
 * 20) Nathan/Nate
 * 21) Nathaniel/Nat
 * 22) Neil
 * 23) Nicholas/Nick/Nicky
 * 24) Noah
 * 25) Narchie
 * 26) Noor
 * 27) Omar
 * 28) Owen
 * 29) Oliver
 * 30) Oogie
 * 31) Patrick/Pat
 * 32) Paul
 * 33) Pedro
 * 34) Peter/Pete
 * 35) Pietro
 * 36) Philip/Phillip/Phil
 * 37) Pranav
 * 38) Rafael/Raphael
 * 39) Ramón
 * 40) Randall/Randy
 * 41) Raymond/Ray
 * 42) Reed/Reid
 * 43) Ricardo
 * 44) Richard/Rick/Rich/Ritchie/Ricky
 * 45) Robert/Rob/Bob
 * 46) Roberto
 * Roy
 * 1) Russell/Russ/Rusty
 * 2) Ryan/Ry
 * 3) Samuel/Sam
 * 4) Scott
 * 5) Sean/Shawn/Shaun
 * 6) Seth
 * 7) Shane
 * 8) Simon
 * 9) Spencer
 * 10) Stanley/Stan
 * 11) Stephen/Steven/Stephan/Steve
 * 12) Taylor
 * 13) Terry/Terrence
 * 14) Theodore/Ted
 * 15) Thomas/Tom/Thom
 * 16) Timothy/Tim
 * 17) Tobias/Toby
 * 18) Todd
 * 19) Tony/Anthony/Antonio
 * 20) Tommy
 * 21) Travis/Trav
 * 22) Trent
 * 23) Trevor/Trev
 * 24) Trey
 * 25) Tristan
 * 26) Troy
 * 27) Tyler/Ty
 * 28) Tyrone/Ty
 * 29) Victor/Viktor
 * 30) Vincent/Vince
 * 31) Wayne
 * 32) Wesley/Wes
 * 33) William/Will
 * 34) Xavier
 * 35) Zachary/Zach/Zac/Zack
 * 36) Zavier
 * 37) Zander
 * 38) Zedrick

Other Names

 * 1) Charlie
 * 2) Dexter
 * 3) Aaron
 * 4) Adan
 * 5) Adel
 * 6) Adonis
 * 7) Ahmad
 * 8) Ahmed
 * 9) Alain
 * 10) Albert/Al
 * 11) Alberto/Al
 * 12) Alex
 * 13) Alfonso/Al
 * 14) Alfred/Al
 * 15) Alfredo/Al
 * 16) Alistaire/Alistair
 * 17) Alvin
 * 18) Amin/Ameen
 * 19) Amir/Aamir
 * 20) Amyas
 * 21) Anand
 * 22) Andreas/Andy
 * 23) Andres
 * 24) Anselm
 * 25) Antoine/Antwan
 * 26) Anton
 * Ari
 * 1) Armando
 * 2) Arnold/Arnie
 * Ash
 * 1) Ashton
 * 2) Aurelio
 * 3) Alfrado
 * 4) Austin
 * 5) Avery
 * 6) Axel/Axl
 * 7) Balthassar
 * 8) Bartholomew/Bart
 * 9) Basheer
 * 10) Benito
 * 11) Bennett
 * 12) Bilal
 * 13) Baily/Baileigh
 * 14) Bailey
 * 15) Bjorn
 * 16) Blade
 * 17) Blaine
 * 18) Blair
 * 19) Boyce
 * 20) Boyd
 * 21) Bradford/Brad
 * 22) Brady
 * 23) Bram
 * 24) Brant
 * 25) Brantley
 * 26) Brendon
 * 27) Brennan/Brennon
 * 28) Brenton
 * 29) Brick
 * 30) Brock
 * 31) Broderick/Brodie
 * 32) Bronson
 * 33) Brook
 * 34) Bruno
 * 35) Caden/Kaiden
 * 36) Calvin/Cal
 * 37) Camilo
 * 38) Calob/Caleb
 * 39) Carlo
 * 40) Carey/Carry
 * 41) Carter
 * 42) Cassius
 * 43) Cedric
 * 44) Cesar
 * 45) Chance
 * 46) Chandler
 * 47) Chester/Chet
 * 48) Clarence
 * 49) Clark
 * 50) Claude
 * 51) Clem
 * 52) Cletus/Clete
 * 53) Cleve/Cleveland
 * 54) Clifton/Cliff
 * 55) Clinton/Clint
 * 56) Clive
 * 57) Colby
 * 58) Conrad/Konrad
 * 59) Constantine/Gus
 * 60) Cosmo
 * 61) Cristian
 * 62) Curly
 * 63) Dallas
 * 64) Damon
 * 65) Dane
 * 66) Dante
 * 67) Darby
 * 68) Darcy
 * 69) Dario
 * 70) Darius
 * 71) Davis
 * 72) Dawson
 * 73) Deandre
 * 74) DeAngelo
 * 75) DeJuan
 * Del
 * 1) Demetri/Demetrius
 * 2) Denzel
 * Dev
 * 1) Dewey
 * 2) DeWitt
 * 3) Dexter
 * 4) Dion/Deon
 * 5) Dirk
 * 6) Donnell/Don
 * 7) Donovan/Donavin/Don
 * 8) Donte
 * 9) Doyle
 * 10) Duncan
 * 11) Dusty
 * 12) Dwight
 * 13) Earl
 * 14) Edgar
 * 15) Eduardo
 * 16) Edwin
 * 17) Elias
 * 18) Elliott
 * 19) Ellis
 * 20) Elroy
 * 21) Elton
 * 22) Elvis
 * 23) Emery/Emory
 * 24) Emil
 * 25) Emilio
 * 26) Emmett
 * 27) Enrico/Rick
 * 28) Enrique
 * 29) Enzo
 * 30) Ernest/Ernie
 * 31) Esteban
 * 32) Ezra
 * 33) Fabio
 * 34) Faruq/Farouq
 * 35) Fernando
 * 36) Ferris
 * 37) Filippo
 * 38) Finn
 * 39) Flint
 * 40) Floyd
 * 41) Forrest
 * 42) Francisco/Chico
 * 43) Franco
 * 44) Franklin
 * 45) Frederick/Fred
 * 46) Fritz
 * 47) Gabriel
 * 48) Gage
 * 49) Galen
 * 50) Gareth
 * 51) Garth
 * 52) Genaro/Gennaro
 * 53) Gerald/Jerry
 * 54) Geraldo
 * 55) Gilbert/Gil
 * 56) Gilberto/Gil
 * 57) Giles/Gilles
 * 58) Gino
 * 59) Giorgio
 * 60) Giovanni
 * 61) Giuseppe/Joey
 * 62) Grayson/Greyson
 * 63) Gus/Augustine
 * Guy
 * 1) Hakeem
 * 2) Halim
 * 3) Hamish
 * 4) Hamzah
 * 5) Harlan
 * 6) Harry
 * 7) Harrison
 * 8) Harvey
 * 9) Hassan
 * 10) Hayden
 * 11) Heath
 * 12) Hector
 * 13) Helias
 * 14) Hendrick/Hendrik
 * 15) Herbert/Herb/Herbie
 * 16) Hercules/Herc
 * 17) Herman
 * 18) Homer
 * 19) Houston
 * 20) Howell/Howie
 * 21) Hudson
 * 22) Hugh/Huey
 * 23) Hugo
 * 24) Hussein/Husain
 * Ike
 * 1) Ilham
 * 2) Imani
 * 3) Immanuel/Emanuel/Emmanuel/Manny
 * Ira
 * 1) Irwin
 * 2) Ivan
 * 3) Jabbar/Jabar
 * 4) Jace
 * 5) Jack
 * 6) Jacques
 * 7) Jafar
 * 8) Jake
 * 9) Jaleel/Jalil
 * 10) Jamaal
 * 11) Jamar
 * 12) Jamison
 * 13) Jamel
 * 14) Jamil
 * Jan
 * 1) Jaron
 * 2) Jasper
 * 3) Javier
 * 4) Javon/Jayvaughn
 * 5) Jayden/Jaden
 * 6) Jean-Luc
 * 7) Jean-Paul
 * 8) Jeb/Jebediah
 * 9) Jed/Jedediah
 * 10) Jeremiah/Jerry
 * 11) Jermaine
 * 12) Jess
 * 13) Jet/Jett
 * 14) Jethro
 * 15) Joaquin
 * 16) Joel
 * 17) John Paul
 * 18) Jonah
 * 19) Jonas
 * 20) Judd/Jude
 * 21) Julian
 * 22) Kaden
 * Kai
 * 1) Kaleel/Kalil
 * 2) Kami
 * 3) Kareem
 * 4) Kaseem/Kasim
 * 5) Kaspar/Kasper
 * 6) Keegan
 * 7) Keenan
 * 8) Kelly
 * 9) Kelvin
 * 10) Kendall
 * 11) Kendrick
 * 12) Kennan/Kennon
 * 13) Kent
 * 14) Khalil
 * 15) Kiley
 * Kim
 * 1) Kimo
 * 2) Kirby
 * 3) Kirk
 * 4) Krishna
 * 5) Kwame
 * 6) Kweisi
 * Kya
 * 1) Laine/Lane/Layne
 * 2) Lamar
 * 3) Lamont
 * 4) Lane
 * 5) LaRon
 * 6) Lars
 * 7) Lateef
 * 8) Leandro
 * 9) Leland
 * 10) Leon
 * 11) Leroy
 * 12) Leslie
 * 13) Lester/Les
 * 14) Levi
 * 15) Liam
 * 16) Lincoln
 * 17) Lloyd
 * 18) Lon/Lonnie
 * 19) London
 * 20) Lorenzo
 * 21) Luca
 * 22) Lucius
 * 23) Lyle
 * 24) Lyman
 * 25) Lyndon
 * 26) Mackenzie
 * 27) Mahmoud
 * 28) Malik
 * 29) Mansoor/Mansur
 * 30) Marcos
 * 31) Mario
 * 32) Marquis
 * 33) Marshall
 * 34) Marvin
 * 35) Mason
 * 36) Masoud
 * 37) Mateo
 * 38) Matteo
 * 39) Mattheo/Matheo
 * 40) Maurice/Morris
 * 41) Maximillian/Max
 * 42) Mehdi
 * 43) Melvin/Mel
 * 44) Micah
 * 45) Milo
 * 46) Mohammed
 * 47) Monte/Monty
 * 48) Morgan
 * Ned
 * 1) Nelson
 * 2) Nestor
 * 3) Neville
 * 4) Nico
 * 5) Nicola
 * 6) Nicolai
 * 7) Nigel
 * 8) Nikolaus
 * 9) Nils/Niels
 * 10) Nino
 * Noe
 * 1) Norman/Norm
 * 2) Odin
 * 3) Oliver
 * 4) Orion
 * 5) Orlando
 * 6) Oscar
 * 7) Pablo
 * 8) Palmer
 * 9) Paolo
 * 10) Paris
 * 11) Parker
 * 12) Payne
 * 13) Percy
 * 14) Perry
 * 15) Philippe
 * 16) Pierce
 * 17) Pierre
 * 18) Prescott
 * 19) Preston/Pres
 * 20) Quentin
 * 21) Quinton/Quint
 * 22) Rafiq
 * 23) Raheem/Rahim
 * 24) Rajeev/Rajiv
 * 25) Raley
 * 26) Ralph
 * 27) Ramiro
 * 28) Randolph
 * 29) Rashad/Rashaad
 * 30) Rashid/Rasheed
 * 31) Raul
 * 32) Ravi
 * 33) Raymi
 * 34) Reagan
 * 35) Reese/Reece
 * 36) Reginald/Rex/Reggie
 * 37) Rembrandt
 * 38) Remington
 * 39) René
 * 40) Riley/Reilly
 * 41) Robin
 * 42) Rock
 * 43) Rocky
 * 44) Rodney/Rod
 * 45) Roger
 * 46) Roland
 * 47) Rolando
 * 48) Rolly
 * 49) Roman
 * 50) Romeo
 * 51) Ronald/Ron
 * 52) Rory
 * 53) Roscoe
 * 54) Ross
 * 55) Royce
 * 56) Ruben/Reuben
 * 57) Rudolph/Rudolf/Rudy
 * 58) Salvador/Sal
 * 59) Sameer/Samir
 * 60) Sancho
 * 61) Sanjay
 * 62) Santiago
 * 63) Saul
 * 64) Sawyer
 * 65) Sebastian/Sebi
 * 66) Sergio
 * 67) Shad
 * 68) Shannon
 * 69) Shareef/Sharif
 * 70) Shea
 * 71) Sheldon
 * 72) Sherman/Sherm
 * 73) Shervin
 * 74) Sidney/Sydney/Sid
 * 75) Silas
 * Sky
 * 1) Slade
 * 2) Smash
 * 3) Socrates
 * 4) Solomon
 * 5) Stefano/Stephano
 * 6) Stone
 * 7) Storm
 * 8) Stuart/Stewart
 * 9) Sulaiman
 * 10) Sven
 * 11) Tahj
 * Tal
 * 1) Tanner
 * 2) Tariq
 * 3) Tate
 * 4) Tawfiq
 * 5) Telly
 * Teo
 * 1) Terrell
 * 2) Thaddeus/Tad
 * 3) Trace
 * 4) Tracy
 * 5) Trenton/Trent
 * 6) Tucker/Tuck
 * 7) Tully
 * 8) Turner
 * 9) Tyson/Ty
 * Van
 * 1) Vance
 * 2) Vernon/Vern
 * 3) Vikram
 * 4) Virgil
 * 5) Wade
 * 6) Walker
 * 7) Walter/Walt
 * 8) Ward
 * 9) Warren
 * 10) Webster
 * 11) Wendell
 * 12) Weston/Wes
 * 13) William/Will
 * 14) Whitney/Whit
 * 15) Wilfredo
 * 16) Wyatt
 * 17) Xavier
 * 18) Zachariah/Zach
 * 19) Zane
 * 20) Zeke
 * 21) Zephyr

Unusual names

 * 1) Abbott
 * 2) Abednego
 * 3) Abelard
 * 4) Abiel
 * Ack
 * 1) Acton
 * 2) Adalbert
 * 3) Addison
 * 4) Adelard
 * 5) Adiel
 * 6) Adley
 * 7) Adlin
 * 8) Adriel
 * 9) Adrin
 * 10) Agrippa
 * 11) Ahab
 * 12) Ainsley
 * 13) Ajax
 * 14) Alaska
 * 15) Alden
 * 16) Alder
 * 17) Aldo
 * 18) Aldon
 * 19) Aldous
 * 20) Alfie
 * 21) Algernon
 * 22) Alick
 * 23) Aloysius
 * 24) Alphonse
 * 25) Alston
 * 26) Alton
 * 27) Alvery
 * 28) Alvis
 * 29) Ammon
 * 30) Andreus
 * 31) Andri
 * 32) Andrue
 * 33) Ansel
 * 34) Arcadio
 * 35) Arec
 * 36) Aren
 * 37) Argus
 * 38) Armand
 * 39) Arundel
 * Asa
 * 1) Ashby
 * 2) Ashleigh
 * 3) Ashon
 * 4) Audie
 * 5) Audiffredy
 * 6) Aurelian
 * 7) Auran
 * 8) Authen
 * 9) Avalon
 * 10) Ayman
 * 11) Bailey
 * 12) Bainbridge
 * 13) Baljeet
 * 14) Bane
 * 15) Banner
 * 16) Barney
 * 17) Baron
 * 18) Barrett
 * 19) Barrington
 * 20) Barrow
 * 21) Bartholomew
 * 22) Baryt
 * 23) Beauregarde
 * 24) Beavis
 * 25) Beckam/Beck
 * 26) Beckham/Beck
 * 27) Beckett
 * 28) Belnar
 * 29) Belvin
 * 30) Benson
 * 31) Bentley
 * 32) Benton
 * 33) Benz
 * 34) Benzer
 * 35) Bertan
 * 36) Bertram
 * 37) Bink
 * 38) Birney
 * 39) Birtle
 * 40) Bishop
 * Bix
 * 1) Blain
 * 2) Boaz
 * 3) Bohden
 * Bon
 * 1) Booker
 * 2) Boston
 * 3) Bosworth
 * 4) Brainard
 * 5) Bramm
 * 6) Brayden
 * 7) Breaden
 * 8) Brecken
 * 9) Brenner
 * 10) Brentland
 * 11) Briar
 * 12) Brij
 * 13) Broden
 * 14) Brodin
 * 15) Bronce
 * 16) Brooks
 * 17) Brutus
 * 18) Bryson
 * Bud
 * 1) Buford
 * 2) Bunker
 * 3) Burl
 * 4) Burton
 * 5) Buxton
 * 6) Cabell
 * 7) Caesar
 * 8) Cage
 * 9) Cairo
 * 10) Caldwell
 * 11) Calhoun
 * 12) Camden
 * 13) Camdon
 * 14) Canaan
 * 15) Canberra
 * 16) Canen
 * 17) Cannon
 * 18) Carldrick
 * 19) Carlisle
 * 20) Carys
 * 21) Case
 * 22) Cass
 * 23) Cassiel
 * 24) Cater
 * 25) Cathal
 * 26) Cavanough
 * 27) Cayd
 * 28) Cepheus
 * 29) Chadoe
 * 30) Chadwick
 * 31) Chancellor
 * 32) Chanton
 * 33) Chapman
 * 34) Charlen
 * 35) Charleston
 * 36) Chasen
 * 37) Chaylor
 * 38) Chirag
 * 39) Christopherus
 * 40) Cicero
 * 41) Cirq
 * 42) Cisco
 * 43) Claiborne
 * 44) Clarus
 * 45) Claudian
 * 46) Cleisthenes
 * 47) Cleon
 * 48) Climacus
 * 49) Clitus
 * 50) Clovis
 * 51) Colorado
 * 52) Concordius
 * 53) Connon
 * 54) Contardo
 * 55) Conway
 * 56) Conwell
 * 57) Cooper
 * 58) Cord
 * 59) Cordell
 * 60) Cordova
 * 61) Cork
 * 62) Cornell
 * 63) Cosby
 * 64) Cosmos
 * 65) Courtland
 * 66) Courtney
 * 67) Covert
 * 68) Crispus
 * 69) Crittenden
 * 70) Critty
 * 71) Cupid
 * 72) Cuthbert
 * 73) Cyle
 * 74) Dabney
 * 75) Dagget
 * 76) Dagwood
 * 77) Dameon
 * 78) Dana
 * 79) Danion
 * 80) Dardanos
 * 81) Daris
 * 82) Darragh
 * 83) Dartagnan
 * 84) Darwin
 * 85) Dash
 * 86) David
 * 87) Davidson
 * 88) Davin
 * 89) Davith
 * Dax
 * 1) Daxton
 * 2) Dayton
 * 3) Dayv
 * 4) Dedrick
 * 5) Deion
 * 6) Delbert
 * 7) Delmer
 * 8) Demon
 * 9) Dennerio
 * 10) Dentury
 * 11) Denuel
 * 12) Denver
 * 13) Derry
 * 14) Desi
 * 15) Desiderius
 * 16) Destin
 * 17) Digby
 * 18) Digger
 * 19) Dijon
 * 20) Dilbert
 * 21) Dillard
 * 22) Dionysius
 * 23) Dodo
 * 24) Donato
 * 25) Donking
 * 26) Dorian
 * 27) Dossie
 * 28) Dotson
 * 29) Draco
 * 30) Drai
 * 31) Drogo
 * Dru
 * 1) Duriel
 * 2) Duwayne
 * 3) Eason
 * 4) Easton
 * 5) Eaton
 * 6) Edwin
 * 7) Elbert
 * 8) Eldon
 * 9) Eldred
 * 10) Eleazar
 * 11) Eliezer
 * 12) Elmer
 * 13) Elmo
 * 14) Elsdon
 * 15) Elvin
 * 16) Elwood
 * 17) Emerson
 * 18) Engelbert
 * 19) Englebert
 * 20) Ennis
 * 21) Erza
 * 22) Ephan
 * 23) Eros
 * 24) Errol
 * 25) Erroll
 * 26) Ervin
 * 27) Erwan
 * 28) Eustace
 * 29) Ezekiel
 * 30) Farley
 * 31) Faron
 * 32) Favian
 * 33) Ferdinand
 * 34) Filbert
 * 35) Fisher
 * 36) Fitch
 * 37) Flame
 * 38) Foster
 * Fox
 * 1) Freeman
 * 2) Friday
 * 3) Frost
 * 4) Fructosius
 * 5) Galloway
 * 6) Gamaliel
 * 7) Garfield
 * 8) Garland
 * 9) Garlon
 * 10) Garnett
 * 11) Garrick
 * 12) Garroth
 * 13) Gatlin
 * 14) Gaylord
 * 15) Gehrig
 * 16) Godfrey
 * 17) Grady
 * 18) Granite
 * 19) Gray
 * 20) Grey
 * 21) Greydon
 * 22) Griswold
 * 23) Grover
 * 24) Guy Edward
 * 25) Hadley
 * 26) Haight
 * 27) Halston
 * Ham
 * Han
 * 1) Harlen
 * 2) Harris
 * 3) Hart
 * 4) Hartley
 * 5) Hawke
 * 6) Hayes
 * 7) Haynes
 * 8) Hayson
 * 9) Hayward
 * 10) Heathcliff
 * 11) Henner
 * 12) Herberth
 * 13) Herwick
 * 14) Heyward
 * 15) Heywood
 * 16) Hobart
 * 17) Holden
 * 18) Hollis
 * 19) Horton
 * 20) Hospatio
 * 21) Huett
 * 22) Humphrey
 * 23) Humps
 * 24) Huntley
 * 25) Hurricane
 * 26) Huxley
 * 27) Hyland
 * 28) Icarus
 * 29) Ichabod
 * 30) Iggy
 * 31) Innocent
 * 32) Iowa
 * 33) Irelan
 * 34) Irvin
 * 35) Ishmael
 * 36) Iziah
 * 37) Iziah Edouard
 * 38) Jabin
 * 39) Jacari
 * 40) Jack Ross
 * 41) Jagger
 * 42) Jaime Ali
 * 43) Jaimie
 * 44) Jamar
 * 45) Jameson
 * 46) Jamyron
 * 47) Japheth
 * 48) Jarek
 * 49) Jarvis
 * 50) Jaspiern
 * 51) Javert
 * 52) Jaxton
 * 53) Jaxxon
 * 54) Jaymes
 * 55) Jay Paul
 * 56) Jayceon
 * 57) Jayson
 * 58) Jaython
 * 59) Jayvion
 * Jaz
 * 1) Jeacock
 * 2) Jeff Anthony
 * Jem
 * 1) Jensen
 * 2) Jericho
 * 3) Jersey
 * 4) Jeumol
 * 5) Joacin
 * 6) Joad
 * 7) Joby
 * 8) Jodocus
 * 9) Johano
 * 10) Johnathan
 * 11) John John
 * 12) John Lee
 * 13) John Cena
 * 14) Johnson
 * 15) Jomario
 * 16) Jonatan
 * 17) Jon Marc
 * 18) Joseph Ryan
 * 19) Joshuah
 * 20) Judah
 * 21) Judas
 * 22) Jude
 * 23) Juston
 * 24) Justus
 * 25) Kade
 * 26) Kairo
 * 27) Kaiser
 * 28) Kalin
 * 29) Kansy
 * 30) Kase
 * 31) Kaymon
 * 32) Kazel
 * 33) Kedric
 * 34) Kedrick
 * 35) Kehre
 * 36) Keifer
 * Kel
 * 1) Kelan
 * 2) Kelton
 * 3) Kennesaw
 * 4) Kenton
 * Kid
 * 1) Kidd
 * 2) Kiefer
 * 3) Kiev
 * 4) Killian
 * 5) Kilroy
 * 6) King
 * 7) Kipland
 * 8) Kipling
 * 9) Kirkland
 * 10) Kirklin
 * 11) Knox
 * 12) Kole
 * 13) Kyrin
 * 14) Kyron
 * 15) Langley
 * 16) Lanny
 * Lap
 * 1) Laramie
 * 2) Lawson
 * 3) Lazarus
 * 4) LeBaron
 * 5) Lee Roy
 * 6) Legend
 * 7) Leopold
 * 8) Leviticus
 * Lex
 * 1) Link
 * 2) Linwood
 * 3) Lithium
 * 4) Livan
 * 5) Logan James
 * 6) Loren
 * 7) Lorin
 * 8) Lorne
 * 9) Lover
 * 10) Lowell
 * 11) Lucian
 * 12) Luck
 * 13) Ludis
 * 14) Lunden
 * 15) Lydel
 * 16) Lymphoid
 * 17) Lyndsey
 * 18) Mackay
 * 19) Manassas
 * 20) Maneill
 * 21) Manfred
 * 22) Manley
 * 23) Marcian
 * 24) Marlon
 * 25) Marlowe
 * 26) Mathan
 * 27) Matthews
 * 28) Matwain
 * 29) Maxton
 * 30) Maynard
 * 31) McKinley
 * 32) McScott
 * 33) Mecole
 * Mei
 * 1) Melanchthon
 * 2) Melchizedek
 * 3) Melville
 * 4) Merle
 * 5) Merlin
 * 6) Merritt
 * 7) Merton
 * 8) Merv
 * 9) Mervin
 * 10) Merwyn
 * 11) Meshach
 * 12) Micahel
 * 13) Michael James
 * 14) Migh
 * 15) Mikal
 * 16) Milford
 * 17) Milhouse
 * 18) Millard
 * 19) Mize
 * 20) Monroe
 * 21) Montana
 * 22) Moore
 * 23) Morley
 * 24) Morton
 * 25) Murgatroyd
 * 26) Myron
 * 27) Nahum
 * 28) Napoleon
 * 29) Narcissus
 * 30) Nash
 * 31) Newt
 * 32) Newton
 * 33) Nicephorus
 * 34) Nicodemus
 * 35) Nikolao
 * 36) Nimrod
 * 37) Noah Bryce
 * 38) Nobert
 * 39) Nobie
 * 40) Norris
 * 41) Norton
 * 42) Norval
 * 43) Norville
 * 44) Numps
 * 45) Oder
 * 46) Odor
 * 47) Omar Jesús
 * 48) O’Mead
 * 49) Omer
 * 50) Omni
 * 51) Ontario
 * 52) Onyx
 * 53) Orson
 * 54) Orwell
 * 55) Othniel
 * 56) Painter
 * 57) Paras
 * 58) Parrish
 * 59) Parrott
 * 60) Parth
 * 61) Patrick Henry
 * 62) Patton/Pat
 * 63) Paxton
 * 64) Pearson
 * 65) Pickford
 * 66) Poindexter
 * 67) Pollard
 * 68) Polyeuctus
 * 69) Porter
 * 70) Prabhdev
 * 71) Primus
 * 72) Prince
 * 73) Princeton
 * 74) Proctor
 * 75) Quaterius
 * 76) Quincy
 * 77) Quinlan
 * 78) Quinn
 * 79) Quintin
 * 80) Quirt
 * 81) Raleigh
 * 82) Raynell
 * 83) Reamer
 * Red
 * 1) Redrick
 * 2) Reef
 * 3) Reen
 * 4) Reginel
 * 5) Relix
 * 6) Renton
 * 7) Rexford
 * 8) Reyes
 * 9) Rezon
 * 10) Rhett
 * 11) Richmond
 * 12) Ridge
 * 13) Ridley
 * 14) Rigden
 * 15) Roark
 * 16) Robert Jay
 * 17) Rocket
 * 18) Roderick
 * Roe
 * 1) Rollin
 * 2) Roosevelt
 * 3) Roper
 * 4) Roxbury
 * 5) Rulon
 * 6) Rulx
 * 7) Rush
 * 8) Russet
 * 9) Rusty James
 * 10) Rutherford
 * 11) Ryal
 * 12) Ryder
 * 13) Rylan
 * 14) Ryland
 * 15) Sage
 * 16) Salathiel
 * 17) Salem
 * 18) San Juan
 * 19) Satchel
 * 20) Savikar
 * 21) Sefton
 * 22) Senna
 * 23) Seymour
 * 24) Shade
 * 25) Shale
 * 26) Shandon
 * 27) Shavar
 * 28) Sheaffer
 * 29) Sherlock
 * 30) Shitrai
 * 31) Sisko
 * 32) Slate
 * 33) Slyder
 * 34) Sonji
 * 35) Speed
 * 36) Spicer
 * 37) Spike
 * 38) Stacius
 * 39) Stacy
 * 40) Standish
 * 41) Stanford
 * 42) Stanislas
 * 43) Stanton
 * 44) Starling
 * 45) Steehl
 * 46) Stenson
 * 47) Stephon
 * 48) Sterling
 * 49) Stetson
 * 50) Stevan
 * 51) Stevenson
 * 52) Steward
 * 53) Strom
 * 54) Stupen
 * 55) Swithin
 * 56) Symmachus
 * 57) Tabio
 * 58) Talbot
 * 59) Talmadge
 * 60) Taurus
 * 61) Tenley
 * 62) Tenner
 * 63) Terry Allen
 * 64) Texas
 * 65) Thaxton
 * 66) Thorne
 * 67) Thurman
 * 68) Turdd
 * 69) Till
 * 70) Tilly Willy
 * 71) Timaeus/Timeus
 * 72) Timmothy
 * 73) Tince
 * 74) Tirqueon
 * 75) Tirrell
 * 76) Tisign
 * 77) Tomen
 * Tor
 * 1) Torey
 * 2) Torrance
 * 3) Tragedy
 * 4) Tramone
 * 5) Trask
 * 6) Travell
 * 7) Traver
 * 8) Travien
 * 9) Tree
 * 10) Tremaine
 * 11) Tristan Kyle
 * 12) Tristran
 * 13) Tryce
 * 14) Tustin
 * 15) Ty Kurt
 * 16) Tyler Frank
 * 17) Tyray
 * 18) Tyrus
 * 19) Ulysses
 * 20) Upton
 * 21) Utah
 * 22) Uzziah
 * Val
 * 1) Valiant
 * 2) Van Buren
 * 3) Vensley
 * 4) Vere
 * 5) Vibson
 * 6) Vicson
 * 7) Ville
 * 8) Vinson
 * 9) Vitus
 * 10) Waldo
 * 11) Walton
 * 12) Walyn
 * 13) Warner
 * 14) Wayland
 * 15) Waylon
 * 16) Weldon
 * 17) Wells
 * 18) Weseley
 * 19) Westerly
 * 20) Westly
 * 21) Whitby
 * 22) Whitley
 * 23) Wilbert
 * 24) Wilbur
 * 25) Wilburn
 * 26) Wilkin
 * 27) Williams
 * 28) Winthrop
 * 29) Wolfgang
 * 30) Woodrow
 * 31) Worth
 * 32) Wylie
 * 33) Xeno
 * 34) Yale
 * 35) Yelberton
 * 36) Yoni
 * 37) York
 * 38) Yoftae
 * 39) Zaki
 * 40) Zander
 * 41) Zechariah
 * 42) Zell
 * 43) Zelman
 * 44) Zephaniah
 * 45) Zitner
 * 46) Zuriel
 * 47) Zurishaddai


text:
Writing Adolescent Fiction/Character names/Botanical

Here are some botanical names.

 * 1) Acacia
 * 2) Achillea
 * 3) Althea
 * 4) Alyssum
 * 5) Amarantha
 * 6) Amaryllis
 * 7) Anemone
 * 8) Angelica
 * 9) Anise
 * 10) Anthea
 * 11) Apple
 * 12) Apricot
 * 13) Aquacea
 * 14) Armeria
 * 15) Aspen
 * 16) Aster
 * 17) Azalea
 * 18) Banana
 * 19) Basil
 * Bay
 * 1) Begonia
 * 2) Begonya
 * 3) Berry (this spelling)
 * 4) Betony
 * 5) Blanchefleur
 * 6) Blossom
 * 7) Bluebell
 * 8) Bluma
 * 9) Briar
 * 10) Briar Rose
 * 11) Briony
 * 12) Bryony
 * 13) Cactusflower
 * 14) Calla
 * 15) Camelia
 * 16) Camellia
 * 17) Canna
 * 18) Cannabis
 * 19) Carnation
 * 20) Carrot
 * 21) Cassia
 * 22) Cattleya
 * 23) Cayenne
 * 24) Cedar
 * 25) Celandine
 * 26) Cereus
 * 27) Cerise (French for cherry)
 * 28) Cherimoya
 * 29) Cherry
 * 30) Chia
 * 31) Cilantro
 * 32) Cinnamon
 * 33) Clematis
 * 34) Cliantha
 * 35) Clover
 * 36) Columbine
 * 37) Coralbell
 * 38) Crocus
 * 39) Cypress
 * 40) Daffodil
 * 41) Daffodile
 * 42) Dahlia
 * 43) Daisy
 * 44) Dalia
 * 45) Daliazucena
 * 46) Daphne
 * 47) Dasheen
 * 48) Dittany
 * 49) Dracena
 * 50) Ebony
 * 51) Elderberry
 * 52) Elodea
 * 53) Erianthe
 * 54) Fern
 * 55) Flora
 * 56) Freesia
 * 57) Frond
 * 58) Fuchsia
 * 59) Gardenia
 * 60) Ginkgo
 * 61) Gloriosa
 * 62) Guava
 * 63) Hazel
 * 64) Heather
 * 65) Hebe
 * 66) Holly
 * 67) Honeysuckle
 * 68) Hyacinth
 * 69) Hyacintha
 * 70) Iris
 * Ivy
 * 1) Jacaranda
 * 2) Jacinta
 * 3) Jacinth
 * 4) Japonica
 * 5) Jasmine
 * 6) Jessamine
 * 7) Jonquil
 * 8) Jonquille
 * 9) Juniper
 * 10) Junipera
 * 11) Kale
 * 12) Kava
 * 13) Kelp
 * 14) Kerria
 * 15) Kiwi
 * 16) Korsbar (Swedish for Cherry)
 * 17) Kumquat
 * 18) Kunzea
 * 19) Lantana
 * 20) Larch
 * 21) Laurel
 * 22) Lavendar
 * 23) Lavender
 * 24) Lemon
 * 25) Lettuce
 * 26) Liana
 * 27) Lilac
 * 28) Lilly/Lily
 * 29) Lilyrose
 * 30) Linnea
 * 31) Lotus
 * 32) Lynnaea
 * 33) Magnolia
 * 34) Mahogany
 * 35) Mallow
 * 36) Malva
 * 37) Mango
 * 38) Marguerite
 * 39) Marigold
 * 40) Mariposa
 * 41) Marjoram
 * 42) Mignonette
 * 43) Mimosa
 * 44) Myrtle
 * 45) Narcissa
 * 46) Nettle
 * 47) Oliander [sic]
 * 48) Olive
 * 49) Orange
 * 50) Orchid
 * 51) Pansy
 * 52) Papaya
 * 53) Peach/Peaches
 * 54) Pear
 * 55) Peony
 * 56) Persimmon
 * 57) Petunia
 * 58) Pink
 * 59) Plum
 * 60) Poplar
 * 61) Poppy
 * 62) Posy
 * 63) Primrose
 * 64) Primula
 * 65) Quince/Quincey/Quincy
 * 66) Rattan
 * 67) Rose
 * 68) Rosemary
 * 69) Rowan
 * 70) Rue (also a Hunger Games name)
 * 71) Saffron
 * 72) Sage
 * 73) Sakura
 * 74) Salvia
 * 75) Samara
 * 76) Sassafras
 * 77) Sequoia
 * 78) Sesame
 * 79) Shamrock
 * 80) Smilax
 * 81) Snowdrop
 * 82) Solandra
 * 83) Sorrel
 * 84) Spruce
 * 85) Sunflower
 * 86) Sweetpea
 * 87) Syringa
 * 88) Tamarind
 * 89) Tansy
 * 90) Thistle
 * 91) Thorn
 * 92) Thyme
 * 93) Torreya
 * 94) Tulip
 * 95) Tulipa
 * 96) Tupelo
 * 97) Valencia
 * 98) Vanilla
 * 99) Vera
 * 100) Verbena
 * 101) Viola
 * 102) Violet
 * 103) Wasabi
 * 104) Willow
 * 105) Wisteria
 * 106) Xilosma
 * 107) Ximenia
 * 108) Xylitol
 * 109) Yarrow
 * 110) Yucca
 * 111) Yuzu
 * 112) Zinnia
 * 113) Zoysia

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/


text:
Electronics/Analog to Digital Converters

Most information in the real world is considered analog (e.g. Audio, temperature and distance) the problem is modern day processing in electronics is done in binary ( a series of 1s and 0s) An analog to digital converter is an IC that solves this problem.

Step Size
The step size is the voltage difference between one digital level (i.e. 0001) and the next one (i.e. 0010 or 0000). For example if an ADC has a step size of 1 Volt an input of 1 volt will produce an output, in a 4 bit converter, of 0001. 0 volts is always considered 0000. Obviously, real world ADCs and DACs would be functionally useless with such a large step size, and most modern devices have step sizes in the microvolt range.

Step size is an important consideration, as well as how many bits will be used. A 4 bit converter with a step size of 1 volt can show a maximum of 15 volts at the input, however a complex sine wave will be heavily distorted. Decreasing the step size to .5 volts will reduce the distortion but lower the maximum input reading. As smaller step sizes are used, higher bit converters are needed to keep maximum voltages equal.

This explains what many consumer audio products mean by "X bit outputs".


text:
User:Dr. know

Cogitur Ergo Sum... ;)

(to be continued... )

title: User:Dr. know


text:
User talk:Ice~enwikibooks

Come introduce yourself at the new users page. If you have any questions, you can ask there or contact me personally. -- Herby talk thyme 07:28, 15 October 2007 (UTC)

Copyright problem with Image:China club.jpg

 * There is no need to upload scaled-down versions of this image, as you did twice. I've deleted them because they're unnecessary. The MediaWiki software can scale images; take a look at m:Help:Images and other uploaded files. Feel free to contact me on my talk page. – Mike.lifeguard  | talk 15:09, 15 October 2007 (UTC)

Your account will be renamed
Hello,

The developer team at Wikimedia is making some changes to how accounts work, as part of our on-going efforts to provide new and better tools for our users like cross-wiki notifications. These changes will mean you have the same account name everywhere. This will let us give you new features that will help you edit and discuss better, and allow more flexible user permissions for tools. One of the side-effects of this is that user accounts will now have to be unique across all 900 Wikimedia wikis. See the announcement for more information.

Unfortunately, your account clashes with another account also called Ice. To make sure that both of you can use all Wikimedia projects in future, we have reserved the name Ice~enwikibooks that only you will have. If you like it, you don't have to do anything. If you do not like it, you can pick out a different name.

Your account will still work as before, and you will be credited for all your edits made so far, but you will have to use the new account name when you log in.

Sorry for the inconvenience.

Yours, Keegan Peterzell Community Liaison, Wikimedia Foundation 23:14, 17 March 2015 (UTC)

Renamed
 This account has been renamed as part of single-user login finalisation. If you own this account you can |log in using your previous username and password for more information. If you do not like this account's new name, you can choose your own using this form after logging in: . -- Keegan (WMF) (talk) 05:03, 19 April 2015 (UTC)

title: User talk:Ice~enwikibooks


text:
Eclipse/FAQ/Classpath Checker

Installation
Help > Software Updates > Find and Install... Search for new features to install > New Remote Site >
 * Name: Classpath Checker
 * URL: http://ClasspathChecker.free.fr/update-site

Links

 * ClasspathChecker.free.fr
 * EclipsePluginCentral.com Category: Plugin Directory / Build and Deploy
 * Chapter 20. Integrating Code Libraries (20.5 Troubleshooting Classloading Problems)
 * FAQ What is the classpath of a plug-in?

title: Eclipse/FAQ/Classpath Checker


text:
Using Ubuntu Linux/Master list of Concise Wisdom

User Space ../Your (user account) "Home Folder" & file system/

Web Browser ../Firefox/


text:
Using Ubuntu Linux/Credits

Thanks to everyone who helped!

Please sign here, if you are one of them...

Also, thanks to anyone taking the time to read this page. 😀

Humans

 * ഏത്തപഴം (discuss • contribs)
 * webaware (discuss • contribs)

title: Using Ubuntu Linux/Credits


text:
Using Ubuntu Linux/Master List of Concise Wisdom

Your (user account) "Home Folder" & file system

 * 1. Create one folder to keep all your stuff in: music, documents, porn, etc.; (call it "My Stuff", or whatever you want to call it) make sub-folders as needed within that.

 * This separates your working files from the other items (mostly "Hidden") in your (user account) "Home Folder", like settings & configuration files for various programs. That makes things easier if you want to copy (or back up, or move, or etc...) your stuff without affecting the other files & sub-folders in your home folder, it's also tidier if you're an advanced user & want to work with those other files (there are reasons you might want to copy, back up, move, or etc... your entire home folder, but that's another matter, to be discussed elsewhere).  It's roughly analogous to the "My Documents" folder in Windows, although it's d.i.y. & without some of the built-in features.

 * A "stuff" folder can be created anywhere (if you have the necessary levels of access/permissions), but the most logical place would be inside your home folder; either in the main folder itself, or on the desktop. Your home folder is normally "private" & unavailable to anyone unless they are logged in to your account, or have root/sudo privileges.  You can change the "Permissions" settings on folders (or files & sub-folders within) to allow other people to have various kinds & degrees of access as desired.

 * You could also create a "stuff" folder on the main file system in the root folder (or elsewhere), if you want to allow broader access (not recommended).

 * Once you've created a "my stuff" folder, you can put shortcuts to it wherever you find them handy; on the desktop (if you created the folder on your desktop, an icon for it will appear there automatically), on the "Panel(s)", in the "Places" drop-down menu, or just about any place that you can think of...

Desktop Effects
Desktop Effects make Ubuntu fun and easier to use. There are a lot of effects in Ubuntu. Desktop effects are optional, and it is not necessary to have them turned on. To enable these, CompizConfig Settings Manager has to be installed in Ubuntu.

Install
sudo apt-get install compizconfig-settings-manager compiz-plugins-extra
 * 1) Open the terminal by pressing ctrl+alt+t on your keyboard.
 * 2) Type the following into the terminal:

Enabling and Configuring Effects
When you have finished installing ccsm, open the dash and type "ccsm". If you use Ubuntu 10.10 or older open it from the applications menu. Click on CompizConfig Settings Manager to open it. Scroll down until you reach the effects subheading. To enable an effect, tick the box (☑) near its icon.

Resetting Compiz
To quickly and easily revert your desktop effects, press ctrl+alt+F1. Type your username and password. Now, type the following: dconf reset -f /org/compiz/ Press ctrl+alt+F7. Now all the non-default settings in CompizConfig will be reset to default.

Bookmarks

 * 1. If you use the "Bookmarks Toolbar", consolidate all of your bookmarks into the "Bookmarks Toolbar Folder", & sub folders as appropriate (A, B, C,; 1, 2, 3,; categories; the Dewey Decimal System... ).  It makes things much tidier, easier to access, & easier to keep organized.  The menus are slightly less twitchy too, you won't get bumped into "Tools" or "History" by accident.  The only drawback is finding a good place to keep your secret stash of samizdata links...


text:
The Poetry of Gaius Valerius Catullus/62

=Text & Translation=


text:
Applied Science BTEC Nationals/Chemical Laboratory Techniques/Cocaine banknotes

Cocaine can be extracted from bank notes by vortex agitation with 15 ml methanol for 5 minutes. The extract is then evaporated and the sample can be reconstituted in 0.5 ml methanol.

The presence of cocaine is confirmed using the cobalt thiocyanate (Scott) test.

The cobalt thiocyanate reagent can be prepared by dissolving ten grams of cobalt (II) thiocyanate in a mixture of 490 milliliters of distilled water and 500 milliliters of glycerin.

The cobalt thiocyanate test is performed by placing approximately 2 to 4 milligrams of a target substance in a glass test tube, then 5 drops of cobalt thiocyanate reagent. After shaking, 1 or 2 drops of concentrated hydrochloric acid are added, and the tube is again shaken. Ten drops of chloroform (or similar solvent) are then added, and the tube is vortexed, then allowed to settle and separate into two layers. The final colour of the chloroform (organic) layer is recorded.

Addition of the cobalt thiocyanate reagent to cocaine hydrochloride results in the surface of the particles turning a bright blue (faint blue for cocaine base). The solution changes back to pink upon adding one or two drops of hydrochloric acid and mixing. Addition of 10 drops of chloroform, vortexing, and allowing the solution to settle results in a blue organic layer for both cocaine hydrochloride and cocaine base.

Diphenhydramine and lidocaine also give blue organic layers. These compounds are known false positives for cocaine.


text:
User talk:Shaffers21

Come introduce yourself at the new users page. If you have any questions, you can ask there or contact me personally. I saw your fixes on the Control Systems book, more help with that book is always appreciated. --Whiteknight (Page) (Talk) 13:02, 15 October 2007 (UTC)

title: User talk:Shaffers21


text:
User talk:129.137.29.179

--Jomegat 13:34, 15 October 2007 (UTC)

title: User talk:129.137.29.179


text:
Java Persistence/Caching

=Caching=

Caching is the most important performance optimisation technique. There are many things that can be cached in persistence, objects, data, database connections, database statements, query results, meta-data, relationships, to name a few. Caching in object persistence normally refers to the caching of objects or their data. Caching also influences object identity, that is that if you read an object, then read the same object again you should get the identical object back (same reference).

JPA 1.0 does not define a JPA providers can support a shared object cache or not, however most do. Caching in JPA is required within a transaction or within an extended persistence context to preserve object identity, but JPA does not require that caching be supported across transactions or persistence contexts.

JPA 2.0 defines the concept of a shared cache. The annotation or   XML attribute can be used to enable or disable caching on a class.

Example JPA 2.0 Cacheable annotation
The enum can also be set in the   XML element in the persistence.xml to configure the default cache mode for the entire persistence unit.

Example JPA 2.0 SharedCacheMode XML
There are two types of caching. You can cache the objects themselves including all of their structure and relationships, or you can cache their database row data. Both provide a benefit, however just caching the row data is missing a huge part of the caching benefit as the retrieval of each relationship typically involves a database query, and the bulk of the cost of reading an object is spent in retrieving its relationships.

Object Identity
Object identity in Java means if two variables refer to the same logical object, then   returns. Meaning that both reference the same thing (both a pointer to the same memory location).

In JPA object identity is maintained within a transaction, and (normally) within the same. The exception is in a JEE managed, object identity is only maintained inside of a transaction.

So the following is true in JPA:

This holds true no matter how the object is accessed:

In JPA object identity is not maintained across s.  Each   maintains its own persistence context, and its own transactional state of its objects.

So the following is true in JPA:

Object identity is normally a good thing, as it avoids having your application manage multiple copies of objects, and avoids the application changing one copy, but not the other. The reason different s or transactions (in JEE) don't maintain object identity is that each transaction must isolate its changes from other users of the system. This is also normally a good thing, however it does require the application to be aware of copies, detached objects and merging.

Some JPA products may have a concept of read-only objects, in which object identity may be maintained across s through a shared object cache.

Object Cache
An object cache is where the Java objects (entities) are themselves cached. The advantage of an object cache is that the data is cached in the same format that it is used in Java. Everything is stored at the object-level and no conversion is required when obtaining a cache hit. With JPA the  must still copy the objects to and from the cache, as it must maintain its transaction isolation, but that is all that is required. The objects do not need to be re-built, and the relationships are already available.

With an object cache, transient data may also be cached. This may occur automatically, or may require some effort. If transient data is not desired, you may also need to clear the data when the object gets cached.

Some JPA products allow read-only queries to access the object cache directly. Some products only allow object caching of read-only data. Obtaining a cache hit on read-only data is extremely efficient as the object does not need to be copied, other than the look-up, no work is required.

It is possible to create your own object cache for your read-only data by loading objects from JPA into your own object cache or  implementation. The main issue, which is always the main issue in caching in general, is how to handle updates and stale cached data, but if the data is read-only, this may not be an issue.

 * TopLink / EclipseLink : Support an object cache. The object cache is on by default, but can be globally or selectively enabled or configured per class.  The persistence unit property   can be set to   to disable the cache.  Read-only queries are supported through the   query hint, entities can also be marked to always be read-only using the   annotation.

Data Cache
A data cache caches the object's data, not the objects themselves. The data is normally a representation of the object's database row. The advantage of a data cache is that it is easier to implement as you do not have to worry about relationships, object identity, or complex memory management. The disadvantage of a data cache is that it does not store the data as it is used in the application, and does not store relationships. This means that on a cache hit the object must still be built from the data, and the relationships fetched from the database. Some products that support a data cache, also support a relationship cache, or query cache to allow caching of relationships.

 * Hibernate : Supports integration with a third party data cache. Caching is not enabled by default and a third party caching product such as Ehcache must be used to enable caching.

Caching Relationships
Some products support a separate cache for caching relationships. This is normally required for  and   relationships. and  relationships normally do not need to be cached, as they reference the object's. However an inverse  will require the relationship to be cached, as it references the foreign key, not primary key.

For a relationship cache, the results normally only store the related object's, not the object, or its data (to avoid duplicate and stale data). The key of the relationship cache is the source object's  and the relationship name. Sometimes the relationship is cached as part of the data cache, if the data cache stores a structure instead of a database row. When a cache hit occurs on a relationship, the related objects are looked up in the data cache one by one. A potential issue with this, is that if the related object is not in the data cache, it will need to be selected from the database. This could result in very poor database performance as the objects can be loaded one by one. Some product that support caching relationships also support batching the selects to attempt to alleviate this issue.

Cache Types
There are many different caching types. The most common is a LRU cache, or one that ejects the Least Recently Used objects and maintains a fixed size number of MRU (Most Recently Used) objects.

Some cache types include:
 * LRU - Keeps X number of recently used objects in the cache.
 * Full - Caches everything read, forever. (not always the best idea if the database is large)
 * Soft - Uses Java garbage collection hints to release objects from the cache when memory is low.
 * Weak - Normally relevant with object caches, keeps any objects currently in use in the cache.
 * L1 - This refers to the transactional cache that is part of every, this is not a shared cache.
 * L2 - This is a shared cache, conceptually stored in the, so accessible to all  s.
 * Data cache - The data representing the objects is cached (database rows).
 * Object cache - The objects are cached directly.
 * Relationship cache - The object's relationships are cached.
 * Query cache - The result set from a query is cached.
 * Read-only - A cache that only stores, or only allows read-only objects.
 * Read-write - A cache that can handle insert, updates and deletes (non read-only).
 * Transactional - A cache that can handle insert, updates and deletes (non read-only), and obeys transactional ACID properties.
 * Clustered - Typically refers to a cache that uses JMS, JGroups or some other mechanism to broadcast invalidation messages to other servers in the cluster when an object is updated or deleted.
 * Replicated - Typically refers to a cache that uses JMS, JGroups or some other mechanism to broadcast objects to all servers when read into any of the servers cache.
 * Distributed - Typically refers to a cache that spreads the cached objects across several servers in a cluster, and can look-up an object in another server's cache.

 * TopLink / EclipseLink : Support an L1 and L2 object cache. LRU, Soft, Full and Weak cache types are supported.  A query cache is supported.  The object cache is read-write and always transactional.  Support for cache coordination through RMI and JMS is provided for clustering.  The TopLink product includes a Grid component that integrates with Oracle Coherence to provide a distributed cache.

Query Cache
A query cache caches query results instead of objects. Object caches cache the object by its, so are generally not very useful for queries that are not by. Some object caches support secondary indexes, but even indexed caches are not very useful for queries that can return multiple objects, as you always need to access the database to ensure you have all of the objects. This is where query caches are useful, instead of storing objects by, the query results are cached. The cache key is based on the query name and parameters. So if you have a  that is commonly executed, you can cache its results, and only need to execute the query the first time.

The main issue with query caches, as with caching in general is stale data. Query caches normally interact with an object cache to ensure the objects are at least as up to date as in the object cache. Query caches also typically have invalidation options similar to object caches.

 * TopLink / EclipseLink : Support query cache enabled through the query hint .  Several configuration options including invalidation are supported.

Stale Data
The main issue with caching anything is the possibility of the cache version getting out of synch with the original. This is referred to as stale or out of synch data. For read-only data, this is not an issue, but for data that changes infrequently or frequently this can be a major issue. There are many techniques for dealing with stale data and out of synch data.

1st Level Cache
Caching the object's state for the duration of a transaction or request is normally not an issue. This is normally called a 1st level cache, or the  cache, and is required by JPA for proper transaction semantics. If you read the same object twice, you must get the identical object, with the same in-memory changes. The only issues occur with querying and DML.

For queries that access the database, the query may not reflect the un-written state of the objects. For example you have persisted a new object, but JPA has not yet inserted this object in the database as it generally only writes to the database on the commit of the transaction. So your query will not return this new object, as it is querying the database, not the 1st level cache. This is normally solved in JPA by the user first calling, or the   automatically triggering a flush. The default  on an   or   is to trigger a flush, but this can be disabled if a write to the database before every query is not desired (normally it isn't, as it can be expensive and lead to poor concurrency). Some JPA providers also support conforming the database query results with the object changes in memory, which can be used to get consistent data without triggering a flush. This can work for simple queries, but for complex queries this typically gets very complex to impossible. Applications normally query data at the start of a request before they start making changes, or don't query for objects they have already found, so this is normally not an issue.

If you bypass JPA and execute DML directly on the database, either through native SQL queries, JDBC, or JPQL  or   queries, then the database can be out of synch with the 1st level cache. If you had accessed objects before executing the DML, they will have the old state and not include the changes. Depending on what you are doing this may be ok, otherwise you may want to refresh the affected objects from the database.

The 1st level, or  cache can also span transaction boundaries in JPA. A JTA managed  will only exist for the duration of the JTA transaction in JEE. Typically the JEE server will inject the application with a proxy to an, and after each JTA transaction a new   will be created automatically or the   will be cleared, clearing the 1st level cache. In an application managed, the 1st level cache will exist for the duration of the. This can lead to stale data, or even memory leaks and poor performance if the  is held too long. This is why it is generally a good idea to create a new  per request, or per transaction. The 1st level cache can also be cleared using the  method, or an object can be refreshed using the   method.

2nd Level Cache
The 2nd level cache spans transactions and s, and is not required as part of JPA. Most JPA providers support a 2nd level cache, but the implementation and semantics vary. Some JPA providers default to enabling a 2nd level cache, and some do not use a 2nd level cache by default.

If the application is the only application and server accessing the database there is little issue with the 2nd level cache, as it should always be up to date. The only issue is with DML, if the application executes DML directly to the database through native SQL queries, JDBC, or JPQL  or   queries. JPQL queries should automatically invalidate the 2nd level cache, but this may depend on the JPA provider. If you use native DML queries or JDBC directly, you may need to invalidate, refresh or clear the objects affected by the DML.

If there are other applications, or other application servers accessing the same database, then stale data can become a bigger issue. Read-only objects, and inserting new objects should not be an issue. New objects should get picked up by other servers even when using caching as queries typically still access the database. It is normally only  operations and relationships that hit the cache. Updated and deleted objects by other applications or servers can cause the 2nd level cache to become stale.

For deleted objects, the only issue is with  operations, as queries that access the database will not return the deleted objects. A  by the object's   could return the object if it is cached, even if it does not exist. This could lead to constraint issues if you add relations to this object from other objects, or failed updates, if you try to update the object. Note that these can both occur without caching, even with a single application and server accessing the database. During a transaction, another user of the application could always delete the object being used by another transaction, and the second transaction will fail in the same way. The difference is the potential for this concurrency issue to occur increases.

For updated objects, any query for the objects can return stale data. This can trigger optimistic lock exceptions on updates, or cause one user to overwrite another user's changes if not using locking. Again note that these can both occur without caching, even with a single application and server accessing the database. This is why it is normally always important to use optimistic locking. Stale data could also be returned to the user.

Refreshing
Refreshing is the most common solution to stale data. Most application users are familiar with the concept of a cache, and know when they need fresh data and are willing to click a refresh button. This is very common in an Internet browser, most browsers have a cache of web pages that have been accessed, and will avoid loading the same page twice, unless the user clicks the refresh button. This same concept can be used in building JPA applications. JPA provides several refreshing options, see refreshing.

Some JPA providers also support refreshing options in their 2nd level cache. One option is to always refresh on any query to the database. This means that  operations will still access the cache, but if the query accesses the database and brings back data, the 2nd level cache will be refreshed with the data. This avoids queries returning stale data, but means there will be less benefit from caching. The cost is not just in refreshing the objects, but in refreshing their relationships. Some JPA providers support this option in combination with optimistic locking. If the version value in the row from the database is newer than the version value from the object in the cache, then the object is refreshed as it is stale, otherwise the cache value is returned. This option provides optimal caching, and avoids stale data on queries. However objects returned through  or through relationships can still be stale. Some JPA providers also allow  operation to be configured to first check the database, but this general defeats the purpose of caching, so you are better off not using a 2nd level cache at all. If you want to use a 2nd level cache, then you must have some level of tolerance to stale data.

JPA 2.0 Cache APIs
JPA 2.0 provides a set of standard query hints to allow refreshing or bypassing the cache. The query hints are defined on the two enum classes CacheRetrieveMode and CacheStoreMode.

Query hints:
 * : Ignore the cache, and build the object directly from the database result.
 * : Allow the query to use the cache. If the object/data is already in the cache, the cached object/data will be used.
 * : Do not cache the database results.
 * : If the object/data is already in the cache, then refresh/replace it with the database results.
 * : Cache the objects/data returned from the query.
 * : If the object/data is already in the cache, then refresh/replace it with the database results.
 * : Cache the objects/data returned from the query.

Cache hints example
JPA 2.0 also provides a Cache interface. The  interface can be obtained from the   using the   API. The  can be used to manually evict/invalidate entities in the cache. Either a specific entity, an entire class, or the entire cache can be evicted. The  can also be checked to see if it contains an entity.

Some JPA providers may extend the  interface to provide additional API.

 * TopLink / EclipseLink : Provide an extended  interface  .  It provides additional API for invalidation, query cache, access and clearing.

Cache Invalidation
A common way to deal with stale cached data is to use cache invalidation. Cache invalidation removes or invalidates data or objects in the cache after a certain amount of time, or at a certain time of day. Time to live invalidation guarantees that the application will never read cached data that is older than a certain amount of time. The amount of the time can be configured with respect to the application's requirements. Time of day invalidation allows the cache to be invalidated at a certain time of day, typically done in the night, this ensures data is never older than a day old. This can also be used if it is known that a batch job updates the database at night, the invalidation time can be set after this batch job is scheduled to run. Data can also be invalidated manually, such as using the JPA 2.0  API.

Most cache implementations support some form of invalidation, JPA does not define any configurable invalidation options, so this depends on the JPA and cache provider.

 * TopLink / EclipseLink : Provide support for time to live and time of day cache invalidation using the  annotation and   orm.xml element.  Cache invalidation is also supported through API, and can be used in a cluster to invalidate objects changed on other machines.

Caching in a Cluster
Caching in a clustered environment is difficult because each machine will update the database directly, but not update the other machine's caches, so each machines cache can become out of date. This does not mean that caching cannot be used in a cluster, but you must be careful in how it is configured.

For read-only objects caching can still be used. For read mostly objects, caching can be used, but some mechanism should be used to avoid stale data. If stale data is only an issue for writes, then using optimistic locking will avoid writes occurring on stale data. When an optimistic lock exception occurs, some JPA providers will automatically refresh or invalidate the object in the cache, so if the user or application retries the transaction the next write will succeed. Your application could also catch the lock exception and refresh or invalidate the object, and potentially retry the transaction if the user does not need to be notified of the lock error (be careful doing this though, as normally the user should be aware of the lock error). Cache invalidation can also be used to decrease the likelihood of stale data by setting a time to live on the cache. The size of the cache can also affect the occurrence of stale data.

Although returning stale data to a user may be an issue, normally returning stale data to a user that just updated the data is a bigger issue. This can normally be solved through session affinity, but ensuring the user interacts with the same machine in the cluster for the duration of their session. This can also improve cache usage, as the same user will typically access the same data. It is normally also useful to add a refresh button to the UI, this will allow the user to refresh their data if they think their data is stale, or they wish to ensure they have data that is up to date. The application can also choose the refresh the objects in places where up to date data is important, such as using the cache for read-only queries, but refreshing when entering a transaction to update an object.

For write mostly objects, the best solution may be to disable the cache for those objects. Caching provides no benefit to inserts, and the cost of avoiding stale data on updates may mean there is no benefit to caching objects that are always updated. Caching will add some overhead to writes, as the cache must be updated, having a large cache also affects garbage collection, so if the cache is not providing any benefit it should be turned off to avoid this overhead. This can depend on the complexity of the object though, if the object has a lot of complex relationships, and only part of the object is updated, then caching may still be worth it.

Cache Coordination
One solution to caching in a clustered environment is to use a messaging framework to coordinate the caches between the machines in the cluster. JMS or JGroups can be used in combination with JPA or application events to broadcast messages to invalidate the caches on other machines when an update occurs. Some JPA and cache providers support cache coordination in a clustered environment.

 * TopLink / EclipseLink : Support cache coordination in a clustered environment using JMS or RMI. Cache coordination is configured through the   annotation or   orm.xml element, and using the persistence unit property.

Distributed Caching
A distributed cache is one where the cache is distributed across each of the machines in the cluster. Each object will only live on one or a set number of the machines. This avoids stale data, because when the cache is accessed or updated the object is always retrieved from the same location, so is always up to date. The draw back to this solution is that cache access now potentially requires a network access. This solution works best when the machines in the cluster are connected together on the same high speed network, and when the database machine is not as well connected, or is under load. A distributed cache reduces database access, so allows the application to be scaled to a larger cluster without the database becoming a bottleneck. Some distributed cache providers also provide a local cache, and offer cache coordination between the caches.

 * TopLink : Supports integration with the Oracle Coherence distributed cache.

Cache Transaction Isolation
When caching is used, the consistency and isolation of the cache becomes as important as the database transaction isolation. For basic cache isolation it is important that changes are not committed into the cache until after the database transaction has been committed, otherwise uncommitted data could be accessed by other users.

Caches can be either transactional, or non-transactional. In a transactional cache, the changes from a transaction are committed to the cache as a single atomic unit. This means the objects/data are first locked in the cache (preventing other threads/users from accessing the objects/data), then updated in the cache, then the locks are released. Ideally the locks are obtained before committing the database transaction, to ensure consistency with the database. In a non-transactional cache the objects/data are updated one by one without any locking. This means there will be a brief period where the data in the cache is not consistent with the database. This may or may not be an issue, and is a complex issue to think about and discuss, and gets into the issue of locking, and the application's isolation requirements.

Optimistic locking is another important consideration in cache isolation. If optimistic locking is used, the cache should avoid replacing new data, with older data. This is important when reading, and when updating the cache.

Some JPA providers may allow for configuration of their cache isolation, or different caches may define different levels of isolation. Although the defaults should normally be used, it can be important to understand how the usage of caching is affecting your transaction isolation, as well as your performance and concurrency.

I can't see changes made directly on the database, or from another server

 * This means you have either enabled caching in your JPA configuration, or your JPA provider caches by default. You can either disable the 2nd level cache in your JPA configuration, or refresh the object or invalidate the cache after changing the database directly. See, Stale Data
 * TopLink / EclipseLink : Caching is enabled by default. To disable caching set the persistence property   to   in your persistence.xml or persistence properties.  You can also configure this on a per class basis if you want to allow caching in some classes and not in others. See, EclipseLink FAQ.

Caching

title: Java Persistence/Caching


text:
User:Whiteknight/Gadgetscore

About
This page is going to be some basic documentation about User:Whiteknight/gadgetscore.js. This script is a series of functions to make some of my common javascripting tasks easier. All functions have a "wk." prefix, to help reduce namespace pollution. Functions that start with an underscore are private functions, and will not be documented here. Don't try to use them, because they will likely be changed in future versions.

Versions
The current version of the script can be gotten with. This will return a string of text such as. To test for particular functionality, try. This will return true if the current script version is greater then or equal to the version you specify.

All functions will be listed with the version number required in parenthesis.

Display Functions

 * (2.1) displayConLine(String):Turns the Wikibooks logo area in the upper-right of the screen into a display console, and posts the specified line of text to it.
 * (2.1) toggleDebug: toggles the debug state. Default value is false. returns the current debug state.
 * (2.1) debug(String): If debug is true, posts the specified text to the console.

AJAX Methods

 * (2.0) httpClient: Returns an XMLHttpRequest object
 * (2.0) loadPage(url, callback, type): GET request for page at url. Passes result text to callback function. If type is specified, overrides the MIME type of the request to type. Default MIME type is "text/xml".
 * (2.0) loadWikiPage(page, callback):
 * (2.0) loadEditPage(page, callback):
 * (2.0) loadWikiText(page, callback): Loads the raw wikitext from the specified page. Passes text to callback. Text has MIME type "text/x-wiki".
 * (2.3) postEdit(page, text, summary, filter): Posts text to the page with the specified edit summary. filter is a function that can be used in place of a raw text post. If filter is provided, the text posted to the page is given by filter(pagetext, text), where pagetext is the current text of the page. Two predefined filters are wk.filter.append, and wk.filter.prepend.
 * (2.4) showEditWindow(page, parent): Takes a loaded edit page, either XML formatted or as plain text, isolates the edit form, and appends that form to the parent. Returns an associative array with the entries "form", "text", and "summary", which are the editform, wpTextbox1, and wpSummary elements of the form, respectively.

Element Methods

 * (2.0) makeElement
 * (2.0) elementBuilder
 * (2.0) makeButton
 * (2.0) makeInput
 * (2.2) appendChildren
 * (2.0) spanText
 * (2.0) spanEditor
 * (2.2) appendSpanText
 * (2.0) toggleDisplay
 * (2.0) toggleDisable

Wikilink Methods

 * (2.0) wikiLink
 * (2.0) wikiLinkText

Revision History

 * 2.64 Improve handling of showEditWindow in Chrome and Safari

title: User:Whiteknight/Gadgetscore


text:
ERP5 Handbook/From form to API

= From form to API - first look behind the scenes =

Management interface of a form
When you look at the ERP5 screen, what you see is a rendered form (ERP5 Form, which is based on a Formulator form). Its name is usually at the end of the URL (like "Person_viewCareer"); often, the URL ends with "/view", which means that you are looking at the default form of an object. If you see a number of tabs (like "View / Details / Career"), click on any of them and you will have the form name in the URL. If you are in a module and there is no tabs, things are a bit more difficult, we will come to that a bit later.

Once you have the form name, append "/manage_main" to it - now you are in a management screen, and you have a complete list of fields which are visible in on the form (and possibly some which are not visible).

We won't be talking in detail about editing a form - you can consult Formulator documentation for that. The purpose here is show how fields are filled with values, and how they interact with the object.

Property fields and API
Simple fields - those containing strings, numbers, or checkboxes with boolean values, are bound to object attributes by naming convention. When a field is rendered, it invokes an appropriate accessor to get an attribute value. This is why all controls begin with "my_" - a field:

my_title

invokes a method:

.getTitle

to get value of an attribute:

title

Most of the accessors are auto-generated (see "Magic of ERP5" to know more) - if a property "title" is defined, an object has the accessor, but you won't find it in the code (!). Sometimes accessors are overwritten - e.g. a Person object has a different .getTitle method. This one you can find in the code.

When a form is submitted, and you had changed value of a "title" field, the script which is being called by the form (usu. "Base_edit") invokes a setter:

.setTitle

which, not surprisingly, sets the title. Replace the form_name/manage_main with "/Base_viewDict" - you will see raw data of the object, and you will find your title.

That's almost all there is to it. There is a number of special fields for different types of attributes - there is a StringField, TextAreaField, IntField, FloatField, DateField, EmailField. These fields check if the value you've entered is appropriate.

Relation fields and API
A relation field (specifically, RelationStringField) has already been described in UI section. Basically, it follows the same principle as property fields. The difference is that in most cases a relation field used for relation

source

is called

my_source_title

so it invokes accessor:

.getSourceTitle

the result being that it displays a nice title of the related object, instead of its relative url (like "/organisation_module/12"). And conversely, when you fill it and submit a form, it uses the title to search for the appropriate object.

You can also apply the same convention to use other properties then title, e.g. you could create a field:

my_source_relative_url

which will display and use a relative url of a related object.

There is also a MultiRelationStringField, which is used to get/set a relation to many objects:

my_destination_title_list

uses

.getDestinationTitleList

and has a funny behaviour, which will be explained somewhere else.

Category membership fields and API
Some fields allow you to assign an object to certain categories (in other words, to use categories for classification). For example, you can set a product_line on a product, or nationality on a person. For this purpose, a ListField is used. It follows the same principle:

my_nationality

allows you to choose a nationality, and it assigns the person to a chosen subcategory of "nationality" base category.

The way to field such a control with values is to give it a list of tuples containing title and url of categories, like: , , ['German', 'd'], ['British', 'en']... This is most easily achieved through the category's API; most commonly used method are: .getCategoryChildLogicalPathItemList and getCategoryChildCompactLogicalPathItemList

The latter different from the former in that if the path made of titles becomes too long, it tries to trim it in a reasonable way.

A MultiListField works the same way, only it allows for selecting many categories (by ctrl-clicking), and, obviously, uses a: .get[category]List accessor.

title: ERP5 Handbook/From form to API


text:
Talk:Mongolian

Speedy deletion
I've rolled back your edits to the last version, where I added categories to the book. There is not "no content" on the page as it stands now. There is meta-content, which would better be used to create content rather than deleting it. Every book has to start somewhere, and deleting the plan which has been created there would not be helpful. Please consider contributing to the book rather than asking to have it deleted. If you still feel that it should be deleted, please nominate it at WB:VFD. – Mike.lifeguard  | talk 15:03, 15 October 2007 (UTC)

 * Ok, sounds good--It might as well stay :)--Uzbekscholar 17:45, 30 October 2007 (UTC)

Peace Corps Stuffs
You can help (even if you don't know a word of Mongolian!!!) ! The following books should be typed in, and then expanded and improved upon:

All the following stuffs are in the Public Domain.

 * Anyways, the first step is typing in this first pdf:
 * Amraa et. al. - Mongol Language Competencies for Peace Corps (1993)PDF

See Uzbek for an example on how this is being done.

Even if you don't know Mongolian, you can still help with this project by typing in the remaining Lessons from the Mongol Language Competencies for Peace Corps (1993)!! It's easy, and doesn't require any special skill. If you know Mongolian well feel free to do what you want with this book--provided you believe it'll help people be able to study Mongolian.

picture...
horrible!! :( --Remi (talk) 15:50, 30 May 2008 (UTC)

Is Mongolian a Category II or III language?
Here it says that it's a category III language, but on the Language Learning Difficulty for English Speakers page, it says it's a category 2* language.

title: Talk:Mongolian


text:
ERP5 Handbook/Magic Security

Playing with security
Needless to say, security is crucial in most projects. And designing a tight yet flexible permission system could be a developer's nightmare.

Fortunately, ERP5 comes with extremely powerful security machinery. Unfortunately, it does not work out of the box and need to be customized.

5A Security model
ERP5's security model is based on roles. Roles are a Zope concept and are explained in the Zope documentation (Zope Book). Generally speaking, a role describes who the user is (e.g. accountant, clerk, officer), but not what he can do. That is defined by permissions (e.g. view permission, modify permission). For each document there is a role-to-permission mapping. The user with the accountant role can be allowed to access some documents, but not allowed to access others.

ERP5 extends Zope's concept and introduces the 5A Security Model, which provides a simple and consistent view of business security. 5A stands for the ERP5 roles of Author, Auditor, Assignor, Assignee and Associate. Each of these roles have a specific purpose:

Author can create new documents. He doesn't necessarily need to be able to view documents (he would probably be able to view his own documents, thanks to Zope's role of Owner).

Auditor is allowed to view documents.

Assignor can view, modify, delete and create documents, as well as assign other users to specified documents.

Assignee can work only on some documents from the module. For example, he can access only documents related to a specified region.

Associate can work on documents under certain conditions (e.g., he can view Organisations only if they are related to the Invoice documents he is responsible for).

Roles are described in: http://wiki.erp5.org/HowToDesignSecurity

How can one become a user?
When a user tries to log into the ERP5 site, the security machinery tries to find a Person (in a person_module) that has the value of the reference property (called "user name" on the Details tab on Person form) set to the login name of a user. If such a Person exists, has 'Internal' role and is Validated (see chapter about workflows), and the password given by the user matches the password of this Person, then the user is allowed to log in.

(Important — Starting from revision r15915, the Person doesn't need to have an 'Internal' role any longer. Instead, the Person must have at least one open Assignment.)

So to let somebody log into the ERP5 site, you must:
 * define a Person;
 * set reference property to user login name;
 * set password;
 * set Person's role to Internal (not needed in revisions later than r15915);
 * validate a person;
 * open an Assignment for that Person (from revision r15915).

The concept
Security is divided into two parts – user side security and object side security.

User side security defines security settings user has after successful logging in.

Object side security defines conditions that should be met by the user to obtain role in context of the given object.

In ERP5 almost everything is an object – modules, preferences, categories and so on. Every time the user tries to access an object, ERP5 does the following:

 * checks if the user security settings and object security settings allow to grant user a role or roles in context of this object;
 * finds permissions granted for those role(s);
 * allows or disallows access to the object.

How does it work?
When a user logs to the ERP5, the security categories are calculated for him. Those security categories are analogous to a set of keys (by "key" I mean a small metal object, not the key in the sense used in cryptography!). Back to the programming, categories are just a list of strings, for example:

Each ERP5 object has also its security categories. Those categories can be considered as keyholes. Each category has the role associated to it. For instance:

When a user has a key that matches a given keyhole, he gets the role "hidden" behind the keyhole. In the previous examples the user gets the Auditor role for the object, as he has (among others) MA_CS_WA security category, and the object has Auditor role associated with it.

As each object can have different security categories, user can obtain different roles for different objects. If another object has the following category: the user from the first example will not get any role and thus will not be able to access the object.

The main question now is - how are security categories calculated? Well, it depends if we are talking about user side security settings or object side security settings.

User side security settings
User side security is based on portal categories (see the explanation of the category tool if you are not familiar with it). As we mentioned earlier (see " How can one become a user?" above), each logged user has the associated Person object, defined in person module (this is not true for special users like Zope, so the ERP5 security machinery will not work for them!). This Person belongs to some categories (directly off by acquisition from contained Careers or Assignments), like function, group or site.

If you take a look at the portal categories, you'll find that each category value could have a codification defined, that is, a short string identifying that value. Let's assume that category function can have (among others) value of "Manager", which has "MA" codification. Category group can have value of "Customer Service", which has "CS" codification.

If the user Person's function is "Manager" and group is "Customer Service", the security category for this user could be "MA" (codification of "Manager") and "CS" (codification of "Customer Service"), joined with an underscore: MA_CS. For another user, which has function of "Clerk" ("CL" codification) and group "Customer Service", the security category would be CL_CS.

The key question is: what categories are used for security calculations and how does it work?

The insides
So let's take the screwdriver, remove the front panel of the ERP5 security machinery, and have a look at the insides.

The central point in calculating user security settings is the Python script called: which defines which scripts and which base categories would be used for security calculations. This script should return a tuple:

Each element of this tuple is also a tuple: where script is the name of the script that will be used to calculate security category, while cat_list a list of base categories that will be passed to this script as one of its parameters (rest of them will be discussed later). So if ERP5Type_getSecurityCategoryMapping returns: then first script1 would be called with then script2 would be called with .

What do those scripts do? They examine user's Person object, get values for specified categories and return them as a list of dicts. In previous example, script1 should get the function category value id, while script2 should get the function and group categories value ids. So for Person being Manager in Customer Service, script1 would probably return: while script2 would return:

One thing should be explained – why the scripts return list of dicts instead of a single dict? This is because some categories could be defined in objects contained in Person object, e.g. Assignments, and user could have several open Assignments, which results in multiple values for the given category.

What do those scripts look like? They should take the following arguments:
 * base_category_list: this was discussed earlier.
 * user_name: name (login) of a logged user,
 * object: generally not used here;
 * portal_type: the portal type of the object (not used here either).

ERP5Type_getSecurityCategoryMapping should be provided by the developer and be placed somewhere in portal skins. If there is no such script, the system behaves as if the script exists and returns the following tuple:

(('ERP5Type_getSecurityCategoryFromAssignment', self.getPortalAssignmentBaseCategoryList ),)

which results in calling ERP5Type_getSecurityCategoryFromAssignment with a base_category_list parameter got from call to getPortalAssignmentBaseCategoryList, which currently is:

The ERP5Type_getSecurityCategoryFromAssignment calculates security mappings from all open Assignments of the logged users Person object.

An (almost) real case example
Let's imagine there is an energy selling company that is spanned across multiple regions. The company has Customer Service department. Regional Managers of Customer Service should be able to access connection documents of end customers from their respective regions, but shouldn't be able to access documents of end customers from other regions. The region is stored as site category.

Assume that user jacek is a Manager. He has two open assignments – for the Warsaw and the Pruszkow regions. The first of these assignments has the following settings: function: manager group: customer_service site: warsaw while the second has the following settings: function: manager group: customer_service site: pruszkow

Note: Having a manager with two assignments for two different regions is probably not very common for such companies. However, I want to show that even such uncommon needs could be easily fulfilled in ERP5.

The ERP5Type_getSecurityCategoryFromAssignment will return the following list of dicts for user jacek: [{'function': 'manager', 'group': 'customer_service', 'site': 'warsaw'}, {'function': 'manager', 'group': 'customer_service', 'site': 'pruszkow'}]

The user bartek is a manager in the Siedlce region. He has the following assignment: function: manager group: customer_service site: siedlce

so the script returns for him: [{'function': 'manager', 'group': 'customer_service', 'site': 'siedlce'},]

But what about the string representation of the security categories I've mentioned at the beginning of this chapter? For that, a codification is used. Let's imagine that: function/manager has the codification MA

group/production has the codification CS

site/warsaw has the codification WA

site/pruszkow has the codification PRS

and

site/siedlce has the codification SL

After obtaining list of dict, ERP5 security machinery for each dict: So for user jacek and first dict, the codification would be: MA_CS_WA while for the second: MA_CS_PRS
 * sorts keys alphabetically;
 * replaces category value id by its codification;
 * joins all codifications in one string, separated by underscores;

And jacek finally gets the following mappings:

User bartek gets :

Note: If the codification is not defined for a given category, the category's id is taken. However, it is good practice to define codifications for categories used in security.

These security settings would be then used by ERP5 to control access to objects. It will be explained in next chapter.

Object side security settings
Object security settings (roles settings) are defined on Portal Type basis (if you are not familiar with Portal Types, read here). Those setting are "keyholes" that allows the keys owners to get access to specified roles.

Roles may be calculated either statically or dynamically. Unfortunately, there is no apparent difference between static and dynamic roles calculation, as both are defined in the same form. We well discuss that difference later.

To define security settings for the portal type, you should navigate to its management form and click the "Roles" tab.

In the Name field you can put a name of the setting. (it is NOT the role name). In practice, a short description is often put here. This is informational only.

In the Role field you can set a name of the role that would be granted to the user whose "key" matches this "keyhole" (that is, the user that has proper security category).

In the Description field you can set a more detailed description of the setting. This is informational only.

In the Condition field you can set a condition that should be fulfilled in order to apply the settings (it could be a Python script call, for instance).

In the Base Category field you can set space-separated list of names of base categories that would be used for role calculation.

In the Base Category Script field you can set the name of the Python script that would be called if dynamic role calculation method is used. If the static role calculation is used, the script is not called and the field value has no meaning.

In Category text area you can set a list of category values ids that would be used for role calculation. Each category value id should be put ion a separate line.

Static vs. dynamic
If, for each base category name defined in Base Category field, there is a matching definition in Category text area, the calculation is static, that is, the Base Category Script is not called. If there are base category names for whom there are no matching definition in Category text area, the calculation is dynamic, that is, the script would be called and its return value would be used for the missing definitions.

How does it work?
Static calculation is really simple – a mapping is created based on category values. If Base Category field contains function group and Category text area contains: function/sale_manager group/customer_service then calculated mapping would be MA_CS, providing that codifications are the same as in previous examples. Any user that has MA_CS security category would be granted role for the object.

However, dynamic calculation is more difficult. If there are more entries in the Base Category field than category values in Category text area, then the script defined in Base Category Script field would be called for the missing categories.

The script gets following parameters:

 * base_category_list: a list of categories defined in Base Category field.
 * user_name: name (login) of a logged user,
 * object: object for which the role setting is calculated,
 * portal_type: the portal type of the object.

Script should return a list of dicts, just like scripts for user-side security calculation do (in fact, in some situations those can be the same scripts). Each dict contains names of categories from base_category_list and their respective value ids.

What should those scripts do? It's up to the developer.

Back to the (almost) real case example
In our example we wanted to restrict access to customer connection parameters only to managers in charge of the specified region (i.e. region in which the customer lives). Connection parameters are stored in objects of portal type Connection Parameters. This object is linked to the Person object (representing the end customer) by the source relation. The Person contains Address object, which in turn has city property.

Let's navigate to Connection Parameters management form, select Role tab and fill the form:

function/manager group/customer_service (You should put each category value id in separate line) It can be easily seen, that we have three base categories defined, but only two category value ids. So for the missing category (site) the ConnectionParameters_getSecurityCategoryFromCustomerAddress script would be used.
 * In the Name field put short description, e.g. Customer Service Management People.
 * In the Role field a name of the role to be granted to the user, e.g. Assignor;
 * In the Description field put description of the setting, e.g. Customer Management People should have Assignor access to all Connection Parameters for customers living in their region.
 * Leave the Condition field empty.
 * In the Base Category field put space-separated list of names of base categories: "function group site".
 * In the Base Category Script field put the name of the Python script. Let's name the script ConnectionParameters_getSecurityCategoryFromCustomerAddress, to follow ERP5 naming convention.
 * In Category text area put a list of category values ids:

The script should examine the Connection Parameters object, get linked Person object, get its default address city, calculate the region from the city name (it can have city-to-region mapping defined in categories; or call external GIS system; or use crystal ball), then return the appropriate dictionary list.

This script could be similar to the following one:

if portal_type != 'Connection Parameters': raise RuntimeError, 'Error: Script called for invalid portal type'

customer = object.getSourceValue city = customer.getDefaultAddressCity region = context.ERP5Site_GetRegionFromCity #guess the region somehow category_dict = {}

for base_category in base_category_list: if base_category == 'site': category_dict[base_category]=region

For customer living in city in Pruszkow region the script should then return:

The rest of the mapping would be calculated statically – function/manager maps to MA, group/customer_service maps to CS, and as site/pruszkow maps to PRS, the final mapping would be MA_CS_PRS. Any user that have such security category (that is, a Manager of Customer Service in charge of Pruszków region) would be granted Assignor role for the document.

And what about documents related to more than one customer, possibly living in different regions? No problem, this just needs a small modification. The script should examine the list of Persons related to the document and return a list of dicts – one dict for one customer. So if the document is related to two customers – one in Pruszkow region and one in Jeziorna region, the return value would be as follows: and finally the document gets following mappings

Extending the defaults
Let's assume there is a class of documents (say connection standards, portal type Connection Standard) that should be available to all managers, regardless of the region they are responsible for. How to achieve this? The first idea would be to write a Base Category Script for Connection Standard portal type so that it returns all possible mappings for all regions: MA_CS_PRS, MA_CS_WA, MA_CS_SL,... and so on. Well, if the company has twenty regions, there would be twenty different mappings. Quite a lot, huh? Worse, if the company grows and new regions appears, security settings for all documents would have to be redefined.

Better idea is to define mapping without the region code, that is MA_CS. Documents with this mapping would be accessible for all Customer Service Managers... or not?

Well, not exactly, as no manager would got MA_CS security category! So there is a need to modify the default ERP5 security machinery a little bit.

To do this, you must place the ERP5Type_getSecurityCategoryMapping script somewhere in skins. The script should look as follows:

return (('ERP5Type_getSecurityCategoryFromAssignment', ['function','group','site']), ('ERP5Type_getSecurityCategoryFromAssignment', ['function','group']))

The first line looks similar to the system default (I replaced getPortalAssignmentBaseCategoryList with explicit list of base categories), the second is new. Now, when user logs in, the ERP5Type_getSecurityCategoryFromAssignment would be called twice – once with ['function','group','site'], and once with ['function','group'] only. This second call produces MA_CS for any 'Customer Service Manager regardless of the region.

For the Connection Standard portal type we should define the following role definition (only relevant fields shown) function/manager group/customer_service This would produce mapping MA_CS, so all users with MA_CS security category would be given Assignor role.
 * In the Role field: Assignor;
 * In the Base Category field: function group.
 * In Category text area:

Roles are NOT permissions
Well, at this point you may think that all that should be done has been done, but if you do, you are wrong. You have not defined the roles-to-permissions mapping yet.

What-to-what mapping? - you may ask. Well, despite their names, roles don't tell anything about privileges associated with them. There is nothing magical in the words Auditor or Assignor and ERP5 does not know by itself what those roles are allowed to do.

(This is true even for a Zope role of Manager! In many systems a Manager (or whatever he is called) is a mighty sheriff which can do everything. Not in ERP5, though. It is you who decide what permissions each role have. Even a Manager would have only as much power as you would give to him. You can define Managers without any permissions at all if you like to, thought it is rather a poor idea. However, you can easily grant a Manager insufficient privileges by mistake, and in such case you will find yourself in heavy troubles during development.)

How to define permissions for roles? It can be done either statically or dynamically.

Static permissions definition
This applies for objects that exists during the development time. They are mainly modules. To define permissions for such object, navigate to this object's management page and go to the Security tab. Read Zope documentation for details.

Dynamic permissions definition
This is the moment workflows enter the scene. As you probably know (and if you don't, read the section about workflows), each portal type can be assigned to one or more workflows. Objects (instances) of this portal type can be therefore in some workflow states. Each workflow state defines separate roles-to-permissions mapping. Object entering specific workflow state gets role-to-permission mapping defined for this workflow state.

This allows for a very flexible privileges manipulation. For instance, a newly created Connection Parameters document should be accessible only by its creator, so the draft state defines view and modify permissions for Owner only. After the document is completed, it can be submitted. In this state it can become readable to Assignees and Auditors and readable/writable to Assignors. Then the document goes through the rest of the workflow and finally ends in an archived state, where nobody can change it, but many can read.

To enable workflow-based security, navigate to the workflow management page, click the Permissions tab and add required permissions. At least the following permissions should be managed by workflow: View and Access content information (read), Modify portal content (write) and Add portal content (create new objects).

To define role-to-permission mapping for a workflow state, navigate to the workflow state management page and click the Permissions tab. You will see only permissions managed by this workflow.

Updating security settings
Security settings on objects are not updated automatically. This is developer's responsibility to update security settings after object state changes.

One way to achieve this is a separate interaction workflow, which have interactions defined for setters of properties that takes part in security calculation (in our "Almost real case example" the Person's Address city name is an example of such property – change of the city name can result in security settings change for related Connection Parameters documents, if the new city is in the different region then the old one). The interaction should fire a script that examines all related objects and recalculates security settings for them.

To recalculate security settings on object, call updateLocalRolesOnSecurityGroups in context of that object. Then, reindex the object (this is necessary, as object permissions are stored in portal catalog -> see the explanation of catalog tool).

title: ERP5 Handbook/Magic Security


text:
ERP5 Handbook/Magic Simulations

Plan:
 * what are simulations
 * where they are used
 * what are their purpose
 * follow Yo guidelines from erp5-dev thread
 * base on Shufla's "Introduction to simulation system" ("Wprowadzenie do systemu symulacji") presentation from 2nd ERP5DevCon, February 2008, Warsaw

Proposed TOC:

= Simulations purpose =

Decision and prevision
= Example user-level scenario =

Decrease quantity and split and defer
= Technical stuff =

title: ERP5 Handbook/Magic Simulations


text:
Cookbook:Roasted Brown Rice Mochi

Ingredients

 * 2 cups uncooked brown rice
 * 2–2 ½ cups water
 * 2 pinches sea salt

Procedure

 * 1) Wash the rice and soak for a couple of hours or overnight.
 * 2) Cook the rice in a pressure cooker until the liquid is absorbed.
 * 3) Grind the cooked rice in a mortar until the grain is completely fluid and sticky. This will take at least 30 minutes of grinding when done by hand.
 * 4) Shape the mash into 2 cm squares. Place the rice squares on an oiled plate and allow to dry for 1–2 days.
 * 5) Keep covered in a cold dry room or in the refrigerator.
 * 6) After this, roast the squares for 5 minutes in a pan.

title: Cookbook:Roasted Brown Rice Mochi


text:
User:Peter Alan McAllister

Your content and efforts are much appreciated. The problem is organization. If you are going to move math learning from books to virtual media, you (and others) need to understand the organization of the content in the present media. This is necessary to transition learners from books to virtual. You may want to include in parenthesis the grade level (or age) each of the key concepts you are developing. A free web site like www.k-12math.info provides that information.

Jim Kelly

title: User:Peter Alan McAllister


text:
Chess Opening Theory/1. d4/1...d5/2. c4/2...c6/3. Nf3

=Slav Defence=

3.Nf3
With the most common move in the Slav, 3.Nf3, White develops his knight and exerts more control over the e5-square.

Theory table
.

'''1. d4 d5 2. c4 c6 3. Nf3'''


text:
User talk:68.191.225.64

--Jomegat 17:54, 15 October 2007 (UTC)

title: User talk:68.191.225.64


text:
User talk:Rambam rashi

Come introduce yourself at the new users page. If you have any questions, you can ask there or contact me personally.

Welcome to the Muggles' Guide! Please don't hesitate to leave me a message on my talk page if you have any questions about the book. -within focus 19:07, 15 October 2007 (UTC)

Recent Muggles' Guide edits
I do appreciate your looking over the Muggles' Guide to Harry Potter, but I'm going to ask you please to stop one change that you are making. English does not have a gender-neutral way to refer to a single person in the third person (e.g. his wand, her feelings) which leaves us a problem when referring to all members of a group individually. In cases like that, particularly where the group can be mixed gender (Slytherins, for instance, or the Trio or Quidditch team members), we have used "their" as a best approximation of the usage we need. E.g.: "The Slytherins, meanwhile, are acting as normal, making rude comments about Lupin's patched robes, obviously more impressed by someone's superficial outer appearance than with their inner character and abilities." While I appreciate, and somewhat share, the impulse that has you change this to "his", this does lose the gender-neutrality of the term, and we would prefer to retain the gender-neutral term when possible.

I could similarly comment about your use of "whom", but jarring as it is to one reading colloquial English like the Potter series — in which I believe the word does not appear — it is still grammatically correct, and so I will not protest its inclusion in a work on literature.

Thank you very much for your continuing scrutiny; and feel free to make larger changes if you feel them warranted. Chazz (talk) 08:07, 3 March 2010 (UTC)

title: User talk:Rambam rashi